golang标准库-strings

字符串处理

字符串在开发中经常用到，包括用户的输入，数据库读取的数据等，我们经常需要对字符串进行分割、连接、转换等操作

字符串操作

下面这些函数来自于strings包，这里介绍一些我平常经常用到的函数，更详细的请参考官方的文档。

1.前缀和后缀

HasPrefix 判断字符串s是否以prefix开头:

函数签名
strings.HasPrefix(s, prefix string) bool

HasSuffix 判断字符串 s 是否以 suffix 结尾：

函数签名
strings.HasSuffix(s, suffix string) bool

示例:

package main
import (
	"fmt"
	"strings"
)
func main(){

	str1 := "this is a example strings"
	fmt.Println(strings.HasPrefix(str1, "th"))
	fmt.Println(strings.HasSuffix(str1, "gs"))
}

Contains 字符串包含关系

func Contains(s, substr string) bool

• 功能：字符串s中是否包含substr，返回bool值
  示例代码：

fmt.Println(strings.Contains("seafood", "foo"))
fmt.Println(strings.Contains("seafood", "bar"))
fmt.Println(strings.Contains("seafood", ""))
fmt.Println(strings.Contains("", ""))
//运行结果:
//true
//false
//true
//true

Join(拼接slice到字符串)

Join 用于将元素类型为 string 的 slice 使用分割符号来拼接组成一个字符串

函数签名
strings.Join(sl []string, sep string) string

举例:

示例1:
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ","))
示例2：
package main
import (
	"fmt"
	"strings"
)
func main() {
	str1 := "hello world python golang"
	field := strings.Fields(str1)
	fmt.Printf("%q\n", field)
	split := strings.Split(str1, " ")
	fmt.Printf("%q\n", split)
	join := strings.Join(split, ";")
	fmt.Println(join)
}

Index、LastIndex、IndexRune

功能：在字符串s中查找sep所在的位置，返回位置值，找不到返回-1

语法：

strings.Index(s, str string) int

LastIndex 返回字符串 str 在字符串 s 中最后出现位置的索引（str 的第一个字符的索引），-1 表示字符串 s 不包含字符串 str：

strings.LastIndex(s, str string) int

示例代码：

fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
//运行结果:
//    4
//    -1

如果需要查询非 ASCII 编码的字符在父字符串中的位置，建议使用以下函数来对字符进行定位：

strings.IndexRune(s string, r rune) int

var c string = "Hi I am Hello world"
fmt.Println(strings.IndexRune(c, rune('a')))
fmt.Println(strings.IndexRune(c, 97))

Count

Count 用于计算字符串 str 在字符串 s 中出现的非重叠次数：

strings.Count(s, str string) int

举例:
str2 := "fffffff"
fmt.Println(strings.Count(str2,"f"))

Repeat

func Repeat(s string, count int) string

功能：重复s字符串count次，并返回一个新的字符串

示例代码：

var orgiS string = "Hi there! "
news := strings.Repeat(orgiS, 3) // Hi there! Hi there! Hi there!
fmt.Printf("news str is: %s\n", news)

Replace (字符串替换)

func Replace(s, old, new string, n int) string

功能：在s字符串中，把old字符串替换为new字符串，n表示替换的次数，小于0表示全部替换
示例代码：

fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
//运行结果:
//oinky oinky oink
//moo moo moo

ToLower,ToUpper(修改字符串的大小写)

ToLower 将字符串中的 Unicode 字符全部转换为相应的小写字符：

函数签名
strings.ToLower(s) string

ToUpper 将字符串中的 Unicode 字符全部转换为相应的大写字符：

函数签名
strings.ToUpper(s) string

举例:
package main
import (
	"fmt"
	"strings"
)
func main() {
	var str1 = "go how are you"
	lower := strings.ToLower(str1)
	fmt.Println(lower)
	upper := strings.ToUpper(str1)
	fmt.Println(upper)
}

Split，Fields(分割字符串)

