mysql_real_escape_string在php8不能用，mysqli_escape_string需要mysqli。

pdo也有一个过滤非法字符函数就是quote()，在laravel中用法如下。

DB::connection()->getPdo()->quote()

排列是将有序列表S的元素重新排列为与S本身一一对应的对应关系。长度为n的字符串有n！排列。让我们以"ABCD"为例，编写一个程序来生成Golang中所有可能的字符串排列和组合。

实现代码：

package main

import (
    "fmt"
)

func join(ins []rune, c rune) (res []string) {
    for i := 0; i <= len(ins); i++ {
        res = append(res, string(ins[:i])+string(c)+string(ins[i:]))
    }
    return res
}

func permutations(testStr string) []string {
    var n func(testStr []rune, p []string) []string
    n = func(testStr []rune, p []string) []string {
        if len(testStr) == 0 {
            return p
        } else {
            result := []string{}
            for _, e := range p {
                result = append(result, join([]rune(e), testStr[0])...)
            }
            return n(testStr[1:], result)
        }
    }

    output := []rune(testStr)
    return n(output[1:], []string{string(output[0])})
}

func main() {
    d := permutations("ABCD")
    fmt.Println(d)
}

输出：

[DCBA CDBA CBDA CBAD DBCA BDCA BCDA BCAD DBAC BDAC BADC BACD DCAB CDAB CADB CABD DACB ADCB ACDB ACBD DABC ADBC ABDC ABCD]

KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt提出的，因此人们称它为克努特—莫里斯—普拉特操作(简称KMP算法)。KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体实现就是通过一个next()函数实现，函数本身包含了模式串的局部匹配信息。KMP算法的时间复杂度O(m+n) 。

示例代码：

package main

import (
	"fmt"
)

const (	
	PatternSize int = 100
)

func SearchNext(haystack string, needle string) int {
	retSlice := KMP(haystack, needle)
	if len(retSlice) > 0 {
		return retSlice[len(retSlice)-1]
	}

	return -1
}

func SearchString(haystack string, needle string) int {
	retSlice := KMP(haystack, needle)
	if len(retSlice) > 0 {
		return retSlice[0]
	}

	return -1
}

func KMP(haystack string, needle string) []int {
	next := preKMP(needle)
	i := 0
	j := 0
	m := len(needle)
	n := len(haystack)

	x := []byte(needle)
	y := []byte(haystack)
	var ret []int

	//got zero target or want, just return empty result
	if m == 0 || n == 0 {
		return ret
	}

	//want string bigger than target string
	if n < m {
		return ret
	}

	for j < n {
		for i > -1 && x[i] != y[j] {
			i = next[i]
		}
		i++
		j++

		//fmt.Println(i, j)
		if i >= m {
			ret = append(ret, j-i)
			//fmt.Println("find:", j, i)
			i = next[i]
		}
	}

	return ret
}

func preMP(x string) [PatternSize]int {
	var i, j int
	length := len(x) - 1
	var mpNext [PatternSize]int
	i = 0
	j = -1
	mpNext[0] = -1

	for i < length {
		for j > -1 && x[i] != x[j] {
			j = mpNext[j]
		}
		i++
		j++
		mpNext[i] = j
	}
	return mpNext
}

func preKMP(x string) [PatternSize]int {
	var i, j int
	length := len(x) - 1
	var kmpNext [PatternSize]int
	i = 0
	j = -1
	kmpNext[0] = -1

	for i < length {
		for j > -1 && x[i] != x[j] {
			j = kmpNext[j]
		}

		i++
		j++

		if x[i] == x[j] {
			kmpNext[i] = kmpNext[j]
		} else {
			kmpNext[i] = j
		}
	}
	return kmpNext
}
	
func main() {
	fmt.Println("Search First Position String:\n")
	fmt.Println(SearchString("cocacola", "co"))
	fmt.Println(SearchString("Australia", "lia"))	
	fmt.Println(SearchString("cocacola", "cx"))
	fmt.Println(SearchString("AABAACAADAABAABA", "AABA"))
	
	fmt.Println("\nSearch Last Position String:\n")
	fmt.Println(SearchNext("cocacola", "co"))
	fmt.Println(SearchNext("Australia", "lia"))	
	fmt.Println(SearchNext("cocacola", "cx"))
	fmt.Println(SearchNext("AABAACAADAABAABAAABAACAADAABAABA", "AABA"))
}

