Overview

strings包提供了简单的函数操作UTF-8编码的字符串

Functions

func Compare(a, b string) int

以字典序比较两个字符串并返回结果,如果结果大于0,说明a大于b,结果等于0,表明a等于b,结果小于0,表明a小于b 提供此函数是为了和包bytes提供一致性,使用内置的= ><会更快更清晰

func Contains(s, substr string) bool

判断substr是否是s的子串

func ContainsAny(s, chars string) bool

判断是否存在任何chars中的Unicode码点存在于s

func ContainsRune(s string, r rune) bool

判断s中是否存在Unicode码点r

func Count(s, substr string) int

返回substr非重叠实例在s中出现次数

package main

import (
	"strings"
	"fmt"
)

func main() {
	text := "hello, world"
	if strings.ContainsAny(text, "w") {
		fmt.Println(text)
	}
	count := strings.Count(text, "o")
	fmt.Println(count)
}

func EuqalFold(s, t string) bool

EuqalFold判断s,t以Unicode大小写折叠的情况下,是否相同

func Fields(s string) []string

Fields分割s每个周围是连续空白字符(由unicode.IsSpace定义)的实例,如果s中只包含空白符,将会返回空切片

func FiledsFunc(s string, f func(r rune) bool) []string

FieldsFunc在每个符合f(c)的Unicode码点c处进行分割,并返回其切片,如果s中所有Unicode码点都符合或s为空,将会返回空切片,FieldsFunc不保证调用f(c)的顺序,如果f(c)没有给出一致的结果,FieldsFunc可能会崩溃

package main
import (
	"strings"
	"fmt"
)

func main() {
	text := "strings bytes strconv bufio"
	words := strings.Fields(text)
	for _, word := range words {
		fmt.Println(word)
	}
	split := func(r rune) bool {
		if string(r) == "s" {
			return true
		}
		return false
	}
	exceptStr := strings.FieldsFunc(text, split)
	for _, except := range exceptStr {
		fmt.Println(except)
	}
}

func HasPrefix(s, prefix string) bool

判断prefix是否是s的前缀

func HasSuffix(s, suffix string) bool

判断suffix是否是s的后缀

func Index(s, substr string) int

返回substr在s中第一次出现的索引,如果不存在返回-1

func IndexAny(s, chars string) int

找出chars任何码点在s中第一次出现的索引,如果不存在返回-1

func IndexByte(s string, c byte) int

返回c在s中第一次出现的位置,如果不存在,返回-1

func IndexFunc(s string, f func(r rune) bool) int

在s中找出第一个符合f(c)的Unicode码点位置,如果不存在返回-1

func IndexRune(s string, r rune) int

在s中找出第一个r的位置,如果不存在,返回-1

package main
import (
	"strings"
	"fmt"
)

func main() {
	text := "hello, world!"
	worldPos := strings.Index(text, "world")
	if worldPos != -1 {
		fmt.Println(worldPos)
	}
	selectPos := strings.IndexAny(text, "qwbr")
	if selectPos != -1 {
		fmt.Println(selectPos)
	}
	ctext := "您好,世界!"
	cPos := strings.IndexRune(ctext, '\u4e16')
	if cPos != -1 {
		fmt.Println(cPos)
	}
}

func Join(a []string, sep string) []string

Join连接a中的元素为一个字符串,元素之间使用sep连接

func LastIndex(s, substr string) int

返回substr在s中最后一次出现的位置,如果不存在,返回-1

func LastIndexAny(s, chars string) int

返回chars任意元素在s中最后一次出现的位置,如果不存在,返回-1

func LastIndexByte(s string, c byte) int

返回c在s中最后一次出现的位置,如果不存在,返回-1

func LastIndexFunc(s string, f func(r rune) bool) int

返回最后一个符合f(c)的c在s中位置,如果不存在,返回-1

package main
import (
	"strings"
	"fmt"
)

func main() {
	text := "abcbabcdbfe"
	prefix := "abc"
	suffix := "dbfe"
	if strings.HasPrefix(text, prefix) {
		fmt.Println(prefix)
	}
	if strings.HasSuffix(text, suffix) {
		fmt.Println(suffix)
	}
	lastPos := strings.LastIndex(text, prefix)
	if lastPos != -1 {
		fmt.Println(lastPos)
	}
	lastPos = strings.LastIndexAny(text, "bef")
	if lastPos != -1 {
		fmt.Println(lastPos)
	}
	list := []string{"Marco", "Epsilon", "sig"}
	fmt.Println(strings.Join(list, " "))
}

