Go中字符串

字符串

在编写程序时，我们通常会使用字符串来进行文本处理

例如：

package main

import "fmt"

func main() {
	var name string = "alex"
	fmt.Printf(name)

	title := "生活要想过得去，头上总得带点绿"
	fmt.Printf(title)
}

字符串的底层存储

计算机中的所有操作和数据最终都是二进制，即100100001011
Go语言中的字符串是utf-8编码的序列
例如：

package main

import "fmt"

func main() {
    // unicode字符集：文字 -> 码点（ucs4, 4个字节表示）
    // utf-8编码，对unicode字符集的码点进行编码最终得到：1000100001
	var name string = "mashiro"
    fmt.Printf(name)
}

又例如：

package main

import (
	"fmt"
	"strconv"
	"unicode/utf8"
)

func main() {
	// 1. 本质是utf-8编码的序列
	var name string = "王大锤"

	// 王
	fmt.Println(name[0], strconv.FormatInt(int64(name[0]), 2))
	fmt.Println(name[1], strconv.FormatInt(int64(name[1]), 2))
	fmt.Println(name[2], strconv.FormatInt(int64(name[2]), 2))

	// 大
	fmt.Println(name[3], strconv.FormatInt(int64(name[3]), 2))
	fmt.Println(name[4], strconv.FormatInt(int64(name[4]), 2))
	fmt.Println(name[5], strconv.FormatInt(int64(name[5]), 2))

	// 锤
	fmt.Println(name[6], strconv.FormatInt(int64(name[6]), 2))
	fmt.Println(name[7], strconv.FormatInt(int64(name[7]), 2))
	fmt.Println(name[8], strconv.FormatInt(int64(name[8]), 2))

	// 2. 获取字符串的长度：9（字节长度）
	fmt.Println(len(name))

	// 3. 字符串转换为一个"字节集合"
	byteSet := []byte(name)
	fmt.Println(byteSet) // [230,173,166,230,178,155,233,189,144]

	// 4. 字节的集合转换为字符串
	byteList := []byte{230, 173, 166, 230, 178, 155, 233, 189, 144}
	targetString := string(byteList)
	fmt.Println(targetString)

	// 5. 将字符串转换为 unicode字符集码点的集合    
	tempSet := []rune(name)
	fmt.Println(tempSet) // [27494 27803 40784]
	fmt.Println(tempSet[0], strconv.FormatInt(int64(tempSet[0]), 16))
	fmt.Println(tempSet[1], strconv.FormatInt(int64(tempSet[1]), 16))
	fmt.Println(tempSet[2], strconv.FormatInt(int64(tempSet[2]), 16))

	// 6. "rune集合" 转换 为字符串
	runeList := []rune{27494, 27803, 40784}
	targetName := string(runeList)
	fmt.Println(targetName)

	// 7. 长度的处理（获取字符长度）
	runeLength := utf8.RuneCountInString(name)
	fmt.Println(runeLength)
}

字符串常见功能

字符串属于在程序中最常见常用的数据类型，所以Go中为字符串提供了很多常见的操作

获取长度

package main

import (
   "fmt"
   "unicode/utf8"
)

func main() {
   var name string = "王大锤"

   fmt.Println( len(name) )                    // 获取 字节 长度，输出：8
   fmt.Println( utf8.RuneCountInString(name) ) // 获取字符长度，输出：3
}

是否以xx开头

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "王大锤"

   result := strings.HasPrefix(name， "王")

   fmt.Println(result) // 输出：true

是否以xx结尾

package main

import (
	"fmt"
	"strings"
)

func main() {
	name := "王大锤"

	result := strings.HasSuffix(name, "锤")

	fmt.Println(result) // 输出：true
}

是否包含

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "你追我如果你追到我，我就让你嘿嘿嘿"
   result := strings.Contains(name, "嘿嘿嘿")

   fmt.Println(result) // 输出：true
}

变大写

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "mashiro"

   result := strings.ToUpper(name)

   fmt.Println(result) // 输出：MASHIRO
}
// 注意：result是大写；name依然是小写。

变小写

package main

import (
	"fmt"
	"strings"
)

func main() {
	name := "MASHIRO"

	result := strings.ToLower(name)

	fmt.Println(result) // 输出：mashiro
}

去两边

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "shinamashiro"

   result1 := strings.TrimRight(name, "mashiro") // 去除右边的mashiro
   result2 := strings.TrimLeft(name, "shina")   // 去除左边的shina
   result3 := strings.Trim(name, "s")       // 去除两边的w

   fmt.Println(result1, result2, result3) // 输出：shina mashiro hinamahiro

替换

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "mashiro"

   result1 := strings.Replace(name, "m", "M", 1)  // 找到m替换为M，从左到右找第一个替换
   result2 := strings.Replace(name, "o", "0", 2)  // 找到o替换为0，从左到右找前两个替换
   result3 := strings.Replace(name, "m", "M", -1) // 找到pei替换为PE，替换所有

   fmt.Println(result1, result2, result3)

分割

package main

import (
   "fmt"
   "strings"
)

func main() {
   name := "我就让你嘿嘿嘿"
   result := strings.Split(name, "你")

   // 根据`你`进行切割，获取一个切片（类似于一个数组）
   fmt.Println(result) // [ 我就让, 嘿嘿嘿]
}

拼接

可以使用 + 让两个字符串进行拼接，但这样的拼接效率会非常的低，不建议使用，建议大家使用以下的方式：

package main

import (
	"bytes"
	"fmt"
	"strings"
)

func main() {
	// 不建议
	message := "我爱" + "北京天安门"
	fmt.Println(message)

	// 建议：效率高一些
	dataList := []string{"我爱", "北京天安门"}
	result := strings.Join(dataList, "")
	fmt.Println(result) // 我爱北京天安门

	// 建议：效率更高一些（go 1.10之前）
	var buffer bytes.Buffer
	buffer.WriteString("你想")
	buffer.WriteString("我干")
	buffer.WriteString("他")
	data := buffer.String()
	fmt.Print(data)

	// 建议：效率更更更更高一些（go 1.10之后）
	var builder strings.Builder
	builder.WriteString("哈哈哈")
	builder.WriteString("去你的吧")
	value := builder.String()
	fmt.Print(value)
}

string转换为int

package main

import (
	"fmt"
	"strconv"
)

func main() {
	num := "666"

	// 内部调用的就是 ParseInt
	var data, _ = strconv.Atoi(num)
	fmt.Println(data)
    
    // 整型转字符串（strconv.ParseInt 和 strconv.FormatInt 可用处理进制转换）
    // 十进制：整型； 其他进制：字符串形式 
    var result, err = strconv.ParseInt(num, 10, 32)
	fmt.Println(result, err)
}

int转换为string

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var result = strconv.Itoa(888)
	fmt.Println(result)
}