Golang中使用字符串函数-我爱分享网

Go字符串函数教程展示了如何在Golang中使用字符串函数。

strings包实现了操作UTF-8编码字符串的简单函数。

$ go version
go version go1.18.1 linux/amd64

我们使用Go版本1.18。

Go字符串重复

repeat函数返回一个由指定数量的字符串副本组成的新字符串。

package main

import (
    "fmt"
    "strings"
)

func main() {

    w := "falcon"
    fmt.Println(strings.Repeat(w+" ", 5))
}

我们将给定的字符串重复五次。

$ go run repeat_fun.go
falcon falcon falcon falcon falcon

Go字符串比较

Compare函数按字典顺序比较两个字符串。要以不区分大小写的方式比较两个字符串，我们使用EqualFold函数。

package main

import (
    "fmt"
    "strings"
)

func main() {

    w1 := "falcon"
    w2 := "Falcon"

    if strings.Compare(w1, w2) == 0 {

        fmt.Println("The words are equal")
    } else {

        fmt.Println("The words are not equal")
    }

    if strings.EqualFold(w1, w2) {

        fmt.Println("The words are equal")
    } else {

        fmt.Println("The words are not equal")
    }
}

该示例比较两个字符串。

$ go run comparing.go
The words are not equal
The words are equal

Go字符串替换和替换所有

Replace函数返回字符串的副本，其中第一次出现的字符串被替换，而ReplaceAll返回所有出现都被替换的副本。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := "I saw a fox in the forest. The fox had brown fur."

    output := strings.Replace(msg, "fox", "wolf", 2)
    fmt.Println(output)

    output2 := strings.ReplaceAll(msg, "fox", "wolf")
    fmt.Println(output2)
}

示例将fox替换为wolf。

$ go run replacing.go
I saw a wolf in the forest. The wolf had brown fur.
I saw a wolf in the forest. The wolf had brown fur.

去字符串索引

Index函数返回找到的第一个子字符串的索引，而LastIndex函数返回最后一个索引。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := "I saw a fox in the forest. The fox had brown fur. I like foxes."

    idx1 := strings.Index(msg, "fox")
    fmt.Println(idx1)

    idx2 := strings.LastIndex(msg, "fox")
    fmt.Println(idx2)
}

我们找到单词“fox”的第一个和最后一个索引。

$ go run indexing.go
8
57

去字符串计数

Count函数计算在astring中找到的子字符串的数量。

package main

import (
    "fmt"
    "strings"
)

func main() {

    word := "wood"

    c1 := "o"
    c2 := "w"

    n1 := strings.Count(word, c1)
    fmt.Printf("# of %s in %s: %d\n", c1, word, n1)

    n2 := strings.Count(word, c2)
    fmt.Printf("# of %s in %s: %d\n", c2, word, n2)
}

我们统计在“wood”中出现“o”和“w”字符的次数。

$ go run counting.go
# of o in wood: 2
# of w in wood: 1

转到字符串ToUpper、ToLower、Title

ToLower函数返回字符串的小写副本，而ToUpper返回大写字符串。Title函数返回给定字符串的首字母大写副本（只有第一个字母大写）。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := "and old falcon"
    msg2 := "ÄereÅ¡Åa"

    fmt.Println(strings.Title(msg))
    fmt.Println(strings.ToUpper(msg))

    fmt.Println(strings.ToUpper(msg2))
    fmt.Println(strings.Title(msg2))
}

我们用给定的函数改变两个单词的大小写。

$ go run lower_upper.go
And Old Falcon
AND OLD FALCON
ÄEREÅ ÅA
ÄereÅ¡Åa

转到字符串HasPrefix和HasSuffix

HasPrefix函数检查字符串是否以给定的前缀开头。HasSufffix函数检查字符串是否以给定的后缀结尾。

package main

import (
    "fmt"
    "strings"
)

