Golang - strings 包的使用

// 创建 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, ":")