当前位置：首页 > article >正文

go strings查找手册

article 2024/11/16 2:36:38

package main

import (
    "fmt"
    "strings"
)

func main() {
    // 1. 字符串查找相关函数
    fmt.Println("=== 字符串查找 ===")
    str := "Hello, World! Hello, Go!"
    
    // Contains - 判断是否包含子串
    fmt.Printf("Contains 'World': %v\n", strings.Contains(str, "World"))        // true
    fmt.Printf("Contains 'world': %v\n", strings.Contains(str, "world"))        // false
    
    // ContainsAny - 判断是否包含字符集合中的任一字符
    fmt.Printf("ContainsAny '123!': %v\n", strings.ContainsAny(str, "123!"))   // true
    
    // Count - 计算子串出现次数
    fmt.Printf("Count 'Hello': %v\n", strings.Count(str, "Hello"))             // 2
    
    // Index - 查找子串第一次出现的位置
    fmt.Printf("Index 'World': %v\n", strings.Index(str, "World"))             // 7
    fmt.Printf("Index 'Python': %v\n", strings.Index(str, "Python"))           // -1
    
    // LastIndex - 查找子串最后一次出现的位置
    fmt.Printf("LastIndex 'Hello': %v\n", strings.LastIndex(str, "Hello"))     // 14

    // 2. 字符串转换相关函数
    fmt.Println("\n=== 字符串转换 ===")
    
    // ToUpper/ToLower - 大小写转换
    fmt.Printf("ToUpper: %v\n", strings.ToUpper(str))
    fmt.Printf("ToLower: %v\n", strings.ToLower(str))
    
    // Title - 每个单词首字母大写
    fmt.Printf("Title: %v\n", strings.Title("hello world"))
    
    // 3. 字符串修剪相关函数
    fmt.Println("\n=== 字符串修剪 ===")
    spacedStr := "  Hello, World!  "
    
    // Trim - 去除两端指定字符
    fmt.Printf("Trim spaces: '%v'\n", strings.TrimSpace(spacedStr))
    
    // TrimLeft/TrimRight - 去除左边或右边指定字符
    fmt.Printf("TrimLeft spaces: '%v'\n", strings.TrimLeft(spacedStr, " "))
    fmt.Printf("TrimRight spaces: '%v'\n", strings.TrimRight(spacedStr, " "))
    
    // TrimPrefix/TrimSuffix - 去除前缀或后缀
    str2 := "test.txt"
    fmt.Printf("TrimSuffix: '%v'\n", strings.TrimSuffix(str2, ".txt"))
    
    // 4. 字符串分割和连接
    fmt.Println("\n=== 字符串分割和连接 ===")
    
    // Split - 按分隔符分割字符串
    parts := strings.Split("a,b,c", ",")
    fmt.Printf("Split: %v\n", parts)
    
    // SplitN - 指定分割次数
    partsN := strings.SplitN("a,b,c,d", ",", 2)
    fmt.Printf("SplitN: %v\n", partsN)
    
    // Join - 连接字符串切片
    joined := strings.Join([]string{"Hello", "World"}, " ")
    fmt.Printf("Join: %v\n", joined)

    // 5. 字符串替换
    fmt.Println("\n=== 字符串替换 ===")
    
    // Replace - 替换指定次数
    replaced := strings.Replace("hello hello hello", "hello", "hi", 2)
    fmt.Printf("Replace: %v\n", replaced)
    
    // ReplaceAll - 替换所有
    replacedAll := strings.ReplaceAll("hello hello hello", "hello", "hi")
    fmt.Printf("ReplaceAll: %v\n", replacedAll)

    // 6. 字符串比较
    fmt.Println("\n=== 字符串比较 ===")
    
    // Compare - 字符串比较
    fmt.Printf("Compare 'a' and 'b': %v\n", strings.Compare("a", "b"))     // -1
    fmt.Printf("Compare 'b' and 'a': %v\n", strings.Compare("b", "a"))     // 1
    fmt.Printf("Compare 'a' and 'a': %v\n", strings.Compare("a", "a"))     // 0
    
    // EqualFold - 忽略大小写比较
    fmt.Printf("EqualFold: %v\n", strings.EqualFold("Hello", "hello"))     // true

    // 7. 字符串检查
    fmt.Println("\n=== 字符串检查 ===")
    
    // HasPrefix - 检查前缀
    fmt.Printf("HasPrefix: %v\n", strings.HasPrefix("Hello, World", "Hello"))  // true
    
    // HasSuffix - 检查后缀
    fmt.Printf("HasSuffix: %v\n", strings.HasSuffix("Hello, World", "World")) // true

    // 8. 字符串重复
    fmt.Println("\n=== 字符串重复 ===")
    
    // Repeat - 重复字符串
    repeated := strings.Repeat("Go! ", 3)
    fmt.Printf("Repeat: %v\n", repeated)

    // 9. 字符串映射
    fmt.Println("\n=== 字符串映射 ===")
    
    // Map - 字符映射转换
    mapped := strings.Map(func(r rune) rune {
        if r == 'o' {
            return '0'
        }
        return r
    }, "Hello World")
    fmt.Printf("Map: %v\n", mapped)

    // 10. 字符串生成器 (Builder)
    fmt.Println("\n=== 字符串生成器 ===")
    var builder strings.Builder
    builder.WriteString("Hello")
    builder.WriteString(" ")
    builder.WriteString("World")
    fmt.Printf("Builder result: %v\n", builder.String())
    fmt.Printf("Builder capacity: %v\n", builder.Cap())
    fmt.Printf("Builder length: %v\n", builder.Len())
}

