go strings


原文链接: go strings

Golang 字符串操作小结

本节主要说明了字符串的一些常用操作,并举例说明之。

  • 字符串比较

    func stringsCompare() {
    left := "hello"
    right := "hell"
    // 方法一,使用Compare
    // func Compare(a, b string) int
    fmt.Println(strings.Compare(left, right)) // 1
    fmt.Println(strings.Compare(right, left)) // -1
    fmt.Println(strings.Compare(left, left))  // 0
    
    // 方法二,使用比较符号
    if left > right {
        fmt.Println(">")
    } else {
        fmt.Println("<=")
    }
    }
    
  • 字符串查找

    func stringsFind() {
    s := "hello world"
    substr := "o"
    
    // 判断给定字符串s中是否包含子串substr, 找到返回true, 找不到返回false
    // func Contains(s, substr string) bool
    fmt.Println(strings.Contains(s, substr)) // true
    
    // 在字符串s中查找sep所在的位置, 返回位置值, 找不到返回-1
    // func Index(s, sep string) int
    fmt.Println(strings.Index(s, substr)) // 4
    
    // 统计给定子串sep的出现次数, sep为空时, 返回1 + 字符串的长度
    // func Count(s, sep string) int
    fmt.Println(strings.Count(s, substr)) // 2
    }
    
  • 字符串重复

    func stringsRepeat() {
    s := "hello world"
    
    // 重复s字符串count次, 最后返回新生成的重复的字符串
    // func Repeat(s string, count int) string
    fmt.Println(strings.Repeat(s, 2)) // hello worldhello world
    }
    
  • 字符串替换

    func stringsReplace() {
    s := "hello world l l l l "
    
    // 在s字符串中, 把old字符串替换为new字符串,n表示替换的次数,小于0表示全部替换
    // func Replace(s, old, new string, n int) string
    fmt.Println(strings.Replace(s, "l", "xyz", 0))  // hello world l l l l
    fmt.Println(strings.Replace(s, "l", "xyz", 1))  // hexyzlo world l l l l
    fmt.Println(strings.Replace(s, "l", "xyz", 2))  // hexyzxyzo world l l l l
    fmt.Println(strings.Replace(s, "l", "xyz", -1)) // hexyzxyzo worxyzd xyz xyz xyz xyz
    }
    
  • 字符串删除

    func stringsDelete() {
    s := "  hello world l l l l "
    
    // 删除在s字符串的头部和尾部中由cutset指定的字符, 并返回删除后的字符串
    // func Trim(s string, cutset string) string
    fmt.Println(s)                     //  hello world l l l l
    fmt.Println(strings.Trim(s, " "))  // hello world l l l l
    fmt.Println(strings.Trim(s, " l")) // hello world
    }
    
  • 字符串大小写转换

    func stringsCaseConvert() {
    s := "hello world l l l l "
    
    // 删除在s字符串的头部和尾部中由cutset指定的字符, 并返回删除后的字符串
    // func Trim(s string, cutset string) string
    fmt.Println(s)                  // hello world l l l l
    fmt.Println(strings.ToUpper(s)) // HELLO WORLD L L L L
    fmt.Println(strings.Title(s))   // Hello World L L L L
    }
    
  • 字符串前缀后缀

    func stringsPrefixSuffix() {
    s := "main.go"
    
    // 前缀和后缀的判断均为大小写敏感
    
    // 判断字符串是否包含前缀prefix
    // func HasPrefix(s, prefix string) bool
    fmt.Println(strings.HasPrefix(s, "x"))       // false
    fmt.Println(strings.HasPrefix(s, "m"))       // true
    fmt.Println(strings.HasPrefix(s, "main"))    // true
    fmt.Println(strings.HasSuffix(s, "main.go")) // true
    
    fmt.Println(strings.HasSuffix(s, "x"))       // false
    fmt.Println(strings.HasSuffix(s, "o"))       // true
    fmt.Println(strings.HasSuffix(s, ".go"))     // true
    fmt.Println(strings.HasSuffix(s, "main.go")) // true
    }
    
  • 字符串分割

    func stringsSplit() {
    s := "hello world boy    x s, grow from 3 to 5" // boy 和 x 之间是\t
    
    // 把字符串按照sep进行分割, 返回slice(类似于python中的split)
    // func Split(s, sep string) []string
    fmt.Println(strings.Split(s, " ")) // [hello world boy    x s, grow from 3 to 5]
    
    // 去除字符串s中的空格符, 并按照空格(可以是一个或者多个空格)分割字符串, 返回slice
    // func Fields(s string) []string
    fmt.Println(strings.Fields(s)) // [hello world boy x s, grow from 3 to 5]
    
    // 当字符串中字符c满足函数f(c)时, 就进行字符串s的分割
    // func FieldsFunc(s string, f func(rune) bool) []string
    f := func(c rune) bool {
        return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    }
    
    fmt.Println(strings.FieldsFunc(s, f)) // [hello world boy x s grow from 3 to 5]
    }
    
  • 字符串拼接

    func stringsAppend() {
    s := "original string"
    // 直接用+=操作符, 直接将多个字符串拼接. 最直观的方法, 不过当数据量非常大时用这种拼接访求是非常低效的.
    // 性能测试(100000次操作)
    // === RUN   Test_Plus
    // --- PASS: Test_Plus (6.29s)
    fmt.Println(s + "xxx") // original stringxxx
    
    // 用字符串切片([]string)装载所有要拼接的字符串,最后使用strings.Join()函数一次性将所有字符串拼接起来。
    // 在数据量非常大时,这种方法的效率也还可以的。
    // 性能测试(100000次操作)
    // === RUN   Test_Append
    // --- PASS: Test_Append (0.01s)
    fmt.Println(strings.Join([]string{s, "xxx"}, "")) // original stringxxx
    
    // 利用Buffer(Buffer是一个实现了读写方法的可变大小的字节缓冲),将所有的字符串都写入到一个Buffer变量中,最后再统一输出.
    // 性能测试(100000次操作)
    // === RUN   Test_WriteString
    // --- PASS: Test_WriteString (0.00s)
    bf := bytes.Buffer{}
    fmt.Println(bf.WriteString(s)) // 15 <nil>
    fmt.Println(bf.String())       // original string
    }
    
  • 字符串转换

    func stringsConvert() {
    // 字符串转换函数在strconv中
    str := make([]byte, 0, 100)
    str = strconv.AppendInt(str, 123, 10)
    str = strconv.AppendBool(str, false)
    str = strconv.AppendQuote(str, "abc")
    str = strconv.AppendQuoteRune(str, '嗨')
    fmt.Println(string(str)) // 123false"abc"'嗨
    
    s := strconv.FormatBool(true)
    fmt.Printf("%T, %v\n", s, s) // string, true
    v := 3.1415926535
    s32 := strconv.FormatFloat(v, 'E', -1, 32)
    fmt.Printf("%T, %v\n", s32, s32) // string, 3.1415927E+00
    s10 := strconv.FormatInt(-44, 10)
    fmt.Printf("%T, %v\n", s10, s10) // string, -44
    
    num := strconv.Itoa(1234)
    fmt.Printf("%T, %v\n", s, s)     // int, 1023
    fmt.Printf("%T, %v\n", num, num) // string, 1234
    }
    

本节完整源码:https://github.com/LeungGeorge/master/blob/master/golang/string/main.go

`