Go——strings包详解

最新推荐文章于 2024-05-11 14:32:28 发布

吴声子夜歌

最新推荐文章于 2024-05-11 14:32:28 发布

阅读量437

点赞数 2

分类专栏： Go 文章标签： golang 算法 strings

本文链接：https://blog.csdn.net/cold___play/article/details/130694406

版权

Go 专栏收录该内容

44 篇文章 1 订阅

订阅专栏

strings包

函数列表：

func Contains(s, substr string) bool
func ContainsAny(s, chars string) bool
func ContainsRune(s string, r rune) bool
func Count(s, sep string) int
func EqualFold(s, t string) bool
func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []string
func HasPrefix(s, prefix string) bool
func HasSuffix(s, suffix string) bool
func Index(s, sep string) int
func IndexAny(s, chars string) int
func IndexFunc(s string, f func(rune) bool) int
func IndexRune(s string, r rune) int
func Join(a []string, sep string) string
func LastIndex(s, sep string) int
func LastIndexAny(s, chars string) int
func LastIndexFunc(s string, f func(rune) bool) int
func Map(mapping func(rune) rune, s string) string
func Repeat(s string, count int) string
func Replace(s, old, new string, n int) string
func Split(s, sep string) []string
func SplitAfter(s, sep string) []string
func SplitAfterN(s, sep string, n int) []string
func SplitN(s, sep string, n int) []string
func Title(s string) string
func ToLower(s string) string
func ToLowerSpecial(_case unicode.SpecialCase, s string) string
func ToTitle(s string) string
func ToTitleSpecial(_case unicode.SpecialCase, s string) string
func ToUpper(s string) string
func ToUpperSpecial(_case unicode.SpecialCase, s string) string
func Trim(s string, cutset string) string
func TrimFunc(s string, f func(rune) bool) string
func TrimLeft(s string, cutset string) string
func TrimLeftFunc(s string, f func(rune) bool) string
func TrimRight(s string, cutset string) string
func TrimRightFunc(s string, f func(rune) bool) string
func TrimSpace(s string) string
func NewReader(s string) *Reader
func NewReplacer(oldnew ...string) *Replacer

1、Contains系列函数

1.1 func Contains(s, substr string) bool

参数列表
- s 表示需要判断的主串
- substr 表示包含的子串
返回值：返回bool
功能说明：这个函数主要是用来判断s中是否包含substr这个子串，如果包含返回true，否者返回false

1.2 func ContainsAny(s, chars string) bool

参数列表
- s 表示需要判断的主串
- chars 表示保存的unicode字符串
返回值：返回bool
功能说明：这个函数主要是用来判断s中是否包含chars中的字符中的任意字符，如果包含返回true，否者返回false

1.3 func ContainsRune(s string, r rune) bool

参数列表
- s 表示需要判断的主串
- r 表示rune字符
返回值：返回bool
功能说明：这个函数主要是用来判断s中是否包含rune类型的r字符，如果包含返回true，否者返回false

1.4 func Count(s, sep string) int

参数列表
- s 表示需要判断的主串
- sep 需要计算的子串
返回值：返回int 表示s中包含sep的个数
功能说明：这个函数主要是用来判断s中包含了多少个sep

func main() {
	fmt.Println(strings.Contains("seafood", "foo")) //true
	fmt.Println(strings.Contains("seafood", "bar")) //false
	fmt.Println(strings.Contains("seafood", ""))    //true
	fmt.Println(strings.Contains("", ""))           //true

	fmt.Println(strings.ContainsAny("team", "i"))       //false
	fmt.Println(strings.ContainsAny("failure", "wwwi")) //true
	fmt.Println(strings.ContainsAny("foo", ""))         //false
	fmt.Println(strings.ContainsAny("", ""))            //false

	fmt.Println(strings.ContainsRune("team", rune('m')))    //true
	fmt.Println(strings.ContainsRune("failure", rune('w'))) //false
	fmt.Println(strings.ContainsRune("谢foo", rune('谢')))    //true
	fmt.Println(strings.ContainsRune("", 30))               //false

	fmt.Println(strings.Count("cheese", "e"))  //3
	fmt.Println(strings.Count("cheese", "ee")) //1
	fmt.Println(strings.Count("five", ""))     // 5，如果子串为空串，返回值+1，
}

2、Fields系列函数

2.1 func Fields(s string) []string

参数列表
- s 表示需要判断的主串
返回值：返回[]string
功能说明：s按照一个空格或者多个连续的空格分割，返回分割之后的串数组，如果字符串没有空格或者只有一个空格，那么返回元素为去空格的s字符串

