Strings

strings.Split #

func Split(s, sep string) []string

strings.Split 函数用于通过指定的分隔符切割字符串，并返回切割后的字符串切片。

func main() {
	fmtPrintln(stringsSplit("Linux, Unix, Windows, Android", ", "))
	fmtPrintln(stringsSplit(" Linux is very very very good! ", " "))
}
输出：返回的是字符串数组。
[Linux Unix Windows Android]
[ Linux is very very very good! ]

strings.Split(s, sep)
1
s：待分割的字符串（字符串类型的参数）
sep：分隔符 （字符串类型的参数）
返回值：
返回一个字符串切片。

strings.Join #

func Join(elems []string, sep string) string

作用：使用 sep 作为分隔符，将elems 中的所有字符连接起来：

func main() {
 		elems := []string{"I", "like", "golang", "!"}
 		fmt.Println(strings.Join(elems, " "))
 		elems = []string{"123", "456", "789"}
 		fmt.Println(strings.Join(elems, "-"))
 }

I like golang !
123-456-789

strings.ToUpper #

func ToUpper(s string) string

作用：返回字符串 s 中字母转大写的拷贝

func main() {
		fmt.Println(strings.ToUpper("Linux, Unix, Windows, Android"))
		fmt.Println(strings.ToUpper(" Linux is very very very good! "))
}

输出： LINUX, UNIX, WINDOWS, ANDROID LINUX IS VERY VERY VERY GOOD!

	for i:=0;i<n;i++{  //自己编写
        if s1[i] >= 'A' && s1[i] <= 'Z' {
			s1[i] = s1[i] - 'A' + 'a'
		} else if s1[i] >= 'a' && s1[i] <= 'z'{
			s1[i] = s1[i] - 'a' + 'A'
		}
	}

strings.ToLower #

func ToLower(s string) string

作用：返回字符串 s 中字母转小写的拷贝

func main() {
  fmt.Println(strings.ToLower("Linux, Unix, Windows, Android"))
  fmt.Println(strings.ToLower(" Linux is very very very good! "))
}

输出：
linux, unix, windows, android
linux is very very very good!

strings.Replace #

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

作用：返回 s 中前 n 个不重复的 old 子串替换为 new 子串的新字符串，如果 n < 0 ，则替换所有 old 子串

func main() {
  fmt.Println(strings.Replace("Linux is very very very good!", "very", "much", 2))
  fmt.Println(strings.Replace("Linux is very very very good!", "very", "much", -1))
}

输出：
Linux is much much very good!
Linux is much much much good!

strings.HasSuffix #

func HasSuffix(s, suffix string) bool

作用：判断字符串 s 是否以 suffix 结尾

func main() {
	fmt.Println(strings.HasSuffix("Linux", "nux"))
	fmt.Println(strings.HasSuffix("Linux", "ix"))
	fmt.Println(strings.HasSuffix("Linux", ""))
}

输出：
true
false
true

strings.HasPrefix #

func HasPrefix(s, prefix string) bool

作用：字符串 s 是否以 prefix 为开头

func main() {
	fmt.Println(strings.HasPrefix("Linux", "Lin"))
 	fmt.Println(strings.HasPrefix("Linux", "in"))
 	fmt.Println(strings.HasPrefix("Linux", ""))
}

输出：
true
false
true

strings.TrimPrefix #

func TrimPrefix(s, prefix string) string

作用：字符串去除prefix开头

func main() {
	fmt.Println(strings.TrimPrefix("Linux", "Lin"))
 	fmt.Println(strings.TrimPrefix("Linux", "in"))
}

输出：
ux
Linux

strings.Contains #

作用：判断 substr 是否是 s 的子串

func Contains(s, substr string) bool

func main() {
  fmtPrintln(stringsContains("Linux", "in"))
  fmtPrintln(stringsContains("Linux", "Unix"))
  fmtPrintln(stringsContains("Linux", ""))
  fmtPrintln(stringsContains("", ""))
}

输出：
true
false
true
true

strings.Index #

用于查找子字符串在另一个字符串中第一次出现的位置,如果找到子字符串，则返回其起始索引；如果未找到，则返回-1。

func main() {
    str := "Hello, world!"
    substr := "world"
    index := strings.Index(str, substr)
    if index != -1 {
        fmt.Printf("The substring '%s' found at index %d\n", substr, index)
    } else {
        fmt.Printf("The substring '%s' not found\n", substr)
    }
}

strings.Count #

strings.Count(s, substr string) int

计算字符串s中子串substr的出现次数，并返回结果。

strings.Index #

strings.Index(s, substr string) int

返回字符串s中第一次出现子串substr的位置索引，如果未找到则返回-1。

strings.LastIndex #

strings.LastIndex(s, substr string) int

返回字符串s中最后一次出现子串substr的位置索引，如果未找到则返回-1。

strings.TrimSpace #

strings.TrimSpace(s string) string

去除字符串s开头和结尾的空白字符（包括空格、制表符、换行符等），并返回去除空白字符后的新字符串。

strings.Trim #

strings.Trim(s string, cutset string) string

去除字符串s开头和结尾处包含在cutset中的字符，并返回去除后的新字符串。

strings.TrimLeft #

strings.TrimLeft(s string, cutset string) string

去除字符串s开头处包含在cutset中的字符，并返回去除后的新字符串。

strings.TrimRight #

strings.TrimRight(s string, cutset string) string

去除字符串s结尾处包含在cutset中的字符，并返回去除后的新字符串。

strings.TrimSuffix #

去除字符串末尾的指定后缀。如果字符串不以指定的后缀结尾，则返回原字符串。

func TrimSuffix(s, suffix string) string

strings.Fields #

strings.Fields(s string) []string