func Map(mapping func(rune) rune, s string) string

Map返回通过mapping修改的s副本,如果mapping产生负值,该值将不会被替换

func Repeat(s string, count int) string

返回一个s连续复制count次的新字符串如果count为负或(len(s) * count)溢出将会造成panic

func Replace(s, old, new string, count int) string

Replace返回前n个s中old被替换为new后s的副本,如果old为空字符串,它匹配每个UTF-8序列的开始,产生k+1替换一个k-rune string,如果n < 0,则会没有限制的替换

func ReplaceAll(s, old, new string) string

等价于Replace(s, old, new, -1)

func Split(s, sep string) []string

按照sep分割s,并返回其分割后产生的列表如果s中不含sep,且sep非空,函数将会返回一个整个s 如果sep为空,将会在每个UTF-8序列后分割,如果二者皆为空,将会返回空列表等价于count为-1的SplitN

func SplitAfter(s, sep string) []string

在字符串sep后分割,返回分割后的列表如果s不含sep且sep非空,将会返回真整个字符串如果sep为空,则在每个UTF-8序列处分割,如果s和sep都为空,将会返回空切片等价于count为-1的SplitAfterN

func SplitAfterN(s, sep string, n int) []string

在字符串sep后处分割,并返回切片返回的切片大小与n有关
n > 0 最多返回n个子字符串,最后一个子字符串是未分割的 n == 0,不发生分割,返回nil n < 0,返回所以子字符串

func SplitN(s, sep string, n int) []string

和SplitAfterN类似,不过它在sep处分割

func Title(s string) string

返回所有s中所有Unicode words的Unicode字母映射为Unicode Title的副本 Bug(rsc):对于单词边界为Unicode标点符号Unicode Title不能恰当处理

package main
import (
	"fmt"
	"strings"
)

func main() {
	text := "hello, world"
	trans := strings.Map(func(r rune) rune {return r + 2}, text)
	fmt.Println(trans)
	split := strings.Split(text, ",")
	fmt.Printf("%q\n", split)
	replaced := strings.Replace(text, "o", "*", -1)
	fmt.Println(replaced)
	titled := strings.Title(text)
	fmt.Println(titled)
	splitAfter := strings.SplitAfterN(text, ",", -1)
	fmt.Printf("%q\n", splitAfter)
}

func ToLower(s string) string

返回将s转换为小写的副本

func ToLowerSpecial(c unicode.SpecialCase, s string) string

返回由unicode.SpecialCase映射的Unicode字母的小写副本

func ToTitle(s string) string

返回s所有Unicode字母的Title Case的副本

func ToTitleSpecial(c unicode.SpecialCase, s string) string

返回所有s中所有Unicode字母通过指定c映射的Title Case副本

func ToUpper(s string) string

返回s中Unicode字母的大写副本

func ToUpperSpecial(c unicode.SpecialCase, s string) string

返回s中所有Unicode字母指定c映射的Upper Case副本

func ToValidUTF8(s string, replacement string) string

返回s中不合理UTF-8字符被replacement替换的副本

func Trim(s, cutset string) string

Trim返回移除s中前导和后导含有cutset字符的副本

func TrimFunc(s string, f func(r rune) bool) string

返回移除前导和后导中含有符合f(c)的副本

func TrimLeft(s, cutset string) string

TrimLeft返回移除s中前导含有cutset中Unicode码点的副本 Ps:为了移除前缀,可以使用TrimPrefix

func TrimLeftFunc(s string, f func(r rune) bool) string

返回移除前导字符符合f(c)的副本

func TrimPrefix(s, prefix) string

返回移除s指定前缀prefix的副本

func TrimRight(s string, cutset string) string

返回s后导移除包含cutset字符的副本

func TrimRightFunc(s string, f func(r rune) bool) string

返回移除后导字符符合f(c)后的副本

func TrimSpace(s string) string

返回移除s两边空白的副本

func TrimSuffix(s, suffix string) string

返回s移除后缀suffix的副本

package main
import (
	"fmt"
	"strings"
)

