Golang - strings 包的使用

方法列表

官方连接

方法名	描述
reader 对象
NewReader	返回一个 reader 对象指针
统计相关
Count	返回参数字符串出现的次数
Trim
Trim	参数作为字符集, 遍历字符串, 如果当前字符在字符集内, 则去掉, 直到遍历的字符串没有匹配结果为止 如果字符串为空, 或者字符集为空, 则直接返回原字符串
TrimLeft	Trim 的逻辑, 只去除开头部分
TrimRight	Trim 的逻辑, 只去除结尾部分
TrimPrefix	去除开头的字符串
TrimSuffix	去除结尾的字符串
TrimSpace	去除前后的空格
TrimFunc	自定义方法, 返回 true 则去除
判断相关
HasPrefix	是否由 xx 开头
HasSuffix	是否由 xx 结尾
Contains	是否包含 xx(字符串)
ContainsAny	是否包含 xx(字符集合)
ContainsRune	是否包含 xx 字符, rune 类型
索引相关
Index	查找字符串第一次出现的索引, 不存在返回 -1, 正向查找
LastIndex	同上, 反向
IndexAny	参数为字符集合, 按顺序查找是否存在字符, 存在则返回索引, 不存在查找下一个字符, 直到查完全部字符, 且未找到, 正向
LastIndexAny	同上, 反向
IndexByte	查找 byte 字符索引, 正向
LastIndexByte	同上, 反向
IndexRune	查找 rune 字符索引, 正向
IndexFunc	根据自定义方法确定查找条件, 返回值为 true 则返回索引, 正向
LastIndexFunc	同上, 反向
大小写转换相关
ToTitle	字符串首字母大写
ToUpper	全部大写
ToLower	全部小写
分隔/拼接/替换
Fields	去除前后空格, 并将非空格字符组成切片
Split	根据分隔符切分, 获得切片
SplitN	根据分隔符切分, 获得切片, 限制索引范围
SplitAfter	同 Split, 保留分隔符
SplitAfterN	同 SplitN, 保留分隔符
Join	切片根据分隔符拼接字符串
Repeat	字符串 * n
Replace	根据索引替换
ReplaceAll	替换所有
Map	根据自定义的方法, 判断后替换
对比
Compare	对比两个字符串是否相同, 底层就是 if a == b { return 0 }
EqualFold	忽略大小写的比较

---

示例

生成 reader 对象

// 创建 reader 对象
newReaderPtr := strings.NewReader(s string)

---

索引相关

package main

import (
	"fmt"
	"strings"
)

func getTrue(s rune) bool {
	// 如果字符满足 xx 条件, 返回 true
	if s == '中' {
		return true
	}
	return false
}

func main() {
	s := "ab中国中国ca"

	// Index & LastIndex
	// 根据字符查索引, 返回第一次出现的索引, 不存在返回 -1
	// Index 为从左至右查询, LastIndex 为从右至左查询
	// 支持但不建议查询中文字符
	// 因为索引为 byte 类型计算方式, 可以使用长度*3
	index := strings.Index(s, "中国")
	lastIndex := strings.LastIndex(s, "中国")
	fmt.Println(index, lastIndex)

	// IndexAny & LastIndexAny
	// 参数为待查询字符集, 可理解为(['d', 'c']), 返回字符第一次出现的索引
	// 先查d, 不存在; 再查c, 存在返回索引
	// 同样支持但不建议查询中文, 原因同上
	indexAny := strings.IndexAny(s, "d国")
	lastIndexAny := strings.LastIndexAny(s, "dc")
	fmt.Println(indexAny, lastIndexAny)

	// IndexByte & LastIndexByte
	// 根据 byte 类型字符查索引
	indexByte := strings.IndexByte(s, 'a')
	lastIndexByte := strings.LastIndexByte(s, 'a')
	fmt.Println(indexByte, lastIndexByte)

	// 根据 rune 类型字符查索引, 只有正向查询
	indexRune := strings.IndexRune(s, '中')
	fmt.Println(indexRune)

	// 自定义方法, 方法中定义满足何种条件时, 返回 true
	// 当返回为 true 时, 返回对应索引, 索引为 byte 类型计算方式
  // 匿名函数写法
	indexFunc := strings.IndexFunc(s, func(r rune) bool {
		if r == '中' {
			return true
		} else {
			return false
		}
	})
  // 声明函数写法
	lastIndexFunc := strings.LastIndexFunc(s, getTrue)
	fmt.Println(indexFunc, lastIndexFunc)
}

---