2.2 func FieldsFunc(s string, f func(rune) bool) []string

参数列表
- s 表示需要判断的主串
- f 表示一个函数，该函数参数是rune，返回值是bool，如果rune符合f函数的逻辑那么返回true，否者返回false
  返回值：返回[]string
功能说明：该函数实现的功能：s的每一个字符传入函数f，如果f返回true，那么按照该字符进行分割（该字符不保留），继续下一个字符，以此类推直到最后，如果返回的都是为false或者s为空，那么将返回空的字符串slice

func main() {
	fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   ")) //Fields are: ["foo" "bar" "baz"]
	fmt.Printf("Fields are: %q", strings.Fields(" baz "))             //Fields are: ["bar"]

	a := strings.FieldsFunc("astaxie", splitfunc)
	fmt.Println(a) //输出：[asta ie]

}

func splitfunc(a rune) bool {
	if a > 't' {
		return true
	}
	return false
}

3、Index系列函数

3.1 func HasPrefix(s, prefix string) bool

参数列表
- s 表示需要判断的主串
- prefix 需要判断的前缀字符串
返回值：返回bool，
功能说明：该函数主要判断s串中是否含有前缀prefix，如果包含，那么返回true，否则返回false

3. 2 func HasSuffix(s, suffix string) bool

参数列表
- s 表示需要判断的主串
- suffix 需要判断的后缀字符串
返回值：返回bool，
功能说明：该函数主要判断s串中是否含有后缀suffix，如果包含，那么返回true，否则返回false

3.3 func Index(s, sep string) int

参数列表
- s 表示需要判断的主串
- sep 需要判断的第一次出现位置的字符串
返回值：返回int，对应sep出现在s中的位置
功能说明：该函数主要判断sep串在s串中第一次出现的位置，如果不存在返回-1

3.4 func IndexAny(s, chars string) int

参数列表
- s 表示需要判断的主串
- chars 需要判断的第一次出现位置的字符集
返回值：返回int，对应sep出现在s中的位置
功能说明：该函数主要判断chars集中任意的一个字符在s串中第一次出现的位置，如果不存在返回-1

3.5 func IndexFunc(s string, f func(rune) bool) int

参数列表
- s 表示需要判断的主串
- f 表示一个函数，该函数参数是rune，返回值是bool，如果rune符合f函数的逻辑那么返回true，否者返回false
返回值：返回int，对应符合函数f的字符的位置
功能说明：该函数主要判断s中的每一个字符传入函数f，如果符合，那么返回该字符的位置，如果都不符合则返回-1

3.6 func IndexRune(s string, r rune) int

参数列表
- s 表示需要判断的主串
- r 需要判断的第一次出现位置的unicode码
返回值：返回int，对应r出现在s中的位置
功能说明：该函数主要判断unicode r在s串中第一次出现的位置，如果不存在返回-1

3.7 func LastIndex(s, sep string) int

参数列表
- s 表示需要判断的对象字符串
- sep 表示最后出现的字符串
返回值：返回int
功能说明：该函数主要判断sep串在s串中最后一次出现的位置，如果不存在返回-1

3.8 func LastIndexAny(s, chars string) int

参数列表
- s 表示需要判断的主串
- chars 需要判断的最后一次出现位置的字符集
返回值：返回int，对应sep出现在s中的最后位置
功能说明：该函数主要判断chars集中任意的一个字符在s串中最后一次出现的位置，如果不存在返回-1

3.9 func LastIndexFunc(s string, f func(rune) bool) int

参数列表
- s 表示需要判断的主串
- f 表示一个函数，该函数参数是rune，返回值是bool，如果rune符合f函数的逻辑那么返回true，否者返回false
返回值：返回int，对应符合函数f的字符的位置
功能说明：该函数主要判断s中的每一个字符传入函数f，返回符合函数f的最后一个字符的位置，如果都不符合则返回-1

