Go语言常用手册

Posted 2021-04-05 成长飞翔号

1.Go安装(2018.02.10)

1.Linux 系统下安装：

1).下载源码包：go1.10.linux-amd64.tar.gz。

2). 将下载的源码包拷贝至 /usr/local 目录。

cd  /usr/local tar -zxvf go1.10.linux-amd64.tar.gz

3). 将 /usr/local/go/bin 目录添加至PATH环境变量：

export PATH=$PATH:/usr/local/go/bin

4).测试：在 /home/eighthroute 目录下新建 godev 目录

新建文件 test.go，代码如下：

 
   
   
 

  
    
    
  
 
   
 
    
package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}
 
   
 
  
 
   
   
 

使用 go 命令执行以上代码输出结果如下：

[eighthroute@localhost godev]$ go run test.go Hello, World!

2.Windows 系统下安装：

Windows 下可以使用 .msi 后缀(在下载列表中可以找到该文件，如go1.10.windows-amd64.msi)的安装包来安装。

默认情况下.msi文件会安装在 C:\Go 目录下。你可以将 C:\Go\bin 目录添加到 PATH 环境变量中。添加后你需要重启命令窗口才能生效。我们自定义安装到 F:\Go 目录下。

安装测试

创建工作目录 F:\>godevelop。

文件名: test.go，代码如下：

 
   
   
 

  
    
    
  
 
   
 
    
package main

import "fmt"

func main() {
   fmt.Println("Hello, World!")
}
 
   
 
  
 
   
   
 

使用 go 命令执行以上代码输出结果如下：

F:\godevelop>go run test.go Hello, World!

----------------------------华丽分割线----------------------------

0.1.GO其他常用函数&参考手册

1.低精度转高精度：

a := 12             //a默认是int类型 var b int64 b = int64(a)     //int转int64 var c float64 c = float64(a)    //int转float64

2.int和string常用：

strconv.Itoa(1023)    //数字转字符串 strconv.Atoi("1023")  //字符串转数字

3.时间，时间戳和字符串常用：

s := time.Now().Unix()            //精确到秒:1522375988 now := time.Now()      //2018-03-30 10:13:08.1173064 +0800 CST m=+0.064003701 t := time.Unix(1469579899, 0)     //2016-07-27 08:38:19 +0800 CST t1 := time.Unix(1469579899, 0).Format("2006-01-02 15:04:05")   //2016-07-27 08:38:19 t2, _ := time.Parse("2006-01-02 15:04:05", "2016-07-27 08:46:15") //2016-07-27 08:46:15 +0000 UTC

----------------------------华丽分割线----------------------------

0.2.String常用函数(2018.02.11)

1.字符串操作：

使用之前请先引入：

import (     "fmt"     "strings" )

1).ToUpper:将字符串s全部转为大写。

定义：

func ToUpper(s string) string {}

用法：

fmt.Println(strings.ToUpper("Gopher"))  //GOPHER

2).ToLower:将字符串s全部转为小写。

定义：

func ToLower(s string) string {}

用法：

fmt.Println(strings.ToLower("Gopher"))   //gopher

3).Contains:检查字符串s中是否包含字符串substr，返回bool值。

定义：

func Contains(s, substr string) bool {}

用法：

fmt.Println(strings.Contains("seafood", "foo"))  //true fmt.Println(strings.Contains("seafood", "bar"))  //false fmt.Println(strings.Contains("seafood", ""))     //true fmt.Println(strings.Contains("", ""))            //true

4).Replace:在s字符串中，把old字符串替换为new字符串，n表示替换的次数，小于0表示全部替换。

定义：

func Replace(s, old, new string, n int) string {}

用法：

fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))       //oinky oinky oink fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))    //moo moo moo

5.1).Trim:在s字符串的头部和尾部去除cutset指定的字符串。注意：该方法很强大，cutset每个字符将在头和尾逐一去掉。

定义：

func Trim(s string, cutset string) string {}

用法：

fmt.Printf("[%q]", strings.Trim("!!! Achtung !!!", "!"))  //["Achtung"] //头部和尾部的"!"," ","A"都将去掉 fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! A")) //["chtung"]

5.2).Fields:去除s字符串的空格符，并且按照空格分割返回slice。

定义：

func Fields(s string) []string {}

用法：

fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   "))  //Fields are: ["foo" "bar" "baz"]