去除字符相关

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := " abc cba "

	// 参数作为字符集, 遍历字符串, 如果当前字符在字符集内, 则去掉, 直到遍历的字符串没有匹配结果为止
	// 如果字符串为空, 或者字符集为空, 则直接返回原字符串
	trim := strings.Trim(s, "a b")
	fmt.Println(trim)

	// 根据 Trim 的逻辑, 只去掉左边的
	left := strings.TrimLeft(s, "a b")
	fmt.Println(left)

	// 根据 Trim 的逻辑, 只去掉右边的
	right := strings.TrimRight(s, "a b")
	fmt.Println(right)

	// 根据参数, 从起始处完全匹配字符串, 并去掉
	prefix := strings.TrimPrefix(s, " ab")
	fmt.Println(prefix)

	// 根据参数, 从结尾处完全匹配字符串, 并去掉
	suffix := strings.TrimSuffix(s, "ba ")
	fmt.Println(suffix)

	// 去前后空格
	space := strings.TrimSpace(s)
	fmt.Println(space, len(space), len(s))

	trimFunc := strings.TrimFunc(s, func(r rune) bool {
		// 场景模拟, rune 即 int, 根据 int 范围判断是否需要去除
		if r < 100 {
			return true
		} else {
			return false
		}
	})
	fmt.Println(trimFunc)
}

---

分隔, 拼接和替换

package main

import (
	"fmt"
	"strings"
)

func main() {

	s1 := " a b c d e "

	// 去除所有空格, 并将非空格字符组成切片
	fields := strings.Fields(s1)
	for _, v := range fields {
		fmt.Println(v)
	}

	// 切片根据分隔符拼接字符串
	s := strings.Join(fields, ":")
	fmt.Println(s)

	// 根据分隔符切分, 获得切片
	split := strings.Split(s, ":")
	fmt.Println(split)

	// 根据分隔符切分, 获得切片, 生效范围[:n]
	splitn := strings.SplitN(s, ":", 2)
	fmt.Println(splitn)

	// 根据分隔符切分, 保留分隔符, 获得切片
	after := strings.SplitAfter(s, ":")
	fmt.Println(after)

	// 根据分隔符切分, 保留分隔符, 生效范围[:n], 获得切片
	afterN := strings.SplitAfterN(s, ":", 2)
	fmt.Println(afterN)

  // 替换
	replace := strings.Replace(s, "a", "c", -1)
	fmt.Println(replace)
  
  // 替换所有, 实际上就是 replace() 参数填 -1
	all := strings.ReplaceAll(s, "a", "c")
	fmt.Println(all)
  
	// 判断后替换, 如果符合条件, 如何处理, 不符合条件, 如何处理
	m := strings.Map(func(r rune) rune {
		if r == ':' {
			return '/'
		}
		return r
	}, s)
	fmt.Println(m)
  
  // 重复
	repeat := strings.Repeat(s, 2)
	fmt.Println(repeat)
}

---

判断相关

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "A....Z"

	// 参数为完全匹配的字符串, 匹配成功返回 true, 失败返回 false
	prefixBool := strings.HasPrefix(s, "A")
	suffixBool := strings.HasSuffix(s, "Z")

	fmt.Println(prefixBool, suffixBool)
  
  s = "a ac"

  // 判断是否包含 "a c"
	contains := strings.Contains(s, "a c")
	fmt.Println(contains)

  // 判断是否包含 ['b','c',' ']
	any := strings.ContainsAny(s, "b c")
	fmt.Println(any)

  // 判断是否包含 'c'
	containsRune := strings.ContainsRune(s, 'c')
	fmt.Println(containsRune)
}

---

对比相关

package main

import (
	"fmt"
	"strings"
)

func main() {
	s1 := "aa"
	s2 := "AA"

	// 底层实现就是 if s1 == s2 { return 0 }, 感觉上用处不大
	compare := strings.Compare(s1, s2)
	fmt.Println(compare)

	// 忽略大小写的比较
	fold := strings.EqualFold(s1, s2)
	fmt.Println(fold)
}

---

大小写转换相关

package main

import (
	"fmt"
	"strings"
)

func main() {
	s := "Hello world"

	// 首字母大写
	title := strings.Title(s)
	fmt.Println(title)

	// 全部大写
	toTitle := strings.ToTitle(s)
	fmt.Println(toTitle)

	// 全部大写
	toUpper := strings.ToUpper(s)
	fmt.Println(toUpper)

	// 全部小写
	toLower := strings.ToLower(toTitle)
	fmt.Println(toLower)
}

---

统计

// 字符出现次数
count := strings.Count(s, ":")