strings 包中的函數(shù)和方法
// strings.go
------------------------------------------------------------
// Count 計(jì)算字符串 sep 在 s 中的非重疊個(gè)數(shù)
// 如果 sep 為空字符串，則返回 s 中的字符(非字節(jié))個(gè)數(shù) + 1
// 使用 Rabin-Karp 算法實(shí)現(xiàn)
func Count(s, sep string) int
func main() {
s := "Hello,世界!!!!!"
n := strings.Count(s, "!")
fmt.Println(n) // 5
n = strings.Count(s, "!!")
fmt.Println(n) // 2
}
------------------------------------------------------------
// Contains 判斷字符串 s 中是否包含子串 substr
// 如果 substr 為空，則返回 true
func Contains(s, substr string) bool
func main() {
s := "Hello,世界!!!!!"
b := strings.Contains(s, "!!")
fmt.Println(b) // true
b = strings.Contains(s, "!?")
fmt.Println(b) // false
b = strings.Contains(s, "")
fmt.Println(b) // true
}
------------------------------------------------------------
// ContainsAny 判斷字符串 s 中是否包含 chars 中的任何一個(gè)字符
// 如果 chars 為空，則返回 false
func ContainsAny(s, chars string) bool
func main() {
s := "Hello,世界!"
b := strings.ContainsAny(s, "abc")
fmt.Println(b) // false
b = strings.ContainsAny(s, "def")
fmt.Println(b) // true
b = strings.Contains(s, "")
fmt.Println(b) // true
}
------------------------------------------------------------
// ContainsRune 判斷字符串 s 中是否包含字符 r
func ContainsRune(s string, r rune) bool
func main() {
s := "Hello,世界!"
b := strings.ContainsRune(s, '\n')
fmt.Println(b) // false
b = strings.ContainsRune(s, '界')
fmt.Println(b) // true
b = strings.ContainsRune(s, 0)
fmt.Println(b) // false
}
------------------------------------------------------------
// Index 返回子串 sep 在字符串 s 中第一次出現(xiàn)的位置
// 如果找不到，則返回 -1，如果 sep 為空，則返回 0。
// 使用 Rabin-Karp 算法實(shí)現(xiàn)
func Index(s, sep string) int
func main() {
s := "Hello,世界!"
i := strings.Index(s, "h")
fmt.Println(i) // -1
i = strings.Index(s, "!")
fmt.Println(i) // 12
i = strings.Index(s, "")
fmt.Println(i) // 0
}
------------------------------------------------------------
// LastIndex 返回子串 sep 在字符串 s 中最后一次出現(xiàn)的位置
// 如果找不到，則返回 -1，如果 sep 為空，則返回字符串的長(zhǎng)度
// 使用樸素字符串比較算法實(shí)現(xiàn)
func LastIndex(s, sep string) int
func main() {
s := "Hello,世界! Hello!"
i := strings.LastIndex(s, "h")
fmt.Println(i) // -1
i = strings.LastIndex(s, "H")
fmt.Println(i) // 14
i = strings.LastIndex(s, "")
fmt.Println(i) // 20
}
------------------------------------------------------------
// IndexRune 返回字符 r 在字符串 s 中第一次出現(xiàn)的位置
// 如果找不到，則返回 -1
func IndexRune(s string, r rune) int
func main() {
s := "Hello,世界! Hello!"
i := strings.IndexRune(s, '\n')
fmt.Println(i) // -1
i = strings.IndexRune(s, '界')
fmt.Println(i) // 9
i = strings.IndexRune(s, 0)
fmt.Println(i) // -1
}
------------------------------------------------------------
// IndexAny 返回字符串 chars 中的任何一個(gè)字符在字符串 s 中第一次出現(xiàn)的位置
// 如果找不到，則返回 -1，如果 chars 為空，則返回 -1
func IndexAny(s, chars string) int
func main() {
s := "Hello,世界! Hello!"
i := strings.IndexAny(s, "abc")
fmt.Println(i) // -1
i = strings.IndexAny(s, "dof")
fmt.Println(i) // 1
i = strings.IndexAny(s, "")
fmt.Println(i) // -1
}
------------------------------------------------------------
// LastIndexAny 返回字符串 chars 中的任何一個(gè)字符在字符串 s 中最后一次出現(xiàn)的位置
// 如果找不到，則返回 -1，如果 chars 為空，也返回 -1
func LastIndexAny(s, chars string) int
func main() {
s := "Hello,世界! Hello!"
i := strings.LastIndexAny(s, "abc")
fmt.Println(i) // -1
i = strings.LastIndexAny(s, "def")
fmt.Println(i) // 15
i = strings.LastIndexAny(s, "")
fmt.Println(i) // -1
}
------------------------------------------------------------
// SplitN 以 sep 為分隔符，將 s 切分成多個(gè)子串，結(jié)果中不包含 sep 本身
// 如果 sep 為空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒(méi)有 sep 子串，則將整個(gè) s 作為 []string 的第一個(gè)元素返回
// 參數(shù) n 表示最多切分出幾個(gè)子串，超出的部分將不再切分。
// 如果 n 為 0，則返回 nil，如果 n 小于 0，則不限制切分個(gè)數(shù)，全部切分
func SplitN(s, sep string, n int) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.SplitN(s, " ", 2)
fmt.Printf("%q\n", ss) // ["Hello," "世界! Hello!"]
ss = strings.SplitN(s, " ", -1)
fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
ss = strings.SplitN(s, "", 3)
fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}
------------------------------------------------------------
// SplitAfterN 以 sep 為分隔符，將 s 切分成多個(gè)子串，結(jié)果中包含 sep 本身
// 如果 sep 為空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒(méi)有 sep 子串，則將整個(gè) s 作為 []string 的第一個(gè)元素返回
// 參數(shù) n 表示最多切分出幾個(gè)子串，超出的部分將不再切分。
// 如果 n 為 0，則返回 nil，如果 n 小于 0，則不限制切分個(gè)數(shù)，全部切分
func SplitAfterN(s, sep string, n int) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.SplitAfterN(s, " ", 2)
fmt.Printf("%q\n", ss) // ["Hello, " "世界! Hello!"]
ss = strings.SplitAfterN(s, " ", -1)
fmt.Printf("%q\n", ss) // ["Hello, " "世界! " "Hello!"]
ss = strings.SplitAfterN(s, "", 3)
fmt.Printf("%q\n", ss) // ["H" "e" "llo, 世界! Hello!"]
}
------------------------------------------------------------
// Split 以 sep 為分隔符，將 s 切分成多個(gè)子切片，結(jié)果中不包含 sep 本身
// 如果 sep 為空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒(méi)有 sep 子串，則將整個(gè) s 作為 []string 的第一個(gè)元素返回
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) // 單個(gè)字符列表
}
------------------------------------------------------------
// SplitAfter 以 sep 為分隔符，將 s 切分成多個(gè)子切片，結(jié)果中包含 sep 本身
// 如果 sep 為空，則將 s 切分成 Unicode 字符列表。
// 如果 s 中沒(méi)有 sep 子串，則將整個(gè) s 作為 []string 的第一個(gè)元素返回
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) // 單個(gè)字符列表
}
------------------------------------------------------------
// Fields 以連續(xù)的空白字符為分隔符，將 s 切分成多個(gè)子串，結(jié)果中不包含空白字符本身
// 空白字符有：\t, \n, \v, \f, \r, ' ', U+0085 (NEL), U+00A0 (NBSP)
// 如果 s 中只包含空白字符，則返回一個(gè)空列表
func Fields(s string) []string
func main() {
s := "Hello, 世界! Hello!"
ss := strings.Fields(s)
fmt.Printf("%q\n", ss) // ["Hello," "世界!" "Hello!"]
}
------------------------------------------------------------
// FieldsFunc 以一個(gè)或多個(gè)滿(mǎn)足 f(rune) 的字符為分隔符，
// 將 s 切分成多個(gè)子串，結(jié)果中不包含分隔符本身。
// 如果 s 中沒(méi)有滿(mǎn)足 f(rune) 的字符，則返回一個(gè)空列表。
func FieldsFunc(s string, f func(rune) bool) []string
func isSlash(r rune) bool {
return r == '\\' || r == '/'
}
func main() {
s := "C:\\Windows\\System32\\FileName"
ss := strings.FieldsFunc(s, isSlash)
fmt.Printf("%q\n", ss) // ["C:" "Windows" "System32" "FileName"]
}
------------------------------------------------------------
// Join 將 a 中的子串連接成一個(gè)單獨(dú)的字符串，子串之間用 sep 分隔
func Join(a []string, sep string) string
func main() {
ss := []string{"Monday", "Tuesday", "Wednesday"}
s := strings.Join(ss, "|")
fmt.Println(s)
}
------------------------------------------------------------
// HasPrefix 判斷字符串 s 是否以 prefix 開(kāi)頭
func HasPrefix(s, prefix string) bool
func main() {
s := "Hello 世界!"
b := strings.HasPrefix(s, "hello")
fmt.Println(b) // false
b = strings.HasPrefix(s, "Hello")
fmt.Println(b) // true
}
------------------------------------------------------------
// HasSuffix 判斷字符串 s 是否以 prefix 結(jié)尾
func HasSuffix(s, suffix string) bool
func main() {
s := "Hello 世界!"
b := strings.HasSuffix(s, "世界")
fmt.Println(b) // false
b = strings.HasSuffix(s, "世界!")
fmt.Println(b) // true
}
------------------------------------------------------------
// Map 將 s 中滿(mǎn)足 mapping(rune) 的字符替換為 mapping(rune) 的返回值。
// 如果 mapping(rune) 返回負(fù)數(shù)，則相應(yīng)的字符將被刪除。
func Map(mapping func(rune) rune, s string) string
func Slash(r rune) rune {
if r == '\\' {
return '/'
}
return r
}
func main() {
s := "C:\\Windows\\System32\\FileName"
ms := strings.Map(Slash, s)
fmt.Printf("%q\n", ms) // "C:/Windows/System32/FileName"
}
-----------------------------------------------------------
// Repeat 將 count 個(gè)字符串 s 連接成一個(gè)新的字符串
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 中的所有字符修改為其大寫(xiě)格式
// 對(duì)于非 ASCII 字符，它的大寫(xiě)格式需要查表轉(zhuǎn)換
func ToUpper(s string) string
// ToLower 將 s 中的所有字符修改為其小寫(xiě)格式
// 對(duì)于非 ASCII 字符，它的小寫(xiě)格式需要查表轉(zhuǎn)換
func ToLower(s string) string
// ToTitle 將 s 中的所有字符修改為其 Title 格式
// 大部分字符的 Title 格式就是其 Upper 格式
// 只有少數(shù)字符的 Title 格式是特殊字符
// 這里的 ToTitle 主要給 Title 函數(shù)調(diào)用
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]) // 大寫(xiě)格式
// l := uint32(cr.Delta[unicode.LowerCase]) // 小寫(xiě)格式
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 中的所有字符修改為其大寫(xiě)格式。
// 優(yōu)先使用 _case 中的規(guī)則進(jìn)行轉(zhuǎn)換
func ToUpperSpecial(_case unicode.SpecialCase, s string) string
// ToLowerSpecial 將 s 中的所有字符修改為其小寫(xiě)格式。
// 優(yōu)先使用 _case 中的規(guī)則進(jìn)行轉(zhuǎn)換
func ToLowerSpecial(_case unicode.SpecialCase, s string) string
// ToTitleSpecial 將 s 中的所有字符修改為其 Title 格式。
// 優(yōu)先使用 _case 中的規(guī)則進(jìn)行轉(zhuǎn)換
func ToTitleSpecial(_case unicode.SpecialCase, s string) string
_case 規(guī)則說(shuō)明，以下列語(yǔ)句為例：
unicode.CaseRange{'A', 'Z', [unicode.MaxCase]rune{3, -3, 0}}
·其中 'A', 'Z' 表示此規(guī)則只影響 'A' 到 'Z' 之間的字符。
·其中 [unicode.MaxCase]rune 數(shù)組表示：
當(dāng)使用 ToUpperSpecial 轉(zhuǎn)換時(shí)，將字符的 Unicode 編碼與第一個(gè)元素值（3）相加
當(dāng)使用 ToLowerSpecial 轉(zhuǎn)換時(shí)，將字符的 Unicode 編碼與第二個(gè)元素值（-3）相加
當(dāng)使用 ToTitleSpecial 轉(zhuǎn)換時(shí)，將字符的 Unicode 編碼與第三個(gè)元素值（0）相加
func main() {
// 定義轉(zhuǎn)換規(guī)則
var _MyCase = unicode.SpecialCase{
// 將半角逗號(hào)替換為全角逗號(hào)，ToTitle 不處理
unicode.CaseRange{',', ',',
[unicode.MaxCase]rune{'，' - ',', '，' - ',', 0}},
// 將半角句號(hào)替換為全角句號(hào)，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."
}
------------------------------------------------------------
// Title 將 s 中的所有單詞的首字母修改為其 Title 格式
// BUG: Title 規(guī)則不能正確處理 Unicode 標(biāo)點(diǎn)符號(hào)
func Title(s string) string
func main() {
s := "heLLo worLd"
ts := strings.Title(s)
fmt.Printf("%q\n", ts) // "HeLLo WorLd"
}
------------------------------------------------------------
// TrimLeftFunc 將刪除 s 頭部連續(xù)的滿(mǎn)足 f(rune) 的字符
func TrimLeftFunc(s string, f func(rune) bool) string
------------------------------------------------------------
// TrimRightFunc 將刪除 s 尾部連續(xù)的滿(mǎn)足 f(rune) 的字符
func TrimRightFunc(s string, f func(rune) bool) string
func isSlash(r rune) bool {
return r == '\\' || r == '/'
}
func main() {
s := "\\\\HostName\\C\\Windows\\"
ts := strings.TrimRightFunc(s, isSlash)
fmt.Printf("%q\n", ts) // "\\\\HostName\\C\\Windows"
}
------------------------------------------------------------
// TrimFunc 將刪除 s 首尾連續(xù)的滿(mǎn)足 f(rune) 的字符
func TrimFunc(s string, f func(rune) bool) string
func isSlash(r rune) bool {
return r == '\\' || r == '/'
}
func main() {
s := "\\\\HostName\\C\\Windows\\"
ts := strings.TrimFunc(s, isSlash)
fmt.Printf("%q\n", ts) // "HostName\\C\\Windows"
}
------------------------------------------------------------
// 返回 s 中第一個(gè)滿(mǎn)足 f(rune) 的字符的字節(jié)位置。
// 如果沒(méi)有滿(mǎn)足 f(rune) 的字符，則返回 -1
func IndexFunc(s string, f func(rune) bool) int
func isSlash(r rune) bool {
return r == '\\' || r == '/'
}
func main() {
s := "C:\\Windows\\System32"
i := strings.IndexFunc(s, isSlash)
fmt.Printf("%v\n", i) // 2
}
------------------------------------------------------------
// 返回 s 中最后一個(gè)滿(mǎn)足 f(rune) 的字符的字節(jié)位置。
// 如果沒(méi)有滿(mǎn)足 f(rune) 的字符，則返回 -1
func LastIndexFunc(s string, f func(rune) bool) int
func isSlash(r rune) bool {
return r == '\\' || r == '/'
}
func main() {
s := "C:\\Windows\\System32"
i := strings.LastIndexFunc(s, isSlash)
fmt.Printf("%v\n", i) // 10
}
------------------------------------------------------------
// Trim 將刪除 s 首尾連續(xù)的包含在 cutset 中的字符
func Trim(s string, cutset string) string
func main() {
s := " Hello 世界! "
ts := strings.Trim(s, " Helo!")
fmt.Printf("%q\n", ts) // "世界"
}
------------------------------------------------------------
// TrimLeft 將刪除 s 頭部連續(xù)的包含在 cutset 中的字符
func TrimLeft(s string, cutset string) string
func main() {
s := " Hello 世界! "
ts := strings.TrimLeft(s, " Helo")
fmt.Printf("%q\n", ts) // "世界! "
}
------------------------------------------------------------
// TrimRight 將刪除 s 尾部連續(xù)的包含在 cutset 中的字符
func TrimRight(s string, cutset string) string
func main() {
s := " Hello 世界! "
ts := strings.TrimRight(s, " 世界!")
fmt.Printf("%q\n", ts) // " Hello"
}
------------------------------------------------------------
// TrimSpace 將刪除 s 首尾連續(xù)的的空白字符
func TrimSpace(s string) string
func main() {
s := " Hello 世界! "
ts := strings.TrimSpace(s)
fmt.Printf("%q\n", ts) // "Hello 世界!"
}
------------------------------------------------------------
// TrimPrefix 刪除 s 頭部的 prefix 字符串
// 如果 s 不是以 prefix 開(kāi)頭，則返回原始 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 結(jié)尾，則返回原始 s
func TrimSuffix(s, suffix string) string
func main() {
s := "Hello 世界!!!!!"
ts := strings.TrimSuffix(s, "!!!!")
fmt.Printf("%q\n", ts) // " 世界"
}
注：TrimSuffix只是去掉s字符串結(jié)尾的suffix字符串，只是去掉１次，而TrimRight是一直去掉s字符串右邊的字符串，只要有響應(yīng)的字符串就去掉，是一個(gè)多次的過(guò)程，這也是二者的本質(zhì)區(qū)別．
------------------------------------------------------------
// Replace 返回 s 的副本，并將副本中的 old 字符串替換為 new 字符串
// 替換次數(shù)為 n 次，如果 n 為 -1，則全部替換
// 如果 old 為空，則在副本的每個(gè)字符之間都插入一個(gè) 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)
}
------------------------------------------------------------
// EqualFold 判斷 s 和 t 是否相等。忽略大小寫(xiě)，同時(shí)它還會(huì)對(duì)特殊字符進(jìn)行轉(zhuǎn)換
// 比如將“ϕ”轉(zhuǎn)換為“Φ”、將“DŽ”轉(zhuǎn)換為“Dž”等，然后再進(jìn)行比較
func EqualFold(s, t string) bool
func main() {
s1 := "Hello 世界! ϕ DŽ"
s2 := "hello 世界! Φ Dž"
b := strings.EqualFold(s1, s2)
fmt.Printf("%v\n", b) // true
}
============================================================
// reader.go
------------------------------------------------------------
// Reader 結(jié)構(gòu)通過(guò)讀取字符串，實(shí)現(xiàn)了 io.Reader，io.ReaderAt，
// io.Seeker，io.WriterTo，io.ByteScanner，io.RuneScanner 接口
type Reader struct {
s string // 要讀取的字符串
i int // 當(dāng)前讀取的索引位置，從 i 處開(kāi)始讀取數(shù)據(jù)
prevRune int // 讀取的前一個(gè)字符的索引位置，小于 0 表示之前未讀取字符
}
// 通過(guò)字符串 s 創(chuàng)建 strings.Reader 對(duì)象
// 這個(gè)函數(shù)類(lèi)似于 bytes.NewBufferString
// 但比 bytes.NewBufferString 更有效率，而且只讀
func NewReader(s string) *Reader { return Reader{s, 0, -1} }
------------------------------------------------------------
// Len 返回 r.i 之后的所有數(shù)據(jù)的字節(jié)長(zhǎng)度
func (r *Reader) Len() int
func main() {
s := "Hello 世界!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 獲取字符串的編碼長(zhǎng)度
fmt.Println(r.Len()) // 13
}
------------------------------------------------------------
// Read 將 r.i 之后的所有數(shù)據(jù)寫(xiě)入到 b 中（如果 b 的容量足夠大）
// 返回讀取的字節(jié)數(shù)和讀取過(guò)程中遇到的錯(cuò)誤
// 如果無(wú)可讀數(shù)據(jù)，則返回 io.EOF
func (r *Reader) Read(b []byte) (n int, err error)
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 創(chuàng)建長(zhǎng)度為 5 個(gè)字節(jié)的緩沖區(qū)
b := make([]byte, 5)
// 循環(huán)讀取 r 中的字符串
for n, _ := r.Read(b); n > 0; n, _ = r.Read(b) {
fmt.Printf("%q, ", b[:n]) // "Hello", " Worl", "d!"
}
}
------------------------------------------------------------
// ReadAt 將 off 之后的所有數(shù)據(jù)寫(xiě)入到 b 中（如果 b 的容量足夠大）
// 返回讀取的字節(jié)數(shù)和讀取過(guò)程中遇到的錯(cuò)誤
// 如果無(wú)可讀數(shù)據(jù)，則返回 io.EOF
// 如果數(shù)據(jù)被一次性讀取完畢，則返回 io.EOF
func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 創(chuàng)建長(zhǎng)度為 5 個(gè)字節(jié)的緩沖區(qū)
b := make([]byte, 5)
// 讀取 r 中指定位置的字符串
n, _ := r.ReadAt(b, 0)
fmt.Printf("%q\n", b[:n]) // "Hello"
// 讀取 r 中指定位置的字符串
n, _ = r.ReadAt(b, 6)
fmt.Printf("%q\n", b[:n]) // "World"
}
------------------------------------------------------------
// ReadByte 將 r.i 之后的一個(gè)字節(jié)寫(xiě)入到返回值 b 中
// 返回讀取的字節(jié)和讀取過(guò)程中遇到的錯(cuò)誤
// 如果無(wú)可讀數(shù)據(jù)，則返回 io.EOF
func (r *Reader) ReadByte() (b byte, err error)
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 讀取 r 中的一個(gè)字節(jié)
for i := 0; i 3; i++ {
b, _ := r.ReadByte()
fmt.Printf("%q, ", b) // 'H', 'e', 'l',
}
}
------------------------------------------------------------
// UnreadByte 撤消前一次的 ReadByte 操作，即 r.i--
func (r *Reader) UnreadByte() error
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 讀取 r 中的一個(gè)字節(jié)
for i := 0; i 3; i++ {
b, _ := r.ReadByte()
fmt.Printf("%q, ", b) // 'H', 'H', 'H',
r.UnreadByte() // 撤消前一次的字節(jié)讀取操作
}
}
------------------------------------------------------------
// ReadRune 將 r.i 之后的一個(gè)字符寫(xiě)入到返回值 ch 中
// ch： 讀取的字符
// size：ch 的編碼長(zhǎng)度
// err： 讀取過(guò)程中遇到的錯(cuò)誤
// 如果無(wú)可讀數(shù)據(jù)，則返回 io.EOF
// 如果 r.i 之后不是一個(gè)合法的 UTF-8 字符編碼，則返回 utf8.RuneError 字符
func (r *Reader) ReadRune() (ch rune, size int, err error)
func main() {
s := "你好 世界！"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 讀取 r 中的一個(gè)字符
for i := 0; i 5; i++ {
b, n, _ := r.ReadRune()
fmt.Printf(`"%c:%v", `, b, n)
// "你:3", "好:3", " :1", "世:3", "界:3",
}
}
------------------------------------------------------------
// 撤消前一次的 ReadRune 操作
func (r *Reader) UnreadRune() error
func main() {
s := "你好 世界！"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 讀取 r 中的一個(gè)字符
for i := 0; i 5; i++ {
b, _, _ := r.ReadRune()
fmt.Printf("%q, ", b)
// '你', '你', '你', '你', '你',
r.UnreadRune() // 撤消前一次的字符讀取操作
}
}
------------------------------------------------------------
// Seek 用來(lái)移動(dòng) r 中的索引位置
// offset：要移動(dòng)的偏移量，負(fù)數(shù)表示反向移動(dòng)
// whence：從那里開(kāi)始移動(dòng)，0：起始位置，1：當(dāng)前位置，2：結(jié)尾位置
// 如果 whence 不是 0、1、2，則返回錯(cuò)誤信息
// 如果目標(biāo)索引位置超出字符串范圍，則返回錯(cuò)誤信息
// 目標(biāo)索引位置不能超出 1 31，否則返回錯(cuò)誤信息
func (r *Reader) Seek(offset int64, whence int) (int64, error)
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 創(chuàng)建讀取緩沖區(qū)
b := make([]byte, 5)
// 讀取 r 中指定位置的內(nèi)容
r.Seek(6, 0) // 移動(dòng)索引位置到第 7 個(gè)字節(jié)
r.Read(b) // 開(kāi)始讀取
fmt.Printf("%q\n", b)
r.Seek(-5, 1) // 將索引位置移回去
r.Read(b) // 繼續(xù)讀取
fmt.Printf("%q\n", b)
}
------------------------------------------------------------
// WriteTo 將 r.i 之后的數(shù)據(jù)寫(xiě)入接口 w 中
func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
func main() {
s := "Hello World!"
// 創(chuàng)建 Reader
r := strings.NewReader(s)
// 創(chuàng)建 bytes.Buffer 對(duì)象，它實(shí)現(xiàn)了 io.Writer 接口
buf := bytes.NewBuffer(nil)
// 將 r 中的數(shù)據(jù)寫(xiě)入 buf 中
r.WriteTo(buf)
fmt.Printf("%q\n", buf) // "Hello World!"
}
============================================================
// replace.go
------------------------------------------------------------
// Replacer 根據(jù)一個(gè)替換列表執(zhí)行替換操作
type Replacer struct {
Replace(s string) string
WriteString(w io.Writer, s string) (n int, err error)
}
------------------------------------------------------------
// NewReplacer 通過(guò)“替換列表”創(chuàng)建一個(gè) Replacer 對(duì)象。
// 按照“替換列表”中的順序進(jìn)行替換，只替換非重疊部分。
// 如果參數(shù)的個(gè)數(shù)不是偶數(shù)，則拋出異常。
// 如果在“替換列表”中有相同的“查找項(xiàng)”，則后面重復(fù)的“查找項(xiàng)”會(huì)被忽略
func NewReplacer(oldnew ...string) *Replacer
------------------------------------------------------------
// Replace 返回對(duì) s 進(jìn)行“查找和替換”后的結(jié)果
// Replace 使用的是 Boyer-Moore 算法，速度很快
func (r *Replacer) Replace(s string) string
func main() {
srp := strings.NewReplacer("Hello", "你好", "World", "世界", "!", "！")
s := "Hello World!Hello World!hello world!"
rst := srp.Replace(s)
fmt.Print(rst) // 你好 世界！你好 世界！hello world！
}
span style="color:#FF0000;">注：這兩種寫(xiě)法均可．/span>
func main() {
wl := []string{"Hello", "Hi", "Hello", "你好"}
srp := strings.NewReplacer(wl...)
s := "Hello World! Hello World! hello world!"
rst := srp.Replace(s)
fmt.Print(rst) // Hi World! Hi World! hello world!
}
------------------------------------------------------------
// WriteString 對(duì) s 進(jìn)行“查找和替換”，然后將結(jié)果寫(xiě)入 w 中
func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
func main() {
wl := []string{"Hello", "你好", "World", "世界", "!", "！"}
srp := strings.NewReplacer(wl...)
s := "Hello World!Hello World!hello world!"
srp.WriteString(os.Stdout, s)
// 你好 世界！你好 世界！hello world！
}
您可能感興趣的文章:- Go中strings的常用方法詳解
- strings命令分析淺談Go和C++編譯時(shí)的一點(diǎn)小區(qū)別
- Go語(yǔ)言中strings和strconv包示例代碼詳解
- golang 中strings包的Replace的使用說(shuō)明