6.1).Index:在字符串s中查找substr所在的位置，返回位置值，找不到返回-1。

定义：

func Index(s, substr string) int {}

用法：

fmt.Println(strings.Index("chicken", "ken"))  //4 fmt.Println(strings.Index("chicken", "dmr"))  //-1

6.2).LastIndex:在字符串s中查找substr最后一次出现的位置，返回位置值，找不到返回-1。

定义：

func LastIndex(s, substr string) int {}

用法：

fmt.Println(strings.LastIndex("go gopher", "go")) // 3 fmt.Println(strings.LastIndex("go gopher", "hi")) // -1

6.3).HasPrefix:字符串s的前缀是否以字符串prefix开头。

定义：

func HasPrefix(s, prefix string) bool {}

用法：

fmt.Println(strings.HasPrefix("NLT_abc", "NLT"))  //true

6.4).HasSuffix:字符串s的前缀是否以字符串suffix结尾。

定义：

func HasSuffix(s, suffix string) bool {}

用法：

fmt.Println(strings.HasSuffix("NLT_abc", "abc")) //true

7).EqualFold:比较字符串s和t是否相等，并且忽略大小写。

定义：

func EqualFold(s, t string) bool {}

用法：

fmt.Println(strings.EqualFold("Go", "go")) //true

8).Join:字符串链接，把slice a通过sep链接起来。

定义：

func Join(a []string, sep string) string {}

用法：

s := []string{"foo", "bar", "baz"} fmt.Println(strings.Join(s, ", "))   //foo, bar, baz

9.1).Split:把s字符串按照sep分割，返回slice。

定义：

func Split(s, sep string) []string {}

用法：

fmt.Printf("%q\n", strings.Split("a,b,c", ","))  //["a" "b" "c"] fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))  //["" "man " "plan " "canal panama"] fmt.Printf("%q\n", strings.Split(" xyz ", ""))  //[" " "x" "y" "z" " "] fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))  //[""]

9.2).SplitAfter:把s字符串按照sep分割，结果中包含 sep 本身，返回slice。

定义：

func SplitAfter(s, sep string) []string {}

用法：

fmt.Printf("%q\n", strings.SplitAfter("/home/test/src", "/")) //["/" "home/" "test/" "src"]

10).Count:统计字符串s中包含子字符串substr的个数。

定义：

func Count(s, substr string) int {}

用法：

fmt.Println(strings.Count("cheese", "e")) // 3 fmt.Println(strings.Count("five", ""))    //5

11).Repeat:重复s字符串count次，最后返回重复的字符串。

定义：

func Repeat(s string, count int) string {}

用法：

fmt.Println("ba" + strings.Repeat("na", 2))  //banana

2.字符串转换：

使用之前请先引入：

import (     "fmt"     "strconv" )

1).Append系列:将整数等转换为字符串后，添加到现有的字节数组中。

str := make([]byte, 0, 100) str = strconv.AppendInt(str, 4567, 10) //以10进制方式追加 str = strconv.AppendBool(str, false) str = strconv.AppendQuote(str, "abcdefg") //追加多个字符 str = strconv.AppendQuoteRune(str, '单') //只能追加一个字符 fmt.Println(string(str)) //4567false"abcdefg"'单'

2).Format系列:把其他类型的转换为字符串。

a := strconv.FormatBool(false) b := strconv.FormatInt(1234, 10)  //10表示按照10进制转换 c := strconv.FormatUint(12345, 10)  //10表示按照10进制转换 d := strconv.Itoa(1023)    //常用 fmt.Println(a, b, c, d)  //false 1234 12345 1023

3).Parse系列:把字符串转换为其他类型。

a, err := strconv.ParseBool("false") b, err := strconv.ParseFloat("123.23", 64)  //64表示64位存储 c, err := strconv.ParseInt("1234", 10, 64)  //10表示按照10进制转换，64表示64位存储 d, err := strconv.ParseUint("12345", 10, 64)  //10表示按照10进制转换，64表示64位存储 e, err := strconv.Atoi("1023")  //常用 fmt.Println(a, b, c, d, e) //false 123.23 1234 12345 1023

----------------------------华丽分割线----------------------------

    

0.3.Array&Slice常用函数(2018.02.12)

1.切片截取：

