Golang 字符串操作小結

本文形式為, 給出一個函數接口, 然后匹配相關example. 關注函數主要集中在 strings 和 strconv

字符串比較

函數接口

// Compare比較字符串的速度比字符串內建的比較要快
funcCompare(a, bstring)int

fmt.Println(strings.Compare(string("hello"),string("haha")))// 1
fmt.Println(strings.Compare(string("hello"),string("world")))// -1
fmt.Println(strings.Compare(string("hello"),string("helloworld")))// -1
fmt.Println(strings.Compare(string("hello"),string("hello")))//0

字符串查找

字符串查找的相關接口

// 判斷給定字符串s中是否包含子串substr, 找到返回true, 找不到返回false
funcContains(s, substrstring)bool

// 在字符串s中查找sep所在的位置, 返回位置值, 找不到返回-1
funcIndex(s, sepstring)int

// 統計給定子串sep的出現次數, sep為空時, 返回1 + 字符串的長度
funcCount(s, sepstring)int

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

fmt.Println(strings.Index("chicken","ken"))// 4
fmt.Println(strings.Index("chicken","dmr"))// -1


fmt.Println(strings.Count("cheeseeee","ee"))// 3
fmt.Println(strings.Count("five",""))// 5

字符串重復

// 重復s字符串count次, 最后返回新生成的重復的字符串
func Repeat(sstring,countint)string

fmt.Println("ba"+ strings.Repeat("na",2))// banana

字符串替換

// 在s字符串中, 把old字符串替換為new字符串，n表示替換的次數，小于0表示全部替換
funcReplace(s, old,newstring, nint)string

fmt.Println(strings.Replace("oink oink oink","k","ky",2))// oinky oinky oink
fmt.Println(strings.Replace("oink oink oink","oink","moo", -1))// moo moo moo

字符串刪除

// 刪除在s字符串的頭部和尾部中由cutset指定的字符, 并返回刪除后的字符串
funcTrim(sstring, cutsetstring)string

// 刪除首尾的空格

// 刪除首部和尾部的 ! 和空格
fmt.Printf("%q\n", strings.Trim(" !!! Achtung! Achtung! !!! ","! ")) //"Achtung! Achtung"

fmt.Printf("%q\n", strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) //"a lone gopher"

字符串大小寫轉換

// 給定字符串轉換為英文標題的首字母大寫的格式(不能正確處理unicode標點)
funcTitle(sstring)string

// 所有字母轉換為小寫
funcToLower(sstring)string

// 所有字母轉換為大寫
funcToUpper(sstring)string

fmt.Println(strings.Title("her royal highness"))// Her Royal Highness

fmt.Println(strings.ToLower("Gopher123"))// gopher123

fmt.Println(strings.ToUpper("Gopher"))// GOPHER

字符串前綴后綴

前綴和后綴的判斷均為大小寫敏感

// 判斷字符串是否包含前綴prefix
funcHasPrefix(s, prefixstring)bool

// 判斷字符串是否包含后綴suffix, 
funcHasSuffix(s, suffixstring)bool

fmt.Println(strings.HasPrefix("Gopher","Go"))// true
fmt.Println(strings.HasPrefix("Gopher","go"))// false
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

字符串分割

函數接口

// 把字符串按照sep進行分割, 返回slice(類似于python中的split)
funcSplit(s, sepstring) []string

// 去除字符串s中的空格符, 并按照空格(可以是一個或者多個空格)分割字符串, 返回slice
funcFields(sstring) []string

// 當字符串中字符c滿足函數f(c)時, 就進行字符串s的分割
funcFieldsFunc(sstring, ffunc(rune)bool) []string

使用example

func main() {
 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")) // [""]
 fmt.Printf("%q\n", strings.Split("1 og.txt"," "))
} // ["1""og.txt"]

 fmt.Printf("Fields are: %q\n", strings.Fields(" foo bar baz ")) //Fieldsare: ["foo""bar""baz"]

 f := func(c rune) bool{
return!unicode.IsLetter(c) && !unicode.IsNumber(c)
 }
 // 表示按照非字母, 非數字來分割字符串
 fmt.Printf("Fields are: %q\n", strings.FieldsFunc(" foo1;bar2,baz3...", f)) //Fieldsare: ["foo1""bar2""baz3"]

字符串拼接

三種拼接方案:

• 直接用 += 操作符, 直接將多個字符串拼接. 最直觀的方法, 不過當數據量非常大時用這種拼接訪求是非常低效的.
• 用字符串切片([]string)裝載所有要拼接的字符串，最后使用strings.Join() 函數一次性將所有字符串拼接起來。在數據量非常大時，這種方法的效率也還可以的。
• 利用Buffer( Buffer是一個實現了讀寫方法的可變大小的字節緩沖 )，將所有的字符串都寫入到一個Buffer變量中，最后再統一輸出.

函數接口

// bytes.Buffer的方法, 將給定字符串追加(append)到Buffer
func(b *Buffer) WriteString(sstring) (nint, err error)

// 字符串拼接, 把slice通過給定的sep連接成一個字符串
funcJoin(a []string, sepstring)string

三種字符串拼接方式的性能測試(出自參考鏈接的文章)

package main

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

func main() {
 var buffer bytes.Buffer

 s := time.Now()
fori :=0; i <100000; i++ {
 buffer.WriteString("test is here\n")
 }
 buffer.String() // 拼接結果
 e := time.Now()
 fmt.Println("taked time is ", e.Sub(s).Seconds())

 s = time.Now()
 str := ""
fori :=0; i <100000; i++ {
 str += "test is here\n"
 }
 e = time.Now()
 fmt.Println("taked time is ", e.Sub(s).Seconds())

 s = time.Now()
 var sl []string
fori :=0; i <100000; i++ {
 sl = append(sl, "test is here\n")
 }
 strings.Join(sl, "")
 e = time.Now()
 fmt.Println("taked time is", e.Sub(s).Seconds())
}

運行結果如下

taked timeis0.004145088
taked timeis13.78821647
taked timeis0.024005696

字符串轉換

字符串轉化的函數在 strconv 中

• Append* 函數表示將給定的類型(如 bool, int 等)轉換為字符串后, 添加在現有的字節數組中 []byte
• Format* 函數將給定的類型變量轉換為string返回
• Parse* 函數將字符串轉換為其他類型

// 字符串轉整數
funcAtoi(sstring) (iint, err error)
// 整數值換字符串
funcItoa(iint)string

str:= make([]byte,0,100)
str= strconv.AppendInt(str,123,10)// 10用來表示進制, 此處為10進制
str= strconv.AppendBool(str,false)
str= strconv.AppendQuote(str,"andrew")
str= strconv.AppendQuoteRune(str,'劉')
fmt.Println(string(str))// 123false"andrew"'劉'

s := strconv.FormatBool(true)
fmt.Printf("%T, %v\n", s, s)// string, true
v := 3.1415926535
s32 := strconv.FormatFloat(v, 'E', -1,32)
fmt.Printf("%T, %v\n", s32, s32)// string, 3.1415927E+00
s10 := strconv.FormatInt(-44,10)
fmt.Printf("%T, %v\n", s10, s10)// string, -44


num := strconv.Itoa(1234)
fmt.Printf("%T, %v\n", s, s)// int, 1023
fmt.Printf("%T, %v\n", num, num)// string, 1234

參考鏈接

• go語言中高效字符串拼接
• 7.6 字符串處理

來自： http://andrewliu.in/2016/04/29/Golang-字符串操作小結/