strings 庫

strings 庫包含了許多高效的字符串常用操作的函數(shù)和方法，巧用這些函數(shù)與方法，能極大的提高我們程序的性能。下面介紹一些常用的函數(shù)和方法。

高效拼接字符串

使用 strings 庫里的 Builder 變量，結(jié)合其寫入方法如 WriteString 方法，可以進(jìn)行高效的拼接字符串。

import (
    "strings"
)

func main() {
    var builder strings.Builder
    builder.WriteString("hello")
    builder.WriteString(" ")
    builder.WriteString("world")
    builder.WriteString("!")
    s := builder.String()
    println(s) // hello world!
}

strings.Builder 底層是通過其內(nèi)部的 slice 來儲(chǔ)存內(nèi)容的。當(dāng)調(diào)用其相關(guān)的寫入方法(如 WriteString )的時(shí)，新的字節(jié)數(shù)據(jù)就會(huì)被追加到 slice 上。相比普通字符串的多次拼接，減少了拼接時(shí)需要?jiǎng)?chuàng)建新字符串的內(nèi)存開銷。

大小寫轉(zhuǎn)換

小寫轉(zhuǎn)大寫

ToUpper(s string) string：將一個(gè)字符串里的小寫字符轉(zhuǎn)成大寫，因?yàn)樽址豢勺兊奶攸c(diǎn)，該函數(shù)會(huì)返回一個(gè)新的字符串。

import "strings"

func main() {
    s1 := "hello"
    s2 := strings.ToUpper(s1)
    println(s2) // HELLO
}

大寫轉(zhuǎn)小寫

ToLower(s string) string：將一個(gè)字符串里的大寫字符轉(zhuǎn)成小寫，因?yàn)樽址豢勺兊奶攸c(diǎn)，該函數(shù)會(huì)返回一個(gè)新的字符串。

import "strings"

func main() {
    s1 := "HELLO"
    s2 := strings.ToLower(s1)
    println(s2) // hello
}

比較兩個(gè)字符串

區(qū)分大小寫比較

func main() {
    s1 := "hello"
    s2 := "hello"
    s3 := "HELLO"
    println(s1 == s2) // true
    println(s1 == s3) // false
}

直接通過 == 操作符進(jìn)行區(qū)分大小寫的字符串比較即可。

不區(qū)分大小寫比較 使用 EqualFold(s, t string) bool 函數(shù)進(jìn)行比較，兩個(gè)參數(shù)為需要比較的兩個(gè)字符串，返回值為布爾值，如果是 true 說明字符串相等，反之 false 則字符串不相等。

func main() {
    s1 := "hello"
    s2 := "hello"
    s3 := "HELLO"
    isEual := strings.EqualFold(s1, s2)
    println(isEual) // true
    isEual2 := strings.EqualFold(s1, s3)
    println(isEual2) // true
}

字符串的替換

字符串替換的函數(shù)：Replace(s, old, new string, n int) string

• 第一個(gè)參數(shù) s 為原字符串。
• 第二個(gè)參數(shù) old 為需要替換的字符串。
• 第三個(gè)參數(shù) new 為替換后的字符串。
• 第四個(gè)參數(shù) n 為指定替換幾個(gè) old ，如果 n 小于 0，則替換全部。
• 返回值為替換后的新字符串。

案例：實(shí)現(xiàn)對(duì)敏感詞的替換

func main() {
    s1 := "我靠啊靠"
    s2 := strings.Replace(s1, "靠", "*", 1)
    println(s2) // true 我*啊靠
    s3 := "我靠啊靠"
    s4 := strings.Replace(s3, "靠", "*", -1)
    println(s4) // true 我*啊*
}

第一次替換時(shí)，n 指定為 1，因此只替換了一個(gè)敏感詞。 第二次替換時(shí)，n 指定為 -1，小于 0，因此將所有敏感詞都替換了。

按照某個(gè)分割標(biāo)識(shí)分割字符串

分割字符串的函數(shù)：Split(s, sep string) []string

• 第一個(gè)參數(shù) s 為需要分割的字符串。
• 第二個(gè)參數(shù) sep 為分割的標(biāo)識(shí)。
• 返回值為字符串切片，保存被分割出來的子字符串。