操作	含义
s[n]	切片s中索引位置为n的项
s[:]	从切片s的索引位置0到len(s)-1处所获得的切片
s[low:]	从切片s的索引位置low到len(s)-1处所获得的切片
s[:high]	从切片s的索引位置0到high处所获得的切片，len=high
s[low:high]	从切片s的索引位置low到high处所获得的切片，len=high-low
s[low:high:max]	从切片s的索引位置low到high处所获得的切片，len=high-low，cap=max-low
len(s)	切片s的长度，总是<=cap(s)
cap(s)	切片s的容量，总是>=len(s)

 

2.示例说明：

array := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

操作	结果	len	cap	说明
array[:6:8]	[0 1 2 3 4 5]	6	8	省略 low
array[5:]	[5 6 7 8 9]	5	5	省略 high、 max
array[:3]	[0 1 2]	3	10	省略 high、 max
array[:]	[0 1 2 3 4 5 6 7 8 9]	10	10	全部省略

3.append函数：向 slice 尾部添加数据，返回新的 slice 对象。

var s1 []int                       //创建nil切换 //s1 := make([]int, 0) s1 = append(s1, 1)         //追加1个元素 s1 = append(s1, 2, 3)     //追加2个元素 s1 = append(s1, 4, 5, 6) //追加3个元素 fmt.Println(s1)               //[1 2 3 4 5 6] s2 := make([]int, 5) s2 = append(s2, 6) fmt.Println(s2)               //[0 0 0 0 0 6] s3 := []int{1, 2, 3} s3 = append(s3, 4, 5) fmt.Println(s3)               //[1 2 3 4 5]

4.copy函数：将一个 slice 内容复制到另外一个 slice 中。

data := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}  //这是数组 s1 := data[8:]            //{8, 9} s2 := data[:5]            //{0, 1, 2, 3, 4} copy(s2, s1)              //将s1内容复制到s2中，对应下标的数据将被修改 fmt.Println(s2)         //[8 9 2 3 4] fmt.Println(data)        //[8 9 2 3 4 5 6 7 8 9]

 ----------------------------华丽分割线----------------------------

0.4.Math常用函数(2018.02.13)

尽量用 math 包里面的函数，少用 math/big 包里的方法。

1.math包的使用：

使用之前请先引入：

import (     "fmt"     "math" )

1).Ceil:向上取整。

定义：

func Ceil(x float64) float64{}

用法：

fmt.Println(math.Ceil(3.14))  //4 fmt.Println(math.Ceil(-3.14)) //-3

2).Floor:向下取整。

定义：

func Floor(x float64) float64{}

用法：

fmt.Println(math.Floor(3.14))  //3 fmt.Println(math.Floor(-3.14)) //-4

3).Max:取两个数的最大值。

定义：

func Max(x, y float64) float64{}

用法：

fmt.Println(math.Max(1, 5)) //5

4).Min:取两个数的最小值。

定义：

func Min(x, y float64) float64{}

用法：

fmt.Println(math.Min(1, 5)) //1

5).Mod:取余运算，等价于：x%y，余数符号跟x相同。

定义：

func Mod(x, y float64) float64{}

用法：

fmt.Println(math.Mod(10, 3))  //1 fmt.Println(math.Mod(-10, 3)) //-1

6).Abs:返回x的绝对值。

定义：

func Abs(x float64) float64{}

用法：

fmt.Println(math.Abs(3.14))  //3.14 fmt.Println(math.Abs(-3.14)) //3.14

7).Modf:分解f，以得到f的整数和小数部分。

定义：

func Modf(f float64) (int float64, frac float64){}

用法：

f1, f2 := math.Modf(3.14) fmt.Printf("整数部分为:%f,小数部分为:%f \n", f1, f2) //整数部分为:3.000000,小数部分为:0.140000

8).Trunc:截取整数部分函数。

定义：

func Trunc(x float64) float64{}

用法：

fmt.Println(math.Trunc(3.14)) //3

9).Dim:函数返回(x-y)和0中的最大值。

定义：

func Dim(x, y float64) float64{}

用法：

fmt.Println(math.Dim(10, 3)) //7 fmt.Println(math.Dim(3, 5))  //0

2.math/big包的使用：

使用之前请先引入：

import (     "fmt"     "math/big" )

1).NewInt:新建一个64位int数据。

定义：

func NewInt(x int64) *Int{}

