go语言的魔幻旅程16-strings包

故人西辞黄鹤去，此地空余黄鹤楼

不知道一千多年前诗仙李白在创作这首诗词的内心是怎样的，如果真的有时空穿梭机这种神奇的东西，倒是可以拿来穿越一下。只可惜昔人已逝、物是人非，诗仙早已经消失在历史的年轮中，唯黄鹤楼历经千年，依然矗立于长江之巅。初尝不知诗中意，再读已是诗中人。在这一站的路程中，短短不到一载的时光，左右两边刚刚熟络的大佬由于团队中各种各样的原因，先后选择了离开，或许在不远的未来，自己也许会成为下一个到站的旅客，前途尚不可知，但愿征途依然向好。

go语言的strings包

go语言的strings包为go语言提供了一些内置的类型、函数、方法，下面主要针对一些重要的内置函数、方法展开讲解。

1、实战案例演练

package main

/*********************************************************************/
/**************** golang中strings包相关API讲解 **********************/
/********************************************************************/

/*
func Compare(a, b string) int
func Contains(s, substr string) bool
func ContainsAny(s, chars string) bool
func ContainsRune(s string, r rune) bool
func Count(s, substr string) int
func EqualFold(s, t string) bool
func Fields(s string) []string
func FieldsFunc(s string, f func(rune) bool) []string
func HasPrefix(s, prefix string) bool
func HasSuffix(s, suffix string) bool
func Index(s, substr string) int
func IndexAny(s, chars string) int
func IndexByte(s string, c byte) int
func IndexFunc(s string, f func(rune) bool) int
func IndexRune(s string, r rune) int
func Join(elems []string, sep string) string
func LastIndex(s, substr string) int
func LastIndexAny(s, chars string) int
func LastIndexByte(s string, c byte) int
func LastIndexFunc(s string, f func(rune) bool) int
func Map(mapping func(rune) rune, s string) string
func Repeat(s string, count int) string
func Replace(s, old, new string, n int) string
func ReplaceAll(s, old, new string) string
func Split(s, sep string) []string
func SplitAfter(s, sep string) []string
func SplitAfterN(s, sep string, n int) []string
func SplitN(s, sep string, n int) []string
func Title(s string) string
func ToLower(s string) string
func ToLowerSpecial(c unicode.SpecialCase, s string) string
func ToTitle(s string) string
func ToTitleSpecial(c unicode.SpecialCase, s string) string
func ToUpper(s string) string
func ToUpperSpecial(c unicode.SpecialCase, s string) string
func ToValidUTF8(s, replacement string) string
func Trim(s, cutset string) string
func TrimFunc(s string, f func(rune) bool) string
func TrimLeft(s, cutset string) string
func TrimLeftFunc(s string, f func(rune) bool) string
func TrimPrefix(s, prefix string) string
func TrimRight(s, cutset string) string
func TrimRightFunc(s string, f func(rune) bool) string
func TrimSpace(s string) string
func TrimSuffix(s, suffix string) string
type Builder
	func (b *Builder) Cap() int
	func (b *Builder) Grow(n int)
	func (b *Builder) Len() int
	func (b *Builder) Reset()
	func (b *Builder) String() string
	func (b *Builder) Write(p []byte) (int, error)
	func (b *Builder) WriteByte(c byte) error
	func (b *Builder) WriteRune(r rune) (int, error)
	func (b *Builder) WriteString(s string) (int, error)
type Reader
	func NewReader(s string) *Reader
	func (r *Reader) Len() int
	func (r *Reader) Read(b []byte) (n int, err error)
	func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
	func (r *Reader) ReadByte() (byte, error)
	func (r *Reader) ReadRune() (ch rune, size int, err error)
	func (r *Reader) Reset(s string)
	func (r *Reader) Seek(offset int64, whence int) (int64, error)
	func (r *Reader) Size() int64
	func (r *Reader) UnreadByte() error
	func (r *Reader) UnreadRune() error
	func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
type Replacer
	func NewReplacer(oldnew ...string) *Replacer
	func (r *Replacer) Replace(s string) string
	func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
Bugs
*/


