最受欢迎的Golang字符串函数代码示例

xcvxvxc
260 阅读14分钟

Golang提供了许多内置的字符串函数，这些函数在处理字符串数据时可以帮助执行一些操作。Golang的字符串函数是核心的一部分。使用这个函数不需要安装，只需要导入 "strings "包即可。重要的Golang字符串函数的列表如下。

比较函数 [按字母顺序比较两个字符串] 。

你可以使用Compare()来比较两个字符串。它返回大于零、小于零或等于零的输出。如果字符串1大于字符串2，那么它返回大于0。如果字符串1小于字符串2，则返回小于0。如果两个字符串相等，则返回零。

语法

func Compare(a, b string) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.Compare("A", "B"))  // A < B
  fmt.Println(strings.Compare("B", "A"))  // B > A  
  fmt.Println(strings.Compare("Japan", "Australia"))  // J > A
  fmt.Println(strings.Compare("Australia", "Japan"))  // A < J
  fmt.Println(strings.Compare("Germany", "Germany"))  // G == G
  fmt.Println(strings.Compare("Germany", "GERMANY"))  // GERMANY > Germany
  fmt.Println(strings.Compare("", ""))
  fmt.Println(strings.Compare("", " ")) // Space is less
}

输出

-1
1
1
-1
0
1
0
-1

Contains 函数 [区分大小写] 。

你可以通过使用Contains()在一个字符串中搜索一个特定的文本/字符串/字符。它返回真或假的输出。如果字符串1在字符串2中找到，那么它返回true。如果字符串1在字符串2中没有找到，那么它将返回false。

语法

func Contains(s, substr string) bool

例子

package main
import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("Australia", "Aus"))	// Any part of string
	fmt.Println(strings.Contains("Australia", "Australian")) 
	fmt.Println(strings.Contains("Japan", "JAPAN"))	// Case sensitive
	fmt.Println(strings.Contains("Japan", "JAP")) // Case sensitive
	fmt.Println(strings.Contains("Become inspired to travel to Australia.", "Australia"))
	fmt.Println(strings.Contains("", ""))
	fmt.Println(strings.Contains("  ", " ")) // space also consider as string
	fmt.Println(strings.Contains("12554", "1"))   
}

输出

true
false
false
false
true
true
true
true

ContainsAny函数 [区分大小写)

你可以通过使用ContainsAny()函数在一个字符串中搜索一个特定的文本/字符串/字符。它的输出结果是真或假。如果在字符串中发现字符的unicode，那么它将返回true，否则输出将是false。你可以在下面的程序中看到ContainsAny和Contains的比较。

语法

func ContainsAny(s, chars string) bool

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.ContainsAny("Australia", "a"))
  fmt.Println(strings.ContainsAny("Australia", "r & a"))
  fmt.Println(strings.ContainsAny("JAPAN", "j"))
  fmt.Println(strings.ContainsAny("JAPAN", "J"))
  fmt.Println(strings.ContainsAny("JAPAN", "JAPAN"))  
  fmt.Println(strings.ContainsAny("JAPAN", "japan"))
  fmt.Println(strings.ContainsAny("Shell-12541", "1"))

  //  Contains vs ContainsAny
  fmt.Println(strings.ContainsAny("Shell-12541", "1-2")) // true
  fmt.Println(strings.Contains("Shell-12541", "1-2"))   // false
}

输出

true
true
false
true
true
false
true
true
false

Count函数[区分大小写]

这个函数计算字符串中一个字符/字符串/文本的非重叠实例的数量。

语法

func Count(s, sep string) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.Count("Australia", "a"))
  fmt.Println(strings.Count("Australia", "A"))
  fmt.Println(strings.Count("Australia", "M"))
  fmt.Println(strings.Count("Japanese", "Japan"))   // 1
  fmt.Println(strings.Count("Japan", "Japanese"))   // 0
  fmt.Println(strings.Count("Shell-25152", "-25"))
  fmt.Println(strings.Count("Shell-25152", "-21"))
  fmt.Println(strings.Count("test", ""))    // length of string + 1
  fmt.Println(strings.Count("test", " "))
}

