常用函数

字符串相关

1) 统计字符串的长度，按字节 len(str) golang //统计字符串的长度，按字节 len(str) //golang的编码统一为utf-8 (ascii的字符(字母和数字) 占一个字节，汉字占用3个字节) str := "hello北" fmt.Println("str len=", len(str)) // 8 2) 字符串遍历，同时处理有中文的问题 r := []rune(str)

```golang
str2 := "hello北京"
//字符串遍历，同时处理有中文的问题 r := []rune(str)
r := []rune(str2)
for i := 0; i < len(r); i++ {
    fmt.Printf("字符=%c\n", r[i])
}
```

3) 字符串转整数: n, err := strconv.Atoi("12")

```golang
//字符串转整数:    n, err := strconv.Atoi("12")
n, err := strconv.Atoi("123")
if err != nil {
    fmt.Println("转换错误", err)
}else {
    fmt.Println("转成的结果是", n)
}
```

4) 整数转字符串 str = strconv.Itoa(12345)

```golang
//4)整数转字符串  str = strconv.Itoa(12345)
str = strconv.Itoa(12345)
fmt.Printf("str=%v, str=%T\n", str, str)
```

5) 字符串 转 []byte: var bytes = []byte("hello go")

```golang
//5)字符串 转 []byte:  var bytes = []byte("hello go")
var bytes = []byte("hello go")
fmt.Printf("bytes=%v\n", bytes)
```

6) []byte 转 字符串: str = string([]byte{97, 98, 99})

```golang
//6)[]byte 转 字符串: str = string([]byte{97, 98, 99})
str = string([]byte{97, 98, 99}) 
fmt.Printf("str=%v\n", str)
```

7) 10 进制转 2, 8, 16 进制: str = strconv.FormatInt(123, 2) // 2-> 8 , 16

```golang
//10进制转 2, 8, 16进制:  str = strconv.FormatInt(123, 2),返回对应的字符串
str = strconv.FormatInt(123, 2)
fmt.Printf("123对应的二进制是=%v\n", str)
str = strconv.FormatInt(123, 16)
fmt.Printf("123对应的16进制是=%v\n", str)
```

8) 查找子串是否在指定的字符串中: strings.Contains("seafood", "foo") //true

```golang
//查找子串是否在指定的字符串中: strings.Contains("seafood", "foo") //true
b := strings.Contains("seafood", "mary")
fmt.Printf("b=%v\n", b) 
```

9) 统计一个字符串有几个指定的子串 ： strings.Count("ceheese", "e") //4

```golang
//统计一个字符串有几个指定的子串 ： strings.Count("ceheese", "e") //4
num := strings.Count("ceheese", "e")
fmt.Printf("num=%v\n", num)
```

10) 不区分大小写的字符串比较(== 是区分字母大小写的): fmt.Println(strings.EqualFold("abc", "Abc")) // true

```golang
//10)不区分大小写的字符串比较(==是区分字母大小写的): fmt.Println(strings.EqualFold("abc", "Abc")) // true

b = strings.EqualFold("abc", "Abc")
fmt.Printf("b=%v\n", b) //true

fmt.Println("结果","abc" == "Abc") // false //区分字母大小写
```

11) 返回子串在字符串第一次出现的 index 值，如果没有返回-1 : strings.Index("NLT_abc", "abc") // 4

```golang
//11)返回子串在字符串第一次出现的index值，如果没有返回-1 : 
//strings.Index("NLT_abc","abc") // 4

index := strings.Index("NLT_abcabcabc", "abc") // 4
fmt.Printf("index=%v\n",index)
```

12) 返回子串在字符串最后一次出现的 index，如没有返回-1 : strings.LastIndex("go golang", "go")

```golang
//12)返回子串在字符串最后一次出现的index，
//如没有返回-1 : strings.LastIndex("go golang", "go")

index = strings.LastIndex("go golang", "go") //3
fmt.Printf("index=%v\n",index)
```

13) 将指定的子串替换成 另外一个子串: strings.Replace("go go hello", "go", "go 语言", n) n 可以指定你希望替换几个，如果 n=-1 表示全部替换

```golang
//将指定的子串替换成 另外一个子串: strings.Replace("go go hello", "go", "go语言", n) 
//n可以指定你希望替换几个，如果n=-1表示全部替换

str2 = "go go hello"
str = strings.Replace(str2, "go", "北京", -1)
fmt.Printf("str=%v str2=%v\n", str, str2)
```

14) 按 照 指 定 的 某 个 字 符 ， 为 分 割 标 识 ， 将 一 个 字 符 串 拆 分 成 字 符 串 数 组 ： strings.Split("hello,wrold,ok", ",")

```golang
//按照指定的某个字符，为分割标识，将一个字符串拆分成字符串数组： 
//strings.Split("hello,wrold,ok", ",")
strArr := strings.Split("hello,wrold,ok", ",")
for i := 0; i < len(strArr); i++ {
    fmt.Printf("str[%v]=%v\n", i, strArr[i])
} 
fmt.Printf("strArr=%v\n", strArr)
```

15) 将字符串的字母进行大小写的转换: strings.ToLower("Go") // go strings.ToUpper("Go") // GO

```golang
//15)将字符串的字母进行大小写的转换: 
//strings.ToLower("Go") // go strings.ToUpper("Go") // GO

str = "goLang Hello"
str = strings.ToLower(str) 
str = strings.ToUpper(str) 
fmt.Printf("str=%v\n", str) //golang hello
```