func main() {

	/**
	*Compare返回一个按字典顺序比较两个字符串的整数。如果a == b，结果将为0；
	*如果a <b，结果将为-1；如果a> b，结果将为+1。
	*func Compare(a, b string) int
	*/

	/*
	fmt.Println(strings.Compare("a", "b"))
	fmt.Println(strings.Compare("a", "a"))
	fmt.Println(strings.Compare("b", "a"))
	*/

	/**
	*判断substr是否在s之内。
	*func Contains(s, substr string) bool
	*/

	/*
	fmt.Println(strings.Contains("seafood", "foo"))
	fmt.Println(strings.Contains("seafood", "bar"))
	fmt.Println(strings.Contains("seafood", ""))
	fmt.Println(strings.Contains("", ""))
	*/

	/**
	*ContainsAny判断char中的任何Unicode代码点是否在s之内
	*func ContainsAny(s, chars string) bool
	*/

	/*
	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("", ""))
	*/

	/**
	*ContainsRune判断Unicode代码点r是否在s内
	*func ContainsRune(s string, r rune) bool
	*/

	/*
	fmt.Println(strings.ContainsRune("aardvark", 97))
	fmt.Println(strings.ContainsRune("timeout", 97))
	*/

	/**
	*Count计算s中substr的非重叠实例的数量。如果substr是一个空字符串，
	*则Count返回1 + s中的Unicode代码点数。
	*func Count(s, substr string) int
	*/

	/*
	fmt.Println(strings.Count("cheese", "e"))
	fmt.Println(strings.Count("five", ""))
	*/

	/**
	*EqualFold判断在Unicode case-folding下这是UTF-8字符串的s和t是否相等，
	×这是不区分大小写的更通用形式。
	*func EqualFold(s, t string) bool
	*/

	/*
	fmt.Println(strings.EqualFold("Go", "go"))
	*/

	/**
	*字段根据unicode.IsSpace的定义，将字符串s围绕一个或多个连续的空白字符的每个
	*实例进行拆分，返回s的子字符串片段，如果s仅包含空格，则返回空片段。
	*func Fields(s string) []string
	*/

	/*
	fmt.Printf("Fields are: %q", strings.Fields("  foo bar  baz   "))
	*/


	/**
	*FieldsFunc在每次运行满足f(c)的Unicode代码点c时拆分字符串s，并返回s的切片数组。
	*如果s中的所有代码点都满足f(c)或字符串为空，则返回一个空切片。
	*FieldsFunc不保证调用f(c)的顺序，并假定f对于给定的c总是返回相同的值
	*func FieldsFunc(s string, f func(rune) bool) []string
	*/

	/*
	f := func(c rune) bool {
		return !unicode.IsLetter(c) && !unicode.IsNumber(c)
	}
	fmt.Printf("Fields are: %q", strings.FieldsFunc("  foo1;bar2,baz3...", f))
	*/


	/**
	*HasPrefix测试字符串s是否以前缀开头。。
	*func HasPrefix(s, prefix string) bool
	*/

	/*
	fmt.Println(strings.HasPrefix("Gopher", "Go"))
	fmt.Println(strings.HasPrefix("Gopher", "C"))
	fmt.Println(strings.HasPrefix("Gopher", ""))
	*/

	/**
	*HasSuffix测试字符串s是否以后缀结尾。
	*func HasSuffix(s, suffix string) bool
	*/

	/*
	fmt.Println(strings.HasSuffix("Amigo", "go"))
	fmt.Println(strings.HasSuffix("Amigo", "O"))
	fmt.Println(strings.HasSuffix("Amigo", "Ami"))
	fmt.Println(strings.HasSuffix("Amigo", ""))
	*/

	/**
	*Index返回s中substr的第一个实例的索引；如果s中不存在substr，则返回-1。
	*func Index(s, substr string) int
	*/

	/*
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dmr"))
	*/

	/**
	*IndexAny返回s中chars中任何Unicode代码点的第一个实例的索引；如果s中不存在
	*chars中的Unicode代码点，则返回-1。
	*func IndexAny(s, chars string) int
	*/

	/*
	fmt.Println(strings.IndexAny("chicken", "aeiouy"))
	fmt.Println(strings.IndexAny("crwth", "aeiouy"))
	*/

	/**
	*IndexByte返回s中c的第一个实例的索引；如果s中不存在c，则返回-1。
	*func IndexByte(s string, c byte) int
	*/

	/*
	fmt.Println(strings.IndexByte("golang", 'g'))
	fmt.Println(strings.IndexByte("gophers", 'h'))
	fmt.Println(strings.IndexByte("golang", 'x'))
	*/

	/**
	*IndexFunc将索引返回到满足f(c)的第一个Unicode代码点的s中，如果没有，则返回-1。
	*func IndexFunc(s string, f func(rune) bool) int
	*/

	/*
	f := func(c rune) bool {
		return unicode.Is(unicode.Han, c)
	}
	fmt.Println(strings.IndexFunc("Hello, 世界", f))
	fmt.Println(strings.IndexFunc("Hello, world", f))
	*/

	/**
	*IndexRune返回Unicode代码点r的第一个实例的索引；如果s中不存在符文，则返回-1。
	*如果r为utf8.RuneError，它将返回任何无效UTF-8字节序列的第一个实例。
	*func IndexRune(s string, r rune) int
	*/

	/*
	fmt.Println(strings.IndexRune("chicken", 'k'))
	fmt.Println(strings.IndexRune("chicken", 'd'))
	*/

	/**
	*Join将其第一个参数的元素连接起来以创建单个字符串。分隔符字符串sep放置在结果字符
	*串中的元素之间。
	*func Join(elems []string, sep string) string
	*/

	/*
	s := []string{"foo", "bar", "baz"}
	fmt.Println(strings.Join(s, ", "))
	*/

	/**
	*LastIndex返回s中substr的最后一个实例的索引；如果s中不存在substr，则返回-1。
	*func LastIndex(s, substr string) int
	*/

	/*
	fmt.Println(strings.Index("go gopher", "go"))
	fmt.Println(strings.LastIndex("go gopher", "go"))
	fmt.Println(strings.LastIndex("go gopher", "rodent"))
	*/

	/**
	*LastIndexAny返回s中chars中任何Unicode代码点的最后一个实例的索引；
	*如果s中不存在chars中的Unicode代码点，则返回-1。
	*func LastIndexAny(s, chars string) int
	*/

	/*
	fmt.Println(strings.LastIndexAny("go gopher", "go"))
	fmt.Println(strings.LastIndexAny("go gopher", "rodent"))
	fmt.Println(strings.LastIndexAny("go gopher", "fail"))
	*/

	/**
	*LastIndexByte返回s中c的最后一个实例的索引；如果s中不存在c，则返回-1。
	*func LastIndexByte(s string, c byte) int
	*/

	/*
	fmt.Println(strings.LastIndexByte("Hello, world", 'l'))
	fmt.Println(strings.LastIndexByte("Hello, world", 'o'))
	fmt.Println(strings.LastIndexByte("Hello, world", 'x'))
	*/


	/**
	*LastIndexFunc将索引的最后一个满足f(c)的Unicode代码点的s返回，如果没有，则返回-1。
	*func LastIndexFunc(s string, f func(rune) bool) int
	*/

	/*
	fmt.Println(strings.LastIndexFunc("go 123", unicode.IsNumber))
	fmt.Println(strings.LastIndexFunc("123 go", unicode.IsNumber))
	fmt.Println(strings.LastIndexFunc("go", unicode.IsNumber))
	*/

	/**
	*Map返回字符串s的副本，其所有字符都根据映射函数进行了修改。如果映射返回负值，
	*则从字符串中删除该字符且不进行替换。
	*func Map(mapping func(rune) rune, s string) string
	*/

	/*
	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..."))
	*/

	/**
	*则从字符串中删除该字符且不进行替换,如果count为负数或(len * s * count)的结果溢出，
	*则表示恐慌。
	*func Repeat(s string, count int) string
	*/

	/*
	fmt.Println("ba" + strings.Repeat("na", 2))
	*/

	/**
	*Replace返回字符串s的副本，其中旧的前n个非重叠实例被新的替换。如果old为空，
	*则它在字符串的开头和每个UTF-8序列之后匹配，最多可对k-rune字符串进行k + 1个替换。
	*如果n <0，则替换次数没有限制。
	*func Replace(s, old, new string, n int) string
	*/

	/*
	fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))
	fmt.Println(strings.Replace("oink oink oink", "oink", "moo", -1))
	*/

	/**
	*ReplaceAll返回字符串s的副本，其中所有旧的非重叠实例都被new替换。如果old为空，
	*则它在字符串的开头和每个UTF-8序列之后匹配，最多可对k-rune字符串进行k + 1个替换。
	*func ReplaceAll(s, old, new string) string
	*/

	/*
	fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))
	*/

	/**
	*将片段s分割为所有由sep分隔的子字符串，并返回这些分隔符之间的子字符串的片段。
	*如果s不包含sep且sep不为空，则Split返回长度为1的切片，其唯一元素为s。
	*如果sep为空，则Split在每个UTF-8序列后拆分。如果s和sep均为空，则Split返回一个空切片。
	*它等效于SplitN，计数为-1。
	*func Split(s, sep string) []string
	*/

	/*
	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"))
	*/

	/**
	*SplitAfter在sep的每个实例之后将s切片为所有子字符串，并返回这些子字符串的切片。
	*如果s不包含sep且sep不为空，则SplitAfter返回长度为1的切片，其唯一元素为s。
	*如果sep为空，则SplitAfter在每个UTF-8序列之后拆分。如果s和sep均为空，则
	*SplitAfter返回一个空切片,它等效于SplitAfterN，计数为-1。
	*func SplitAfter(s, sep string) []string
	*/

	/*
	fmt.Printf("%q\n", strings.SplitAfter("a,b,c", ","))
	*/

	/**
	*SplitAfterN在sep的每个实例之后将s切片为子字符串，并返回这些子字符串的切片。
	*该计数确定要返回的子字符串的数量：
	*func SplitAfterN(s, sep string, n int) []string
	*/

	/*
	fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2))
	*/

	/**
	*SplitN将s切片成由sep分隔的子字符串，并返回这些分隔符之间的子字符串的切片。
	*该计数确定要返回的子字符串的数量：
	*func SplitN(s, sep string, n int) []string
	*/

	/*
	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)
	*/

	/**
	*Title返回字符串s的副本，其中包含所有Unicode字母，这些单词以映射到其
	*Unicode标题大小写的单词开头,该计数确定要返回的子字符串的数量：
	*func Title(s string) string
	*/

	/*
	fmt.Println(strings.Title("her royal highness"))
	fmt.Println(strings.Title("loud noises"))
	fmt.Println(strings.Title("хлеб"))
	*/

	/**
	*ToLower返回s，其中所有Unicode字母均映射为小写字母。
	*func ToLower(s string) string
	*/

	/*
	fmt.Println(strings.ToLower("Gopher"))
	*/

	/**
	*ToLowerSpecial返回字符串s的副本，其中所有Unicode字母均使用c指定的大小写映射映射到其小写字母。
	*func ToLowerSpecial(c unicode.SpecialCase, s string) string
	*/

	/*
	fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
	*/

	/**
	*ToTitle返回字符串s的副本，其中所有Unicode字母都映射到其Unicode标题大小写。
	*func ToTitle(s string) string
	*/

	/*
	fmt.Println(strings.ToTitle("her royal highness"))
	fmt.Println(strings.ToTitle("loud noises"))
	fmt.Println(strings.ToTitle("хлеб"))
	*/


	/**
	*ToTitleSpecial返回字符串s的副本，其中所有Unicode字母都映射到其Unicode标题大小写，
	*并优先使用特殊的大小写规则。
	*func ToTitleSpecial(c unicode.SpecialCase, s string) string
	*/

	/*
	fmt.Println(strings.ToTitleSpecial(unicode.TurkishCase, "dünyanın ilk borsa yapısı Aizonai kabul edilir"))
	*/

	/**
	*ToUpper返回s，其中所有Unicode字母都映射到其大写字母
	*func ToUpper(s string) string
	*/

	/*
	fmt.Println(strings.ToUpper("Gopher"))
	*/

	/**
	*ToUpperSpecial返回字符串s的副本，其中所有Unicode字母均使用c指定的大小写映射映射到其大写字母。
	*func ToUpperSpecial(c unicode.SpecialCase, s string) string
	*/

	/*
	fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
	*/

	/**
	*将s内不属于utf-8范围的字符替换为replacement子串，如果不存在非法字符则无事发生。
	*func ToValidUTF8(s, replacement string) string
	*/

	/*
	fmt.Println(strings.ToValidUTF8("街角\xF3魔族是最好的动漫\x80", "替换字符"))
	fmt.Println(strings.ToValidUTF8("街角魔族是最好的动漫", "替换字符"))
	*/

	/**
	*Trim返回字符串s的一部分，其中切除集中包含的所有开头和结尾的Unicode代码点都已删除。
	*func Trim(s, cutset string) string
	*/

	/*
	fmt.Print(strings.Trim("¡¡¡Hello, Gophers!!!", "!¡"))
	*/

	/**
	*TrimFunc返回字符串s的一部分，并删除所有满足f(c)的前导和尾随Unicode代码点c。
	*func TrimFunc(s string, f func(rune) bool) string
	*/

	/*
	fmt.Print(strings.TrimFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
	}))
	*/

	/**
	*TrimLeft返回字符串s的一部分，其中删除了cutset中包含的所有前导Unicode代码点。
	*要删除前缀，请改用TrimPrefix。
	*func TrimLeft(s, cutset string) string
	*/

	/*
	fmt.Print(strings.TrimLeft("¡¡¡Hello, Gophers!!!", "!¡"))
	*/

	/**
	*TrimLeftFunc返回字符串s的一部分，其中所有满足f(c)的前导Unicode代码点c被删除。
	*func TrimLeftFunc(s string, f func(rune) bool) string
	*/

	/*
	fmt.Print(strings.TrimLeftFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
	}))
	*/

	/**
	*TrimPrefix返回s，而没有提供的前导前缀字符串。如果s不以前缀开头，则s不变返回。
	*func TrimPrefix(s, prefix string) string
	*/

	/*
	var s = "¡¡¡Hello, Gophers!!!"
	s = strings.TrimPrefix(s, "¡¡¡Hello, ")
	s = strings.TrimPrefix(s, "¡¡¡Howdy, ")
	fmt.Print(s)
	*/

	/**
	*TrimRight返回字符串s的一部分，其中删除了cutset中包含的所有尾随Unicode代码点。
	*要删除后缀，请改用TrimSuffix。
	*func TrimRight(s, cutset string) string
	*/

	/*
	fmt.Print(strings.TrimRight("¡¡¡Hello, Gophers!!!", "!¡"))
	*/

	/**
	*TrimRightFunc返回字符串s的一部分，其中所有满足f(c)的尾随Unicode代码点c均被删除。
	*func TrimRightFunc(s string, f func(rune) bool) string
	*/

	/*
	fmt.Print(strings.TrimRightFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
	}))
	*/

	/**
	*TrimSpace返回字符串s的一部分，并删除了Unicode定义的所有前导和尾随空格。
	*func TrimSpace(s string) string
	*/

	/*
	fmt.Println(strings.TrimSpace(" \t\n Hello, Gophers \n\t\r\n"))
	*/

	/**
	*TrimSuffix返回s，但不提供结尾的后缀字符串。如果s不以后缀结尾，则s不变返回
	*func TrimSuffix(s, suffix string) string
	*/

	/*
	var s = "¡¡¡Hello, Gophers!!!"
	s = strings.TrimSuffix(s, ", Gophers!!!")
	s = strings.TrimSuffix(s, ", Marmots!!!")
	fmt.Print(s)
	*/

	/*********************************************************************/
	/******************* Builder相关方法实例讲解 ************************/
	/********************************************************************/

	/**
	*Cap方法返回字节数组分配的内存空间大小
	*func (b *Builder) Cap() int
	*/

	/*
	var b strings.Builder
	for i := 3; i >= 1; i-- {
		fmt.Fprintf(&b, "%d...", i)
	}
	b.WriteString("ignition")
	fmt.Println(b.String())
	fmt.Println(b.Cap())
	*/


	/**
	*Grow方法来扩展buf数组的分配内存的大小
	*func (b *Builder) Grow(n int)
	*/

	/*
	var b strings.Builder
	for i := 3; i >= 1; i-- {
		fmt.Fprintf(&b, "%d...", i)
	}
	b.WriteString("ignition")
	b.Grow(10)
	*/

	/**
	*Len 方法返回 b 的数据长度
	*func (b *Builder) Len() int
	*/

	/*
	b := strings.Builder{}
	_ = b.WriteByte('7')
	_, _ = b.WriteRune('好')
	fmt.Println(b.Len())
	*/

	/**
	*Reset方法将b清空b的所有内容。
	*func (b *Builder) Reset()
	*/

	/*
	b := strings.Builder{}
	_ = b.WriteByte('7')
	_, _ = b.WriteRune('好')
	fmt.Println(b.Len())
	b.Reset()
	fmt.Println(b.Len())
	*/

	/**
	*String 方法将b的数据以string类型返回。
	*func (b *Builder) String() string
	*/

	/*
	b := strings.Builder{}
	_ = b.WriteByte('7')
	fmt.Println(b.String())
	*/

	/**
	*Write方法向b写入字节数组
	*func (b *Builder) Write(p []byte) (int, error)
	*/

	/*
	b := strings.Builder{}
	n, _ := b.Write([]byte("Hello, World"))
	fmt.Println(n)
	*/

	/**
	*该方法向 b 写入一个字节
	*func (b *Builder) WriteByte(c byte) error
	*/

	/*
	b := strings.Builder{}
	_ = b.WriteByte('7')
	fmt.Println(b.String())
	*/

	/**
	*WriteRune 方法向 b 写入一个字符
	*func (b *Builder) WriteRune(r rune) (int, error)
	*/

	/*
	b := strings.Builder{}
	n, _ := b.WriteRune('夕')
	fmt.Println(n)
	*/


	/**
	*向b写入字符串s
	*func (b *Builder) WriteString(s string) (int, error)
	*/

	/*
	b := strings.Builder{}
	n , _ := b.WriteString("hello world")
	fmt.Println(n)
	*/

	/*********************************************************************/
	/****************** Reader相关方法实例讲解 *************************/
	/********************************************************************/

	/**
	*NewReader创建一个从s读取数据的Reader。本函数类似bytes.NewBufferString，
	*但是更有效率，且为只读的。
	*func NewReader(s string) *Reader
	*/

	/*
	r := strings.NewReader("hello")
	fmt.Println(r)
	*/

	/**
	*Len返回r包含的字符串还没有被读取的部分。
	*func (r *Reader) Len() int
	*/

	/*
	r := strings.NewReader("hello")
	fmt.Println(r.Len())
	*/

	/**
	*读取字符串信息。
	*func (r *Reader) Read(b []byte) (n int, err error)
	*/

	/*
	buf := make([]byte, 5)
	r := strings.NewReader("hello")
	n, _ :=r.Read(buf)
	fmt.Println(n)
	*/

	/**
	*读取偏移off字节后的剩余信息到b中
	*func (r *Reader) ReadAt(b []byte, off int64) (n int, err error)
	*/

	/*
	r := strings.NewReader("abcdefghijklmn")
	var bufAt, buf []byte
	buf = make([]byte, 5)
	r.Read(buf)
	fmt.Println("剩余未读的长度", r.Len())   //剩余未读的长度 9
	fmt.Println("已读取的内容", string(buf)) //已读取的内容 abcde
	bufAt = make([]byte, 256)
	r.ReadAt(bufAt, 5)
	fmt.Println(string(bufAt))
	*/

	/**
	*ReadByte从当前已读取位置继续读取一个字节
	*func (r *Reader) ReadByte() (byte, error)
	*/

	/*
	r := strings.NewReader("hello")
	b, _ := r.ReadByte()
	fmt.Printf("%c", b)
	*/

	/**
	*ReadRune从r *Reader中读出一个UTF8编码的字符串并返回第一个参数ch rune.
	*同时返回该字符的 UTF8 编码长度，返回的第二个参数 size int，如果发生错误，
	*第三个参数即错误 err error,如果 UTF8 序列无法解码出一个正确的 Unicode 字符，
	*只读出 r *Reader 中的一个字节，并返回 ch = U+FFFD 字符，size = 1
	*func (r *Reader) ReadRune() (ch rune, size int, err error)
	*/

	/*
	r := strings.NewReader("hello world")
	ch, n, _ := r.ReadRune()
	fmt.Println(ch, n)
	*/

	/**
	*将读取器重置为从s读取。
	*func (r *Reader) Reset(s string)
	*/

	/*
	r := strings.NewReader("hello")
	r.Reset("worldwe")
	fmt.Println(r.Size())
	*/

	/**
	*Seek实现了io.Seeker接口
	*func (r *Reader) Seek(offset int64, whence int) (int64, error)
	*/

	/*
	r := strings.NewReader("hello world")
	n, _ := r.Seek(0,2)
	fmt.Println(n)
	*/

	/**
	*Size返回基础字符串的原始长度。大小是可通过ReadAt读取的字节数。返回的值始终相同，
	*并且不受任何其他方法的调用影响。
	*func (r *Reader) Size() int64
	*/

	/*
	r := strings.NewReader("hello")
	n := r.Size()
	fmt.Println(n)
	*/

	/**
	*UnreadByte将当前已读取位置回退一位，当前位置的字节标记成未读取字节,
	*会改变reader对象的长度
	*func (r *Reader) UnreadByte() error
	*/

	/*
	r := strings.NewReader("hello")
	err := r.UnreadByte()
	fmt.Println(err)
	*/

	/**
	*UnreadRune退回到上一次ReadRune的位置，上一次的位置记在r.prevRune，
	所以r.i直接赋值为r.prevRune。这个方法必须配合ReadRune使用，如果上一
	*次不是ReadRune，这个方法会报错
	*func (r *Reader) UnreadRune() error
	*/

	/*
	r := strings.NewReader("hello world")
	err := r.UnreadRune()
	fmt.Println(err)
	*/

	/**
	*将r中的数据读出并写入io.Writer对象w中。实现了io.WriterTo方法。
	*func (r *Reader) WriteTo(w io.Writer) (n int64, err error)
	*/

	/*
	r := strings.NewReader("hello world")
	r.WriteTo(os.Stdout)
	*/

	/*********************************************************************/
	/****************** Replace相关方法实例讲解 ************************/
	/********************************************************************/

	/**
	*使用提供的多组old、new字符串对创建并返回一个*Replacer。替换是依次进行的，匹配时不会重叠。
	*func NewReplacer(oldnew ...string) *Replacer
	*/

	/*
	r := strings.NewReplacer("a", "A" , "B", "C")
	s := r.Replace("dd")
	fmt.Println(s)
	*/

	/**
	*Replace返回s的所有替换进行完后的拷贝
	*func (r *Replacer) Replace(s string) string
	*/

	/*
	var test1 = strings.NewReplacer("a", "A", "a", "B")
	s1 := test1.Replace("abc")
	fmt.Println(s1)

	var test2 = strings.NewReplacer("a", "B", "a", "A")
	s2 := test2.Replace("abc")
	fmt.Println(s2)
	*/


	/**
	*WriteString向w中写入s的所有替换进行完后的拷贝。
	*func (r *Replacer) WriteString(w io.Writer, s string) (n int, err error)
	*/

	/*
	r := strings.NewReplacer("a", "b", "c")
	n, _ := r.WriteString(os.Stdout, "C")
	fmt.Println(n)
	*/
}

小结

strings包这部分的内容还是非常重要的，这个部分的函数的内容在日常的开发的过程中类库的使用也是高频率的，从某种程度上来讲，对于字符串相关功能的操作只要认真把这部分的内容掌握了，应该就不会存在多大的问题了。