本文介绍go语言处理字符串类型的常见函数。
## 多行字符串
在 Go 中创建多行字符串非常容易。只需要在你声明或赋值时使用 (``) 。
```
str := `This is a
multiline
string.`
```
## 字符串的拼接
```go
// fmt.Sprintf方式拼接字符串
str1 := "abc"
str2 := "def"
str1_2 := fmt.Sprintf("%s%s", str1, str2)
fmt.Printf("str1_2: %s\n", str1_2) //abcdef
// strings.join方式
collectstring1 := strings.Join([]string{"aaa", "bbb", "ccc"}, "-")
fmt.Printf(collectstring1) // aaa-bbb
fmt.Println()
```
## 字符串的类型转换
### 其他类型转换为字符串-formatint
- FormatFloat接受4个参数，第一个参数就是待转换的浮点数，第二个参数表示我们希望转换之后得到的格式。一共有'f', 'b', 'e', 'E', 'g', 'G'这几种格式。
'f' 表示普通模式：（-ddd.dddd）
'b' 表示指数为二进制：（-ddddp±ddd）
'e' 表示十进制指数，也就是科学记数法的模式：(-d.dddde±dd)
'E' 和'e'一样，都是科学记数法的模式，只不过字母e大写：(-d.ddddE±dd)
'g' 表示指数很大时用'e'模式，否则用‘f'模式
'G' 表示指数很大时用’E'模式，否则用'f'模式
```go
// int 转化为字符串
var num1 int = 99
str := fmt.Sprintf("%d", num1)
fmt.Printf("str type %T str=%q\n", str, str) // str type string str="99"
var myChar byte = 'h'
str = fmt.Sprintf("%c", myChar)
fmt.Printf("str type %T str=%q\n", str, str) // str type string str="h"
var num2 int = 99
// 转换为2进制格式的字符串
str = strconv.FormatInt(int64(num2), 2)
fmt.Printf("str type %T str=%q\n", str, str) //str type string str="1100011"
// 转换为10进制格式的字符串
str = strconv.FormatInt(int64(num2), 10)
fmt.Printf("str type %T str=%q\n", str, str) //str type string str="99"
var num3 float32 = 23.2424
// f 表示格式，2表示保留位数，64 表示这个num3是float32
str = strconv.FormatFloat(float64(num3), 'f', 2, 32)
fmt.Printf("str type %T str=%q\n", str, str) //str type string str="23.24"
var num4 bool = true
str = strconv.FormatBool(num4)
fmt.Printf("str type %T str=%q\n", str, str) //str type string str="true"
var num5 = 99
str = strconv.Itoa(num5)
fmt.Printf("str type %T str=%q\n", str, str) //str type string str="99"
```
### 字符串转换为其他类型-parseint
- 转为int
```go
var str1 string = "99"
// ParseInt返回的是int64
n1, _ := strconv.ParseInt(str1, 10, 0)
fmt.Printf("n1 type %T n1=%v\n", n1, n1) // n1 type int64 n1=99
```
- 转为float
```go
var str2 string = "99.2"
// 2表示保留小数点位数
n2, _ := strconv.ParseFloat(str2, 2)
fmt.Printf("n2 type %T n1=%v\n", n2, n2) // n2 type float64 n1=99.2
```
- 换为bool
```go
var str string = "true"
b, _ := strconv.ParseBool(str)
fmt.Printf("b type %T b=%v\n", b, b)
```
## 字符串的比较-compare
语法:
`cmp := strings.Compare(str1, str2)`
cmp等于-1表示str1字典序小于str2，如果str1和str2相等，cmp等于0。如果cmp=1，表示str1字典序大于str2.
```go
// 字符串必须
fmt.Println(strings.Compare("abb", "bbb")) //-1
fmt.Println(strings.Compare("cbb", "bbb")) //1
fmt.Println(strings.Compare("bbb", "bbb")) //0
```
## 查找字符串的字串-index
`var theInd = strings.Index(str, "sub")`
我们可以用Index函数查找一个字符串中子串的位置，它会返回第一次出现的位置，如果不存在返回-1.
`var theLastIdx = strings.LastIndex(str, "last")`
类似的方法是LastIndex，它返回的是出现的最后一个位置，同样，如果不存在返回-1.
```
// 字符串查找是第几个字符
fmt.Println(strings.Index("yes hello world hello", "hello")) //4,第一次出现的位置，是第4个字符
fmt.Println(strings.Index("yes hello world hello", "Hello")) //-1 没找到
fmt.Println(strings.LastIndex("yes hello world hello", "hello")) //16,最后一次出现的位置，第16个字符
fmt.Println(strings.LastIndex("yes hello world hello", "Hello")) //-1 没找到
```
## 统计字串的次数-count/repeat
`strings.Count("abcabcabababc", "abc") `
第一个参数是母串，第二个参数是子串。如果子串为空，则返回母串的长度+1.
`repeat := strings.Repeat("abc", 10)`
用Repeat方法来讲字符串重复指定的次数
```go
// 字串出现次数
fmt.Println(strings.Count("abcabcabc", "abc")) //3
fmt.Println(strings.Count("abcabcabc", "abcd")) //0
fmt.Println(strings.Count("abcabcabc", "")) //结果为字符串长度加1=10
// 字符串复制多次
fmt.Println(strings.Repeat("abc", 3)) //abcabcabc
fmt.Println(strings.Repeat("abc", 0)) //空串
fmt.Println(strings.Repeat("abc", 1)) //abc
```
## 字符替换-replace
Replace函数接收四个参数，分别是字符串，匹配串和目标串，还有替换的次数。如果小于0，表示全部替换
```
// 字符串替换
fmt.Println(strings.Replace("abcdabcd", "ab", "bb", 1)) //只替换一次，bbcdabcd
fmt.Println(strings.Replace("abcdabcd", "ab", "bb", -1)) //bbcdbbcd
fmt.Println(strings.Replace("abcd ab cd", " ", "", -1)) //去掉空格,结果为bbcdbbcd
```
## 字符串与切片的转换-split/join/fields
```
// split，字符串转换为slice
fmt.Println(strings.Split("abc,def,xyz", ",")) //["abc","def","xyz"]
// slice切片组合成字符串
slice1 := []string{"abc", "def", "xyz"}
fmt.Println(strings.Join(slice1, ","))//abc,def,xyz
```
`func Fields(s string) []string`
去除 s 字符串的空格符，并且按照空格分割返回 slice
```
fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))
// Output:Fields are: ["foo" "bar" "baz"]
```
## 去掉头尾字符Trim
```go
//去掉头尾字符串
fmt.Println(strings.Trim("$ab$cd$", "$")) //ab$cd
fmt.Println(strings.TrimRight("$abcd$", "$")) //$abcd
fmt.Println(strings.TrimLeft("$abcd$", "$")) //abcd$
```
## 大小写转换
```go
// 大小写转换
fmt.Println(strings.ToLower("Golang")) //golang
fmt.Println(strings.ToUpper("Golang")) //GOLANG
```
## 判断是否包含字串-contains
```go
// 判断包含字串
fmt.Println(strings.Contains("hello world", "hello")) //true
fmt.Println(strings.Contains("hello world", "Hello")) //false
```
## 判断前缀与后缀---HasPrefix/HasSufix
```go
// 判断包含前缀与后缀
fmt.Println(strings.HasPrefix("present", "pre")) //true
fmt.Println(strings.HasSuffix("present", "sent")) //true
```
## 产生随机字符串
```go
var source = rand.NewSource(time.Now().UnixNano())
fmt.Println("source.Int63():", source.Int63()) //一个随机的int64数，2252798765959001229
```
```go
package main
import (
"fmt"
"math/rand"
"time"
)
/*
产生随机数的方法
*/
var source = rand.NewSource(time.Now().UnixNano())
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
func main() {
// 一个随机的int64数
fmt.Println("source.Int63():", source.Int63()) //一个随机的int64数，2252798765959001229
fmt.Println("int64(len(charset)):", int64(len(charset))) //62
fmt.Println(source.Int63() % int64(len(charset))) // 小于62位的数
fmt.Println(RandString(10))
}
func RandString(length int) string {
// 产生length长度的随机串
b := make([]byte, length)
for i := range b {
randInt64 := source.Int63()
b[i] = charset[randInt64%int64(len(charset))]
}
return string(b)
}
```
## 去掉开头或末尾几个字符串
```
// 截掉最后6个字符
podname := "virt-launcher-kvm-xianwei-test-31-nwdg5"
kvmname := podname[:len(podname)-6] //kvm-xianwei-test-31
```