// 自定义字符串处理函数示例
func customStringUtils() {
    // 1. 自定义分词函数
    splitFunc := func(data []byte, atEOF bool) (advance int, token []byte, err error) {
        // 实现自定义分词逻辑
        return
    }
    
    // 使用自定义分词器
    str := "custom,split;function"
    scanner := bufio.NewScanner(strings.NewReader(str))
    scanner.Split(splitFunc)
    
    // 2. 自定义字符串过滤
    filter := func(r rune) bool {
        return unicode.IsLetter(r) || unicode.IsNumber(r)
    }
    filtered := strings.Map(func(r rune) rune {
        if filter(r) {
            return r
        }
        return -1
    }, "Hello123,World!")
    
    // 3. 自定义字符串转换
    transform := func(r rune) rune {
        if unicode.IsLower(r) {
            return unicode.ToUpper(r)
        }
        return unicode.ToLower(r)
    }
    transformed := strings.Map(transform, "Hello,World!")
}

1. 查找函数

// 包含关系
strings.Contains(s, substr)      // 是否包含子串
strings.ContainsAny(s, chars)    // 是否包含字符集合中的任一字符
strings.ContainsRune(s, r)       // 是否包含特定 rune

// 位置查找
strings.Index(s, substr)         // 子串首次出现的位置
strings.LastIndex(s, substr)     // 子串最后出现的位置
strings.IndexAny(s, chars)       // 字符集合中任一字符首次出现的位置

// 计数
strings.Count(s, substr)         // 子串出现的次数

2. 转换函数

// 大小写转换
strings.ToUpper(s)              // 转大写
strings.ToLower(s)              // 转小写
strings.Title(s)                // 单词首字母大写

// 特殊转换
strings.ToTitle(s)              // 特殊大写转换
strings.ToUpperSpecial(c, s)    // 特定大写转换规则

3. 修剪函数

// 空白处理
strings.TrimSpace(s)            // 去除两端空白
strings.Trim(s, cutset)         // 去除两端指定字符
strings.TrimLeft(s, cutset)     // 去除左边指定字符
strings.TrimRight(s, cutset)    // 去除右边指定字符

// 前缀后缀
strings.TrimPrefix(s, prefix)   // 去除前缀
strings.TrimSuffix(s, suffix)   // 去除后缀

4. 分割和连接

// 分割
strings.Split(s, sep)           // 分割字符串
strings.SplitN(s, sep, n)       // 指定分割次数
strings.SplitAfter(s, sep)      // 保留分隔符分割
strings.Fields(s)               // 按空白分割

// 连接
strings.Join(elems, sep)        // 使用分隔符连接字符串切片

5. 替换函数

strings.Replace(s, old, new, n)     // 替换指定次数
strings.ReplaceAll(s, old, new)     // 替换所有

6. 比较函数

strings.Compare(a, b)               // 字符串比较
strings.EqualFold(s1, s2)          // 忽略大小写比较

7. 前缀后缀检查

strings.HasPrefix(s, prefix)        // 检查前缀
strings.HasSuffix(s, suffix)        // 检查后缀

8. Builder（字符串构建器）

var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(" World")
result := builder.String()

9. 实用功能

// 重复
strings.Repeat(s, count)            // 重复字符串

// 映射
strings.Map(mapping func(rune) rune, s string)  // 字符映射

// Reader
strings.NewReader(s)                // 创建字符串读取器