将字符串s根据连续的空白字符（包括空格、制表符、换行符等）进行分割，返回一个字符串切片。

strings.Repeat #

strings.Repeat(s string, count int) string

将字符串s重复count次，并返回重复后的新字符串。

strings.Compare #

strings.Compare(a, b string) int

比较字符串a和字符串b，按字典顺序比较，返回一个整数表示比较结果（0 表示相等，-1 表示a小于b，1 表示a大于b）。

strings.NewReader #

strings.NewReader(s string) *strings.Reader

创建一个新的Reader对象，该对象可用于从字符串s中读取数据。

func main() {
	str := "Hello, World!"
	// 使用strings.NewReader创建一个读取器
	reader := strings.NewReader(str)
	// 使用标准库中的Read函数读取字符串内容
	buffer := make([]byte, 5)
	for {
		n, err := reader.Read(buffer)
		if err == io.EOF {
			break
		}
		fmt.Print(string(buffer[:n]))
	}
}

在上述示例中，我们首先使用strings.NewReader函数创建了一个读取器reader，并将字符串"Hello, World!“作为参数传递给它。然后，我们使用Read函数从读取器中读取内容，并将其存储在缓冲区buffer中。最后，我们将读取的内容打印出来。

strings.NewReplacer #

strings.NewReplacer(oldnew ...string) *strings.Replacer

创建一个Replacer对象，用于执行字符串的批量替换操作。它可以同时替换多个字符串。NewReplacer函数接受一对或多对字符串参数，每一对参数中的第一个字符串是待替换的目标字符串，第二个字符串是替换目标字符串的字符串。

func main() {
	str := "Hello, World! Hello, Go!"

	// 创建一个Replacer实例
	replacer := strings.NewReplacer("Hello", "Hi", "World", "Gopher")

	// 使用Replace方法替换字符串
	newStr := replacer.Replace(str)

	fmt.Println(newStr)
}

通过strings.NewReplacer函数将字符串"Hello"替换为"Hi”，“World"替换为"Gopher”。然后，我们使用Replace方法将目标字符串str中的目标字符串替换为指定的字符串。

strings.Builder #

strings.Builder：这是一个结构体类型，提供了用于构建字符串的高效方法。可以使用strings.Builder类型的变量来拼接字符串，而不需要每次都创建新的字符串。

需要注意的是，strings包中的函数和方法操作的都是不可变的字符串，即每个操作都会返回一个新的字符串。如果你需要对字符串进行频繁的修改操作，推荐使用strings.Builder或者bytes.Buffer来提高性能。

strings.Builder在进行字符串拼接时，具有较低的内存分配和拷贝开销，因此比直接使用+或+=操作符来拼接字符串更高效。因此，在需要频繁拼接字符串的场景下，推荐使用strings.Builder来提高性能。

func main() {
	var builder strings.Builder

	// 添加字符串
	builder.WriteString("Hello, ")
	builder.WriteString("World!")

	// 获取拼接后的字符串
	result := builder.String()

	fmt.Println(result) // 输出: Hello, World!
}

builder.Len #

builder.Len() int

获取当前构建的字符串长度。

builder.Cap #

builder.Cap() int

获取当前构建的字符串的容量。

builder.WriteByte #

builder.WriteByte(c byte) error

向构建器添加一个字节。

builder.WriteRune #

builder.WriteRune(r rune) (int, error)

向构建器添加一个Unicode字符

builder.WriteString #

builder.WriteString(s string) (int, error)

向构建器添加一个字符串。该方法返回写入的字节数和可能的错误。你可以利用这个信息来进行错误处理或其他逻辑。

builder := strings.Builder{}
n, err := builder.WriteString("Hello, ")
if err != nil {
    // 处理错误
}
fmt.Printf("写入的字节数: %d\n", n) // 输出: 写入的字节数: 7

builder.WriteTo #

builder.WriteTo(w io.Writer) (int64, error)

该方法将构建的字符串写入实现了io.Writer接口的目标对象，并返回写入的字节数和可能的错误。

goCopy codebuilder := strings.Builder{}
builder.WriteString("Hello, World!")
n, err := builder.WriteTo(os.Stdout)
if err != nil {
    // 处理错误
}
fmt.Printf("写入的字节数: %d\n", n) // 输出: 写入的字节数: 13

builder.ReadFrom #

builder.ReadFrom(r io.Reader) (int64, error)

该方法从实现了io.Reader接口的源对象中读取数据，并将读取的内容添加到构建器中。它返回读取的字节数和可能的错误。

goCopy codebuilder := strings.Builder{}
n, err := builder.ReadFrom(strings.NewReader("Hello, World!"))
if err != nil {
    // 处理错误
}
fmt.Printf("读取的字节数: %d\n", n) // 输出: 读取的字节数: 13
result := builder.String()
fmt.Println(result) // 输出: Hello, World!

builder.WriteByte #

builder.WriteByte(c byte) 和 builder.WriteRune(r rune)

这两个方法分别用于向构建器添加单个字节和单个Unicode字符。它们不仅可以用于添加ASCII字符，还可以用于添加任意字节或字符。

goCopy codebuilder := strings.Builder{}
builder.WriteByte(72)  // 字节 'H'
builder.WriteRune('你') // Unicode字符 '你'
result := builder.String()
fmt.Println(result) // 输出: H你

builder.Write #

builder.Write([]byte) (int, error)

向构建器添加一个字节切片。

builder.Grow #

builder.Grow(n int)

增加构建器的容量，确保可以容纳至少n个字节的字符串。

builder.Truncate #

builder.Truncate(n int)

将构建的字符串截断为n个字节长度。

builder.String #

builder.String() string

获取构建的最终字符串。

builder.Reset #

builder.Reset()

重置构建器，将其状态重置为初始值。