输出

2
1
0
1
0
1
0
5
0

EqualFold函数 [不区分大小写]

使用EqualFold你可以检查两个字符串是否相等。如果两个字符串相等，它将返回输出true，如果两个字符串不相等，则返回输出false。

语法

func EqualFold(s, t string) bool

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.EqualFold("Australia", "AUSTRALIA"))
  fmt.Println(strings.EqualFold("Australia", "aUSTRALIA"))
  fmt.Println(strings.EqualFold("Australia", "Australia"))
  fmt.Println(strings.EqualFold("Australia", "Aus"))
  fmt.Println(strings.EqualFold("Australia", "Australia & Japan"))
  fmt.Println(strings.EqualFold("JAPAN-1254", "japan-1254"))  
  fmt.Println(strings.EqualFold(" ", " "))  // single space both side
  fmt.Println(strings.EqualFold(" ", "  "))  // double space right side
}

输出

true
true
true
false
false
false
true
true
false

字段函数

字段函数将一个字符串周围的一个或多个连续空白字符的实例分解成一个数组。

语法

func Fields(s string) []string

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  testString := "Australia is a country and continent surrounded by the Indian and Pacific oceans."
  testArray := strings.Fields(testString)  
  for _, v := range testArray {    
    fmt.Println(v)
  }
}

输出

Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans

函数FieldsFunc

FieldsFunc函数在每一个Unicode代码点c的运行处对字符串s进行分割，满足f(c)的要求，并返回s的数组片断。请看下面两个FieldsFunc的例子。

语法

func FieldsFunc(s string, f func(rune) bool) []string

例子

package main

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

func main() {
  
  x := func(c rune) bool {
    return !unicode.IsLetter(c)
  }
  strArray := strings.FieldsFunc(`Australia major cities – Sydney, Brisbane,
                                 Melbourne, Perth, Adelaide – are coastal`,x)
  for _, v := range strArray {    
    fmt.Println(v)
  }

  fmt.Println("\n*****************Split by number*******************\n")

  y := func(c rune) bool {
    return unicode.IsNumber(c)
  }
  testArray := strings.FieldsFunc(`1 Sydney Opera House.2 Great Barrier Reef.3 Uluru-Kata Tjuta National Park.4 Sydney Harbour Bridge.5 Blue Mountains National Park.6 Melbourne.7 Bondi Beach`,y)
  for _, w := range testArray {    
    fmt.Println(w)
  }

}

输出

Australia
major
cities
Sydney
Brisbane
Melbourne
Perth
Adelaide
are
coastal

*****************Split by number*******************

 Sydney Opera House.
 Great Barrier Reef.
 Uluru-Kata Tjuta National Park.
 Sydney Harbour Bridge.
 Blue Mountains National Park.
 Melbourne.
 Bondi Beach

HasPrefix函数

HasPrefix函数检查字符串s是否以指定的字符串开始。如果字符串S以前缀字符串开始，则返回真，否则返回假。

语法

func HasPrefix(s, prefix string) bool

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.HasPrefix("Australia", "Aus"))
  fmt.Println(strings.HasPrefix("Australia", "aus"))
  fmt.Println(strings.HasPrefix("Australia", "Jap"))
  fmt.Println(strings.HasPrefix("Australia", ""))
}

输出

true
false
false
true

函数HasSuffix

HasSuffix函数检查字符串s是否以指定的字符串结束。如果字符串S以后缀字符串结束，则返回真，否则返回假。

语法

func HasSuffix(s, prefix string) bool

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.HasSuffix("Australia", "lia"))
  fmt.Println(strings.HasSuffix("Australia", "A"))
  fmt.Println(strings.HasSuffix("Australia", "LIA"))
  fmt.Println(strings.HasSuffix("123456", "456"))
  fmt.Println(strings.HasSuffix("Australia", ""))
}

输出

true
false
false
true
true

索引函数