用法：

fmt.Println(big.NewInt(7)) //7

2).Int64:返回x的int64值。

定义：

func (x *Int) Int64() int64{}

用法：

i := big.NewInt(7) fmt.Println(i.Int64()) //7

3).String:将x转换为字符串返回。

定义：

func (x *Int) String() string{}

用法：

i := big.NewInt(7) fmt.Println(i.String()) //7

4).Abs:将z设为|x|并返回z。

定义：

func (z *Int) Abs(x *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(-3) fmt.Println(z.Abs(x)) //3 fmt.Println(z)        //3

5).Neg:将z设为-x并返回z。

定义：

func (z *Int) Neg(x *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(-3) fmt.Println(z.Neg(x)) //3 fmt.Println(z)        //3

6).Add:将z设为x + y并返回z。

定义：

func (z *Int) Add(x, y *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(2) y := big.NewInt(1) fmt.Println(z.Add(x,y)) //3 fmt.Println(z)        //3

7).Sub:将z设为x - y并返回z。

定义：

func (z *Int) Sub(x, y *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(2) y := big.NewInt(1) fmt.Println(z.Sub(x,y)) //1 fmt.Println(z)        //1

8).Mul:将z设为x * y并返回z。

定义：

func (z *Int) Mul(x, y *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(2) y := big.NewInt(1) fmt.Println(z.Mul(x,y)) //2 fmt.Println(z)        //2

9).Div:如果y != 0会将z设为x/y并返回z；如果y==0会panic。

定义：

func (z *Int) Div(x, y *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(2) y := big.NewInt(1) fmt.Println(z.Div(x,y)) //2 fmt.Println(z)        //2

10).Mod:如果y != 0会将z设为x%y并返回z；如果y==0会panic。

定义：

func (z *Int) Mod(x, y *Int) *Int{}

用法：

z := big.NewInt(7) x := big.NewInt(10) y := big.NewInt(3) fmt.Println(z.Mod(x,y)) //1 fmt.Println(z)        //1

3.伪随机数生成器：生成随机数。

使用之前请先引入：

import (     "fmt"     "math/rand"     "time" )

1).使用全局函数生成（推荐）:

//资源会在程序每次运行时都产生确定的序列。如果需要每次运行产生不同的序列，应使用Seed函数进行初始化 rand.Seed(time.Now().Unix()) //用时间对资源进行初始化 fmt.Println(rand.Int())       // 非负的int随机值，返回值为int fmt.Println(rand.Intn(100))   // [0,100)的随机值，返回值为int fmt.Println(rand.Int31())     // 非负的31位int随机值，返回值为int32 fmt.Println(rand.Int31n(100)) // [0,100)的随机值，返回值为int32 fmt.Println(rand.Int63())     // 非负的63位int随机值，返回值为int64 fmt.Println(rand.Int63n(100)) // [0,100)的随机值，返回值为int64 fmt.Println(rand.Float32())   // 取值范围在[0.0, 1.0)的32位float随机值，返回值为float32 fmt.Println(rand.Float64())   // 取值范围在[0.0, 1.0)的64位float随机值，返回值为float64 // 如果要产生负数到正数的随机值，只需要将生成的随机数减去相应数值即可 fmt.Println(rand.Intn(100) - 50) // [-50, 50)的随机值

2).使用Rand对象生成:

r := rand.New(rand.NewSource(time.Now().Unix())) fmt.Println(r.Int())       // 非负的int随机值，返回值为int fmt.Println(r.Intn(100))   // [0,100)的随机值，返回值为int fmt.Println(r.Int31())     // 非负的31位int随机值，返回值为int32 fmt.Println(r.Int31n(100)) // [0,100)的随机值，返回值为int32 fmt.Println(r.Int63())     // 非负的63位int随机值，返回值为int64 fmt.Println(r.Int63n(100)) // [0,100)的随机值，返回值为int64 fmt.Println(r.Float32())   // 取值范围在[0.0, 1.0)的32位float随机值，返回值为float32 fmt.Println(r.Float64())   // 取值范围在[0.0, 1.0)的64位float随机值，返回值为float64 // 如果要产生负数到正数的随机值，只需要将生成的随机数减去相应数值即可 fmt.Println(r.Intn(100) - 50) // [-50, 50)的随机值

----------------------------华丽分割线----------------------------

