本文介绍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

```