golang标准库之strings包

Contains 判断字符串是否包含子串

package main

import (
    "fmt"
    "strings"
)

func main() {
    src := "It's a cat."
    fmt.Println(strings.Contains(src, "It's"))
    fmt.Println(strings.ContainsRune(src, 'C')) //判断字符串s是否包含utf-8码值r
    fmt.Println(strings.ContainsRune(src, 83))
    fmt.Println(strings.ContainsAny(src, "ABC ")) // 判断字符串s是否包含字符串chars中的任一字符
    fmt.Println(strings.HasPrefix(src, "It's"))   // 判断s是否有前缀字符串prefix
    fmt.Println(strings.HasSuffix(src, "It's"))   // 判断s是否有后缀字符串suffix
}

判断相等&子串计数

package main

import (
    "fmt"
    "strings"
)

func main() {
    src := "It's a cat."
    // 判断相等
    fmt.Println(src == "It's a cat.")
    fmt.Println(strings.EqualFold(src, "it's a cat.")) // 判断两个utf-8编码字符串（将unicode大写、小写、标题三种格式字符视为相同）是否相同

    // 子串计数
    fmt.Println(strings.Count("srcit's srca cat.src", "src")) // 返回字符串s中有几个不重复的sep子串
    fmt.Println(strings.Count("five", ""))                    // 5
}

计算索引

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Index("it's srca cat.src", "src"))    // 子串sep在字符串s中第一次出现的位置，不存在则返回-1
    fmt.Println(strings.IndexRune("it's srca cat.src", 's'))  // unicode码值r在s中第一次出现的位置，不存在则返回-1
    fmt.Println(strings.IndexByte("it's srca cat.src", 's'))  // 字符c在s中第一次出现的位置，不存在则返回-1
    fmt.Println(strings.IndexAny("it's srca cat.src", "ABC")) // 字符串chars中的任一utf-8码值在s中第一次出现的位置，如果不存在或者chars为空字符串则返回-1
    fmt.Println(strings.IndexFunc("it's srca cat.src", func(c rune) bool {
        if c >= 'A' && c <= 'C' {
            return true
        } else {
            return false
        }
    })) // s中第一个满足函数f的位置i（该处的utf-8码值r满足f(r)==true），不存在则返回-1
    fmt.Println(strings.LastIndex("it's srca cat.src", "src"))
    fmt.Println(strings.IndexAny("it's srca cat.src", "ABC"))
    fmt.Println(strings.LastIndexFunc("it's srca cat.src", func(c rune) bool {
        if c >= 'A' && c <= 'C' {
            return true
        } else {
            return false
        }
    }))
}

大小写转换

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    var sc unicode.SpecialCase
    fmt.Println(strings.Title("it's srca cat.src"))   // 返回s中每个单词的首字母都改为标题格式的字符串拷贝
    fmt.Println(strings.ToTitle("it's srca cat.src")) // 返回将所有字母都转为对应的标题版本的拷贝
    fmt.Println(strings.ToLower("it's srca cat.src"))
    fmt.Println(strings.ToLowerSpecial(sc, "it's srca cat.src"))
    fmt.Println(strings.ToUpper("it's srca cat.src"))
    fmt.Println(strings.ToUpperSpecial(sc, "it's srca cat.src"))
}

字符串拆分&拼接

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {
    //字符串拆分
    fmt.Println(strings.Split("it'ssrcacat.src", "s"))
    fmt.Println(strings.SplitN("it'ssrcacat.src", "s", 2))
    fmt.Println(strings.SplitAfter("it'ssrcacat.src", "s"))
    fmt.Println(strings.SplitAfterN("it'ssrcacat.src", "s", 2))
    fmt.Println(strings.Fields("it's src cat  src ")) //返回将字符串按照空白（unicode.IsSpace确定，可以是一到多个连续的空白字符）分割的多个字符串。如果字符串全部是空白或者是空字符串的话，会返回空切片
    f := func(c rune) bool {
        return !unicode.IsLetter(c) && !unicode.IsNumber(c)
    }
    fmt.Println(strings.FieldsFunc("it's src cat  src ", f)) //类似Fields，但使用函数f来确定分割符（满足f的unicode码值）。如果字符串全部是分隔符或者是空字符串的话，会返回空切片

    //字符串拼接
    fmt.Println(strings.Join([]string{"foo", "bar", "baz"}, ", ")) //将一系列字符串连接为一个字符串，之间用sep来分隔
    fmt.Println(strings.Repeat("test", 5))                         //返回count个s串联的字符串
}

