字符串函数 (fmt/strconv/内置)

常用

• 部分内置函数 (无需导包)
• 部分strconv库
• 部分fmt库

// 遍历
for i, value := range str {}		// 字符串遍历 (按字符)，方式1
									// 方式2：字符串转切片再遍历

// 查 (只读，遍历/统计/查找/是否)
len(str)							// 统计字符串长度 (按字节)
...									// 统计字符串长度 (按字符)
strings.Count("js & golang", "a")	// 统计字符串子串
strings.Contains("js & go", "go")	// 查找子串是否在指定字符串
strings.lIndex("js & golang", "a")	// 查找子串第一次出现的索引值，若无则-1
strings.EqualFold("go", "Go")		// 是否两字符相同 (不区分大小写)
									// ^ 区分大小写直接用 `==`
strings.HasPrefix("http://", "ht")	// 是否以指定子串开头
strings.HasSuffix("http://", "//")	// 是否以指定子串结尾

// 改 (str -> str)
strings.Replace("js & go", "go", "golang", n)	// 字符串替换。n指定希望替换几个，-1全部替换
strings.ToLower("Go")				// 大小写转换
strings.ToUpper("go")				// ^
strings.TrimSpace(" go & java ")	// 去除左右空格
strings.Trim("~go~", "~")			// ^ 去除左右两边指定字符
strings.TrimLeft("~go~", "~")		// ^ 仅去除左边
strings.TrimRight("~go~", "~")		// ^ 仅去除右边

// 改 (类型转换)
n, err := strconv.Atoi("66")		// str转整数 (strconv库)
str = strconv.ltoa(6887)			// 整数转str (strconv库)
									// 			  更多互相转详见泛操作
strings.Split("go-py-js", "-")		// str转数组，通过分割标识
r := []rune(str)					// str转切片 (按字符)，可用于字符串遍历

数值与string 互相转化

两种方式：

1. fmt包的Sprinf函数：fmt.Sprintf("%参数", 表达式)，C语言中也有一个类似的函数

   // 数值转string
   var n1 int = 19
   var s1 string = fmt.Sprintf("%d", n1)
   fmt.Printf("s1类型 %T，值 %v", s1, s1)	// 类型 string，值 19
   
   // string转数值
   该方式没办法
   

2. strconv包的函数

   // 数值转string
   // 原型
   func FormatBool(b bool) string
   func FormatInt(i int64, base int) string	// base意思是几进制的
   func FormatUint(i uint64, base int) string
   func FormatFloat(f float64, fmt byte, prec, bitSize int) string
   
   // 使用
   import(
       "fmt"
       "strconv"
   )
   func main(){
       var n1 int = 18
       var s1 string = strconv.FormatInt(int64(n1), 10)
       fmt.Printf("s1类型 %T, 值 %q\n", s1, s1)	// string "18"
       
       var n2 float64 = 3.14
       var s2 string = strconv.FormatInt(n2, 'f', 9, 64)
       fmt.Printf("s2类型 %T, 值 %q\n", s2, s2)	// string "3.14"
   }
   
   // string转数值
   // 原型
   // 注意：与其他语言不同：这里可以双返回值，有点类似于Python的返回元组，而C/C++就做不到这点。传统的C/C++在这方面，错误处理要么通过抛出异常，要么通过errno，不太舒服
   func ParseBool(str string) (value bool, err error)
   func ParseInt(s string, base int, bitSize int) (i int64, err error)
   func ParseUint(s string, base int, bitSize int) (n uint64, err error)
   func ParseFloat(s string, bitSize int) (f float64, err error)
   
   // 使用
   import(
       "fmt"
       "strconv"
   )
   func main(){
       var s1 string = "ture"
   	var b1 bool
       b1, _ = strconv.ParseBool(s1)				// 这里可以忽略第二个返回值，即忽略错误
       fmt.Printf("b类型 %T, 值 %v\n", b1, b1)	  // bool true
       
       var s2 string = "19"
   	var n1 int64
       n1, _ = strconv.ParseInt(s1, 10, 64)		// 这里可以忽略第二个返回值，即忽略错误
       fmt.Printf("n1类型 %T, 值 %v\n", n1, n1)	  // int64 19
       
       var s3 string = "go"
   	var b3 bool
       b3, _ = strconv.ParseBool(s3)				// 这里是错误的，但忽略了错误。此时没转化成功，b3会被赋予默认值，即零值
       fmt.Printf("b类型 %T, 值 %v\n", b3, b3)	  // bool false
   }
   

在数值转string中，似乎fmt.Sprintf的方式会简单一些