go strings包

字符串的遍历

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {
	s := "天气好干燥啊A"
	fmt.Println("字节长度", len(s))
	fmt.Println("================")
	// for  range 遍历字符串
	len := 0
	for i, ch := range s {
		fmt.Printf("%d:%c ", i, ch)
		len++
	}
	// 遍历所有字节
	for i, ch := range []byte(s) {
		fmt.Printf("%d:%x ", i, ch)
	}
	fmt.Println()
	fmt.Println("================")
	// 遍历所有字符
	count := 0
	for i, ch := range []rune(s) {
		fmt.Printf("%d:%c ", i, ch)
		count++
	}
	fmt.Println()
	fmt.Println("字符串长度", len)
	fmt.Println("字符长度", count)
	fmt.Println("字符长度", utf8.RuneCountInString(s))
}

结果
字节长度 19
================
0:天 3:气 6:好 9:干 12:燥 15:啊 18:A 0:e5 1:a4 2:a9 3:e6 4:b0 5:94 6:e5 7:a5 8:bd 9:e5 10:b9 11:b2 12:e7 13:87 14:a5 15:e5 16:95 17:8a 18:41 
================
0:天 1:气 2:好 3:干 4:燥 5:啊 6:A 
字符串长度 7
字符长度 7
字符长度 7

遍历字符推荐使用rune，因为一个byte存不下一个汉字的unicode值。

字符串处理函数

检索字符串

方法	功能描述
func Contains(s, substr string) bool	判断字符串 s 是否包含 substr 字符串
func ContainsAny(s, chars string) bool	判断字符串 s 是否包含 chars 字符串中的任一字符
func ContainsRune(s string, r rune) bool	判断字符串 s 是否包含 unicode 码值 r
func Count(s, sep string) int	返回字符串 s 包含字符串 sep 的个数
func HasPrefix(s, prefix string) bool	判断字符串 s 是否有前缀字符串 prefix
func HasSuffix(s, suffix string) bool	判断字符串 s 是否有后缀字符串 suffix
func Index(s, sep string) int	返回字符串 s 中字符串 sep 首次出现的位置
func IndexAny(s, chars string) int	返回字符串 chars 中的任意一个 unicode 码值在 s 中首次出现的位置
func IndexByte(s string, c byte) int	返回字符串 s 中字符 c 首次出现的位置
func IndexFunc(s string, f func(rune) bool) int	返回字符串 s 中满足函数 f (r)=true 字符首次出现的位置
func IndexRune(s string, r rune) int	返回 unicode 码值 r 在字符串中首次出现的位置
func LastIndex(s, sep string) int	返回字符串 s 中字符串 sep 最后一次出现的位置
func LastIndexAny(s, chars string) int	返回字符串 chars 中的任意一个 unicode 码值在 s 中最后一次出现的位置
func LastIndexByte(s string, c byte) int	返回字符串 s 中字符 c 最后一次出现的位置
func LastIndexFunc(s string, f func(rune) bool) int	返回字符串 s 中满足函数 f (r)=true 字符最后一次出现的位置

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestContains()

}
func TestContains() {
	fmt.Println(strings.Contains("hello", "i"))
	fmt.Println(strings.Contains("hello", "o"))
	fmt.Println(strings.Contains("hello", "o & e"))
	fmt.Println(strings.Contains("hello", ""))
	fmt.Println(strings.Contains("", ""))
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    TestContainsAny()

}

func TestContainsAny() {
    fmt.Println(strings.ContainsAny("hello", "i"))
    fmt.Println(strings.ContainsAny("hello", "o"))
    fmt.Println(strings.ContainsAny("hello", "o & e"))
    fmt.Println(strings.ContainsAny("hello", ""))
    fmt.Println(strings.ContainsAny("", ""))
}

package main

import (
    "fmt"
    "strings"
)

func main() {
    TestContainsRune()

}

func TestContainsRune() {
    fmt.Println(strings.ContainsRune("一丁", '丁'))
    fmt.Println(strings.ContainsRune("一丁", 19969))
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestCount()

}

func TestCount() {
	fmt.Println(strings.Count("一丁", "丁"))
	fmt.Println(strings.Count("一丁", "000"))
	fmt.Println(strings.Count("one", "")) // 结果是4
	fmt.Println(strings.Count("one", "e"))
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestHasPrefix()

}