字符串替换

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.Replace("foo, bar, baz", ", ", " ", 1)) //返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串。
    fmt.Println(strings.Replace("foo, bar, baz", ", ", " ", -1))
    fmt.Println(strings.Map(func(r rune) rune {
        switch {
        case r >= 'A' && r <= 'Z':
            return 'A' + (r-'A'+13)%26
        case r >= 'a' && r <= 'z':
            return 'a' + (r-'a'+13)%26
        }
        return r
    }, "test")) // 将s的每一个unicode码值r都替换为mapping(r)，返回这些新码值组成的字符串拷贝。如果mapping返回一个负值，将会丢弃该码值而不会被替换。（返回值中对应位置将没有码值）
}

trim 去除首尾字符

package main

import (
    "fmt"
    "strings"
)

func main() {
    src := "It's a cat."
    fmt.Println(strings.Trim(src, ".It"))
    fmt.Println(strings.TrimSpace(src))
    fmt.Println(strings.TrimLeft(src, ".It"))
    fmt.Println(strings.TrimRight(src, ".It"))
    fmt.Println(strings.TrimPrefix(src, "It's"))
    fmt.Println(strings.TrimSuffix(src, "It's"))
    fmt.Println(strings.TrimFunc(src, func(c rune) bool {
        if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
            return true
        } else {
            return false
        }
    }))
    fmt.Println(strings.TrimRightFunc(src, func(c rune) bool {
        if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
            return true
        } else {
            return false
        }
    }))
    fmt.Println(strings.TrimLeftFunc(src, func(c rune) bool {
        if (c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z' {
            return true
        } else {
            return false
        }
    }))
}

NewReader

package main

import (
    "bytes"
    "fmt"
    "strings"
)

func main() {
    s := "<!DOCTYPE html>\n<html>\n<head>\n<meta charset=\"utf-8\">\n<title>菜鸟教程(runoob.com)</title>\n</head>\n<body>\n    <h1>我的第一个标题</h1>\n    <p>我的第一个段落。</p>\n</body>\n</html>"
    nr := strings.NewReader(s)
    // 获取字符串大小
    fmt.Println(nr.Size()) //194

    // 读取一个字节，byte类型
    fmt.Println(nr.ReadByte()) // 60 <nil>
    //获取以读指针到字符串结尾的byte长度
    fmt.Println(nr.Len())        // 193
    fmt.Println(nr.UnreadByte()) // <nil>
    fmt.Println(nr.Len())        // 194

    // 读取一个字节，rune类型
    fmt.Println(nr.ReadRune())   // 60 1 <nil>
    fmt.Println(nr.Len())        // 193
    fmt.Println(nr.UnreadRune()) // <nil>
    fmt.Println(nr.Len())        // 194

    // func (r *Reader) Seek(offset int64, whence int) (int64, error)
    //重定位读指针
    fmt.Println(nr.Seek(100, 0)) // 100 <nil>
    fmt.Println(nr.Len())        // 94

    // func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
    //从起始位置偏移off的长度读取字节，不影响读指针
    readContent := make([]byte, 100)
    fmt.Println(nr.ReadAt(readContent, 50))            // 100 <nil>
    fmt.Println(bytes.NewBuffer(readContent).String()) // ">\n<title>菜鸟教程(runoob.com)</title>\n</head>\n<body>\n    <h1>我的第一个标题</h1>\n    <p>
    fmt.Println(nr.Len())                              // 94

    // func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
    //从起始位置偏移off的长度读取字节，不影响读指针

    buf := bytes.NewBuffer(nil)  // 创建 bytes.Buffer 对象，它实现了 io.Writer 接口
    fmt.Println(nr.WriteTo(buf)) // 94 <nil>
}

NewReplacer

package main

import (
    "bytes"
    "fmt"
    "strings"
)

func main() {
    // 使用提供的多组old、new字符串对创建并返回一个*Replacer。替换是依次进行的，匹配时不会重叠
    // func NewReplacer(oldnew ...string) *Replacer
    r := strings.NewReplacer("<", "&lt;", ">", "&gt;")

    // Replace返回s的所有替换进行完后的拷贝。
    // func (r *Replacer) Replace(s string) string
    fmt.Println(r.Replace("This is <b>HTML</b>!")) // This is &lt;b&gt;HTML&lt;/b&gt;!

    // WriteString向w中写入s的所有替换进行完后的拷贝。
    // func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
    buf := bytes.NewBuffer(nil) // 创建 bytes.Buffer 对象，它实现了 io.Writer 接口
    s := "<"
    fmt.Println(r.WriteString(buf, s)) // 4 <nil>
    fmt.Println(buf)                   // &lt;
}