最受欢迎的Golang字符串函数

高朗提供了许多内置的字符串函数,这些函数可在处理字符串数据时帮助执行一些操作。 高朗字符串函数是核心部分。使用此功能无需安装,仅需要导入“字符串”包。重要的Golang字符串函数列表如下:

1)高朗 比较 函数[按字典顺序比较两个字符串]

您可以使用Compare()比较两个字符串。它返回大于零,小于零或等于零的输出。如果字符串1大于字符串2,则返回大于零。如果字符串1小于字符串2,则它返回小于零。如果字符串相等,则返回零。

句法:
func 比较(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", "澳大利亚"))  // J > A
  fmt.Println(strings.Compare("澳大利亚", "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 是 less
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go -1 1 1 -1 0 1 0 -1 C:\golang>

2)高朗 包含 功能[区分大小写]

您可以使用Contains()在字符串中搜索特定的文本/字符串/字符。它返回true或false的输出。如果在字符串2中找到字符串1,则返回true。如果在字符串2中找不到字符串1,则返回false。

句法:
func 包含(s, substr string) bool
例:
package main
import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Contains("澳大利亚", "Aus"))	// Any part of string
	fmt.Println(strings.Contains("澳大利亚", "澳大利亚n")) 
	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 澳大利亚.", "澳大利亚"))
	fmt.Println(strings.Contains("", ""))
	fmt.Println(strings.Contains("  ", " ")) // space also consider as string
	fmt.Println(strings.Contains("12554", "1"))   
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go true false false false true true true true C:\golang>

3)高朗 包含任何 功能[区分大小写]

您可以使用ContainsAny()在字符串中搜索特定的文本/字符串/字符。它返回true或false的输出。如果在字符串中找到字符的unicode,则它返回true,否则输出将为false。您可以在下面的程序中看到ContainsAny与Contains的比较。

句法:
func 包含任何(s, chars string) bool
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.ContainsAny("澳大利亚", "a"))
  fmt.Println(strings.ContainsAny("澳大利亚", "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"))

  //  包含 vs 包含任何
  fmt.Println(strings.ContainsAny("Shell-12541", "1-2")) // 真正
  fmt.Println(strings.Contains("Shell-12541", "1-2"))   // 假
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go true true false true true false true true false C:\golang>

4)高朗 计数 功能[区分大小写]

此函数计算字符串中字符/字符串/文本的不重叠实例的数量。

句法:
func 计数(s, sep string) int
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.Count("澳大利亚", "a"))
  fmt.Println(strings.Count("澳大利亚", "A"))
  fmt.Println(strings.Count("澳大利亚", "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", " "))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 2 1 0 1 0 1 0 5 0 C:\golang>

5)高朗 等倍 功能[不区分大小写]

使用EqualFold,您可以检查两个字符串是否相等。如果两个字符串相等,则返回输出true,如果两个字符串都不相等,则返回false。

句法:
func 等倍(s, t string) bool
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.EqualFold("澳大利亚", "AUSTRALIA"))
  fmt.Println(strings.EqualFold("澳大利亚", "aUSTRALIA"))
  fmt.Println(strings.EqualFold("澳大利亚", "澳大利亚"))
  fmt.Println(strings.EqualFold("澳大利亚", "Aus"))
  fmt.Println(strings.EqualFold("澳大利亚", "澳大利亚 & 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
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go true true true false false false true true false C:\golang>

6)高朗 领域 功能

领域函数将一个或多个连续空白字符的每个实例周围的字符串分解为一个数组。

句法:
func 领域(s string) [] string
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  testString := "澳大利亚 是 a 国家 和 大陆 被包围 通过 的 印度人 和 太平洋地区 海洋。"
  testArray := strings.Fields(testString)  
  for _, v := range testArray {    
    fmt.Println(v)
  }
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go Australia is a country and continent surrounded by the Indian and Pacific oceans. C:\golang>

7)高朗 领域Func 功能

领域Func函数在每次运行满足f(c)的Unicode代码点c时都将字符串s断开,并返回s的切片数组。您可以使用此功能按数字或特殊字符的每个点分割字符串。检查以下两个FieldsFunc示例:

句法:
func 领域Func(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 重大的 城市 – 悉尼, 布里斯班,
                                 墨尔本, 珀斯, 阿德莱德 – 是 沿海`,x)
  for _, v := range strArray {    
    fmt.Println(v)
  }

  fmt.Println("\n*****************按数字分割*******************\n")

  y := func(c rune) bool {
    return unicode.IsNumber(c)
  }
  testArray := strings.FieldsFunc(`1 悉尼歌剧院。2 大堡礁。3 乌鲁鲁-卡塔丘塔国家公园。4 悉尼海港大桥。5 蓝山国家公园。6 墨尔本7 邦迪海滩`,y)
  for _, w := range testArray {    
    fmt.Println(w)
  }

}
运行该程序时,将得到以下输出:
C:\golang>go run string.go Australia major cities Sydney Brisbane Melbourne Perth Adelaide are coastal *****************按数字分割******************* 悉尼歌剧院。 大堡礁。 乌鲁鲁-卡塔丘塔国家公园。 悉尼海港大桥。 蓝山国家公园。 墨尔本 邦迪海滩 C:\golang>

8)高朗 HasPrefix 功能

HasPrefix函数检查字符串s是否以指定的字符串开头。如果字符串S以前缀字符串开头,则返回true,否则返回false。

句法:
func HasPrefix(s, prefix string) bool
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.HasPrefix("澳大利亚", "Aus"))
  fmt.Println(strings.HasPrefix("澳大利亚", "aus"))
  fmt.Println(strings.HasPrefix("澳大利亚", "Jap"))
  fmt.Println(strings.HasPrefix("澳大利亚", ""))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go true false false true C:\golang>

9)高朗 有后缀 功能

有后缀函数检查字符串s是否以指定的字符串结尾。如果字符串S以后缀字符串结尾,则返回true,否则返回false。

句法:
func 有后缀(s, prefix string) bool
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.HasSuffix("澳大利亚", "lia"))
  fmt.Println(strings.HasSuffix("澳大利亚", "A"))
  fmt.Println(strings.HasSuffix("澳大利亚", "LIA"))
  fmt.Println(strings.HasSuffix("123456", "456"))
  fmt.Println(strings.HasSuffix("澳大利亚", ""))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go true false false true true C:\golang>

10)高朗 指数 功能

索引功能可以搜索字符串中的特定文本。它仅通过匹配字符串中的特定文本即可工作。如果找到,则返回以0开头的特定位置。如果找不到,则返回-1。

句法:
func 指数(s, sep string) int
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  fmt.Println(strings.Index("澳大利亚", "Aus"))
  fmt.Println(strings.Index("澳大利亚", "aus"))
  fmt.Println(strings.Index("澳大利亚", "A"))
  fmt.Println(strings.Index("澳大利亚", "a"))
  fmt.Println(strings.Index("澳大利亚", "Jap"))
  fmt.Println(strings.Index("Japan-124", "-"))
  fmt.Println(strings.Index("Japan-124", ""))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 0 -1 0 5 -1 5 0 C:\golang>

11)高朗 索引 功能

索引函数从string [left]中的chars [right]返回任何Unicode代码点的第一个实例的索引。它仅通过匹配字符串中的特定文本即可工作。如果找到,则返回以0开头的特定位置。如果找不到,则返回-1。

句法:
func 索引(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
}

运行该程序时,将得到以下输出:
C:\golang>go run string.go 0 2 1 3 -1 C:\golang>

12)高朗 索引字节 功能

索引字节函数返回字符串中第一个字符实例的索引。如果找到,则返回以0开头的特定位置。如果找不到,则返回-1。

句法:
func 索引字节(s string, c 通过te) int
例:
package main

import (
  "fmt"
  "strings"
)

func main() {
  var s,t,u 通过te  
  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))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 6 -1 -1 -1 3 C:\golang>

13)高朗 指数Rune 功能

指数Rune函数以字符串形式返回Unicode代码点r的第一个实例的索引。如果找到,则返回以0开头的特定位置。如果找不到,则返回-1。在下面的示例中,s,t和u变量类型声明为符文。

句法:
func 指数Rune(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))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 6 -1 -1 -1 3 C:\golang>

14)高朗 加入 功能[连接]

加入()函数从切片的元素返回字符串。 加入将字符串Slice的元素连接起来以创建单个字符串。分隔符字符串sep指定在结果字符串中的切片元素之间放置的内容。

句法:
func 加入(stringSlice [] string, sep string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	// Slice of strings
	textString := [] string{"澳大利亚", "Japan", "Canada"}
	fmt.Println(strings.Join(textString, "-"))
	
	// Slice of strings
	textNum := [] string{"1", "2", "3", "4", "5"}
	fmt.Println(strings.Join(textNum,""))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 澳大利亚-日本-加拿大 12345 C:\golang>

15)高朗 LastIndex 功能[区分大小写]

LastIndex函数可在字符串中搜索特定的特定文本/字符/字符串。它返回字符串中最后一个实例text / character / strin的索引。如果找到,则返回以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("澳大利亚 澳大利亚n", "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"))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 3 -1 16 -1 20 -1 11 C:\golang>

16)高朗 重复 功能

重复函数将字符串重复指定的次数,并返回一个新字符串,该字符串由字符串s的计数副本组成。 计数指定将重复字符串的次数。必须大于或等于0。

句法:
func 重复(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)		// 重复 space also
	
	fmt.Println("ba" + strings.Repeat("na", 2))
	fmt.Println("111" + strings.Repeat("22", 2))
	fmt.Println("111" + strings.Repeat(" ",2))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 日本日本日本日本日本 A A A A A banana 1112222 111 C:\golang>

17)高朗 更换 功能[区分大小写]

替换功能用字符串中的某些其他字符替换某些字符。 n指定要在字符串中替换的字符数。如果n小于0,则替换次数没有限制。

句法:
func 更换(s, old, new string, n int) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Replace("澳大利亚日本加拿大印第安纳", "an", "anese", 0))
	fmt.Println(strings.Replace("澳大利亚日本加拿大印第安纳", "an", "anese", 1))
	fmt.Println(strings.Replace("澳大利亚日本加拿大印第安纳", "an", "anese", 2))
	fmt.Println(strings.Replace("澳大利亚日本加拿大印第安纳", "an", "anese", -1))
	fmt.Println(strings.Replace("1234534232132", "1", "0", -1))
	// case-sensitive
	fmt.Println(strings.Replace("澳大利亚日本加拿大印第安纳", "AN", "anese", -1))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 澳大利亚日本加拿大印第安纳 澳大利亚日本加拿大印第安纳 澳大利亚日本Caneseada印第安纳州 澳大利亚日语Caneseada 印度人esea 0234534232032 澳大利亚日本加拿大印第安纳 C:\golang>

18)高朗 分裂 功能[区分大小写]

拆分功能将字符串拆分为一个切片。将s字符串拆分为用sep分隔的所有子字符串,并返回这些分隔符之间的子字符串的一部分。

句法:
func 分裂(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("澳大利亚 是 a 国家 和 大陆 被包围 通过 的 印度人 和 太平洋地区 海洋。", " ")
	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)
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go [a b c] Australia is a country and continent surrounded by the Indian and Pacific oceans. [b c d e f] [abacadaeaf] [123234345345456567678789] [123023403450456056706780789] C:\golang>

19)高朗 斯普利特N 功能[区分大小写]

斯普利特N函数将字符串分成片。 斯普利特N将s字符串拆分为所有由sep分隔的子字符串,并返回这些分隔符之间的子字符串的一部分。 n确定要返回的子字符串数。
n小于0:最多n个子字符串;最后一个子字符串将是未拆分的余数。
n等于0:结果为nil(零子字符串)
n大于0:所有子串

句法:
func 斯普利特N(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("澳大利亚 是 a 国家 和 大陆 被包围 通过 的 印度人 和 太平洋地区 海洋。", " ",-1)
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	strSlice = strings.SplitN("123023403450456056706780789","0",5)	
	fmt.Println("\n",strSlice)
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go [] [a,b,c] [a b,c] [a b c] Australia is a country and continent surrounded by the Indian and Pacific oceans. [123234345 456 56706780789] C:\golang>

20)高朗 拆分后 功能[区分大小写]

拆分后函数将字符串分成片。在Sep的每个实例之后,SplitAfter将S切片为所有子字符串,并返回这些子字符串的切片。

句法:
func 拆分后(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("澳大利亚 是 a 国家 和 大陆 被包围 通过 的 印度人 和 太平洋地区 海洋。", " ")
	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)
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go [a, b, c] Australia is a country and continent surrounded by the Indian and Pacific oceans. [一个吧! [abacadaeaf] [1230 2340 3450 4560 5670 6780 789] [123023403450456056706780789] C:\golang>

21)高朗 N后 功能[区分大小写]

N后函数将字符串分成片。 N后在sep的每个实例之后将String切片为子字符串,并返回这些子字符串的切片。 n确定要返回的子字符串数。
n小于0:最多n个子字符串;最后一个子字符串将是未拆分的余数。
n等于0:结果为nil(零子字符串)
n大于0:所有子串

句法:
func N后(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("澳大利亚 是 a 国家 和 大陆 被包围 通过 的 印度人 和 太平洋地区 海洋。", " ",-1)
	for _, v := range strSlice {    
		fmt.Println(v)
	}
	strSlice = strings.SplitAfterN("123023403450456056706780789","0",5)	
	fmt.Println("\n",strSlice)
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go [] [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] C:\golang>

22)高朗 标题 功能

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

句法:
func 标题(s string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Title("Germany 是 a Western European 国家 with a landscape of forests, rivers, mountain ranges 和 North Sea beaches."))
	fmt.Println(strings.Title("巴伐利亚黑森州勃兰登堡州"))
	fmt.Println(strings.Title("小镇和城市"))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 德国是具有森林,河流,山脉和北海海滩景观的西欧国家。 巴伐利亚黑森州勃兰登堡州 Towns And Cities C:\golang>

23)高朗 标题 功能

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

句法:
func 标题(s string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToTitle("Germany 是 a Western European 国家 with a landscape of forests, rivers, mountain ranges 和 North Sea beaches."))
	fmt.Println(strings.ToTitle("巴伐利亚黑森州勃兰登堡州"))
	fmt.Println(strings.ToTitle("小镇和城市"))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 德国是一个西欧国家,拥有森林,河流,山脉和北海海滩的景观。 巴伐利亚黑森州勃兰登堡州 TOWNS AND CITIES C:\golang>

24)高朗 降低 功能

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

句法:
func 降低(s string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToLower("Germany 是 a Western European 国家 with a landscape of forests, rivers, mountain ranges 和 North Sea beaches."))
	fmt.Println(strings.ToLower("巴伐利亚黑森州勃兰登堡州"))
	fmt.Println(strings.ToLower("小镇和城市"))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 德国是一个西欧国家,拥有森林,河流,山脉和北海海滩的景观。 巴伐利亚黑森勃兰登堡萨尔 towns 和 城市 C:\golang>

25)高朗 上层 功能

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

句法:
func 上层(s string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.ToUpper("Germany 是 a Western European 国家 with a landscape of forests, rivers, mountain ranges 和 North Sea beaches."))
	fmt.Println(strings.ToUpper("巴伐利亚黑森州勃兰登堡州"))
	fmt.Println(strings.ToUpper("小镇和城市"))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 德国是一个西欧国家,拥有森林,河流,山脉和北海海滩的景观。 巴伐利亚黑森州勃兰登堡州 TOWNS AND CITIES C:\golang>

26)高朗 修剪 功能[区分大小写]

修剪函数从字符串s的两侧删除预定义的字符cutset。

句法:
func 修剪(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 ", " "))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 120 251 bcd axyz abcd axyz ! Abcd dcbA! Abcd dcbA Abcd dcbA C:\golang>

27)高朗 修剪左 功能[区分大小写]

修剪左函数仅从字符串s的左侧删除预定义的字符cutset。

句法:
func 修剪左(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 ", " "))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 120 2510 bcd axyz abcd axyz ! Abcd dcbA! Abcd dcbA! Abcd dcbA C:\golang>

28)高朗 修剪权 功能[区分大小写]

修剪权函数仅从字符串s的右侧删除预定义的字符cutset。

句法:
func 修剪权(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 ", " "))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 0120 251 abcd axyz abcd axyz ! Abcd dcbA! ! Abcd dcbA Abcd dcbA C:\golang>

29)高朗 修剪空间 功能

修剪空间函数从字符串的两侧删除空格和其他预定义字符。
"\t" - tab
"\n" - new line
“ \ x0B”-垂直标签
“ \ r”-回车
“”-普通空白

句法:
func 修剪空间(s string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {	
	fmt.Println(strings.TrimSpace(" 新西兰是西南太平洋的一个国家 "))
	fmt.Println(strings.TrimSpace(" \t\n  新西兰是西南太平洋的一个国家 \t\n "))
	fmt.Println(strings.TrimSpace(" \t\n\r\x0B新西兰是西南太平洋的一个国家\t\n "))
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go 新西兰是西南太平洋的一个国家 新西兰是西南太平洋的一个国家 新西兰是西南太平洋的一个国家 C:\golang>

30)高朗 修剪Prefix 功能[区分大小写]

修剪Prefix函数从S字符串的开头删除前缀字符串。如果S不以前缀开头,则S保持不变。

句法:
func 修剪Prefix(S string, prefix string) string
例:
package main

import (
	"fmt"
	"strings"
)

func main() {
	var s string
	s = "澳大利亚加拿大日本"
	s = strings.TrimPrefix(s, "澳大利亚")
	s = strings.TrimSpace(s)
	fmt.Println(s)
	
	s = "澳大利亚加拿大日本"
	s = strings.TrimPrefix(s, "australia")
	fmt.Println(s)
	
	s = "\n澳大利亚-加拿大-日本"
	s = strings.TrimPrefix(s, "\n")
	fmt.Println(s)
	
	s = "\t澳大利亚-加拿大-日本"
	s = strings.TrimPrefix(s, "\t")
	fmt.Println(s)
}
运行该程序时,将得到以下输出:
C:\golang>go run string.go Canada Japan 澳大利亚加拿大日本 澳大利亚-加拿大-日本 澳大利亚-加拿大-日本 C:\golang>