func TestHasPrefix() {
	fmt.Println(strings.HasPrefix("100000 phone news", "1000"))
	fmt.Println(strings.HasPrefix("100000 phone news", "1000a"))
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestHasSuffix()

}

func TestHasSuffix() {
	fmt.Println(strings.HasSuffix("100000 phone news", "news"))
	fmt.Println(strings.HasSuffix("100000 phone news", "SSS0a"))
}

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestIndex()

}

func TestIndex() {
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dne"))
}
// 没有则返回-1

// 返回字符串中满足函数f(c)==true字符最后一次出现的位置
package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    TestLastIndexFunc()
}

func TestLastIndexFunc() {
    f := func(c rune) bool {
       return unicode.Is(unicode.Han, c)
    }
    fmt.Println(strings.LastIndexFunc("hello,世界", f))
    fmt.Println(strings.LastIndexFunc("hello,四季青", f))
}

分割字符串

方法	功能描述
func Fields(s string) []string	将字符串 s 以空白字符分割，返回一个切片
func FieldsFunc(s string, f func(rune) bool) []string	将字符串 s 以满足 f (r)==true 的字符分割，返回一个切片
func Split(s, sep string) []string	将字符串 s 以 sep 作为分隔符进行分割，分割后字符最后去掉 sep
func SplitAfter(s, sep string) []string	将字符串 s 以 sep 作为分隔符进行分割，分割后字符最后附上 sep
func SplitAfterN(s, sep string, n int) []string	将字符串 s 以 sep 作为分隔符进行分割，分割后字符最后附上 sep，n 决定返回的切片数
func SplitN(s, sep string, n int) []string	将字符串 s 以 sep 作为分隔符进行分割，分割后字符最后去掉 sep，n 决定返回的切片数

package main

import (
	"fmt"
	"strings"
)

func main() {
	TestFields()
}

func TestFields() {
	fmt.Println(strings.Fields(" abc 123 "))
}

大小写转换

方法	功能描述
func Title(s string) string	将字符串 s 每个单词首字母大写返回
func ToLower(s string) string	将字符串 s 转换成小写返回
func ToLowerSpecial(_case unicode.SpecialCase, s string) string	将字符串 s 中所有字符按_case 指定的映射转换成小写返回
func ToTitle(s string) string	将字符串 s 转换成大写返回
func ToTitleSpecial(_case unicode.SpecialCase, s string) string	将字符串 s 中所有字符按_case 指定的映射转换成大写返回
func ToUpper(s string) string	将字符串 s 转换成大写返回
func ToUpperSpecial(_case unicode.SpecialCase, s string) string	将字符串 s 中所有字符按_case 指定的映射转换成大写返回

修剪字符串

方法	功能描述
func Trim(s string, cutset string) string	将字符串 s 首尾包含在 cutset 中的任一字符去掉返回
func TrimFunc(s string, f func(rune) bool) string	将字符串 s 首尾满足函数 f (r)==true 的字符去掉返回
func TrimLeft(s string, cutset string) string	将字符串 s 左边包含在 cutset 中的任一字符去掉返回
func TrimLeftFunc(s string, f func(rune) bool) string	将字符串 s 左边满足函数 f (r)==true 的字符去掉返回
func TrimPrefix(s, prefix string) string	将字符串 s 中前缀字符串 prefix 去掉返回
func TrimRight(s string, cutset string) string	将字符串 s 右边包含在 cutset 中的任一字符去掉返回
func TrimRightFunc(s string, f func(rune) bool) string	将字符串 s 右边满足函数 f (r)==true 的字符去掉返回
func TrimSpace(s string) string	将字符串 s 首尾空白去掉返回
func TrimSuffix(s, suffix string) string	将字符串 s 中后缀字符串 suffix 去掉返回

比较字符串

方法	功能描述
func Compare(a, b string) int	按字典顺序比较 a 和 b 字符串大小
func EqualFold(s, t string) bool	判断 s 和 t 两个 UTF - 8 字符串是否相等，忽略大小写
func Repeat(s string, count int) string	将字符串 s 重复 count 次返回
func Replace(s, old, new string, n int) string	替换字符串 s 中 old 字符为 new 字符并返回，n<0 时替换所有 old 字符串
func Join(a []string, sep string) string	将 a 中的所有字符连接成一个字符串，使用字符串 sep 作为分隔符