6. golang之字符串常用的系统函数（21个）

说明： 字符串在我们程序开发中，使用的是非常多的，常用的函数需要带着手册

1. 统计字符串的长度，按字节 len(str)

package main
import (
	"fmt"
)

func main() {
	// 1. 统计字符串的长度，按字节： len(str)
	// golang的编码统一为utf-8（ASCII的字符（字母和数字）占一个字节，汉字占3个字节）
	str := "hello北"
	fmt.Println("str len=",len(str)) // 8
}

2. 字符串遍历，同时处理有中文的问题  r := []rune(str)

package main
import (
	"fmt"
)

func main() {
	str2 := "hello北京"
	// 2. 字符串遍历，同时处理有中文的问题  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")

package main
import (
	"fmt"
	"strconv"
)

func main() {
	// 3. 字符串转整数： n, err := strconv.Atoi("12")
	n, err := strconv.Atoi("1234")
	if err != nil {
		fmt.Println("转换错误",err)
	} else {
		fmt.Println("转换的结果是：",n)
	}
}

4. 整数转字符串

package main
import (
	"fmt"
	"strconv"
)

func main() {
	// 4. 整数转字符串  str := strconv.Itoa(123456)
	str := strconv.Itoa(123456)
	fmt.Printf("str=%v, str=%T\n",str,str)
}

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

package main
import (
	"fmt"
)



func main() {
	// 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})

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

7. 十进制转二进制、八进制、十六进制： strconv.FormatInt(十进制数,要转换的进制类型)

package main
import (
	"fmt"
	"strconv"
)

func main() {
	// 7. 十进制 => 二进制、八进制、十六进制：str = strconv.FormatInt(123,2) // 2 -> 8, 16
	var str string
	// 十进制转二进制
	str = strconv.FormatInt(123,2)
	fmt.Printf("十进制转二进制 str=%v 转换后的类型为%T \n",str,str)
	// 十进制转八进制
	str = strconv.FormatInt(123,8)
	fmt.Printf("十进制转八进制 str=%v \n",str)
	// 十进制转十六进制
	str = strconv.FormatInt(123,16)
	fmt.Printf("十进制转十六进制 str=%v",str)
}

8. 查找子串是否在指定的字符串中出现： strings.Contains(指定字符串, 子串)  返回值为 Bool

package main
import (
	"fmt"
	"strings"
)

func main() {
	// 8. 查找子串是否在指定的字符串中：strings.Contains("seafood","foo")  true
	b := strings.Contains("seafood","food")
	fmt.Printf("b=%v\n",b) // true
	b = strings.Contains("seafood","mary")
	fmt.Printf("b=%v",b)  // false
}

9. 统计指定子串在指定字符串中的出现次数：strings.Count(指定字符串,指定子串)

package main
import (
	"fmt"
	"strings"
)

func main() {
	// 9. 统计一个字符串中有几个指定的子串：strings.Count(指定的字符串,指定的子串)
	num := strings.Count("chinese","e")
	fmt.Printf("num=%v \n",num)
}

10. 不区分字母大小写的字符串比较: strings.EqualFold(字符串1,字符串2)

package main
import (
	"fmt"
	"strings"
)

func main() {
	// 10. 不区分字母大小写的字符串比较: strings.EqualFold(字符串1,字符串2)
	// 用  == 判断可以区分字母大小写进行字符串比较
	b := strings.EqualFold("abc", "ABC")
	fmt.Printf("b=%v",b)
}

11.  返回子串在字符串中第一次出现的起始index值，如果没有则返回-1：strings.Index(目标字符串,查询的子串)

package main
import (
	"fmt"
	"strings"
)
func main() {
	// 11. 返回子串在字符串中第一次出现的index，如果没有则返回-1：strings.Index(目标字符串,查询的子串)
	index := strings.Index("NLT_abcabcabc","abc")
	fmt.Printf("index=%v",index)
}

12. 返回子串在字符串中最后一次出现的起始index值，如果没有则返回-1：strings.LastIndex(目标字符串, 子串)

package main
import (
	"fmt"
	"strings"
)
func main() {
	// 12. 返回子串在字符串中最后一次出现的index：strings.LastIndex(目标字符串,子串) 如果没有则返回-1
	index := strings.LastIndex("go lang,go lang,go lang,go lang","go lang")
	fmt.Printf("index=%v",index)
}

13. 将字符串中的指定子串替换成另一个子串（不改变原有字符串，生成一个新的字符串）: strings.Replace(指定字符串,指定字符串中需要被替换的子串,替换的子串内容,n) n代表替换的个数，若n为-1则代表替换全部

package main 
import (
	"fmt"
	"strings"
)

func main() {
	// 13. 将字符串中的指定子串替换成另一个子串（不改变原有字符串，生成一个新的字符串）: strings.Replace(指定字符串,指定字符串中需要被替换的子串,替换的子串内容,n) n代表替换的个数，若为-1则为全部替换
	str1 := "go hello go hello go hello"
	str2 := strings.Replace(str1,"go","go语言",1)
	fmt.Printf("str2=%v \n",str2)
	str2 = strings.Replace(str1,"go","go语言",2)
	fmt.Printf("str2=%v \n",str2)
	str2 = strings.Replace(str1,"go","go语言",-1)
	fmt.Printf("str2=%v \n",str2)
}

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

package main
import (
	"fmt"
	"strings"
)

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

15. 将指定字符串中的字母转换为大写或小写：不改变原字符串

        1）将指定字符串中的字母转为大写：strings.ToUpper(指定字符串)

        2）将指定字符串中的字母转为小写：strings.ToLower(指定字符串)

package main
import (
	"fmt"
	"strings"
)
func main() {
	// 15. 将字符串的字母进行大小写的转换：不改变原字符串
	// 	1）将字符串的字母转为小写：  strings.ToLower(指定字符串)
	// 	2）将字符串的字母转为大写：strings.ToUpper(指定字符串)
	str := "GoaA"
	str2 := strings.ToLower(str)
	fmt.Printf("str=%v,str2=%v \n",str,str2)
	str2 = strings.ToUpper(str)
	fmt.Printf("str=%v,str2=%v",str,str2)
}

16. 将字符串左右两边的空格去掉： strings.TrimSpace(指定字符串) 不会改变原字符串

17. 将字符串左右两边指定的字符去掉： strings.Trim(指定字符串,指定去掉的字符) 不会改变原字符串

18. 将字符串左边指定的字符去掉： strings.TrimLeft(指定字符串，指定去掉的字符) 不会改变原字符串

19. 将字符串右边指定的字符去掉：strings.TrimRight(指定字符串,指定去掉的字符) 不会改变原字符串

20. 判断字符串是否以指定的字符串开头： strings.HasPrefix(指定字符串,指定开头字符串) 返回Bool

21. 判断字符串是否以指定的字符串结束：strings.HasSuffix(指定字符串,指定结尾字符串)

package main
import (
	"fmt"
	"strings"
)

func main() {
	// 16. 将字符串左右两边的空格去掉： strings.TrimSpace(指定字符串) 不会改变原字符串
	str1 := "  hello world  "
	res1 := strings.TrimSpace(str1)
	fmt.Printf("str1=%q，res1 = %q \n",str1,res1)

	// 17. 将字符串左右两边指定的字符去掉： strings.Trim(指定字符串,指定去掉的字符) 不会改变原字符串
	str2 := "!!!!hello !!!!"	
	res2 := strings.Trim("!hello!!","!")
	fmt.Printf("str2=%q,res2=%q \n",str2,res2)

	// 18. 将字符串左边指定的字符去掉： strings.TrimLeft(指定字符串，指定去掉的字符) 不会改变原字符串
	str3 := "!!hello!!"
	res3 := strings.TrimLeft(str3,"!")
	fmt.Printf("str3=%q, res3=%q \n",str3,res3)

	// 19. 将字符串右边指定的字符去掉：strings.TrimRight(指定字符串,指定去掉的字符) 不会改变原字符串
	str4 := "!!!!hello!!"
	res4 := strings.TrimRight(str4,"!")
	fmt.Printf("str4=%v,res4=%v \n",str4,res4)

	// 20. 判断字符串是否以指定的字符串开头： strings.HasPrefix(指定字符串,指定开头字符串) 返回Bool
	str5 := "ftp://192.168.10.1"
	res5 := strings.HasPrefix(str5,"ftp")
	fmt.Printf("是否以ftp开头%, res5=%v \n",res5)

	// 21. 判断字符串是否以指定的字符串结束：strings.HasSuffix(指定字符串,指定结尾字符串)
	str6 := "ftp://192.168.10.1"
	res6 := strings.HasSuffix(str6,"1025")
	fmt.Printf("是否以指定字符串结尾：res6=%v",res6)
}