输出：

Search First Position String:

0
6
-1
0

Search Last Position String:

4
6
-1
25

Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：

Title函数：

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" - 制表符 "\n" - 换行
符 "\x0B" - 垂直制表符 "\r" - 回车符
" " - 普通空格

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

Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：

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函数允许在字符串中搜索特定的特定文本/字符/字符串。它返回字符串中最后一个实例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("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函数：

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

Replace函数：区分大小写

Replace函数将字符串中的某些字符替换为其他一些字符。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函数：区分大小写

Split函数将字符串分解为切片。将String拆分为由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将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分割后，在分割的字符串中保留sep。如ab1cd1，用1分割后结果是[ab1, cd1]。

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实例之后将String 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]

Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：

HasPrefix函数：

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

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以后缀string结尾，则返回true，否则返回false。

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函数：

Index函数允许在字符串中搜索特定文本。它只需匹配字符串中的特定文本即可工作。如果找到，则返回从0开始的特定位置。如果未找到，则返回 -1。

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下标fmt.Println(strings.IndexAny("japan", "pen")) // 字母p下标fmt.Println(strings.IndexAny("mobile", "one")) // 字母o下标fmt.Println(strings.IndexAny("123456789", "4")) // 数字4下标fmt.Println(strings.IndexAny("123456789", "0")) // 数字0下标
}

输出：

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变量类型声明为rune。

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

Golang提供了许多内置的字符串函数，它们有助于在处理字符串数据时执行多项操作。Golang字符串函数是核心的一部分。使用此功能无需安装，只需导入"strings"包即可。重要的Golang字符串函数列表如下：

Compare函数：区分大小写

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

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() 搜索字符串中的特定文本/字符串/字符。它返回true或false的输出。如果在字符串2中找到字符串1，则返回true。如果在字符串2中找不到字符串1，则返回false。

