golang中strings包用法

1.strings.Split
/ Split 以 sep 爲分隔符，將 s 切分成多個子切片，結果中不包含 sep 本身
// 如果 sep 爲空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒有 sep 子串，則將整個 s 作爲 []string 的第一個元素返回

func Split(s, sep string) []string
func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.Split(s, " ")
	fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
	ss = strings.Split(s, ", ")
	fmt.Printf("%q\n", ss) // ["Hello" "世界! Hello!"]
	ss = strings.Split(s, "")
	fmt.Printf("%q\n", ss) // 單個字符列表
}

2.strings.SplitAfter
// SplitAfter 以 sep 爲分隔符，將 s 切分成多個子切片，結果中包含 sep 本身
// 如果 sep 爲空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒有 sep 子串，則將整個 s 作爲 []string 的第一個元素返回

func SplitAfter(s, sep string) []string
func main() {
	s := "Hello, 世界! Hello!"
	ss := strings.SplitAfter(s, " ")
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
	ss = strings.SplitAfter(s, ", ")
	fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
	ss = strings.SplitAfter(s, "")
	fmt.Printf("%q\n", ss) // 單個字符列表
}

3. strings.Join
// Join 將 a 中的子串連接成一個單獨的字符串，子串之間用 sep 分隔

func Join(a []string, sep string) string
func main() {
	ss := []string{"Monday", "Tuesday", "Wednesday"}
	s := strings.Join(ss, "|")
	fmt.Println(s)
}

4.trings.Repeat
// Repeat 將 count 個字符串 s 連接成一個新的字符串

func Repeat(s string, count int) string
func main() {
	s := "Hello!"
	rs := strings.Repeat(s, 3)
	fmt.Printf("%q\n", rs) // "Hello!Hello!Hello!"
}

// ToUpper 將 s 中的所有字符修改爲其大寫格式
// 對於非 ASCII 字符，它的大寫格式需要查錶轉換
func ToUpper(s string) string

// ToLower 將 s 中的所有字符修改爲其小寫格式
// 對於非 ASCII 字符，它的小寫格式需要查錶轉換
func ToLower(s string) string

// ToTitle 將 s 中的所有字符修改爲其 Title 格式
// 大部分字符的 Title 格式就是其 Upper 格式
// 只有少數字符的 Title 格式是特殊字符
// 這裏的 ToTitle 主要給 Title 函數調用

func ToTitle(s string) string
func main() {
	s := "heLLo worLd Ａｂｃ"
	us := strings.ToUpper(s)
	ls := strings.ToLower(s)
	ts := strings.ToTitle(s)
	fmt.Printf("%q\n", us) // "HELLO WORLD ＡＢＣ"
	fmt.Printf("%q\n", ls) // "hello world ａｂｃ"
	fmt.Printf("%q\n", ts) // "HELLO WORLD ＡＢＣ"
}

// 獲取非 ASCII 字符的 Title 格式列表

func main() {
	for _, cr := range unicode.CaseRanges {
		// u := uint32(cr.Delta[unicode.UpperCase]) // 大寫格式
		// l := uint32(cr.Delta[unicode.LowerCase]) // 小寫格式
		t := uint32(cr.Delta[unicode.TitleCase]) // Title 格式
		// if t != 0 && t != u {
		if t != 0 {
			for i := cr.Lo; i <= cr.Hi; i++ {
				fmt.Printf("%c -> %c\n", i, i+t)
			}
		}
	}
}

// ToUpperSpecial 將 s 中的所有字符修改爲其大寫格式。
// 優先使用 _case 中的規則進行轉換
func ToUpperSpecial(_case unicode.SpecialCase, s string) string

// ToLowerSpecial 將 s 中的所有字符修改爲其小寫格式。
// 優先使用 _case 中的規則進行轉換
func ToLowerSpecial(_case unicode.SpecialCase, s string) string

// ToTitleSpecial 將 s 中的所有字符修改爲其 Title 格式。
// 優先使用 _case 中的規則進行轉換
func ToTitleSpecial(_case unicode.SpecialCase, s string) string