Index 函数可以在一个字符串中搜索特定的文本。它的工作原理很简单，就是匹配字符串中的特定文本。如果找到了，那么它将返回从0开始的特定位置。

语法

func Index(s, sep string) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.Index("Australia", "Aus"))
  fmt.Println(strings.Index("Australia", "aus"))
  fmt.Println(strings.Index("Australia", "A"))
  fmt.Println(strings.Index("Australia", "a"))
  fmt.Println(strings.Index("Australia", "Jap"))
  fmt.Println(strings.Index("Japan-124", "-"))
  fmt.Println(strings.Index("Japan-124", ""))
}

输出

0
-1
0
5
-1
5
0

IndexAny 函数

IndexAny 函数返回 string[left] 中 chars[right] 的任何 Unicode 码位的第一个实例的索引。它的工作原理是简单地匹配字符串中的特定文本。如果找到，则返回从 0 开始的特定位置；如果没有找到，则返回 -1。

语法

func IndexAny(s, chars string) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.IndexAny("australia", "japan")) // a position
  fmt.Println(strings.IndexAny("japan", "pen")) // p position
  fmt.Println(strings.IndexAny("mobile", "one")) // o position
  fmt.Println(strings.IndexAny("123456789", "4")) // 4 position
  fmt.Println(strings.IndexAny("123456789", "0")) // 0 position
}

输出

0
2
1
3
-1

IndexByte函数

IndexByte函数返回字符串中第一个字符实例的索引。如果找到了，则返回从0开始的具体位置；如果没有找到，则返回-1。

语法

func IndexByte(s string, c byte) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  var s,t,u byte  
  t = 'l'
  fmt.Println(strings.IndexByte("australia",t))
  fmt.Println(strings.IndexByte("LONDON",t))
  fmt.Println(strings.IndexByte("JAPAN",t))
  
  s = 1
  fmt.Println(strings.IndexByte("5221-JAPAN",s))

  u = '1'
  fmt.Println(strings.IndexByte("5221-JAPAN",u))
}

输出

6
-1
-1
-1
3

IndexRune函数

IndexRune函数返回字符串中Unicode代码点r的第一个实例的索引。如果找到，则返回从0开始的具体位置；如果没有找到，则返回-1。在下面的例子中，s、t和u变量类型被声明为符文。

语法

func IndexRune(s string, r rune) int

例子

package main

import (
  "fmt"
  "strings"
)

func main() {
  var s,t,u rune
  t = 'l'
  fmt.Println(strings.IndexRune("australia",t))
  fmt.Println(strings.IndexRune("LONDON",t))
  fmt.Println(strings.IndexRune("JAPAN",t))
  
  s = 1
  fmt.Println(strings.IndexRune("5221-JAPAN",s))

  u = '1'
  fmt.Println(strings.IndexRune("5221-JAPAN",u))
}

输出

6
-1
-1
-1
3

Join函数 [连接]

Join()函数从一个片断的元素中返回一个字符串。Join连接字符串Slice的元素以创建一个单一的字符串。分隔符 sep 指定了在结果字符串中的片断元素之间的内容。

语法

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

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	// Slice of strings
	textString := []string{"Australia", "Japan", "Canada"}
	fmt.Println(strings.Join(textString, "-"))
	
	// Slice of strings
	textNum := []string{"1", "2", "3", "4", "5"}
	fmt.Println(strings.Join(textNum,""))
}

输出

Australia-Japan-Canada
12345

LastIndex函数 [区分大小写)

LastIndex函数可以在一个字符串中搜索特定的文本/字符/字符串。它返回字符串中最后一个实例文本/字符/字符串的索引。如果找到，则返回从0开始的特定位置；如果没有找到，则返回-1。

语法

func LastIndex(s, sep string) int

例子

package main

import (
	"fmt"
	"strings"
)