func main() {

    words := []string {"sky", "lot", "car", "wood", "cloud",
        "cup", "war", "wind", "near", "tell", "cheer", "coin", "book"}

    for _, word := range words {

        if strings.HasPrefix(word, "c") {

            fmt.Println(word)
        }
    }

    fmt.Println("----------------------")

    for _, word := range words {

        if strings.HasSuffix(word, "r") {

            fmt.Println(word)
        }
    }
}

我们有一段话。我们遍历切片的元素并打印以“c”开头并以“r”结尾的所有单词。

$ go run starts_ends.go
car
cloud
cup
cheer
coin
----------------------
car
war
near
cheer

GostringContains和ContainsRune

Contains函数检查给定的子字符串是否存在于字符串中。ConstainsRune检查Unicode代码点是否在字符串中。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := "a blue ð"
    r := 'ð'

    if strings.ContainsRune(msg, r) {

        fmt.Println("yes")
    } else {

        fmt.Println("no")
    }

    fmt.Println("-----------------")

    if strings.Contains(msg, "ð") {

        fmt.Println("yes")
    } else {

        fmt.Println("no")
    }
}

我们使用这两种方法来判断海豚符文是否在字符串中。

$ go run contains.go
yes
-----------------
yes

Go字符串修剪函数

Trim返回字符串的一个片段，其中删除了切割集中包含的所有前导和尾随Unicode代码点。TrimLeft函数返回字符串的一部分，其中删除了切割集中包含的所有前导Unicode代码点。TrimRight函数返回字符串的一部分，其中删除了切割集中包含的所有尾随Unicode代码点。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := ".an old falcon!"
    cutset := ".!"

    msg2 := strings.Trim(msg, cutset)
    fmt.Println(msg2)

    msg3 := strings.TrimLeft(msg, cutset)
    fmt.Println(msg3)

    msg4 := strings.TrimRight(msg, cutset)
    fmt.Println(msg4)
}

我们使用树函数从字符串中删除一个点和一个感叹号。

$ go run trim_funs.go
an old falcon
an old falcon!
.an old falcon

TrimSpace函数删除所有前导和尾随空白字符。TrimFunc返回字符串的一个片段，其中所有前导和尾随的Unicode代码点满足所提供的函数已被移除。

package main

import (
    "fmt"
    "strings"
    "unicode"
)

func main() {

    msg := "\t\tand old falcon\n"

    msg2 := strings.TrimSpace(msg)
    fmt.Println(msg2)

    msg3 := strings.TrimFunc(msg, trimSpace)
    fmt.Println(msg3)
}

func trimSpace(r rune) bool {

    return !unicode.IsLetter(r)
}

在代码示例中，我们使用上述函数删除了前导空格和尾随空格。

TrimPrefix

函数返回没有提供前导前缀的字符串，而

TrimSuffix

返回没有尾随后缀字符串的字符串。

package main

import (
    "fmt"
    "strings"
)

func main() {

    msg := "--and old falcon--"

    msg2 := strings.TrimPrefix(msg, "--")
    fmt.Println(msg2)

    msg3 := strings.TrimSuffix(msg, "--")
    fmt.Println(msg3)
}

该示例从字符串的开头和结尾删除“–”字符。

$ go run trim_funs3.go
and old falcon--
--and old falcon

去字符串拆分

Split函数将切片拆分为由给定分隔符分隔的所有子字符串，并返回这些分隔符之间的子字符串切片。

package main

import (
    "fmt"
    "log"
    "strconv"
    "strings"
)

func main() {

    msg := "3,4,5,6,7,8,9,10,11"

    data := strings.Split(msg, ",")
    fmt.Printf("%v\n", data)

    var sum = 0
    for _, e := range data {

        val, err := strconv.Atoi(e)

        if err != nil {
            log.Fatal(err)
        }

        sum += val
    }

    fmt.Println(sum)
}

我们有一串整数值，用逗号分隔。字符串被逗号分成几部分。使用strconv.Atoi将字符串部分转换为整数，并对整数求和。

$ go run split_fun.go
[3 4 5 6 7 8 9 10 11]
63

去字符串连接

Join函数连接切片参数的元素以创建单个字符串。