0.5.文件常用函数(2018.02.14)

使用之前请先引入：

import (     "fmt"     "os" )

1.建立与打开文件：

1).新建文件：

定义：根据提供的文件名创建一个新文件，返回一个文件对象，默认权限是0666，返回的文件对象是可读写的。

func Create(name string) (file *File, err Error){}

用法：

fileName := "E://wyw.txt" fout, err := os.Create(fileName)    //新建文件 if err != nil {     fmt.Println(err)     return } defer fout.Close()                         //关闭文件

2).打开文件：

定义：

函数1：该方法以只读方式打开一个名称为name的文件，内部实现其实调用了OpenFile。

func Open(name string) (file *File, err Error){}

函数2：打开名称为name的文件，flag是打开的方式，只读、读写等，perm是权限。

func OpenFile(name string, flag int, perm uint32) (file *File, err Error){}

用法：

fileName := "E://wyw.txt" fout, err := os.OpenFile(fileName, os.O_CREATE, 0666) if err != nil {     fmt.Println(err)     return } defer fout.Close()                          // 关闭文件

2.写文件：

方法1：写入[]byte类型的数据到文件。

func (file *File) Write(b []byte) (n int, err Error){}

方法2：从指定位置开始写入byte类型的信息。

func (file *File) WriteAt(b []byte, off int64) (n int, err Error){}

方法3：写入string数据到文件。

func (file *File) WriteString(s string) (ret int, err Error){}

 

3.读文件：

方法1：读取数据到[]byte中。

func (file *File) Read(b []byte) (n int, err Error){}

方法2：从off开始读取数据到[]byte中。

func (file *File) ReadAt(b []byte, off int64) (n int, err Error){}

 

4.删除文件：

函数1：调用该函数就可以删除文件名为name的文件。

func Remove(name string) Error{}

用法：

os.Remove("E://wyw.txt")

函数2：调用该函数就可以删除目录名为path的目录。

func RemoveAll(path string) Error{}

用法：

os.RemoveAll("E://path")

5.案例：

1).写文件：

package main import (     "bufio"     "fmt"     "os" ) func main() {     fileName := "E://wyw.txt"     fout, err := os.Create(fileName)  //新建文件     if err != nil {         fmt.Println(err)         return     }     defer fout.Close()       //关闭文件     //方法1：写入string数据到文件     for i := 0; i < 5; i++ {         outstr := fmt.Sprintf("%s:%d\n", "Hello go", i)         fout.WriteString(outstr)     }     //方法2：写入[]byte类型的数据到文件     for i := 0; i < 5; i++ {         fout.Write([]byte("abcd\n"))     }     //方法3：从指定位置开始写,位置从0开始     fout.WriteAt([]byte("123456789"), 5)     //方法4：利用缓冲写数据,返回写入字节个数(一个中文3个字节)     w := bufio.NewWriter(fout)     n4, err3 := w.WriteString("缓冲：bufferedn")     fmt.Println(n4)     if err3 != nil {         fmt.Println(err3)         return     }     w.Flush() }

wyw.txt内容如下（换行也会当成一个字符被替换掉）：

Hello123456789lo go:1

Hello go:2

Hello go:3

Hello go:4

abcd

abcd

abcd

abcd

abcd

缓冲：bufferedn

2).读文件：