func main() {	
	fmt.Println(strings.LastIndex("japanese", "a")) // position j=0,a=1,p=2,a=3
	fmt.Println(strings.LastIndex("japanese", "A"))
	fmt.Println(strings.LastIndex("Australia Australian", "lia"))
	fmt.Println(strings.LastIndex("AUSTRALIA AUSTRALIAN", "lia"))
	fmt.Println(strings.LastIndex("1234567890 1234567890", "0"))
	fmt.Println(strings.LastIndex("1234567890 1234567890", "00"))
	fmt.Println(strings.LastIndex("1234567890 1234567890", "123"))
}

输出

3
-1
16
-1
20
-1
11

重复函数

Repeat 函数将一个字符串重复指定的次数，并返回一个由字符串 s 的复制品组成的新字符串，Count 指定了字符串被重复的次数。必须大于或等于0。

语法

func Repeat(s string, count int) string

例子


package main

import (
	"fmt"
	"strings"
)

func main() {
	textString := "Japan"
	repString := strings.Repeat(textString, 5)
	fmt.Println(repString)
	
	textString = " A " // char with space on both side
	repString = strings.Repeat(textString,5)
	fmt.Println(repString)		// Repeat space also
	
	fmt.Println("ba" + strings.Repeat("na", 2))
	fmt.Println("111" + strings.Repeat("22", 2))
	fmt.Println("111" + strings.Repeat(" ",2))
}

输出

JapanJapanJapanJapanJapan
 A  A  A  A  A
banana
1112222
111

替换函数 [区分大小写]

替换函数将字符串中的一些字符替换成另一些字符。n指定你要替换的字符串中的字符数。如果n小于0，则对替换的数量没有限制。

语法

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

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 0))
	fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 1))
	fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", 2))
	fmt.Println(strings.Replace("Australia Japan Canada Indiana", "an", "anese", -1))
	fmt.Println(strings.Replace("1234534232132", "1", "0", -1))
	// case-sensitive
	fmt.Println(strings.Replace("Australia Japan Canada Indiana", "AN", "anese", -1))
}

输出

Australia Japan Canada Indiana
Australia Japanese Canada Indiana
Australia Japanese Caneseada Indiana
Australia Japanese Caneseada Indianesea
0234534232032
Australia Japan Canada Indiana

分割函数 [区分大小写]

Split函数将一个字符串分割成一个片断。将 s 字符串分割成由 sep 分隔的所有子字符串，并返回这些分隔符之间的子字符串的一个片断。

语法

func Split(S string, sep string) []string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	strSlice := strings.Split("a,b,c", ",")	
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.Split("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ")
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	
	strSlice = strings.Split("abacadaeaf","a")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.Split("abacadaeaf","A")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.Split("123023403450456056706780789","0")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.Split("123023403450456056706780789",",")	
	fmt.Println("\n",strSlice)
}

输出

[a b c]

Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.

 [ b c d e f]

 [abacadaeaf]

 [123 234 345 456 567 678 789]

 [123023403450456056706780789]

SplitN函数 [区分大小写]

SplitN函数将一个字符串分割成一个片断。SplitN 将 s String 分割成所有以 sep 分隔的子串，并返回这些分隔符之间的子串的一个片断。n决定要返回的子串数量。
n小于0：最多有n个子串；最后一个子串将是未拆分的剩余部分。
n等于0：结果是nil（零子串）
n大于0：所有子串

语法

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

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	strSlice := strings.SplitN("a,b,c", ",",0)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitN("a,b,c", ",",1)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitN("a,b,c", ",",2)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitN("a,b,c", ",",3)
	fmt.Println(strSlice,"\n")
		
	strSlice = strings.SplitN("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ",-1)
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	strSlice = strings.SplitN("123023403450456056706780789","0",5)	
	fmt.Println("\n",strSlice)
}

输出

[]

[a,b,c]

[a b,c]

[a b c]

Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.

 [123 234 345 456 56706780789]

SplitAfter函数 [区分大小写]

SplitAfter函数将一个字符串分成一个片断。SplitAfter 在 sep 的每个实例之后将 S 切成所有子字符串，并返回这些子字符串的一个片断。

语法