package main

import (
    "fmt"
    "strings"
)

func main() {

    words := []string{"an", "old", "falcon", "in", "the", "sky"}

    msg := strings.Join(words, " ")
    fmt.Println(msg)
}

我们通过空格字符连接切片的单词。

Go字符串字段

Fields函数将给定的字符串分成一个或多个空格字符。它提供了一种将字符串切割成单词的简单方法。

The Battle of Thermopylae was fought between an alliance of Greek city-states,
led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the
course of three days, during the second Persian invasion of Greece.

这是一个小文本文件。

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "strings"
)

func main() {

    fileName := "thermopylae.txt"
    bs, err := ioutil.ReadFile(fileName)

    if err != nil {

        log.Fatal(err)
    }

    text := string(bs)
    fields := strings.Fields(text)

    for _, field := range fields {

        fmt.Println(strings.Trim(field, ".,"))
    }
}

我们将给定的文件读入一个字符串，并利用字段将其切割成单词。我们还删除了单词中的点和逗号字符。

$ go run fields_fun.go
The
Battle
of
Thermopylae
was
fought
between
an
alliance
of
Greek
city-states
...

GostringsFieldsFun

FieldsFunc函数在每次运行满足提供函数的Unicodecode点时拆分字符串，并返回一个切片数组。

$ wget https://raw.githubusercontent.com/janbodnar/data/main/the-king-james-bible.txt

我们使用钦定版圣经。

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "sort"
    "strings"
)

func main() {

    fileName := "the-king-james-bible.txt"

    bs, err := ioutil.ReadFile(fileName)

    if err != nil {

        log.Fatal(err)
    }

    text := string(bs)

    fields := strings.FieldsFunc(text, func(r rune) bool {

        return !('a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || r == '\'')
    })

    wordsCount := make(map[string]int)

    for _, field := range fields {

        wordsCount[field]++
    }

    keys := make([]string, 0, len(wordsCount))

    for key := range wordsCount {

        keys = append(keys, key)
    }

    sort.Slice(keys, func(i, j int) bool {

        return wordsCount[keys[i]] > wordsCount[keys[j]]
    })

    for idx, key := range keys {

        fmt.Printf("%s %d\n", key, wordsCount[key])

        if idx == 10 {
            break
        }
    }
}

我们计算KingJames圣经中单词的出现频率。

fields := strings.FieldsFunc(text, func(r rune) bool {

    return !('a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || r == '\'')
})

FieldsFunc按非字母和撇号的字符剪切文本。这也将忽略所有节号。

wordsCount := make(map[string]int)

for _, field := range fields {

    wordsCount[field]++
}

每个单词及其频率都存储在wordsCount映射中。

keys := make([]string, 0, len(wordsCount))

for key := range wordsCount {

    keys = append(keys, key)
}

sort.Slice(keys, func(i, j int) bool {

    return wordsCount[keys[i]] > wordsCount[keys[j]]
})

为了按频率对单词进行排序，我们创建了一个新的keys切片。我们将所有单词放在那里并按它们的频率值对它们进行排序。

for idx, key := range keys {

    fmt.Printf("%s %d\n", key, wordsCount[key])

    if idx == 10 {
        break
    }
}

我们打印出圣经中最常用的前十个单词。

$ go run word_freq.go
the 62103
and 38848
of 34478
to 13400
And 12846
that 12576
in 12331
shall 9760
he 9665
unto 8942
I 8854

在本教程中，我们介绍了Go的strings包中的字符串函数。

列出所有Go教程。

开放的编程资料库

Golang中使用字符串函数

Go字符串重复

Go字符串比较

Go字符串替换和替换所有

去字符串索引

去字符串计数

转到字符串ToUpper、ToLower、Title

转到字符串HasPrefix和HasSuffix

GostringContains和ContainsRune

Go字符串修剪函数

去字符串拆分

去字符串连接

Go字符串字段

GostringsFieldsFun

感觉很棒！可以赞赏支持我哟~

相关推荐

近期文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

回顶部