Golang标准文档库

1、func len(v Type) int

内建函数len返回 v 的长度，这取决于具体类型：
数组：v中元素的数量
数组指针：v中元素的数量（v为nil时panic）
切片、映射：v中元素的数量；若v为nil，len(v)即为零
字符串：v中*字节的数量， 汉字占用三个字节
通道：通道缓存中队列（未读取）元素的数量；若v为 nil，len(v)即为零

2、字符串遍历

处理含有中文的情况，汉字占3个字节
转成切片： str2 := []rune(str)

func main() {
    name := "xiao"
    name01 := "xiao肖"
    fmt.Println("name len=", len(name))     // name len= 4
    fmt.Println("name01 len=", len(name01)) // name len= 7 // 一个汉字占三个字节
    _name := []rune(name01)                 // str 转成 []rune 切片
    fmt.Printf("%T %v \n", _name, _name)
    for i := 0; i < len(name01); i++ {
        fmt.Printf("name01[%v] = %v \n", i, name01[i])
    }
}
[]int32 [120 105 97 111 32918] //  []rune(name01)  按字符切片
name01[0] = 120
name01[1] = 105
name01[2] = 97
name01[3] = 111
name01[4] = 232
name01[5] = 130
name01[6] = 150
%c  该值对应的unicode码值
// 修改之后
name01 := "xiao肖"
_name := []rune(name01)                 // str 转成 []rune 切片
fmt.Printf("%T %v \n", _name, _name)
for i := 0; i < len(_name); i++ {
  fmt.Printf("_name[%v] = %c \n", i, _name[i])
}
[]int32 [120 105 97 111 32918]
_name[0] = x
_name[1] = i
_name[2] = a
_name[3] = o
_name[4] = 肖

3、func Atoi(s string) (i int, err error)

strconv包
Atoi是ParseInt(s, 10, 0)的简写。

字符串转数字

// 字符串转数字
n, err := strconv.Atoi("123a")
if err != nil {
  fmt.Println("转换错误", err)
} else {
  fmt.Println("转化成功")
  fmt.Println("n = ", n, " err = ", err)
}
// 转换错误 strconv.Atoi: parsing "123a": invalid syntax

4、func Itoa(i int) string

strconv包
Itoa是FormatInt(i, 10) 的简写。

数字转字符串

// 整数转字符串
str := strconv.Itoa(123)
fmt.Printf("str 类型：%T, 值：%s", str, str)
// str 类型：string, 值：123

5、字符串转 []byte

// 字符串转 []byte
var bytes = []byte("hello go")
fmt.Printf("bytes类型： %T, 值： %v \n", bytes, bytes)
// ascii
// bytes类型： []uint8, 值： [104 101 108 108 111 32 103 111]

6、[]byte 转字符串

var str = string([]byte{97, 98, 99})
fmt.Printf("str类型： %T, 值： %s", str, str)
// ascii码对应的字符
// str类型： string, 值： abc

7、十进制转 2 、8 、16进制

strconv包
func FormatInt(i int64, base int) string
返回i的base进制的字符串表示。base 必须在2到36之间，结果中会使用小写字母’a’到’z’表示大于10的数字。

var n1 = strconv.FormatInt(8, 2)
fmt.Printf("n1类型： %T, 值： %v", n1, n1)
// 十进制8对应的2进制的字符串 1000
// n1类型： string, 值： 1000

8、查找字符串是否包含某个子串

strings包
func Contains(s, substr string) bool
判断字符串s是否包含子串substr。

// 查找字符串是否包含某个子串
var isHasStr = strings.Contains("hello go", "go")
fmt.Printf("isHasStr类型： %T, 值： %v \n", isHasStr, isHasStr)
// isHasStr类型： bool, 值： true

9、统计一个字符串中有几个指定的子串

子串不重复出现的次数
strings包
func Count(s, sep string) int
返回字符串s中有几个不重复的sep子串。没有则返回0

var n2 = strings.Count("xiaoxiaoxiao", "xiao")
fmt.Println("n2 = ", n2)
// n2 =  3

10、不区分大小写的字符串比较（==区分大小写）

strings包
func EqualFold(s, t string) bool
判断两个utf-8编码字符串（将unicode大写、小写、标题三种格式字符视为相同）是否相同。

var b2 = strings.EqualFold("abc", "ABC")
fmt.Println("b2 = ", b2)
var b3 = ("abc" == "ABC")
fmt.Println("b3 = ", b3)
// b2 =  true    
// b3 =  false

11、返回子串在字符串第一次出现的index的值

如果没有，则返回 -1 （也可以用来判断是否包含子串）
strings包
func Index(s, sep string) int
子串sep在字符串s中第一次出现的位置，不存在则返回-1。
按字节位置输出