package main import (     "fmt"     "os" ) func main() {     fileName := "E://wyw.txt"     fin, err := os.Open(fileName)     //打开文件     if err != nil {         fmt.Println(err)     }     defer fin.Close()     buf := make([]byte, 1024)        //开辟1024个字节的slice作为缓冲     for {         n, _ := fin.Read(buf)             //读文件         if n == 0 {                            //0表示已经到文件结束             break         }         fmt.Println(string(buf))        //输出读取的内容     }     }

6.常用函数封装（见附件）：

package util import (     "errors"     "io"     "io/ioutil"     "os"     "path/filepath" ) /*    1.根据文件全路径读取文件内容    @filename文件全路径 */ func ReadFileContent(filename string) (string, error) {     //读取文件中的所有数据，返回([]byte, error)     content, err := ioutil.ReadFile(filename)     if err != nil {         return "", errors.New("读取失败，发生错误！")     }     return string(content), nil } /*    2.判断目录或文件是否存在    @path 文件/目录的路径 */ func IsPathOrFileExists(path string) (bool, error) {     _, err := os.Stat(path)                     //os.Stat()这个函数是获取文件的信息(fi FileInfo, err error)     if err != nil || os.IsNotExist(err) {     //看返回的错误信息是否不存在，ture不存在，false存在         return false, nil     }     return true, err } /*    3.创建文件目录    @filepath 要被创建的目录 */ func CreateDir(filepath string) (bool, error) {     _, err := os.Stat(filepath)        //os.Stat()这个函数是获取文件的信息(fi FileInfo, err error)     if err == nil || !os.IsNotExist(err) {         return false, errors.New("目录已存在！")     }     // 级联创建目录     err = os.MkdirAll(filepath, 0666)     if err != nil {         return false, errors.New("目录创建失败！")     }     return true, nil } /*    4.拷贝文件    @source 源文件    @dest  目标文件 */ func CopyFile(source string, dest string) (err error) {     sf, err := os.Open(source)   //读取源文件，返回(*File, error)     if err != nil {         return err     }     defer sf.Close()     df, err := os.Create(dest)    //创建目标文件     if err != nil {         return err     }     defer df.Close()     _, err = io.Copy(df, sf)       //复制文件     if err == nil {         fi, err := os.Stat(source)         if err != nil {             err = os.Chmod(dest, fi.Mode())         }     }     return } /*    5.拷贝目录（包括其下所有子孙目录和文件）    @source 源目录    @dest  目标目录 */ func CopyDir(source string, dest string) (err error) {     fi, err := os.Stat(source) //获取源目录     if err != nil {         return err     }     if !fi.IsDir() {         //返回自定义的错误提示         return errors.New(source + " 不是一个目录")     }     err = os.MkdirAll(dest, fi.Mode())    //创建和源目录权限一致的文件夹     if err != nil {         return err     }     entries, err := ioutil.ReadDir(source)    //读取目录下的所有文件,返回([]os.FileInfo, error)     for _, entry := range entries {         //fmt.Println("这是一个os.FileInfo: ", entry.Name(), entry.IsDir(), entry.Mode(), entry.ModTime(), " 大小：", entry.Size(), " Sys:", entry.Sys())         sfp := filepath.Join(source, entry.Name())    //将源目录和文件/下层目录拼接在一起         dfp := filepath.Join(dest, entry.Name())         if entry.IsDir() {             err = CopyDir(sfp, dfp)    //递归             if err != nil {                 return err             }         } else {             err = CopyFile(sfp, dfp)             if err != nil {                 return err             }         }     }     return nil }

使用上面封装的函数：

package main import (     "fmt"     "io/ioutil"     "os"     "util" ) func main() {     fileName := "E://wyw.txt"     filePath := "E://path//wang//you//wen//"     //1.读取文件内容     content, err := util.ReadFileContent(fileName)     if err != nil {         fmt.Println("文件读取错误：", err)     } else {         fmt.Println(content)     }     //2.判断文件是否存在     isExists, _ := util.IsPathOrFileExists(fileName)     fmt.Println(isExists)     //3.创建目录     createOk, err1 := util.CreateDir(filePath)     if err1 != nil {         fmt.Println("创建目录失败：", err1)     } else {         fmt.Println(createOk)     }     //4.复制文件     err = util.CopyFile(fileName, filePath+"//wyw888.txt")     if err == nil {         fmt.Println("文件复制成功！")     }     //5.复制目录     err = util.CopyDir("E://path", "E://path1")     if err == nil {         fmt.Println("文件夹复制成功！")     }     /* 6.往文件中写入内容        WriteFile 向文件 filename 中写入数据 data,        如果文件不存在，则以 perm 权限创建该文件        如果文件存在，则先清空文件，然后再写入        返回：error     */     data := []byte("Hello World!\n第二行222\n第三行333\n第4行")     err2 := ioutil.WriteFile(fileName, data, os.ModeAppend)     if err2 == nil {         fmt.Println("写入成功！")     }    workdir, _ := os.Getwd()   //获取项目目录     fmt.Println(workdir)   //F:\godevelop\test\src     //将"E://www"整个目录压缩到"E://test"目录下，命名为wywtar.tar.gz     util.Dirtotar("E://www", "E://test", "wywtar") //该方法参考附件文件 }

注：有些方法未列出，具体内容请参考fileUtil.go文件。

----------------------------华丽分割线----------------------------

 0.6.日期与时间常用函数(2018.02.15)

使用之前请先引入：

import (     "time" )

1.获取当前本地时间：

now := time.Now()      //2018-03-30 10:13:08.1173064 +0800 CST m=+0.064003701

2.获取当前本地时间戳：

s := time.Now().Unix()            //精确到秒:1522375988 ns := time.Now().UnixNano() //精确到纳秒:1522375988117306400 m := ns / 1e6                        //纳秒转毫秒:1522375988117 s1 := ns / 1e9                        //纳秒转秒:1522375988

3.时间戳转本地时间：

t := time.Unix(1469579899, 0)     //2016-07-27 08:38:19 +0800 CST y := t.Year()        //2016 m := t.Month()   //7 d := t.Day()         //27 h := t.Hour()       //8 mi := t.Minute()  //38 s := t.Second()    //19

4.当前时间格式化为字符串：

t := time.Now().Format("2006-01-02 15:04:05")    //2018-03-30 10:13:08 // 对精确到秒的时间戳进行格式化 t1 := time.Unix(1469579899, 0).Format("2006-01-02 15:04:05")   //2016-07-27 08:38:19 // 对精确到纳秒的时间戳进行格式化 t2 := time.Unix(0, 1522375988117306400).Format("2006-01-02 15:04:05")   //2018-03-30 10:13:08

注：Format("2006-01-02 15:04:05") 是固定写法，不要修改里面的数字。

5.字符串转为时间：

//time.Parse将字符串转为时间 t2, _ := time.Parse("2006-01-02 15:04:05", "2016-07-27 08:46:15") //2016-07-27 08:46:15 +0000 UTC t2.Unix()       //1469609175 //t2是否在当前时刻之前 t2.Before(time.Now())        //true //t2是否在当前时刻之后 t2.After(time.Now())         //false //获取3天之后的时间 t2.Add(3 * 24 * time.Hour)    //2016-07-30 08:46:15 +0000 UTC //增加日期（年，月，日） t2.AddDate(1, 2, 3)               //2017-09-30 08:46:15 +0000 UTC //返回现在跟t2之间的时间差 time.Now().Sub(t2)              //14658h26m36.8672852s //时间转字符串 t2.String()                           //2016-07-27 08:46:15 +0000 UTC

6.定时休眠：

// 休眠1秒 time.Sleep(1 * time.Second) // 休眠100毫秒 time.Sleep(100 * time.Millisecond)

----------------------------华丽分割线----------------------------

0.7.异常处理(2018.02.16)

使用之前请先引入：

import (     "fmt"     "errors" )

1.error：

使用错误的两种方法：

var err1 error = errors.New("a normal err1")    //常用 var err2 error = fmt.Errorf("%s", "a normal err2")

案例：

package main import (     "errors"     "fmt" ) func main() {     var err1 error = errors.New("a normal err1")     fmt.Println(err1)      //a normal err1     var err2 error = fmt.Errorf("%s", "a normal err2")     fmt.Println(err2)     //a normal err2 }

2.panic：

我们不应通过调用panic函数来报告普通的错误，而应该只把它作为报告致命错误的一种方式。即：错误用error，中断程序用panic。

package main import (     "fmt" ) func TestA() {     fmt.Println("func TestA()") } func TestB(a, b int) int {     if b == 0 {         panic("divide by zero: panic")     }     return a / b } func TestC() {     fmt.Println("func TestC()") } func main() {     TestA()     TestB(1, 0)    //TestB()发生异常，中断程序     TestC() }

结果如下：

3.recover：

运行时panic异常一旦被引发就会导致程序崩溃。如果想当前的程序从运行时panic的状态中恢复并重新获得流程控制权,可以使用recover函数。注意：recover只有在defer调用的函数中有效。

package main import (     "fmt" ) func TestA() {     fmt.Println("func TestA()") } func TestB() (err error) {     defer func() { //在发生异常时，设置恢复         if x := recover(); x != nil {             err = fmt.Errorf("internal error: %v", x)         }     }()     panic("func TestB(): panic") } func TestC() {     fmt.Println("func TestC()") } func main() {     TestA()     err := TestB()     fmt.Println(err)     TestC() }

运行结果：

func TestA()

internal error: func TestB(): panic

func TestC()

扫一扫 关注我