func Contains(s, substr 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

Fields函数：

Fields函数将一个或多个连续空格字符的每个实例周围的字符串分解为一个Array。

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函数在每次运行满足f(c) 的Unicode码位c时断开字符串s，并返回s切片数组。您可以使用此函数按每个数字点或特殊字符拆分字符串。查看以下两个FieldsFunc示例：

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

示例代码：

package main

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

func main() {
  // 是否为unicode字母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*按数字分割***\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

*按数字分割***

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

bufio软件包Scanner适用于从文件中按行或单词读取文本。以下源代码片段显示了从下面的纯文本文件中逐行读取文本。

示例代码：

package main
 
import (
	"bufio"
	"fmt"
	"log"
	"os"
)
 
func main() {
	file, err := os.Open("test.txt")
 
	if err != nil {
		log.Fatalf("failed opening file: %s", err)
	}
 
	scanner := bufio.NewScanner(file)
	scanner.Split(bufio.ScanLines)
	var txtlines []string
 
	for scanner.Scan() {
		txtlines = append(txtlines, scanner.Text())
	}
 
	file.Close()
 
	for _, eachline := range txtlines {
		fmt.Println(eachline)
	}
}

输出：

Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Nunc a mi dapibus, faucibus mauris eu, fermentum ligula.
Donec in mauris ut justo eleifend dapibus.
Donec eu erat sit amet velit auctor tempus id eget mauris.

字符串通过字符编码在计算机中存储和表示。在Go中，字符串默认使用UTF-8编码，这意味着它可以轻松表示任何Unicode字符。

什么是字符编码？

字符编码是一组将字符转换为计算机可以理解的数字代码的规则。常见的字符编码包括ASCII、ISO-8859-1和UTF-8。

UTF-8编码简介

UTF-8是一种可变长度的Unicode字符编码方法，它使用1到4个字节来表示字符。它是Unicode标准的官方推荐编码。

示例代码：

当你运行这个时，你会看到像G和o (ASCII)这样的字符由单个字节表示，而世和界 (Unicode) 在其UTF-8编码中由多个字节表示。

package main

import (
  "fmt"
)

func main() {
  // 包含ASCII和Unicode字符str := "Go世界"

  fmt.Println("String:", str)

  // 输出unicode编码fmt.Println("Rune Code Points:")
  for _, runeValue := range str {
    fmt.Printf("%c: %U\n", runeValue, runeValue)
  }

  // 输出UTF-8编码byte
  fmt.Println("UTF-8 Bytes:")
  for i := 0; i < len(str); i++ {
    fmt.Printf("%c: %x\n", str[i], str[i])
  }
}

输出：

Rune Code Points:
G: U+0047
o: U+006F世: U+4E16界: U+754C

UTF-8 Bytes:
G: 47
o: 6f
ä: e4
¸: b8
–: 96
ç: e7
•: 95
Œ: 8c

Unicode码位和符文类型

Unicode码位是每个字符的唯一数字表示形式。在Go中，可以使用类型存储和处理符文Unicode码位。

示例代码：

当您运行该程序时，它将打印字符串语言中字符的Unicode码位。

package main

import (
  "fmt"
)

func main() {
  str := "语言"

  for _, char := range str {
    fmt.Printf("U+%04X ", char) // U+8BED U+8A00
  }
}

字符串与UTF-8的互操作性

可以使用len函数获取字符串的字节长度，但在UTF-8编码下，需要用utf8.RuneCountInString来获取字符数。

str := "语言"
byteLen := len(str)
runeLen := utf8.RuneCountInString(str)
fmt.Println(byteLen)  // 6
fmt.Println(runeLen)  // 2

将字符串解码为符文切片

使用[]rune将字符串转换为符文切片。

str := "语言"
runes := []rune(str)
fmt.Println(runes) // [35821 35328]

转换字符编码

尽管Go主要支持UTF-8，但有时可能需要与其他字符编码(如ISO-8859-1或GBK)进行互操作。在这种情况下，可以使用第三方库，例如golang.org/x/text/encoding。

import "golang.org/x/text/encoding/simplifiedchinese"
import "golang.org/x/text/transform"

str := "语言"
encoder := simplifiedchinese.GB18030.NewEncoder()
encoded, _, _ := transform.String(encoder, str)
fmt.Println(encoded) // ����

字符串连接

在Go中，可以使用运算符连接两个或多个字符串。

示例代码：

str1 := "Hello, "
str2 := "world!"
result := str1 + str2
fmt.Println(result) // Hello, world!

字符串切片

由于Go字符串是它们后面的字节切片，因此您可以像数组或切片一样处理字符串以获取字符串的子字符串。

示例代码：

str := "Hello, World!"
// 从下标7开始到11，不包含12
substring := str[7:12]
fmt.Println(substring) // Outputs: "World"

字符串搜索

您可以使用包中的字符串函数(如 Contains 等)轻松查找子字符串或字符。

示例代码：

package main

import (
  "fmt"
  "strings"
)

func main() {
  haystack := "Hello, Golang World!"


  needle := "Golang"


  if strings.Contains(haystack, needle) {
    fmt.Println("Found:", needle)
  } else {
    fmt.Println(needle, "not found!")
  }
}

字符串比较

Go提供了一种比较两个字符串是否相等的原生方法。此外，库Compare 中的函数字符串可用于确定两个字符串的字典顺序。

package main

import (
  "fmt"
)

func main() {
  str1 := "hello"
  str2 := "world"
  str3 := "hello"


  if str1 == str2 {
    fmt.Println("str1 and str2 are equal.")
  } else {
    fmt.Println("str1 and str2 are not equal.")
  }

  if str1 == str3 {
    fmt.Println("str1 and str3 are equal.")
  } else {
    fmt.Println("str1 and str3 are not equal.")
  }
}

输出：

str1 and str2 are not equal.
str1 and str3 are equal.

字符串替换

使用 Replace 和 ReplaceAll 函数，可以在Go中替换字符串中的子字符串。

package main

import (
  "fmt"
  "strings"
)

func main() {
  s := "banana"
  
  // 替换前两个'a' 和 'o'
  r1 := strings.Replace(s, "a", "o", 2)
  fmt.Println(r1) // "bonona"

  // 替换所有'a'和'o'
  r2 := strings.ReplaceAll(s, "a", "o")
  fmt.Println(r2) // "bonono"
}

字符串大小写转换

Go字符串库提供用于大小写转换的 ToUpper 和 ToLower 函数。

str := "GoLang"
lowercase := strings.ToLower(str)
uppercase := strings.ToUpper(str)
fmt.Println(lowercase)
fmt.Println(uppercase)

使用正则表达式处理字符串

Go正则表达式库提供了一系列函数来使用正则表达式查询、匹配、替换和拆分字符串。

import "regexp"

str := "My email is example@example.com"
re := regexp.MustCompile(`[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}`)
email := re.FindString(str)
fmt.Println(email) // example@example.com

字符串加密和哈希

Go的加密包提供了多种加密算法，可用于加密字符串或计算字符串的哈希值。

import (
    "crypto/md5"
    "fmt"
    "io"
)

str := "secret data"
hasher := md5.New()
io.WriteString(hasher, str)
fmt.Printf("%x\n", hasher.Sum(nil))

字符串拆分

使用字符串。拆分函数，可以通过指定的分隔符将字符串拆分为子字符串的切片。

str := "apple,banana,cherry"
items := strings.Split(str, ",")
fmt.Println(items)

字符串合并

字符串。Join 函数，将字符串切片组合成一个字符串。

items := []string{"apple", "banana", "cherry"}
str := strings.Join(items, ", ")
fmt.Println(str)

获取字符串中的字符

字符串中的每个字符都可以通过索引访问，但返回字符的字节值。

str := "Go"
byteValue := str[1]
fmt.Println(byteValue)

遍历字符串中的字符

使用for range 循环遍历字符串中的每个字符。

str := "Go"
for index, char := range str {
    fmt.Printf("At index %d, char: %c\n", index, char)
}

// At index 0, char: G
// At index 1, char: o

修剪字符串

字符串。TrimSpace 该函数可以删除字符串开头和结尾的空格。

str := "   Go Lang   "
trimmed := strings.TrimSpace(str)
fmt.Println(trimmed)

填充字符串

使用fmt包，您可以使用特定的格式修饰符填充或对齐字符串。

str := "Go"
padded := fmt.Sprintf("%-10s", str)
fmt.Println(padded)

字符串统计信息

count该函数可以帮助计算子字符串在字符串中出现的次数。

str := "Go is easy to learn. Go is powerful."
count := strings.Count(str, "Go")
fmt.Println(count)

在现代编程中，字符串处理是一个不可或缺的部分。无论是简单的用户界面还是复杂的数据处理，字符串都起着关键作用。Go语言作为一种现代的高性能编程语言，为字符串处理提供了一系列强大的工具和函数。

字符串在编程世界中至关重要，无论您是处理用户输入还是从数据库中读取数据，都离不开它们。Go语言为字符串处理提供了简单高效的工具。

字符串的定义和特征

在Go中，字符串是字节的任意集合，通常用于表示文本。字符串是不可变的，这意味着您不能修改字符串的字符，但可以生成新字符串。

greeting := "Hello, Go!"
fmt.Println(greeting)

Go字符串不可变性原则

在Go中创建的每个字符串都是不可变的。这意味着您不能直接修改字符串中的字符。这种设计可以为字符串操作带来一些性能优势，尤其是在复制和传递字符串时。

package main

import "fmt"

func main() {
    original := "hello"
    modified := original

    modified = "world"

    fmt.Println(original)  // Outputs: hello
    fmt.Println(modified)  // Outputs: world
}

在此示例中，即使我们将original分配给modified，更改modified也不会影响original。
这是因为Go中的字符串是不可变的，并且对modified的更改会在内存中创建一个新字符串，而不是更改现有字符串。

Go字符串的内部表示

Go字符串后面是一个字节数组，这也意味着Go可以存储任何数据，而不仅仅是UTF-8文本。

s := "hello"

在内部，这可以表示为： - 字节数组：
[104， 101， 108， 108， 111] (分别是字母h、e、l、l、o的ASCII值)
- 指向此数组开头的指针。
- 长度为5，表示字符串中有5个字节。

在Go语言中，可以使用len()函数判断一个字符串是否为空。当字符串的长度为0时，即认为该字符串为空。

package main  
  
import "fmt"  
  
func main() {  
 str := "" // 空字符串if len(str) == 0 {  
 fmt.Println("字符串为空")  
 } else {  
 fmt.Println("字符串不为空")  
 }  
}

常规符号

数学符号

希腊文符号

ISO 8859-1符号

ISO 8859-1符号