var n3 = strings.Index("hello,go", "go")
fmt.Println("n3 = ", n3)
// n3 =  6
var n3 = strings.Index("hello,你好", "好")
fmt.Println("n3 = ", n3)
// n3 =  9 // 一个汉字三个字节

12、返回子串在字符串最后一次出现的index的值

如果没有，则返回 -1 （也可以用来判断是否包含子串）
strings包
func LastIndex(s, sep string) int
子串sep在字符串s中最后一次出现的位置，不存在则返回-1。

var n4 = strings.LastIndex("hello,你好好", "好")
fmt.Println("n4 = ", n4)
// n4 =  12

13、将指定的子串替换成另一个子串

strings包
不改变原始字符串
func Replace(s, old, new string, n int) string
返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。

fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2)) // 替换前两个
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1)) // 替换所有
// oinky oinky oink
// moo moo moo
str02 := "go go hello"
str03 := strings.Replace(str02, "go", "北京", 2)
fmt.Println("str03= ", str03)
fmt.Println("str02= ", str02)
// str03=  北京 北京 hello
// str02=  go go hello

14、按照指定字符进行字符串分割

将一个字符串拆成字符串数组（切片）
string包
func Split(s, sep string) []string
不会改变原始字符串
用去掉s中出现的sep的方式进行分割，会分割到结尾，并返回生成的所有片段组成的切片（每一个sep都会进行一次切割，即使两个sep相邻，也会进行两次切割）。如果sep为空字符，Split会将s切分成每一个unicode码值一个字符串。

var strArr = strings.Split("go,go,hello", ",")
fmt.Printf("strArr类型： %T, 值： %v \n", strArr, strArr)
for i := 0; i < len(strArr); i++ {
  fmt.Printf("第%v个，%v \n", i, strArr[i])
}
// strArr类型： []string, 值： [go go hello]
第0个，go
第1个，go
第2个，hello

15、字符串字母大小写转换

strings包
不会改变原始字符串
func ToLower(s string) string
返回将所有字母都转为对应的小写版本的拷贝。
func ToUpper(s string) string
返回将所有字母都转为对应的大写版本的拷贝。

// 字符串大小写转化
var tmp = "HELLO"
var tmp01 = "abc"
var str04 = strings.ToLower(tmp)
fmt.Println("str04 = ", str04)
fmt.Println("tmp = ", tmp)
var str05 = strings.ToUpper(tmp01)
fmt.Println("str05 = ", str05)
fmt.Println("tmp01 = ", tmp01)
str04 =  hello
tmp =  HELLO
str05 =  ABC
tmp01 =  abc

16、去掉字符串左右两边的空格

strings包
不会改变原始字符串
func TrimSpace(s string) string
返回将s前后端所有空白（unicode.IsSpace指定）都去掉的字符串。

%q    该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
var str06 = "    hello, 小伙子   "
var newstr06 = strings.TrimSpace(str06)
fmt.Printf("newstr06 = %q \n", newstr06)
fmt.Printf("str06 = %q", str06)
// newstr06 = "hello, 小伙子"
// str06 = "    hello, 小伙子   "

17、去掉字符串两边指定的字符

strings包
不改变原始字符串
func Trim(s string, cutset string) string
返回将s前后端所有cutset包含的utf-8码值都去掉的字符串。

fmt.Printf("[%q]", strings.Trim(" !!! Achtung! Achtung! !!! ", "! "))
fmt.Printf("[%q]", strings.Trim(" !!! Achtung! Achtung! !!! ", " !"))
// ["Achtung! Achtung"]
// ["Achtung! Achtung"]

18、去掉字符串左边指定的字符

strings包
不改变原始字符串
func TrimLeft(s string, cutset string) string
返回将s前端所有cutset包含的utf-8码值都去掉的字符串。

var str07 = "xxxhello,golang"
fmt.Printf("str07 = [%q]\n", strings.TrimLeft(str07, "x"))
// str07 = ["hello,golang"]

19、去掉字符串右边指定的字符

strings包
不改变原始字符串
func TrimRight(s string, cutset string) string
返回将s后端所有cutset包含的utf-8码值都去掉的字符串。

var str08 = "xxxhello,golang"
fmt.Printf("str08 = [%q]\n", strings.TrimRight(str08, "golang"))
// str08 = ["xxxhello,"]

20、判断字符串是否已指定字符串开头

strings包
func HasPrefix(s, prefix string) bool
判断s是否有前缀字符串prefix。

// 判断字符串是否已指定字符串开头
var b02 = strings.HasPrefix("hello,go", "he")
fmt.Println("b02 = ", b02)
b02 =  true

21、判断字符串是否已指定字符串结尾（后缀）

strings包
func HasSuffix(s, suffix string) bool
判断s是否有后缀字符串suffix。

// 判断字符串是否已指定字符串结束
var b03 = strings.HasSuffix("hello.go", ".go")
fmt.Println("b03 = ", b03)
b03 =  true