func main() {
	text := "!-!-hello, world--!"
	trimed := strings.Trim(text, "-!")
	fmt.Println(trimed)
	trimLeft := strings.TrimLeft(text, "!-")
	fmt.Println(trimLeft)
	trimRight := strings.TrimRight(text, "!-")
	fmt.Println(trimRight)
	upper := strings.ToUpper(trimed)
	fmt.Println(upper)
	trimPrefix := strings.TrimPrefix(text, "!-!-")
	fmt.Println(trimPrefix)
	trimSuffix := strings.TrimSuffix(text, "--!")
	fmt.Println(trimSuffix)
	text = "   hello, world   "
	trimSpace := strings.TrimSpace(text)
	fmt.Println(trimSpace)
}

Builder

Builder通常是更高效的创建字符串使用Write方法,它最大程度上减少了内存复制,零值是准备使用,不要复制一个非零Builder

type Builder struct {
    // contains filtered or unexported fields
}

func (b *Builder) Cap() int

返回底层字节序列的容量,包含所有建立时分配的空间,包括写入的

func (b *Builder) Grow() int

Grow增加b的容量,如有必要,可以保证另外n个byte的空间,调用至少还可以无需分配的写入n个字节,如果n小于0,则会panic

func (b *Builder) Len() int

返回积累的字节数b.Len() == len(b.String())

func (b *Builder) Reset()

清空b中内容

func (b *Builder) String() string

String返回积累的字符串

func (b *Builder) Write(p []byte) (n int, err error)

将p中内容写入b,总是返回len(p),nil

func (b *Builder) WriteByte(c byte) error

将c写入b,总是返回nil

func (b *Builder) WriteRune(r rune) (int, error)

写入UTF-8编码的Unicode码点到b,返回写入r的大小和nil error

func (b *Builder) WriteString(s string) (int, error)

写入s到b,总是返回len(s)和nil error

package main
import (
	"strings"
	"fmt"
)

func main() {
	var builder strings.Builder
	builder.WriteString("hello, strings.Builder")
	fmt.Println(builder.Cap())
	fmt.Println(builder.Len())
	fmt.Println(builder.String())
}

Reader

Reader实现了io.Read,io.ReadAt,io.Seeker,io.WriteTo,io.ByteScanner,io.RuneScanner接口,通过读取字符串,对于零值的操作像操作一个空字符串的Reader

type Reader struct {
    // contains filtered or unexported fields
}

func NewReader(s string) *Reader

NewReader返回一个从s读取的新Reader,它和bytes.NewBufferString相似,但是它更高效且只可读

func (r *Reader) Len() int

返回未读部分的字节数

func (r *Reader) Read(b []byte) (n int, err error)

实现的io.Reader接口

func (r *Reader) ReadAt(b []byte, offset int64) (n int, err error)

实现的ReadAt接口

func (r *Reader) ReadByte() (byte, error)

实现的io.ByteReader接口

func (r *Reader) ReadRune() (ch rune, size int, err error)

实现的io.RuneReader接口

func (r *Reader) Reset(s string)

重新设置Reader从s读取

func (r *Reader) Seek(offset int64, whence int) (int, error)

Seek实现了io.Seek接口

func (r *Reader) Size() int64

返回底层string的原始长度

func (r *Reader) UnreadByte() error

为了实现io.ByteScanner接口

func (r *Reader) UnreadRune() error

为了实现io.RuneScanner接口

func (r *Reader) WriteTo(w io.Writer) (n int64, err error)

实现了io.WriteTo接口

Replacer

Replacer通过替换品替换列表中字符串,这是并发安全的

type Replacer struct {
    // contains filtered or unexported fields
}

func NewReplacer(oldnew string...) *Replacer

NewReplacer返回一个新的Replacer由old,new string的列表,替换品按照它们在目标字符里出现的顺序执行,old string以列表的顺序比较如果给出的参数是奇数的将会panic

func (r *Replace) Replace(s string) string

返回替代品替换后s的副本

func (r *Replace) WriteString(w io.Writer, s string) (n int, err error)

替代品对s中元素替换,并写入w

package main
import (
	"strings"
	"fmt"
)

func main() {
	replacer := strings.NewReplacer("sb", "**", "cnm", "***")
	handled := replacer.Replace("ni shi sb, cnm")
	fmt.Println(handled)
}

Strings

Overview

Functions

Builder

Reader

Replacer