Go中strings的常用方法详解

string操作在编程中具有极高的频率，那么string中有哪些有用的方法呢？

使用strings直接操作

compare

• func compare(a, b string) int
  

按照字典序比较两个字符串，通常情况下直接使用=，>，<会更快一些。

contains，containsany 和 containsrune

• func contains(s, substr string) bool
• func containsany(s, chars string) bool
• func containsrune(s string, r rune) bool
  

字符串s中是否包含substr，返回true或者false。

fmt.println(strings.contains("seafood", "foo")) // true
fmt.println(strings.contains("seafood", "bar")) // false
fmt.println(strings.contains("seafood", "")) // true 
fmt.println(strings.contains("", "")) // true 

containsany用于判断子串中是否具有一个字符在源串s中。子串为空，返回false。

fmt.println(strings.containsany("team", "i")) // false
fmt.println(strings.containsany("fail", "ui")) // true
fmt.println(strings.containsany("ure", "ui")) // true 
fmt.println(strings.containsany("failure", "ui")) // true 
fmt.println(strings.containsany("foo", "")) // false
fmt.println(strings.containsany("", "")) // false

containsrune用于判断ascall码代表的字符是否在源串s中。

// finds whether a string contains a particular unicode code point.
// the code point for the lowercase letter "a", for example, is 97.
fmt.println(strings.containsrune("aardvark", 97))
fmt.println(strings.containsrune("timeout", 97))

count

• func count(s, substr string) int
  

判断子串在源串中的数量，如果子串为空，则长度为源串的长度+1。

fmt.println(strings.count("cheese", "e")) // 3
fmt.println(strings.count("five", "")) // before & after each rune 5=4+1

equalfold

• func equalfold(s, t string) bool

在不区分大小写的情况下，判断两个字符串是否相同。

fields

• func fields(s string) []string
• func fieldsfunc(s string, f func(rune) bool) []string

fields：使用空白分割字符串。

fieldsfunc：根据传入的函数分割字符串，如果当前参数c不是数字或者字母，返回true作为分割符号。

fmt.printf("fields are: %q", strings.fields(" foo bar baz  ")) // ["foo" "bar" "baz"]

f := func(c rune) bool {
  return !unicode.isletter(c) && !unicode.isnumber(c)
}
fmt.printf("fields are: %q", strings.fieldsfunc(" foo1;bar2,baz3...", f)) // ["foo1" "bar2" "baz3"]

hasprefix 和 hassuffix

• func hasprefix(s, prefix string) bool
• func hassuffix(s, suffix string) bool

判断字符串是否是以某个子串作为开头或者结尾。

fmt.println(strings.hasprefix("gopher", "go")) // true
fmt.println(strings.hasprefix("gopher", "c")) // false 
fmt.println(strings.hasprefix("gopher", "")) // true 

fmt.println(strings.hassuffix("amigo", "go")) // true 
fmt.println(strings.hassuffix("amigo", "o")) // false
fmt.println(strings.hassuffix("amigo", "ami")) // false
fmt.println(strings.hassuffix("amigo", "")) // true 

join

• func join(elems []string, sep string) string

使用某个sep，连接字符串。

s := []string{"foo", "bar", "baz"}
fmt.println(strings.join(s, ", ")) // foo,bar,baz

index，indexany，indexbyte，indexfunc，indexrune

• func index(s, substr string) int
• func indexany(s, chars string) int
• func indexbyte(s string, c byte) int
• func indexfunc(s string, f func(rune) bool) int
• func indexrune(s string, r rune) int

index，indexany，indexbyte，indexfunc，indexrune都是返回满足条件的第一个位置，如果没有满足条件的数据，返回-1。

fmt.println(strings.index("chicken", "ken")) // 4 
fmt.println(strings.index("chicken", "dmr")) // -1 

// 子串中的任意字符在源串出现的位置
fmt.println(strings.indexany("chicken", "aeiouy")) // 2
fmt.println(strings.indexany("crwth", "aeiouy")) // -1 

// indexbyte，字符在字符串中出现的位置
fmt.println(strings.indexbyte("golang", 'g')) // 0 
fmt.println(strings.indexbyte("gophers", 'h')) // 3
fmt.println(strings.indexbyte("golang", 'x')) // -1

// indexfunc 满足条件的作为筛选条件 
f := func(c rune) bool {
  return unicode.is(unicode.han, c)
}
fmt.println(strings.indexfunc("hello, 世界", f)) // 7 
fmt.println(strings.indexfunc("hello, world", f)) // -1 

// 某个字符在源串中的位置
fmt.println(strings.indexrune("chicken", 'k')) // 4 
fmt.println(strings.indexrune("chicken", 'd')) // -1 

lastindex，lastindexany，lastindexbyte和lastindexfunc

• func lastindex(s, substr string) int
• func lastindexany(s, chars string) int
• func lastindexbyte(s string, c byte) int
• func lastindexfunc(s string, f func(rune) bool) int

lastindex，lastindexany，lastindexbyte，lastindexfunc和index，indexany，indexbyte，indexfunc，indexrune用法保持一致，从右往前计数。

map