func main() {
	fmt.Println(strings.HasPrefix("astaxie", "as")) //true
	fmt.Println(strings.HasPrefix("astaxie", "ta")) //false

	fmt.Println(strings.HasSuffix("astaxie", "as"))  //false
	fmt.Println(strings.HasSuffix("astaxie", "xie")) //true

	fmt.Println(strings.Index("chickenkenken", "ken")) //4
	fmt.Println(strings.Index("chicken", "dmr"))       //-1

	fmt.Println(strings.IndexAny("chickenkenkenken", "iken")) //2
	fmt.Println(strings.IndexAny("chicken", "dmr"))           //-1

	splitfunc := func(r rune) bool {
		if r > 't' {
			return true
		}
		return false
	}
	fmt.Println(strings.IndexFunc("astaxie", splitfunc)) //符合条件的是字符x，因为字符x的rune大于t，所以这个位置应该返回4
	fmt.Println(strings.IndexFunc("aaabbbb", splitfunc)) //所有的字符都不符合条件，则返回-1

	fmt.Println(strings.IndexRune("chicken", 'k')) //4
	fmt.Println(strings.IndexRune("chicken", 'd')) //-1

	fmt.Println(strings.LastIndex("chickenkenken", "ken")) //10
	fmt.Println(strings.LastIndex("chicken", "dmr"))       //-1

	fmt.Println(strings.LastIndexAny("chickenkenkenken", "iken")) //15
	fmt.Println(strings.LastIndexAny("chicken", "dmr"))           //-1

	splitfunc = func(r rune) bool {
		if r > 'm' {
			return true
		}
		return false
	}
	fmt.Println(strings.LastIndexFunc("astaxie", splitfunc)) //符合条件的有字符t和x，因为字符x是最后出现的位置，所以这个位置应该返回4
	fmt.Println(strings.LastIndexFunc("aaabbbb", splitfunc)) //所有的字符都不符合条件，则返回-1
}

4、Split系列函数

4.1 func Split(s, sep string) []string

参数列表
- s 表示需要处理的字符串
- sep 表示分割的字符串
返回值：返回[]string 分割之后的字符串slice
功能说明：该函数s根据sep分割，返回分割之后子字符串的slice，如果sep为空，那么每一个字符都分割

4.2 func SplitAfter(s, sep string) []string

参数列表
- s 表示需要处理的字符串
- sep 表示分割的字符串
返回值：返回[]string 分割之后的字符串slice
功能说明：该函数s根据sep分割，返回分割之后子字符串的slice,和split一样，只是返回的子字符串保留sep，如果sep为空，那么每一个字符都分割

4.3 func SplitAfterN(s, sep string, n int) []string

参数列表
- s 表示需要处理的字符串
- sep 表示分割的字符串
- n 表示需要分割的子字符串
  - n > 0: 最多n个子字符串; 最后一个就是剩下未分割的子字符串.
  - n == 0: 返回为0的字符串
  - n < 0: 返回所有的子字符串，和SplitAfter
    返回值：返回[]string 分割之后的字符串slice
    功能说明：该函数s根据sep分割，返回分割之后子字符串的slice,和split一样，只是返回的子字符串保留sep，如果sep为空，那么每一个字符都分割

4.4 func SplitN(s, sep string, n int) []string

参数列表
- s 表示需要处理的字符串
- sep 表示分割的字符串
- n 表示分割的最多子串
  - n > 0: 最多n个子字符串; 最后一个就是剩下未分割的子字符串.
  - n == 0: 返回为0的字符串
  - n < 0: 返回所有的子字符串，和SplitAfter
返回值：返回[]string 分割之后的字符串slice
功能说明：该函数s根据sep分割，返回分割之后子字符串的slice，返回的子串的长度如n的定义，如果sep为空，那么每一个字符都分割

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,c", ","))                        //["a" "b" "c"]
	fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a ")) //["" "man " "plan " "canal panama"]
	fmt.Printf("%q\n", strings.Split(" xyz ", ""))                         //[" " "x" "y" "z" " "]
	fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))            //[""]

	fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ",")) //["a," "b," "c"]

	fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2)) //["a," "b,c"]
	fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", "", 5))  //["a" "," "b" "," "c"]
	fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 1)) //["a,b,c"]

	fmt.Printf("%q\n", strings.SplitN("a,b,c", ",", 2)) //["a" "b,c"]
	z := strings.SplitN("a,b,c", ",", 0)
	fmt.Printf("%q (nil = %v)\n", z, z == nil) //[] (nil = true)
}

5、To系列函数

5.1 func Title(s string) string

参数列表
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个单词首字母转化为大写

5.2 func ToLower(s string) string

参数列表
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个单词转化为小写

5.3 func ToLowerSpecial(_case unicode.SpecialCase, s string) string

参数列表
- _case 表示unicode的SpecialCase对象
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个单词转化为小写，但是调用的是unicode.SpecialCase的ToLower方法

5.4 func ToTitle(s string) string

参数列表
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个字符转化为对应的大写字符，其实和ToUpper一样的效果，但是有些语种的unicode,ToTitle和ToUpper效果不一样，但是我没试出来过，英语至少是一样的。