func SplitAfter(S String, sep string) []string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	strSlice := strings.SplitAfter("a,b,c", ",")	
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitAfter("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ")
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	
	strSlice = strings.SplitAfter("abacadaeaf","a")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.SplitAfter("abacadaeaf","A")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.SplitAfter("123023403450456056706780789","0")	
	fmt.Println("\n",strSlice)
	
	strSlice = strings.SplitAfter("123023403450456056706780789",",")	
	fmt.Println("\n",strSlice)
}

输出

[a, b, c]

Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.

 [a ba ca da ea f]

 [abacadaeaf]

 [1230 2340 3450 4560 5670 6780 789]

 [123023403450456056706780789]

SplitAfterN函数 [区分大小写]

SplitAfterN函数将一个字符串分成一个片断。SplitAfterN在每个sep实例之后将字符串s切成子串，并返回这些子串的一个片断。n决定要返回的子串数量。
n小于0：最多有n个子串；最后一个子串将是未拆分的剩余部分。
n等于0：结果是nil（零子串）
n大于0：所有子串

语法

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

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	strSlice := strings.SplitAfterN("a,b,c", ",",0)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitAfterN("a,b,c", ",",1)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitAfterN("a,b,c", ",",2)
	fmt.Println(strSlice,"\n")
	
	strSlice = strings.SplitAfterN("a,b,c", ",",3)
	fmt.Println(strSlice,"\n")
		
	strSlice = strings.SplitAfterN("Australia is a country and continent surrounded by the Indian and Pacific oceans.", " ",-1)
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	strSlice = strings.SplitAfterN("123023403450456056706780789","0",5)	
	fmt.Println("\n",strSlice)
}

输出

[]

[a,b,c]

[a, b,c]

[a, b, c]

Australia
is
a
country
and
continent
surrounded
by
the
Indian
and
Pacific
oceans.

 [1230 2340 3450 4560 56706780789]

标题函数

Title函数将每个单词的第一个字符转换为大写字母。

语法

func Title(s string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Title("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
	fmt.Println(strings.Title("BAVARIA HESSE BRANDENBURG SAARLAND"))
	fmt.Println(strings.Title("towns and cities"))
}

输出

Germany Is A Western European Country With A Landscape Of Forests, Rivers, Mountain Ranges And North Sea Beaches.
BAVARIA HESSE BRANDENBURG SAARLAND
Towns And Cities

ToTitle函数

ToTitle函数将每个词的所有字符转换为大写字母。

语法

func ToTitle(s string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToTitle("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
	fmt.Println(strings.ToTitle("BAVARIA HESSE BRANDENBURG SAARLAND"))
	fmt.Println(strings.ToTitle("towns and cities"))
}

输出

GERMANY IS A WESTERN EUROPEAN COUNTRY WITH A LANDSCAPE OF FORESTS, RIVERS, MOUNTAIN RANGES AND NORTH SEA BEACHES.
BAVARIA HESSE BRANDENBURG SAARLAND
TOWNS AND CITIES

ToLower函数

ToLower函数将每个单词的所有字符转换为小写字母。

语法

func ToLower(s string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToLower("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
	fmt.Println(strings.ToLower("BAVARIA HESSE BRANDENBURG SAARLAND"))
	fmt.Println(strings.ToLower("towns and cities"))
}

输出

germany is a western european country with a landscape of forests, rivers, mountain ranges and north sea beaches.
bavaria hesse brandenburg saarland
towns and cities

ToUpper函数

ToUpper函数将每个单词的所有字符转换为大写字母。

语法

func ToUpper(s string) string

例子


package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToUpper("Germany is a Western European country with a landscape of forests, rivers, mountain ranges and North Sea beaches."))
	fmt.Println(strings.ToUpper("BAVARIA HESSE BRANDENBURG SAARLAND"))
	fmt.Println(strings.ToUpper("towns and cities"))
}

输出

GERMANY IS A WESTERN EUROPEAN COUNTRY WITH A LANDSCAPE OF FORESTS, RIVERS, MOUNTAIN RANGES AND NORTH SEA BEACHES.
BAVARIA HESSE BRANDENBURG SAARLAND
TOWNS AND CITIES

Trim函数 [大小写]

Trim 函数从一个字符串 s 的两边删除预定义的字符 cutset。

语法

func Trim(s string, cutset string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Trim("0120 2510", "0"))
	fmt.Println(strings.Trim("abcd axyz", "a"))
	fmt.Println(strings.Trim("abcd axyz", "A"))
	fmt.Println(strings.Trim("! Abcd dcbA !", "A"))
	fmt.Println(strings.Trim("! Abcd dcbA !", "!"))
	fmt.Println(strings.Trim(" Abcd dcbA ", " "))
}

