//###########################################################
//D:\go\go\go库源码\源码库测试文件集合\strings-example_test.go
// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package strings_test
import (
"fmt"
"strings"
"unicode"
)
func ExampleFields() {
// 以一个或者多个空格分割成切片
//strings.Fields(" foo bar baz ")
fmt.Printf("Fields are: %q", strings.Fields(" foo bar baz "))
// Output: Fields are: ["foo" "bar" "baz"]
}
func ExampleFieldsFunc() {
// 根据指定方法分割成切片
// 以 不是字符或者数字 进行分割
f := func(c rune) bool {
return !unicode.IsLetter(c) && !unicode.IsNumber(c)
}
fmt.Printf("Fields are: %q", strings.FieldsFunc(" foo1;bar2,baz3...", f))
// Output: Fields are: ["foo1" "bar2" "baz3"]
}
func ExampleCompare() {
// 比较a和b, 返回 0: a等于b, 1: a包含b, -1: a不包含b
//bytes.Compare(a, b)
fmt.Println(strings.Compare("a", "b"))
fmt.Println(strings.Compare("a", "a"))
fmt.Println(strings.Compare("b", "a"))
// Output:
// -1
// 0
// 1
}
func ExampleContains() {
// 判断a是否包含b
//bytes.Contains(a, b)
fmt.Println(strings.Contains("seafood", "foo"))
fmt.Println(strings.Contains("seafood", "bar"))
fmt.Println(strings.Contains("seafood", ""))
fmt.Println(strings.Contains("", ""))
// Output:
// true
// false
// true
// true
}
func ExampleContainsAny() {
// 判断byte是否包含字符串中任意字符,只要包含字符串中一个及以上字符返回true,否则false
//bytes.ContainsAny([]byte("I like seafood."), "fÄo!")
fmt.Println(strings.ContainsAny("team", "i"))
fmt.Println(strings.ContainsAny("fail", "ui"))
fmt.Println(strings.ContainsAny("ure", "ui"))
fmt.Println(strings.ContainsAny("failure", "ui"))
fmt.Println(strings.ContainsAny("foo", ""))
fmt.Println(strings.ContainsAny("", ""))
// Output:
// false
// true
// true
// true
// false
// false
}
func ExampleContainsRune() {
// 判断byte是否包含rune字符
//bytes.ContainsRune([]byte("I like seafood."), 'f')
// Finds whether a string contains a particular Unicode code point.
// The code point for the lowercase letter "a", for example, is 97.
fmt.Println(strings.ContainsRune("aardvark", 97))
fmt.Println(strings.ContainsRune("timeout", 97))
// Output:
// true
// false
}
func ExampleCount() {
// 统计a中包含所有b的个数,如果b为空则返回a的长度
//bytes.Count(a, b)
fmt.Println(strings.Count("cheese", "e"))
fmt.Println(strings.Count("five", "")) // before & after each rune
// Output:
// 3
// 5
}
func ExampleEqualFold() {
// 判断a与b是否相同(将unicode大写、小写、标题三种格式字符视为相同)
//strings.EqualFold(a, b)
fmt.Println(strings.EqualFold("Go", "go"))
// Output: true
}
func ExampleHasPrefix() {
//判断a是否以b开头,当b为空时true
//strings.HasPrefix(a, b)
fmt.Println(strings.HasPrefix("Gopher", "Go"))
fmt.Println(strings.HasPrefix("Gopher", "C"))
fmt.Println(strings.HasPrefix("Gopher", ""))
// Output:
// true
// false
// true
}
func ExampleHasSuffix() {
//判断a是否以b结尾,当b为空时true
//strings.HasSuffix(a, b)
fmt.Println(strings.HasSuffix("Amigo", "go"))
fmt.Println(strings.HasSuffix("Amigo", "O"))
fmt.Println(strings.HasSuffix("Amigo", "Ami"))
fmt.Println(strings.HasSuffix("Amigo", ""))
// Output:
// true
// false
// false
// true
}
func ExampleIndex() {
//检索b在a中第一次出现的位置,未检索到返回-1
//strings.Index(a, b)
fmt.Println(strings.Index("chicken", "ken"))
fmt.Println(strings.Index("chicken", "dmr"))
// Output:
// 4
// -1
}
func ExampleIndexFunc() {
//自定义方法检索首个字符的位置,未检索到返回-1
//strings.IndexFunc
f := func(c rune) bool {
return unicode.Is(unicode.Han, c) // 是否包含中文字符
}
fmt.Println(strings.IndexFunc("Hello, 世界", f))
fmt.Println(strings.IndexFunc("Hello, world", f))
// Output:
// 7
// -1
}
func ExampleIndexAny() {
//检索a中首个 字符串中任意字符 的位置,未检索到返回-1
//strings.IndexAny(a, "abc")
fmt.Println(strings.IndexAny("chicken", "aeiouy"))
fmt.Println(strings.IndexAny("crwth", "aeiouy"))
// Output:
// 2
// -1
}
func ExampleIndexByte() {
//检索字符c在s中第一次出现的位置,不存在则返回-1
//strings.IndexByte(a, byte('k'))
fmt.Println(strings.IndexByte("golang", 'g'))
fmt.Println(strings.IndexByte("gophers", 'h'))
fmt.Println(strings.IndexByte("golang", 'x'))
// Output:
// 0
// 3
// -1
}
func ExampleIndexRune() {
//检索a中首个 rune类型字符 的位置,未检索到返回-1
//strings.IndexRune("chicken", 'k')
fmt.Println(strings.IndexRune("chicken", 'k'))
fmt.Println(strings.IndexRune("chicken", 'd'))
// Output:
// 4
// -1
}
func ExampleLastIndex() {
//检索b在a中第一次出现的位置,未检索到返回-1
//strings.Index(a, b)
fmt.Println(strings.Index("go gopher", "go"))
//检索a中最后个b的位置,未检索到返回-1
//strings.LastIndex(a, b)
fmt.Println(strings.LastIndex("go gopher", "go"))
fmt.Println(strings.LastIndex("go gopher", "rodent"))
// Output:
// 0
// 3
// -1
}
func ExampleLastIndexAny() {
//返回字符串str中的任何一个字符在字符串s中最后一次出现的位置。
//如果找不到或str为空则返回-1
fmt.Println(strings.LastIndexAny("go gopher", "go"))
fmt.Println(strings.LastIndexAny("go gopher", "rodent"))
fmt.Println(strings.LastIndexAny("go gopher", "fail"))
// Output:
// 4
// 8
// -1
}
func ExampleLastIndexByte() {
//检索a中最后个 byte类型字符 的位置,未检索到返回-1
//strings.LastIndexByte(a, byte('k'))
fmt.Println(strings.LastIndexByte("Hello, world", 'l'))
fmt.Println(strings.LastIndexByte("Hello, world", 'o'))
fmt.Println(strings.LastIndexByte("Hello, world", 'x'))
// Output:
// 10
// 8
// -1
}
func ExampleLastIndexFunc() {
//自定义方法检索最后个字符的位置,未检索到返回-1
//strings.LastIndexFunc(a, unicode.IsLetter)
fmt.Println(strings.LastIndexFunc("go 123", unicode.IsNumber))
fmt.Println(strings.LastIndexFunc("123 go", unicode.IsNumber))
fmt.Println(strings.LastIndexFunc("go", unicode.IsNumber))
// Output:
// 5
// 2
// -1
}
func ExampleJoin() {
//将string数组以指定字符连接成一个新的string
//s := []string{a, b}
//strings.Join(s, ",")
s := []string{"foo", "bar", "baz"}
fmt.Println(strings.Join(s, ", "))
// Output: foo, bar, baz
}
func ExampleRepeat() {
// 返回count个s串联的字符串
// 例如:a = "abc",返回 "abcabc"
//strings.Repeat(a, 2)
fmt.Println("ba" + strings.Repeat("na", 2))
// Output: banana
}
func ExampleReplace() {
//返回一个 将a中的b替换为c 的新string,n为替换个数,-1替换所有,其他为替换的个数
//strings.Replace(a, b, c, -1)
fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
// Output:
// oinky oinky oink
// moo moo moo
}
func ExampleReplaceAll() {
//返回一个 将a中的b替换为c 的新string,全部替换
//strings.ReplaceAll(a, b, c)
fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))
// Output:
// moo moo moo
}
func ExampleSplit() {
//将a以指定字符分割成string数组
//strings.Split(a, b)
fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
// Output:
// ["a" "b" "c"]
// ["" "man " "plan " "canal panama"]
// [" " "x" "y" "z" " "]
// [""]
}
func ExampleSplitN() {
//将a以指定字符分割成string数组, n为分割个数,-1分割所有
//strings.SplitN(a, b, 2)
fmt.Printf("%q\n", strings.SplitN("a,b,c", ",", 2))
z := strings.SplitN("a,b,c", ",", 0)
fmt.Printf("%q (nil = %v)\n", z, z == nil)
// Output:
// ["a" "b,c"]
// [] (nil = true)
}
func ExampleSplitAfter() {
//将a以指定字符分割成string数组,保留b。
//strings.SplitAfter(a, b)
fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ","))
// Output: ["a," "b," "c"]
}
func ExampleSplitAfterN() {
//将a以指定字符分割成string数组,保留b。n为分割个数,-1分割所有
//strings.SplitAfterN(a, b, 2)
fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2))
// Output: ["a," "b,c"]
}
func ExampleTitle() {
//返回一个 以空格为界限,所有首个字母大写 的标题格式
//strings.Title(a)
// Compare this example to the ToTitle example.
fmt.Println(strings.Title("her royal highness"))
fmt.Println(strings.Title("loud noises"))
fmt.Println(strings.Title("хлеб"))
// Output:
// Her Royal Highness
// Loud Noises
// Хлеб
}
func ExampleToTitle() {
//返回一个 所有字母大写 的标题格式
//strings.ToTitle(a)
// Compare this example to the Title example.
fmt.Println(strings.ToTitle("her royal highness"))
fmt.Println(strings.ToTitle("loud noises"))
fmt.Println(strings.ToTitle("хлеб"))
// Output:
// HER ROYAL HIGHNESS
// LOUD NOISES
// ХЛЕБ
}
func ExampleToTitleSpecial() {
//使用指定的映射表将 a 中的所有字符修改为标题格式返回。
//strings.ToTitleSpecial(unicode.SpecialCase{}, a)
fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "dünyanın ilk borsa yapısı Aizonai kabul edilir"))
// Output:
// DÜNYANIN İLK BORSA YAPISI AİZONAİ KABUL EDİLİR
}
func ExampleMap() {
//遍历a按指定的rune方法处理每个字符
//strings.Map
rot13 := func(r rune) rune {
switch {
case r >= 'A' && r <= 'Z':
return 'A' + (r-'A'+13)%26
case r >= 'a' && r <= 'z':
return 'a' + (r-'a'+13)%26
}
return r
}
fmt.Println(strings.Map(rot13, "'Twas brillig and the slithy gopher..."))
// Output: 'Gjnf oevyyvt naq gur fyvgul tbcure...
}
func ExampleNewReplacer() {
// 使用提供的多组old、new字符串对创建并返回一个*strings.Replacer
// 替换是依次进行的,匹配时不会重叠
r := strings.NewReplacer("<", "<", ">", ">")
fmt.Println(r.Replace("This is <b>HTML</b>!"))
// Output: This is <b>HTML</b>!
}
func ExampleToUpper() {
//所有字母大写
//strings.ToUpper(a)
fmt.Println(strings.ToUpper("Gopher"))
// Output: GOPHER
}
func ExampleToUpperSpecial() {
// 使用指定的映射表将 a 中的所有字符修改为大写格式返回。
fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
// Output: ÖRNEK İŞ
}
func ExampleToLower() {
// 所有字母小写
fmt.Println(strings.ToLower("Gopher"))
// Output: gopher
}
func ExampleToLowerSpecial() {
// 使用指定的映射表将 a 中的所有字符修改为小写格式返回。
fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
// Output: önnek iş
}
func ExampleTrim() {
// 去除开头结尾所有的 指定字符串中的任意字符
fmt.Print(strings.Trim("¡¡¡Hello, Gophers!!!", "!¡"))
// Output: Hello, Gophers
}
func ExampleTrimSpace() {
// 去除开头结尾所有的 空格换行回车缩进
fmt.Println(strings.TrimSpace(" \t\n Hello, Gophers \n\t\r\n"))
// Output: Hello, Gophers
}
func ExampleTrimPrefix() {
//如果a以b开头,则返回a去掉b开头部分的新byte。如果不是,返回a
//bytes.TrimPrefix(a, b)
var s = "¡¡¡Hello, Gophers!!!"
s = strings.TrimPrefix(s, "¡¡¡Hello, ")
s = strings.TrimPrefix(s, "¡¡¡Howdy, ")
fmt.Print(s)
// Output: Gophers!!!
}
func ExampleTrimSuffix() {
//如果a以b结尾,则返回a去掉b结尾部分的新string。如果不是,返回a
//strings.TrimSuffix(a, b)
var s = "¡¡¡Hello, Gophers!!!"
s = strings.TrimSuffix(s, ", Gophers!!!")
s = strings.TrimSuffix(s, ", Marmots!!!")
fmt.Print(s)
// Output: ¡¡¡Hello
}
func ExampleTrimFunc() {
按自定义方法 去除开头结尾所有指定内容
strings.TrimFunc(a, unicode.IsLetter)
fmt.Print(strings.TrimFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
return !unicode.IsLetter(r) && !unicode.IsNumber(r)
}))
// Output: Hello, Gophers
}
func ExampleTrimLeft() {
// 去除开头所有的 指定字符串中的任意字符
fmt.Print(strings.TrimLeft("¡¡¡Hello, Gophers!!!", "!¡"))
// Output: Hello, Gophers!!!
}
func ExampleTrimLeftFunc() {
// 按自定义方法 去除开头所有指定内容
//strings.TrimLeftFunc(a, unicode.IsLetter)
fmt.Print(strings.TrimLeftFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
return !unicode.IsLetter(r) && !unicode.IsNumber(r)
}))
// Output: Hello, Gophers!!!
}
func ExampleTrimRight() {
// 去除结尾所有的 指定字符串中的任意字符
fmt.Print(strings.TrimRight("¡¡¡Hello, Gophers!!!", "!¡"))
// Output: ¡¡¡Hello, Gophers
}
func ExampleTrimRightFunc() {
//按自定义方法 去除结尾所有指定内容
//strings.TrimRightFunc(a, unicode.IsLetter)
fmt.Print(strings.TrimRightFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
return !unicode.IsLetter(r) && !unicode.IsNumber(r)
}))
// Output: ¡¡¡Hello, Gophers
}
func ExampleBuilder() {
//用于字符串拼接
var b strings.Builder
for i := 3; i >= 1; i-- {
fmt.Fprintf(&b, "%d...", i)
}
b.WriteString("ignition")
fmt.Println(b.String())
// Output: 3...2...1...ignition
}
go库函数之-strings-使用示例
最新推荐文章于 2024-09-09 09:17:02 发布