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 := "\n\n\n\n菜鸟教程(runoob.com)\n\n\n    

我的第一个标题

\n

我的第一个段落。

\n\n" nr := strings.NewReader(s) // 获取字符串大小 fmt.Println(nr.Size()) //194 // 读取一个字节,byte类型 fmt.Println(nr.ReadByte()) // 60 //获取以读指针到字符串结尾的byte长度 fmt.Println(nr.Len()) // 193 fmt.Println(nr.UnreadByte()) // fmt.Println(nr.Len()) // 194 // 读取一个字节,rune类型 fmt.Println(nr.ReadRune()) // 60 1 fmt.Println(nr.Len()) // 193 fmt.Println(nr.UnreadRune()) // fmt.Println(nr.Len()) // 194 // func (r *Reader) Seek(offset int64, whence int) (int64, error) //重定位读指针 fmt.Println(nr.Seek(100, 0)) // 100 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 fmt.Println(bytes.NewBuffer(readContent).String()) // ">\n菜鸟教程(runoob.com)\n\n\n

我的第一个标题

\n

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 }

NewReplacer
package main

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

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

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

    // 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 
    fmt.Println(buf)                   // <
}

你可能感兴趣的:(golang标准库之strings包)