5.5 func ToTitleSpecial(_case unicode.SpecialCase, s string) string

参数列表
- _case 表示unicode的SpecialCase对象
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个单词转化为标题体，但是调用的是unicode.SpecialCase的ToTitle方法

5.6 func ToUpper(s string) string

参数列表
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个字符转化为大写

5.7 func ToUpperSpecial(_case unicode.SpecialCase, s string) string

参数列表
- _case 表示unicode的SpecialCase对象
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面的每个单词转化为大写，但是调用的是unicode.SpecialCase的ToUpper方法

func main() {
	fmt.Println(strings.Title("her royal highness")) //Her Royal Highness

	fmt.Println(strings.ToLower("Gopher")) //gopher

	var SC unicode.SpecialCase
	fmt.Println(strings.ToLowerSpecial(SC, "Gopher")) //gopher

	fmt.Println(strings.ToTitle("Gopher")) //GOPHER

	var SC1 unicode.SpecialCase
	fmt.Println(strings.ToTitleSpecial(SC1, "Gopher")) //GOPHER

	fmt.Println(strings.ToUpper("Gopher")) //GOPHER

	var SC2 unicode.SpecialCase
	fmt.Println(strings.ToUpperSpecial(SC2, "Gopher")) //GOPHER
}

6、Trim系列函数

6.1 func Trim(s string, cutset string) string

参数列表
- s 表示需要处理的字符串
- cutset 表示需要过滤的字符集
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串开头或者结尾里面包含字符集的字符全部过滤掉，返回过滤之后的字符串

6.2 func TrimFunc(s string, f func(rune) bool) string

参数列表
- s 表示需要处理的字符串
- f 表示一个函数，判断是否过滤该字符的函数，如果为真那么就过滤
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面开头和结尾部分字符传入f函数进行判断是否过滤，为真就过滤

6.3 func TrimLeft(s string, cutset string) string

参数列表
- s 表示需要处理的字符串
- cutset 表示需要过滤的字符集
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串开头里面包含字符集的字符全部过滤掉，返回过滤之后的字符串

6.4 func TrimLeftFunc(s string, f func(rune) bool) string

参数列表
- s 表示需要处理的字符串
- f 表示一个函数，判断是否过滤该字符的函数，如果为真那么就过滤
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面开头部分字符传入f函数进行判断是否过滤，为真就过滤

6.5 func TrimRight(s string, cutset string) string

参数列表
- s 表示需要处理的字符串
- cutset 表示需要过滤的字符集
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串结尾里面包含字符集的字符全部过滤掉，返回过滤之后的字符串

6.6 func TrimRightFunc(s string, f func(rune) bool) string

参数列表
- s 表示需要处理的字符串
- f 表示一个函数，判断是否过滤该字符的函数，如果为真那么就过滤
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串里面结尾部分字符传入f函数进行判断是否过滤，为真就过滤

6.7 func TrimSpace(s string) string

参数列表
- s 表示需要处理的字符串
返回值：返回string 转化之后的字符串
功能说明：该函数把s字符串开头或者结尾里面空白符(‘\t’, ‘\n’, ‘\v’, ‘\f’, ‘\r’, ’ ', U+0085 (NEL), U+00A0 (NBSP))全部过滤掉，返回过滤之后的字符串

func main() {
	fmt.Printf("[%q]", strings.Trim(" !!! Achtung !!! ", "! ")) //["Achtung"]

	filte := func(r rune) bool {
		if r > 't' {
			return true
		}
		return false
	}
	fmt.Printf("[%q]", strings.TrimFunc("xxastaxieyy", filte)) //astaxie

	fmt.Printf("[%q]", strings.TrimLeft(" !!! Achtung !!! ", "! ")) //["Achtung !!! "]

	fmt.Printf("[%q]", strings.TrimLeftFunc("xxastaxieyy", filte)) //astaxieyy

	fmt.Printf("[%q]", strings.TrimRight(" !!! Achtung !!! ", "! ")) //[" !!! Achtung"]

	fmt.Printf("[%q]", strings.TrimRightFunc("xxastaxieyy", filte)) //xxastaxie

	fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) //a lone gopher
}

7、New系列函数

7.1 func NewReader(s string) *Reader