• func map(mapping func(rune) rune, s string) string

对字符串s中每一个字符执行map函数中的操作。

rot13 := func(r rune) rune { // r是遍历的每一个字符
  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
}
fmt.println(strings.map(rot13, "'twas brillig and the slithy gopher..."))

repeat

• func repeat(s string, count int) string

重复一下s，count是重复的次数，不能传负数。

fmt.println("ba" + strings.repeat("na", 2))

replace和replaceall

• func replace(s, old, new string, n int) string
• func replaceall(s, old, new string) string

使用new来替换old，替换的次数为n。如果n为负数，则替换所有的满足条件的子串。

fmt.println(strings.replace("oink oink oink", "k", "ky", 2)) // oinky oinkky oink
fmt.println(strings.replace("oink oink oink", "oink", "moo", -1)) moo moo moo 

replaceall使用new替换所有的old，相当于使用replace时n<0。

split，splitn，splitafter和splitaftern

• func split(s, sep string) []string
• func splitafter(s, sep string) []string
• func splitaftern(s, sep string, n int) []string
• func splitn(s, sep string, n int) []string

fmt.printf("%q\n", strings.split("a,b,c", ",")) // ["a","b","c"]
fmt.printf("%q\n", strings.split("a man a plan a canal panama", "a ")) // ["" "man " "plan " "canal panama"]
fmt.printf("%q\n", strings.split(" xyz ", "")) // [" " "x" "y" "z" " "]
fmt.printf("%q\n", strings.split("", "bernardo o'higgins")) // [""] 

// splitn 定义返回之后的切片中包含的长度，最后一部分是未被处理的。
fmt.printf("%q\n", strings.splitn("a,b,c", ",", 2)) // ["a", "b,c"]
z := strings.splitn("a,b,c", ",", 0) 
fmt.printf("%q (nil = %v)\n", z, z == nil) // [] (nil = true) 

// 使用sep分割，分割出来的字符串中包含sep，可以限定分割之后返回的长度。
fmt.printf("%q\n", strings.splitaftern("a,b,c", ",", 2)) // ["a,", "b,c"]

// 完全分割 
fmt.printf("%q\n", strings.splitafter("a,b,c", ",")) // ["a,","b,", "c"]

对于splitn和splitaftern的第二个n说明。

n > 0: at most n substrings; the last substring will be the unsplit remainder.
n == 0: the result is nil (zero substrings)
n < 0: all substrings

trim，trimfunc，trimleft，trimleftfunc，trimprefix，trimsuffix，trimright，trimrightfunc

• func trim(s string, cutset string) string
• func trimfunc(s string, f func(rune) bool) string
• func trimleft(s string, cutset string) string
• func trimleftfunc(s string, f func(rune) bool) string
• func trimprefix(s, prefix string) string
• func trimsuffix(s, suffix string) string
• func trimright(s string, cutset string) string
• func trimrightfunc(s string, f func(rune) bool) string

// trim 包含在cutset中的元素都会被去掉
fmt.print(strings.trim("¡¡¡hello, gophers!!!", "!¡")) // hello, gophers

// trimfunc去掉满足条件的字符
fmt.print(strings.trimfunc("¡¡¡hello, gophers!!!", func(r rune) bool {
  return !unicode.isletter(r) && !unicode.isnumber(r)
}))

// trimleft 去掉左边满足包含在cutset中的元素，直到遇到不在cutset中的元素为止
fmt.print(strings.trimleft("¡¡¡hello, gophers!!!", "!¡")) // hello, gophers!!!

// trimleftfunc 去掉左边属于函数返回值部分，直到遇到不在cutset中的元素为止
fmt.print(strings.trimleftfunc("¡¡¡hello, gophers!!!", func(r rune) bool {
  return !unicode.isletter(r) && !unicode.isnumber(r) 
})) // hello, gophers!!!

// trimprefix 去掉开头部分；trimsuffix 去掉结尾部分 
var s = "¡¡¡hello, gophers!!!"
s = strings.trimprefix(s, "¡¡¡hello, ")
s = strings.trimprefix(s, "¡¡¡howdy, ")
fmt.print(s)

trimright，trimrightfunc和trimleft，trimleftfunc功能保持一直，无需赘述。

使用strings.builder操作

a builder is used to efficiently build a string using write methods. it minimizes memory copying. the zero value is ready to use. do not copy a non-zero builder.

strings.builder使用write方法来高效的构建字符串。它最小化了内存拷贝，耗费零内存，不要拷贝非零的builder。

var b strings.builder
for i := 3; i >= 1; i-- {
  fmt.fprintf(&b, "%d...", i)
}
b.writestring("ignition")
fmt.println(b.string())

输出结果：

3...2...1...ignition

strings.builder作为字符串拼接的利器，建议加大使用力度。
func (b *builder) cap() int // 容量，涉及批量内存分配机制
func (b *builder) grow(n int) // 手动分配内存数量
func (b *builder) len() int // 当前builder中含有的所有字符长度
func (b *builder) reset() // 清空builder
func (b *builder) string() string // 转化为字符串输出 
func (b *builder) write(p []byte) (int, error) // 往builder写入数据 
func (b *builder) writebyte(c byte) error // 往builder写入数据 
func (b *builder) writerune(r rune) (int, error) // 往builder写入数据 
func (b *builder) writestring(s string) (int, error) // 往builder写入数据 

