方法列表
方法名 | 描述 |
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 | 对比两个字符串是否相同, 底层就是 |
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, ":")