参数列表
- s 读取的字符串
返回值：*Reader 通过读取一个字符串之后返回Reader对象
对象的方法列表：
- func (r *Reader) Len() int //返回未读取的字符串的长度
- func (r *Reader) Read(b []byte) (n int, err error) //读取数据到b中，返回读取的实际大小n，如果出错返回err，例如EOF或者b的长度为0
- func (r *Reader) ReadAt(b []byte, off int64) (n int, err error) //按照指定的off位置开始读取内容到b，返回读取的实际大小n，如果出错返回err，例如off小于0或者大于本身的长度或者文件尾
- func (r *Reader) ReadByte() (b byte, err error) //读取一个byte的数据
- func (r *Reader) ReadRune() (ch rune, size int, err error) //读取一个rune的数据
- func (r *Reader) Seek(offset int64, whence int) (int64, error) //根据whence来移动offset，如果whence=0为直接移动offset位置，=1为移动到当前位置之后的offset，=2为移动到当前字符串长度之后的offset位置
- func (r *Reader) UnreadByte() error //当前读取的位置向前移一个byte
- func (r *Reader) UnreadRune() error //当前读取的位置向前移一个rune
功能说明：该函数主要是通过把字符串读取Reader之后进行的一些读取操作

7.2 func NewReplacer(oldnew …string) *Replacer

参数列表
- oldnew是一个slice，是一个需要替换的字符串和新的字符串的配对出现
返回参数：Replacer返回一个替换对象
Replacer方法列表
- func (r *Replacer) Replace(s string) string // 把字符串替换为oldnew定义的
- func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error) //替换之后的字符串写入到w之中，返回写入的数量

func main() {
	read := strings.NewReader("I am asta谢")
	var b []byte
	fmt.Println(read.Len()) //12
	b = make([]byte, 8)
	n, err := read.Read(b)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(b) //[73 32 97 109 32 97 115 116]
	fmt.Println(n) //8
	n, err = read.ReadAt(b, 3)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(b) //[109 32 97 115 116 97 232 176]
	fmt.Println(n) //8
	bt, err := read.ReadByte()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(bt) //97
	rn, size, err := read.ReadRune()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(rn)   //35874
	fmt.Println(size) //3

	patterns := []string{"abc", "efg"}
	replacer := strings.NewReplacer(patterns...)
	format := replacer.Replace("abc is abc is abc")
	fmt.Println(format)
	//efg is efg is efg
	replacer.WriteString(os.Stdout, "abc is abc is abc")
	//efg is efg is efg
}

8、其它函数

8.1 func EqualFold(s, t string) bool

参数列表
- s 表示需要判断的主串
- t 表示需要比较的辅串
返回值：返回bool
功能说明：字符串s和t比较，它们在全部小写的情况下，采用UTF8编码的底层的unicode是否一致

8.2 func Join(a []string, sep string) string

参数列表
- a 表示需要链接起来的字符串slice
- sep 表示链接的符号
返回值：返回string
功能说明：该函数主要实现字符串slice的链接功能，把slice的每一个元素通过sep进行链接

8.3 func Map(mapping func(rune) rune, s string) string

参数列表
- mapping 处理函数，输入是字符，输出是字符
- s 表示需要处理的主串
返回值：返回string，处理后的字符串
功能说明：该函数以此读取s中的字符，传入mapping函数，然后返回的字符链接起来，说白了就是字符串的每一个字符通过mapping函数的处理，最后返回处理好的字符串，如果处理不正确，那么就抛弃该字符

8.4 func Repeat(s string, count int) string

参数列表
- s 表示需要重复的字符串
- count 表示重复字数
返回值：返回string 重复的字符串
功能说明：该函数返回一个s的重复count字数的字符串

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

参数列表
- s 表示需要替换的主字符串
- old 表示需要替换的字符串
- new 表示替换的新字符串
- n 表示替换的次数
返回值：返回string，处理之后的字符串
功能说明：该函数实现在s中把old替换为new字符串，替换次数为n，如果n小于0，那么就全部替换

func main() {
	fmt.Println(strings.EqualFold("Go", "go"))   //true
	fmt.Println(strings.EqualFold("go\n", "go")) //false

	s := []string{"foo", "bar", "baz"}
	fmt.Println(strings.Join(s, ", ")) //foo, bar, baz

	rot13 := func(r rune) rune {
		switch {
		case r >= 'A' && r <= 'Z':
			return 'A' + (r-'A'+13)%26
		case r >= 'a' && r <= 'z':
			return 'a' + (r-'a'+13)%26
		}
		return r
	}
	fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))
	//'Gjnf oevyyvt naq gur fyvgul tbcure...

	fmt.Println("ba" + strings.Repeat("na", 2)) //banana

	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))      //oinky oinky oink
	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1)) //moo moo moo
}