使用strings.reader

type reader struct {
 s    string //对应的字符串
 i    int64 // 当前读取到的位置
 prevrune int  
}

a reader implements the io.reader, io.readerat, io.seeker, io.writerto, io.bytescanner, and io.runescanner interfaces by reading from a string. the zero value for reader operates like a reader of an empty string.

reader通过读取字符串的方式，实现了接口io.reader, io.readerat, io.seeker, io.writerto, io.bytescanner和io.runescanner。零值reader操作起来就像操作空字符串的io.reader一样。

func newreader(s string) *reader // 初始化reader实例
func (r *reader) len() int // 未读字符长度 
func (r *reader) read(b []byte) (n int, err error) 
func (r *reader) readat(b []byte, off int64) (n int, err error)
func (r *reader) readbyte() (byte, error)
func (r *reader) readrune() (ch rune, size int, err error)
func (r *reader) reset(s string) // 重置以从s中读
func (r *reader) seek(offset int64, whence int) (int64, error) // seek implements the io.seeker interface. 
func (r *reader) size() int64 // 字符串的原始长度
func (r *reader) unreadbyte() error
func (r *reader) unreadrune() error
func (r *reader) writeto(w io.writer) (n int64, err error) // writeto implements the io.writerto interface.

len，size，read

len作用: 返回未读的字符串长度。
size的作用:返回字符串的长度。
read的作用: 读取字符串信息，读取之后会改变len的返回值

r := strings.newreader("abcdefghijklmn")
fmt.println(r.len())  // 输出14 初始时，未读长度等于字符串长度
var buf []byte
buf = make([]byte, 5)
readlen, err := r.read(buf)
fmt.println("读取到的长度:", readlen) //读取到的长度5
if err != nil {
 fmt.println("错误:", err)
}
fmt.println(buf)      //adcde
fmt.println(r.len())    //9  读取到了5个 剩余未读是14-5
fmt.println(r.size())    //14  字符串的长度

readat

• func (r *reader) readat(b []byte, off int64) (n int, err error)

读取偏移off字节后的剩余信息到b中，readat函数不会影响len的数值。

r := strings.newreader("abcdefghijklmn")
var bufat, buf []byte
buf = make([]byte, 5)
r.read(buf)
fmt.println("剩余未读的长度", r.len())  //剩余未读的长度 9
fmt.println("已读取的内容", string(buf)) //已读取的内容 abcde
bufat = make([]byte, 256)
r.readat(bufat, 5)
fmt.println(string(bufat))       //fghijklmn

//测试下是否影响len和read方法
fmt.println("剩余未读的长度", r.len())  //剩余未读的长度 9
fmt.println("已读取的内容", string(buf)) //已读取的内容 abcde

readbyte,unreadbyte

• func (r *reader) readbyte() (byte, error)
• func (r *reader) unreadbyte() error

readbyte从当前已读取位置继续读取一个字节。
unreadbyte将当前已读取位置回退一位，当前位置的字节标记成未读取字节。
readbyte和unreadbyte会改变reader对象的长度。

r := strings.newreader("abcdefghijklmn")
//读取一个字节
b, _ := r.readbyte()
fmt.println(string(b))   // a
//int(r.size()) - r.len() 已读取字节数
fmt.println(int(r.size()) - r.len()) // 1

//读取一个字节
b, _ = r.readbyte()
fmt.println(string(b))   // b
fmt.println(int(r.size()) - r.len()) // 2

//回退一个字节
r.unreadbyte()
fmt.println(int(r.size()) - r.len()) // 1

//读取一个字节
b, _ = r.readbyte()
fmt.println(string(b)) 

seek

• func (r *reader) seek(offset int64, whence int) (int64, error)

readat方法并不会改变len()的值，seek的移位操作可以改变。offset是偏移的位置，whence是偏移起始位置，支持三种位置：io.seekstart起始位，io.seekcurrent当前位，io.seekend末位。
offset可以是负数，当时偏移起始位与offset相加得到的值不能小于0或者大于size()的长度。

r := strings.newreader("abcdefghijklmn")

var buf []byte
buf = make([]byte, 5)
r.read(buf)
fmt.println(string(buf), r.len()) //adcde 9

buf = make([]byte, 5)
r.seek(-2, io.seekcurrent) //从当前位置向前偏移两位 （5-2)
r.read(buf)
fmt.println(string(buf), r.len()) //defgh 6

buf = make([]byte, 5)
r.seek(-3, io.seekend) //设置当前位置是末尾前移三位
r.read(buf)
fmt.println(string(buf), r.len()) //lmn 0

buf = make([]byte, 5)
r.seek(3, io.seekstart) //设置当前位置是起始位后移三位
r.read(buf)
fmt.println(string(buf), r.len()) //defgh 6

到此这篇关于go中strings的常用方法详解的文章就介绍到这了,更多相关go strings内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！