_case 規則說明，以下列語句爲例：
unicode.CaseRange{‘A’, ‘Z’, [unicode.MaxCase]rune{3, -3, 0}}
·其中 ‘A’, ‘Z’ 表示此規則隻影響 ‘A’ 到 ‘Z’ 之間的字符。
·其中 [unicode.MaxCase]rune 數組表示：
當使用 ToUpperSpecial 轉換時，將字符的 Unicode 編碼與第一個元素值（3）相加
當使用 ToLowerSpecial 轉換時，將字符的 Unicode 編碼與第二個元素值（-3）相加
當使用 ToTitleSpecial 轉換時，將字符的 Unicode 編碼與第三個元素值（0）相加

func main() {
	// 定義轉換規則
	var _MyCase = unicode.SpecialCase{
		// 將半角逗號替換爲全角逗號，ToTitle 不處理
		unicode.CaseRange{',', ',',
			[unicode.MaxCase]rune{'，' - ',', '，' - ',', 0}},
		// 將半角句號替換爲全角句號，ToTitle 不處理
		unicode.CaseRange{'.', '.',
			[unicode.MaxCase]rune{'。' - '.', '。' - '.', 0}},
		// 將 ABC 分別替換爲全角的 ＡＢＣ、ａｂｃ，ToTitle 不處理
		unicode.CaseRange{'A', 'C',
			[unicode.MaxCase]rune{'Ａ' - 'A', 'ａ' - 'A', 0}},
	}
	s := "ABCDEF,abcdef."
	us := strings.ToUpperSpecial(_MyCase, s)
	fmt.Printf("%q\n", us) // "ＡＢＣDEF，ABCDEF。"
	ls := strings.ToLowerSpecial(_MyCase, s)
	fmt.Printf("%q\n", ls) // "ａｂｃdef，abcdef。"
	ts := strings.ToTitleSpecial(_MyCase, s)
	fmt.Printf("%q\n", ts) // "ABCDEF,ABCDEF."
}

// Trim 將刪除 s 首尾連續的包含在 cutset 中的字符

func Trim(s string, cutset string) string
func main() {
	s := " Hello 世界! "
	ts := strings.Trim(s, " Helo!")
	fmt.Printf("%q\n", ts) // "世界"
}

// TrimLeft 將刪除 s 頭部連續的包含在 cutset 中的字符

func TrimLeft(s string, cutset string) string
func main() {
	s := " Hello 世界! "
	ts := strings.TrimLeft(s, " Helo")
	fmt.Printf("%q\n", ts) // "世界! "
}

// TrimRight 將刪除 s 尾部連續的包含在 cutset 中的字符

func TrimRight(s string, cutset string) string
func main() {
	s := " Hello 世界! "
	ts := strings.TrimRight(s, " 世界!")
	fmt.Printf("%q\n", ts) // " Hello"
}

// TrimSpace 將刪除 s 首尾連續的的空白字符

func TrimSpace(s string) string
func main() {
	s := " Hello 世界! "
	ts := strings.TrimSpace(s)
	fmt.Printf("%q\n", ts) // "Hello 世界!"
}

// TrimPrefix 刪除 s 頭部的 prefix 字符串
// 如果 s 不是以 prefix 開頭，則返回原始 s

func TrimPrefix(s, prefix string) string
func main() {
	s := "Hello 世界!"
	ts := strings.TrimPrefix(s, "Hello")
	fmt.Printf("%q\n", ts) // " 世界"
}

// TrimSuffix 刪除 s 尾部的 suffix 字符串
// 如果 s 不是以 suffix 結尾，則返回原始 s

func TrimSuffix(s, suffix string) string
func main() {
	s := "Hello 世界!!!!!"
	ts := strings.TrimSuffix(s, "!!!!")
	fmt.Printf("%q\n", ts) // " 世界"
}

注：TrimSuffix只是去掉s字符串結尾的suffix字符串，只是去掉１次，而TrimRight是一直去掉s字符串右邊的字符串，只要有響應的字符串就去掉，是一個多次的過程，這也是二者的本質區別．
14.
// Replace 返回 s 的副本，並將副本中的 old 字符串替換爲 new 字符串
// 替換次數爲 n 次，如果 n 爲 -1，則全部替換
// 如果 old 爲空，則在副本的每個字符之間都插入一個 new

func Replace(s, old, new string, n int) string
func main() {
	s := "Hello 世界！"
	s = strings.Replace(s, " ", ",", -1)
	fmt.Println(s)
	s = strings.Replace(s, "", "|", -1)
	fmt.Println(s)
}

詳細請參考：
https://studygolang.com/articles/5769