16) 将字符串左右两边的空格去掉： strings.TrimSpace(" tn a lone gopher ntrn ")

```golang
//将字符串左右两边的空格去掉： strings.TrimSpace(" tn a lone gopher ntrn   ")
str = strings.TrimSpace(" tn a lone gopher ntrn   ")
fmt.Printf("str=%q\n", str)

```

17) 将字符串左右两边指定的字符去掉 ： strings.Trim("! hello! ", " !") // ["hello"] //将左右两边 !和 " "去掉

```golang
//17)将字符串左右两边指定的字符去掉 ： 
//strings.Trim("! hello! ", " !")  // ["hello"] //将左右两边 ! 和 " "去掉
str = strings.Trim("! he!llo! ", " !")
fmt.Printf("str=%q\n", str)
```

18) 将字符串左边指定的字符去掉 ： strings.TrimLeft("! hello! ", " !") // ["hello"] //将左边 ! 和 ""去掉

```golang
//将字符串左边指定的字符去掉 ： 
//strings.TrimLeft("! hello! ", " !")  // ["hello"] //将左两边 ! 和 " "去掉
str = strings.TrimLeft("! he!llo! ", " !")
fmt.Printf("str=%q\n", str)
```

19) 将字符串右边指定的字符去掉 ： strings.TrimRight("! hello! ", " !") // ["hello"] //将右边 ! 和 ""去掉

```golang
//将字符串右边指定的字符去掉 ： 
//strings.TrimRight("! hello! ", " !")  // ["hello"] //将右两边 ! 和 " "去掉
str = strings.TrimRight("! he!llo! ", " !")
fmt.Printf("str=%q\n", str)
```

20) 判断字符串是否以指定的字符串开头: strings.HasPrefix("ftp://192.168.10.1", "ftp") // true

```golang
//20)判断字符串是否以指定的字符串开头: 
//strings.HasPrefix("ftp://192.168.10.1", "ftp") // true

b = strings.HasPrefix("ftp://192.168.10.1", "hsp") //false
fmt.Printf("b=%v\n", b)
}
```

21) 判断字符串是否以指定的字符串结束: strings.HasSuffix("NLT_abc.jpg", "abc") //false

```golang
//判断字符串是否以指定的字符串结尾: 
//strings.HasSuffix("NLT_abc.jpg", "abc") // false

b = strings.HasSuffix("NLT_abc.jpg", "jpg") //true
fmt.Printf("b=%v\n", b)
}
```

时间日期相关

1) time.Time 类型，用于表示时间

```golang
//1. 获取当前时间
fmt.Printf("now=%v now type=%T\n", time.Now(), time.Now())
```

2) 如何获取到其它的日期信息

```golang
//2.通过time.now()可以获取到年月日，时分秒
fmt.Printf("年=%v\n", time.now().Year())
fmt.Printf("月=%v\n", time.now().Month())
fmt.Printf("月=%v\n", int(time.now().Month()))
fmt.Printf("日=%v\n", time.now().Day())
fmt.Printf("时=%v\n", time.now().Hour())
fmt.Printf("分=%v\n", time.now().Minute())
fmt.Printf("秒=%v\n", time.now().Second())
```

3) 格式化日期时间

```golang
//格式化日期时间

fmt.Printf("当前年月日 %d-%d-%d %d:%d:%d \n", time.now().Year(), 
time.now().Month(), time.now().Day(), time.now().Hour(), time.now().Minute(), time.now().Second())

dateStr := fmt.Sprintf("当前年月日 %d-%d-%d %d:%d:%d \n", time.now().Year(), 
time.now().Month(), time.now().Day(), time.now().Hour(), time.now().Minute(), time.now().Second())

fmt.Printf("dateStr=%v\n", dateStr)

//格式化日期时间的第二种方式
fmt.Printf(time.now().Format("2006-01-02 15:04:05"))
fmt.Println()
fmt.Printf(time.now().Format("2006-01-02"))
fmt.Println()
fmt.Printf(time.now().Format("15:04:05"))
fmt.Println()

fmt.Printf(time.now().Format("2006"))
fmt.Println() 
//"2006/01/02 15:04:05" 这个字符串的各个数字是固定的，必须是这样写。
//"2006/01/02 15:04:05" 这个字符串各个数字可以自由的组合，这样可以按程序需求来返回时间和日期
```

4) 时间的常量

```golang
const (
Nanosecond  Duration = 1 //纳秒
Microsecond = 1000 * Nanosecond //微秒
Millisecond = 1000 * Microsecond //毫秒Second     = 1000 * Millisecond //秒
Minute  = 60 * Second //分钟
Hour    = 60 * Minute //小时
)
// 常量的作用:在程序中可用于获取指定时间单位的时间，比如想得到 100 毫秒
// 100 * time. Millisecond
```

5) 结合 Sleep 来使用一下时间常量

```golang 
//需求，每隔1秒中打印一个数字，打印到100时就退出
//需求2: 每隔0.1秒中打印一个数字，打印到100时就退出
 i := 0
 for {
    i++
    fmt.Println(i)
    //休眠
    time.Sleep(time.Second)
    time.Sleep(time.Millisecond * 100)
    if i == 100 {
        break
    }
 }
```

6) time 的 Unix 和 UnixNano 的方法

```golang 
//Unix和UnixNano的使用
fmt.Printf("unix时间戳=%v unixnano时间戳=%v\n", now.Unix(), now.UnixNano())
```