输出

120 251
bcd axyz
abcd axyz
! Abcd dcbA !
 Abcd dcbA
Abcd dcbA

TrimLeft函数 [大小写] 。

TrimLeft 函数只从一个字符串 s 的左边删除预定义的字符。

语法

func TrimLeft(s string, cutset string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimLeft("0120 2510", "0"))
	fmt.Println(strings.TrimLeft("abcd axyz", "a"))
	fmt.Println(strings.TrimLeft("abcd axyz", "A"))
	fmt.Println(strings.TrimLeft("! Abcd dcbA !", "A"))
	fmt.Println(strings.TrimLeft("! Abcd dcbA !", "!"))
	fmt.Println(strings.TrimLeft(" Abcd dcbA ", " "))
}

输出

120 2510
bcd axyz
abcd axyz
! Abcd dcbA !
 Abcd dcbA !
Abcd dcbA

TrimRight函数 [大小写]

TrimRight 函数只从一个字符串 s 的右侧删除预定义的字符。

语法

func TrimRight(s string, cutset string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.TrimRight("0120 2510", "0"))
	fmt.Println(strings.TrimRight("abcd axyz", "a"))
	fmt.Println(strings.TrimRight("abcd axyz", "A"))
	fmt.Println(strings.TrimRight("! Abcd dcbA !", "A"))
	fmt.Println(strings.TrimRight("! Abcd dcbA !", "!"))
	fmt.Println(strings.TrimRight(" Abcd dcbA ", " "))
}

输出

0120 251
abcd axyz
abcd axyz
! Abcd dcbA !
! Abcd dcbA
 Abcd dcbA

函数 TrimSpace

TrimSpace函数从一个字符串的两边删除空白和其他预定义的字符。
"\t" - tab
"\n" - new line
"\x0B" - vertical tab
"\r" - carriage return
"" - 普通的白色空间

语法

func TrimSpace(s string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {	
	fmt.Println(strings.TrimSpace(" New Zealand is a country in the southwestern Pacific Ocean "))
	fmt.Println(strings.TrimSpace(" \t\n  New Zealand is a country in the southwestern Pacific Ocean \t\n "))
	fmt.Println(strings.TrimSpace(" \t\n\r\x0BNew Zealand is a country in the southwestern Pacific Ocean\t\n "))
}

输出

New Zealand is a country in the southwestern Pacific Ocean
New Zealand is a country in the southwestern Pacific Ocean
New Zealand is a country in the southwestern Pacific Ocean

TrimPrefix函数 [区分大小写]

TrimPrefix函数将前缀字符串从一个S字符串的开头去除。如果S不以前缀开始，则S将被原样返回。

语法

func TrimPrefix(S string, prefix string) string

例子

package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	s = "Australia Canada Japan"
	s = strings.TrimPrefix(s, "Australia")
	s = strings.TrimSpace(s)
	fmt.Println(s)
	
	s = "Australia Canada Japan"
	s = strings.TrimPrefix(s, "australia")
	fmt.Println(s)
	
	s = "\nAustralia-Canada-Japan"
	s = strings.TrimPrefix(s, "\n")
	fmt.Println(s)
	
	s = "\tAustralia-Canada-Japan"
	s = strings.TrimPrefix(s, "\t")
	fmt.Println(s)
}

输出

Canada Japan
Australia Canada Japan
Australia-Canada-Japan
Australia-Canada-Japan
avatar
文章
阅读
粉丝