strings.Fields(s) 将会利用 1 个或多个空白符号来作为动态长度的分隔符将字符串分割成若干小块，并返回一个 slice，如果字符串只包含空白符号，则返回一个长度为 0 的 slice。

strings.Split(s, sep) 用于自定义分割符号来对指定字符串进行分割，同样返回 slice

func Split(s, sep string) []string

功能：把s字符串按照sep分割，返回slice

示例代码：

package main
import (
	"fmt"
	"strings"
)
func main() {
	str1 := "Hello,    golang, world,python"
	field := strings.Fields(str1)
	fmt.Printf("%q\n", field) // ["Hello," "golang," "world,python"]
	split := strings.Split(str1, ",")
	fmt.Printf("%q\n", split) // ["Hello" "    golang" " world" "python"]
}

Trim Trimleft TrimRight

func Trim(s string, cutset string) string

功能：在s字符串的头部和尾部去除cutset指定的字符串
示例代码：

fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! "))
//运行结果:["Achtung"]

Map

将s的每一个unicode码值r都替换为mapping(r)，返回这些新码值组成的字符串拷贝。如果mapping返回一个负值，将会丢弃该码值而不会被替换

示例代码:
package main
import (
	"fmt"
	"strings"
)
func main() {
	mapFunc := func(r rune) rune {
		switch {
		case r > 'A' && r < 'Z':
			return r + 32
		case r > 'a' && r < 'z':
			return r - 32
		}
		return r
	}
	s := "hello World!"
	sMap := strings.Map(mapFunc, s)
	fmt.Println(sMap)

}

NewReader(从字符串中读取内容)

函数 strings.NewReader(str) 用于生成一个 Reader 并读取字符串中的内容，然后返回指向该 Reader 的指针，从其它类型读取内容的函数还有：

Read() 从 []byte 中读取内容。
ReadByte() 和 ReadRune() 从字符串中读取下一个 byte 或者 rune。
参考:https://blog.csdn.net/sanxiaxugang/article/details/60324012

Reader 结构体

Reader 类型从一个字符串读取数据，实现了io.Reader, io.Seeker等接口。

func NewReader(s string) *Reader // 通过字符串 s 创建一个 Reader
func (r *Reader) Len() int // 返回 r 还没有读取部分的长度
func (r *Reader) Read(b []byte) (n int, err error) // 读取部分数据到 b 中，读取的长度取决于 b 的容量
func (r *Reader) ReadByte() (b byte, err error) // 从 r 中读取一字节数据

示例代码：
package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "hello world"
	r := strings.NewReader(s)
	fmt.Println(r)        // &{hello world 0 -1}
	fmt.Println(r.Size()) // 字符串长度 11
	fmt.Println(r.Len())  // 未读取长度 11
	for r.Len() > 5 {
		b, err := r.ReadByte() // 读取1byte
		fmt.Println(string(b), err, r.Len(), r.Size())
		// h <nil> 10 11
		// e <nil> 9 11
		// l <nil> 8 11
		// l <nil> 7 11
		// o <nil> 6 11
		//   <nil> 5 11
	}
	// 读取还未被读取字符串中5字符的数据
	remainStr := make([]byte, 5)
	n, err := r.Read(remainStr)
	fmt.Println(string(remainStr), n, err) // world 5 <nil>
	fmt.Println(r.Size())                  // 11
	fmt.Println(r.Len())                   // 0
}

Replacer 结构体

Replacer 类型实现字符串替换的操作

func NewReplacer(oldnew ...string) *Replacer // 使用提供的多组old、new字符串对创建一个*Replacer
func (r *Replacer) Replace(s string) string // 返回s 所有替换完后的拷贝
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error) // 向w中写入s替换完后的拷贝

参考：

• https://github.com/unknwon/the-way-to-go_ZH_CN/blob/master/eBook/04.7.md
• https://blog.csdn.net/sanxiaxugang/article/details/60324012