Golang 标准库

strings

import strings

stringsReaderReplacer

1. strings 常用导出函数

判断字符串与子串关系

func EqualFold(s, t string) boolfunc HasPrefix(s, prefix string) boolfunc Contains(s, substr string) boolfunc ContainsAny(s, chars string) boolfunc Count(s, sep string) int

获取字符串中子串位置

func Index(s, sep string) intfunc IndexByte(s string, c byte) intfunc IndexAny(s, chars string) intfunc IndexFunc(s string, f func(rune) bool) intfunc LastIndex(s, sep string) int

字符串中字符处理

func Title(s string) stringfunc ToLower(s string) stringfunc ToUpper(s string) stringfunc Repeat(s string, count int) stringfunc Replace(s, old, new string, n int) stringfunc Map(mapping func(rune) rune, s string) string

字符串前后端处理

func Trim(s string, cutset string) stringfunc TrimSpace(s string) stringfunc TrimFunc(s string, f func(rune) bool) string

字符串分割与合并

func Fields(s string) []stringfunc Split(s, sep string) []stringfunc Join(a []string, sep string) string

strings

$GOPATH/src/github.com/ironxu/go_note/library/strings/strings.go

// go 标准库 strings
package main

import (
    "fmt"
    "strings"
)

func main() {
    // 判断两个utf-8编码字符串，大小写不敏感
    s, t := "hello go", "hello Go"
    is_equal := strings.EqualFold(s, t)
    fmt.Println("EqualFold: ", is_equal) // EqualFold:  true

    // 判断s是否有前缀字符串prefix
    prefix := "hello"
    has_prefix := strings.HasPrefix(s, prefix)
    fmt.Println(has_prefix) // true

    // 判断s是否有后缀字符串suffix
    suffix := "go"
    has_suffix := strings.HasSuffix(s, suffix)
    fmt.Println(has_suffix) // true

    // 判断字符串s是否包含子串substr
    substr := "lo"
    con := strings.Contains(s, substr)
    fmt.Println(con) // true

    // 判断字符串s是否包含utf-8码值r
    r := rune(101)
    ru := 'e'
    con_run := strings.ContainsRune(s, r)
    fmt.Println(con_run, r, ru) // true

    // 子串sep在字符串s中第一次出现的位置，不存在则返回-1
    sep := "o"
    sep_idnex := strings.Index(s, sep)
    fmt.Println(sep_idnex) // 4

    // 子串sep在字符串s中最后一次出现的位置，不存在则返回-1
    sep_lastindex := strings.LastIndex(s, sep)
    fmt.Println(sep_lastindex) // 7

    // 返回s中每个单词的首字母都改为标题格式的字符串拷贝
    title := strings.Title(s)
    fmt.Println(title) // Hello Go

    // 返回将所有字母都转为对应的标题版本的拷贝
    to_title := strings.ToTitle(s)
    fmt.Println(to_title) // HELLO GO

    // 返回将所有字母都转为对应的小写版本的拷贝
    s_lower := strings.ToLower(s)
    fmt.Println(s_lower) // hello go

    // 返回count个s串联的字符串
    s_repeat := strings.Repeat(s, 3)
    fmt.Println(s_repeat) // hello gohello gohello go

    // 返回将s中前n个不重叠old子串都替换为new的新字符串，如果n<0会替换所有old子串
    s_old, s_new := "go", "world"
    s_replace := strings.Replace(s, s_old, s_new, -1)
    fmt.Println(s_replace) // hello world

    // 返回将s前后端所有cutset包含的utf-8码值都去掉的字符串
    s, cutset := "#abc!!!", "#!"
    s_new = strings.Trim(s, cutset)
    fmt.Println(s, s_new) // #abc!!! abc

    // 返回将字符串按照空白（unicode.IsSpace确定，可以是一到多个连续的空白字符）分割的多个字符串
    s = "hello world! go language"
    s_fields := strings.Fields(s)
    for k, v := range s_fields {
        fmt.Println(k, v)
    }
    // 0 hello
    // 1 world!
    // 2 go
    // 3 language

    // 用去掉s中出现的sep的方式进行分割，会分割到结尾，并返回生成的所有片段组成的切片
    s_split := strings.Split(s, " ")
    fmt.Println(s_split) // [hello world! go language]

    // 将一系列字符串连接为一个字符串，之间用sep来分隔
    s_join := strings.Join([]string{"a", "b", "c"}, "/")
    fmt.Println(s_join) // a/b/c

    // 将s的每一个unicode码值r都替换为mapping(r)，返回这些新码值组成的字符串拷贝。如果mapping返回一个负值，将会丢弃该码值而不会被替换
    map_func := func(r rune) rune {
        switch {
        case r > 'A' && r < 'Z':
            return r + 32
        case r > 'a' && r < 'z':
            return r - 32
        }
        return r
    }
    s = "Hello World!"
    s_map := strings.Map(map_func, s)
    fmt.Println(s_map) // hELLO wORLD!
}

• 2. Reader 结构体

Readerio.Readerio.Seeker

func NewReader(s string) *ReadersReaderfunc (r *Reader) Len() intrfunc (r *Reader) Read(b []byte) (n int, err error)bbfunc (r *Reader) ReadByte() (b byte, err error)r

$GOPATH/src/github.com/ironxu/go_note/library/strings/reader.go

// go 标准库 strings.Reader
package main

import (
    "fmt"
    "strings"
)

func main() {
    s := "hello world"
    // 创建 Reader
    r := strings.NewReader(s)

    fmt.Println(r) // &{hello world 0 -1}
    fmt.Println(r.Size()) // 11 获取字符串长度
    fmt.Println(r.Len()) // 11 获取未读取长度

    // 读取前6个字符
    for r.Len() > 5 {
        b, err := r.ReadByte() // 读取1 byte
        fmt.Println(string(b), err, r.Len(), r.Size())
        // h <nil> 10 11
        // e <nil> 9 11
        // l <nil> 8 11
        // l <nil> 7 11
        // o <nil> 6 11
        //   <nil> 5 11
    }

    // 读取还未被读取字符串中5字符的数据
    b_s := make([]byte, 5)
    n, err := r.Read(b_s)
    fmt.Println(string(b_s), n ,err) // world 5 <nil>
    fmt.Println(r.Size()) // 11
    fmt.Println(r.Len()) // 0
}

3. Replacer 结构体

Replacer

func NewReplacer(oldnew ...string) *Replacerfunc (r *Replacer) Replace(s string) stringsfunc (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)

$GOPATH/src/github.com/ironxu/go_note/library/strings/replace.go

// go 标准库 strings.Replacer
package main

import (
    "fmt"
    "strings"
    "os"
)

func main() {
    s := "<p>Go Language</p>"
    r := strings.NewReplacer("<", "&lt;", ">", "&gt;")
    fmt.Println(r.Replace(s))

    r.WriteString(os.Stdout, s)
}

--------------------- 本文来自 好刚 的CSDN 博客 ，全文地址请点击：https://blog.csdn.net/sanxiaxugang/article/details/60324012?utm_source=copy