import (
    "fmt"
    "strings"
)

func main() {
    s1 := "golang-is-awesome"
    strSlice := strings.Split(s1, "-")
    fmt.Println(strSlice) // [golang is awesome]
}

去掉字符串左右兩邊的空格

函數(shù)：TrimSpace(s string) string

• 第一個(gè)參數(shù) s 為需要去除空格的字符串。
• 返回值為去除空格后的新字符串。

import (
    "strings"
)

func main() {
    s1 := "      golang is awesome       "
    s2 := strings.TrimSpace(s1)
    println(s2) // "golang is awesome"
}

將字符串[左邊]或[右邊]或[左右兩邊]所指定的字符（串）去掉

將字符串[左右兩邊]所指定的字符（串）去掉

函數(shù)：Trim(s, cutset string) string

import (
    "strings"
)

func main() {
    s1 := "-golang is awesome-"
    s2 := strings.Trim(s1, "-")
    println(s2) // "golang is awesome"
}

第一個(gè)參數(shù) s 為需要去除指定字符的字符串。

第二個(gè)參數(shù)為指定的字符（串）。

將字符串[左邊]所指定的字符（串）去掉

函數(shù)：TrimLeft(s, cutset string) string

import (
    "strings"
)

func main() {
    s1 := "-golang is awesome"
    s2 := strings.TrimLeft(s1, "-")
    println(s2) // "golang is awesome"
}

第一個(gè)參數(shù) s 為需要去除指定字符的字符串。

第二個(gè)參數(shù)為指定的字符（串）。

將字符串[右邊]所指定的字符（串）去掉

函數(shù)：TrimRight(s, cutset string) string

import (
 "strings"
)

func main() {
    s1 := "golang is awesome-"
    s2 := strings.TrimRight(s1, "-")
    println(s2) // "golang is awesome"
}

第一個(gè)參數(shù) s 為需要去除指定字符的字符串。

第二個(gè)參數(shù)為指定的字符（串）。

判斷字符串是否以指定的字符串開頭

函數(shù)：HasPrefix(s, prefix string) bool

• 第一個(gè)參數(shù) s 為被判斷字符串。
• 第二個(gè)參數(shù) prefix 為指定的字符串。

import (
    "strings"
)

func main() {
    s1 := "hello world!"
    flag := strings.HasPrefix(s1, "hello")
    println(flag) // true
}

判斷字符串是否以指定的字符串結(jié)束

函數(shù)：HasSuffix(s, prefix string) bool

• 第一個(gè)參數(shù) s 為被判斷字符串。
• 第二個(gè)參數(shù) prefix 為指定的字符串。

import (
    "strings"
)

func main() {
    s1 := "hello world!"
    flag := strings.HasSuffix(s1, "!")
    println(flag) // true
}

將字符串切片中的元素以指定字符串連接生成新字符串

函數(shù)：Join(elems []string, sep string) string

• 第一個(gè)參數(shù) elems 為字符串切片。
• 第二個(gè)參數(shù) sep 為連接符。
• 返回值為新的字符串。

import (
    "strings"
)

func main() {
    strSlice := []string{"golang", "is", "awesome"}
    s := strings.Join(strSlice, "-")
    println(s) // golang-is-awesome
}

查找子串是否存在于指定的字符串中

函數(shù)： Contains(s, substr string) bool

• 第一個(gè)參數(shù) s 為指定的字符串。
• 第二個(gè)參數(shù) substr 為子串。
• 返回值為布爾值，如果是 true 說明存在，反之 false 則不存在。

import (
    "strings"
)

func main() {
    s := "golang is awesome"
    isContains := strings.Contains(s, "golang")
    println(isContains) // true
}

小結(jié)

本文先對(duì) strings 標(biāo)準(zhǔn)庫里的 Builder 變量進(jìn)行介紹，使用其寫入方法可以高效地拼接字符串，然后對(duì) ToUpper、ToLower、Replace 等常用函數(shù)的參數(shù)和返回值以及用法進(jìn)行介紹。

到此這篇關(guān)于一文帶你了解Go語言標(biāo)準(zhǔn)庫strings的常用函數(shù)和方法的文章就介紹到這了,更多相關(guān)Go語言strings內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論