街角替换字符魔族是最好的动漫替换字符
街角魔族是最好的动漫
在需要筛选检测的内容中使用还是很好用的
7，Replace(s, old, new string, n int) string将字符串s内的old字符串替换为new字符串，n为替换个数，如果old是空的，则在字符串的开头和每个UTF-8序列之后匹配，产生k+1的k-rune字符串的替换。如果n<0，则替换数没有限制。
fmt.Println(strings.Replace("街角魔族是好好好的动漫", "好", "最好", 2))
fmt.Println(strings.Replace("街角魔族是好好好的动漫", "好", "最好", -1))
fmt.Println(strings.Replace("街角魔族是最好看的动漫", "", "呐", 2))
街角魔族是最好最好好的动漫
街角魔族是最好最好最好的动漫
呐街呐角魔族是最好看的动漫
对于Replace还有其几个扩展方法:
ReplaceAll(s, old, new string) string此方法等于Replace(s, old, new, -1)
源码⬇其实这里很多方法都是这样，如Trim调用的就是TrimFunc。
func ReplaceAll(s, old, new string) string {
return Replace(s, old, new, -1)
对于Replace还有对应的结构体Replacer，利用这个类中的NewReplacer(oldnew ...string) *Replacer就能创建出来，可用其实现更为复杂的替换操作
r := strings.NewReplacer("好", "最好", "<", "<", "&rt;", ">")
fmt.Println(r.Replace("<h1&rt;街角魔族是好看的动漫</h1&rt;"))
<h1>街角魔族是最好看的动漫</h1>
还有一个WriteString就不演示了等写io的时候说说。
8，Map(mapping func(rune) rune, s string) string根据mapping函数修改字符串的所有字符。如果mapping返回一个负值，则该字符将从字符串中删除，不需要替换。
fmt.Println(strings.Map(func(r rune) rune {
switch {
case r == '不':
return -1
case r == '特':
return '最'
case r == ' ':
return '看'
return r
}, "街角魔族是特不好 的动漫"))
街角魔族是最好看的动漫
9，Trim(s string, cutset string) string删除割集中包含的所有前端和尾部//不懂割集是什么的看个例子你就懂了
fmt.Println(strings.Trim("说得好 街角魔族是最好的动漫 说得对", "说得好"))
fmt.Println(strings.Trim("？ 街角魔族是最好的动漫 ！", "？ ！"))
街角魔族是最好的动漫 说得对
街角魔族是最好的动漫
对于Trim还有其几个扩展方法:
TrimFunc(s string, f func(rune) bool) string删除前端和尾部都满足函数f的字符串
TrimLeft(s string, cutset string) string删除割集中包含的所有前端字符串。如果是删除前缀请用TrimPrefix
TrimLeftFunc(s string, f func(rune) bool) string删除s字符串前端都满足函数f的子字符串
TrimPrefix(s, prefix string) string删除s前缀prefix
TrimRight(s string, cutset string) string删除割集中包含的所有尾部字符串。如果是删除后缀请用TrimSuffix
TrimRightFunc(s string, f func(rune) bool) string删除s字符串尾部都满足函数f的子字符串
TrimSpace(s string) string删除s前后端（由Unicode定义）的所有空格
TrimSuffix(s, suffix string) string删除s后缀suffix
10，Fields(s string) []string返回由空格（unicode.IsSpace确定，可以是一到多个连续的空白字符）分割的字符串切片。如果字符串全部是空白或者是空字符串的话，会返回空切片。
str := strings.Fields(" 街角 魔族 是最好 的动漫 ")
for _, v := range str {
fmt.Println(v)
对于Fields还有其几个扩展方法:
FieldsFunc(s string, f func(rune) bool) []string返回满足函数f分割的字符串切片。如果字符串全部满足函数f或者是空字符串的话，会返回空切片
11，Split(s, sep string) []string返回由sep分割的字符串切片，如果s不包含sep，原样返回长度为1的字符串切片，如果sep为空字符串返回每一个字符的切片，如果s和sep都是空的，Split将返回一个空切片。相邻sep依旧会分隔中间的空字符串。
s := strings.Split("街角,魔族,是最好,的动漫,", ",")
fmt.Println(s, "len:", len(s))
s2 := strings.Split("街角魔族是最好的动漫", "")
fmt.Println(s2, "len:", len(s2))
s3 := strings.Split("街角,魔族,,,是最好,,,的动漫", ",")
fmt.Println(s3, "len:", len(s3))
[街角 魔族 是最好 的动漫 ] len: 5
[街 角 魔 族 是 最 好 的 动 漫] len: 10
[街角 魔族 是最好 的动漫] len: 8
这里例1最后一个逗号后没东西依旧算一个分隔切出了一个空字符串。
例2用空字符分隔则返回字符切片。
例3用逗号分隔逗号与逗号之间的空字符依旧分割了出来。
对于Split还有其几个扩展方法:
SplitAfter(s, sep string) []string用法与Split一样，但切片内容保留了分隔符
SplitAfterN(s, sep string, n int) []string用法与SplitAfter一样，增加了参数n决定返回的切片的数目。n > 0 : 返回的切片最多n个子字符串；最后一个子字符串包含未进行切割的部分，n == 0: 返回nil，n < 0 : 返回所有的子字符串组成的切片
SplitN(s, sep string, n int) []string用法与Split一样，增加了参数n决定返回的切片的数目。n > 0 : 返回的切片最多n个子字符串；最后一个子字符串包含未进行切割的部分，n == 0: 返回nil，n < 0 : 返回所有的子字符串组成的切片
12，Repeat(s string, count int) string将s重复count次。如果count为负数或(len(S)*count)溢出，则会引起panic。
fmt.Println("街角魔族是", strings.Repeat("最", 2), "好看的动漫")
街角魔族是 最最 好看的动漫
13，Join(a []string, sep string) string将a内的所有字符串用sep相连
a := []string{“街角”, “魔族”, “是最好看”, “的动漫”}
fmt.Println(strings.Join(a, ""))
fmt.Println(strings.Join(a, "~"))
街角魔族是最好看的动漫
街角~魔族~是最好看~的动漫
如果只是单纯的连接字符串不建议使用这个方法，在没有一个现成的a []string时，效率巨低，用bytes包内Buffer结构体中的WriterString方法连接会快如闪电（以上仅为大批量连接，就以少数string连接时用str + = str2的可读性更好）。
strings包内还有Reader和Builder两个结构体，不过不在strings里说了，等有机会写io的时候说。
strconv包实现了对基本数据类型的字符串表示形式的转换。里面内置了
常量
const IntSize = intSize数值位数
变量
1，ErrRange = errors.New("value out of range")目标类型的值超出范围
2，ErrSyntax = errors.New("invalid syntax")某个值对目标类型没有正确的语法。
1、AppendBool(dst []byte, b bool) []byte根据b的值将“true”或“false”追加到dst并返回扩展缓冲区。
b := []byte("街角魔族是最好看的动漫,对于否？")
fmt.Println(string(strconv.AppendBool(b, true)))
fmt.Println(strconv.AppendBool([]byte{'y', 'e', 's'}, true))
街角魔族是最好看的动漫,对于否？true
[121 101 115 116 114 117 101]
对于AppendBool还有其几个类似方法:
AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte根据f的值将浮点数追加到dst并返回字节切片。
其中
- fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。
- prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
- bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
AppendInt(dst []byte, i int64, base int) []byte根据i的值将整数追加到dst并返回字节切片。base代表进制（ 2 <= base <= 36），结果使用小写字母“a”到“z”表示数字值>=10。
AppendQuote(dst []byte, s string) []byte根据s的值将字符串追加到dst并返回字节切片。
AppendQuoteRune(dst []byte, r rune) []byte根据r的值将字符追加到dst并返回字节切片。
AppendQuoteRuneToASCII(dst []byte, r rune) []byte根据r的值将字符追加到dst并返回字节切片。
AppendQuoteRuneToGraphic(dst []byte, r rune) []byte根据r的值将字符追加到dst并返回字节切片。
AppendQuoteToASCII(dst []byte, s string) []byte根据s的值将字符串追加到dst并返回字节切片。
AppendQuoteToGraphic(dst []byte, s string) []byte根据s的值将字符串追加到dst并返回字节切片。
AppendUint(dst []byte, i uint64, base int) []byte根据i的值将正整数追加到dst并返回字节切片。
以上strconv.Appendxxx函数皆可等价于内置函数Append(dst,strconv.Formatxxx(value)...)
strconv.AppendQuotexxx等价于Append(dst,strconv.Quotexxx(value)...)
可见源码⬇
func AppendBool(dst []byte, b bool) []byte {
if b {
return append(dst, "true"...)
return append(dst, "false"...)
func AppendQuote(dst []byte, s string) []byte {
return appendQuotedWith(dst, s, '"', false, false)
func
Quote(s string) string {
return quoteWith(s, '"', false, false)
func quoteWith(s string, quote byte, ASCIIonly, graphicOnly bool) string {
return string(appendQuotedWith(make([]byte, 0, 3*len(s)/2), s, quote, ASCIIonly, graphicOnly))
对于AppendQuotexxx中的Quotexxx究竟做了些什么，我们在下面转换中在具体提及。使用内置函数append(dst,strconv.xxx()…) 还是strconv.appendxxx() 主要看你们的使用习惯。
2，ParseInt(s string, base int, bitSize int) (i int64, err error)返回字符串表示的整数值，接受正负号。
- base指定进制（2到36），如果base为0，则会从字符串前置判断，"0x"是16进制，"0"是8进制，否则是10进制；
- bitSize指定结果必须能无溢出赋值的整数类型，0、8、16、32、64 分别代表 int、int8、int16、int32、int64；返回的err是*NumErr类型的，如果语法有误，err.Error =
ErrSyntax；如果结果超出类型范围err.Error = ErrRange。
fmt.Println(strconv.ParseInt("-123", 0, 0))
fmt.Println(strconv.ParseInt("+0x123", 0, 0))
fmt.Println(strconv.ParseInt("12a", 16, 0))
fmt.Println(strconv.ParseInt("123456700000", 8, 8))
fmt.Println(strconv.ParseInt("12a", 10, 64))
-123 <nil>
291 <nil>
298 <nil>
127 strconv.ParseInt: parsing "123456700000": value out of range
0 strconv.ParseInt: parsing "12a": invalid syntax
对于ParseInt还有其几个类似方法:
ParseFloat(s string, bitSize int) (float64, error)将字符串s转换为浮点数。
- 精度由bitSize指定：32表示float32，64表示float64。当bitSize=32时，结果仍然具有float64类型，但它可以转换为float32而不更改其值。
- ParseFloat接受十进制和十六进制浮点数语法。如果s格式正确且接近有效的浮点数，则返回使用IEEE754无偏舍入的最接近的浮点数。（仅当十六进制表示中的位比尾数中的位多时，解析十六进制浮点值才会循环。）
- ParseFloat返回的err是*NumErr类型的，如果语法有误，err.Error = ErrSyntax；如果与给定大小的最大浮点数相差超过1/2 ULP，则ParseFloat返回f=±Inf，错误，err.Err = ErrRange。
- ParseFloat将字符串"NaN"，"+Inf"和 "-Inf"识别为它们各自的特殊浮点值。匹配时忽略大小写。
ParseBool(str string) (bool, error)将字符串s转换为bool它接受1、0、t、f、T、F、true、false、True、False、TRUE、FALSE；否则返回错误
ParseUint(s string, base int, bitSize int) (uint64, error)ParseUint与ParseInt类似，但用于无符号数字。
3，Atoi(s string) (int, error)Atoi等效于ParseInt(s，10，0)，int转换为string类型。
4，FormatFloat(f float64, fmt byte, prec, bitSize int) string根据f的值将浮点数转换为string。
其中
- fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。
- prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
- bitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
fmt.Println(strconv.FormatFloat(12323423.141234234, 'f', -1, 64))
fmt.Println(strconv.FormatFloat(3.14123234234234, 'b', -1, 64))
fmt.Println(strconv.FormatFloat(3232323.14234234234234, 'e', 5, 64))
fmt.Println(strconv.FormatFloat(2342343.14123234234234, 'g', -1, 64))
fmt.Println(strconv.FormatFloat(3.14, 'g', -1, 64))
12323423.141232342
7073426403228556p-51
3.23232e+06
2.3423431412323425e+06
对于FormatFloat还有其几个类似方法:
FormatBool(b bool) string根据b的值返回“true”或“false
FormatInt(i int64, base int) string根据i的值将整数转换为字符串，base为进制（ 2 <= base <= 36），结果使用小写字母“a”到“z”表示数字值>=10。
func FormatUint(i uint64, base int) string根据i的值将正整数转换为字符串，base为进制（ 2 <= base <= 36），结果使用小写字母“a”到“z”表示数字值>=10。
5，Itoa(i int) string等效于FormatInt(int 64(i)，10)，int转换为string类型。
6，CanBackquote(s string) bool字符串s是否可以不变地表示为单行反引号字符串，而不需要制表符以外的控制字符。
fmt.Println(strconv.CanBackquote("街角魔族是最好看的动漫\t"))
fmt.Println(strconv.CanBackquote("街角魔族是最好看的动漫\n"))
false
7，IsGraphic(r rune) bool判断字符 r 是否为一个“图形字符”， “图形字符”包括字母、标记、数字、标点、符号、空格，他们分别对应于 L、M、N、P、S、Zs 类别，这些类别是 RangeTable 类型，存储了相应类别的字符范围
fmt.Println(strconv.IsGraphic('a'))
fmt.Println(strconv.IsGraphic('啊'))
fmt.Println(strconv.IsGraphic(' '))
fmt.Println(strconv.IsGraphic('\n'))
false
对于IsGraphic还有其几个类似方法:
IsPrint(r rune) bool判断r是否为Go定义的可打印字符，其定义与Unicode.IsPrint相同：字母（广义上的中文、土耳其都算）、数字、标点符号、符号和ASCII空格。
8，Quote(s string) string返回字符串s在go语法下的字面值表示，由IsPrint定义的不可打印字符会进行转义。（如\t，\n，\xFF，\u0100）
str := "\"街角魔族是 最好看的动漫 \n\xff\""
fmt.Println(str)
fmt.Println(strconv.Quote(str))
fmt.Println(`\"街角魔族是 最好看的动漫 \n\xff\"`)
"街角魔族是 最好看的动漫
"\"街角魔族是\t最好看的动漫 \n\xff\""
\"街角魔族是 最好看的动漫 \n\xff\"
对于Quote还有其几个类似方法:
QuoteRune(r rune) string返回字符r在go语法下的字面值表示，控制字符、由IsPrint定义的不可打印字符会进行转义。（\t，\n，\xFF，\u0100）
QuoteRuneToASCII(r rune) string返回字符r在go语法下的字面值表示，由IsPrint定义的非ASCII字符、不可打印字符会进行转义。（\t，\n，\xFF，\u0100）
QuoteRuneToGraphic(r rune) string返回字符r在go语法下的字面值表示，如果不是由IsGrapch定义的Unicode图形字符，将进行转义。（\t，\n，\xFF，\u0100）
QuoteToASCII(s string) string返回字符串s在go语法下的字面值表示，由IsPrint定义的非ASCII字符、不可打印字符会进行转义。（\t，\n，\xFF，\u0100）
QuoteToGraphic(s string) string返回字符串s在go语法下的字面值表示，如果不是由IsGrapch定义的Unicode图形字符，将进行转义。（\t，\n，\xFF，\u0100）
9，Unquote(s string) (string, error)如果s是一个单引号、双引号、反引号包围的go语法字符串，解析它并返回它表示的值。(如果s是单引号，会认为s是go字符字面值，返回一个单字符的字符串）
s, err := strconv.Unquote("街角魔族是最好看的动漫")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote
("\"街角 魔族是最好看的动漫\"")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("`街角 魔族是最好看的动漫`")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("'\xff'")
fmt.Printf("%q, %v\n", s, err)
s, err = strconv.Unquote("'街角魔族是最好看的动漫'")
fmt.Printf("%q, %v\n", s, err)
"", invalid syntax
"街角\t魔族是最好看的动漫", <nil>
"街角\t魔族是最好看的动漫", <nil>
"�", <nil>
"", invalid syntax
10，UnquoteChar(s string, quote byte) (value rune, multibyte bool, tail string, err error）如果s是一个表示字符的go语法字符串，解析它并返回四个值：
- value，表示一个rune值或者一个byte值
- multibyte，表示value是否是一个多字节的utf-8字符
- tail，表示字符串剩余的部分
- err，表示可能存在的语法错误
参数quote为单引号时，函数认为单引号是语法字符，不接受未转义的单引号；双引号时，函数认为双引号是语法字符，不接受未转义的双引号；如果是零值，函数把单引号和双引号当成普通字符。
v, mb, t, err := strconv.UnquoteChar(`\"Fran & Freddie's Diner\"`, '"')
if err != nil {
log.Fatal(err)
fmt.Println("value:", string(v))
fmt.Println("multibyte:", mb)
fmt.Println("tail:", t)
value: "
multibyte: false
tail: Fran & Freddie's Diner\"
以上就是string的所有内容了。
utf8包实现了函数和常量，以支持用UTF-8编码的文本。其中还内含rune和utf-8编码byte之间相互转换的函数。见https://en.wikipedia.org/wiki/UTF-8
常量
const (
RuneError = ‘\uFFFD’ //错误的Rune或"Unicode replacement character"
RuneSelf = 0x80 // RuneSelf下面的字符以单个字节表示为自己
MaxRune = ‘\U0010FFFF’ // 最大的合法unicode码值
UTFMax = 4 // 最大的utf-8编码的unicode字符长度
)
编码所必需的常量。
1，DecodeRune(p []byte) (r rune, size int)函数解码p开始位置的第一个utf-8编码的码值，返回该码值和编码的字节数。如果编码不合法，会返回(RuneError, 1)。该返回值在正确的utf-8编码情况下是不可能返回的。
如果一个utf-8编码序列格式不正确，或者编码的码值超出utf-8合法码值的范围，或者不是该码值的最短编码，该编码序列即是不合法的。函数不会执行其他的验证。
s := []byte("街角魔族是最好看的动漫")
code, size := utf8.DecodeRune(s)
fmt.Println("rune:", string(code), "size:", size)
s2 := []byte("\n街角魔族是最好看的动漫")
code2, size2 := utf8.DecodeRune(s2)
fmt.Println("rune:", string(code2), "size:", size2)
rune: 街 size: 3
rune:
size: 1
对于DecodeRune还有其几个类似方法:
DecodeRuneInString(s string) (r rune, size int) 类似于DecodeRune，但是它的输入是一个字符串。
DecodeLastRune(p []byte) (r rune, size int)解码p最后一个utf-8编码的码值，返回该码值和编码的字节数。如果编码不合法，会返回(RuneError, 1)。该返回值在正确的utf-8编码情况下是不可能返回的。
如果一个utf-8编码序列格式不正确，或者编码的码值超出utf-8合法码值的范围，或者不是该码值的最短编码，该编码序列即是不合法的。函数不会执行其他的验证。
DecodeLastRuneInString(s string) (r rune, size int)类似于DecodeRuneLastRune，但是它的输入是一个字符串。
2，EncodeRune(p []byte, r rune) int将字符r写入字节切片p(必须有足够的长度)，它返回写入的字节数。
r := 'の'
buf := make([]byte, 3)
n := utf8.EncodeRune(buf, r)
fmt.Println(n, ",", buf)
3 , [227 129 174]
3，RuneCount(p []byte) int返回p中的utf-8编码的码值的个数。错误或者不完整的编码会被视为宽度1字节的单个码值。
buf := []byte("街角魔族是全宇宙第1好看的动漫")
fmt.Println("bytes =", len(buf))
fmt.Println("runes =", utf8.RuneCount(buf))
bytes = 43
runes = 15
对于RuneCount还有其几个类似方法：
RuneCountInString(s string) (n int)与RuneCount类似，但其输入是一个字符串。
4，RuneLen(r rune) int返回编码rune所需的字节数。如果符文不是在UTF-8中编码的有效值，则返回-1。
fmt.Println(utf8.RuneLen('\n'))
fmt.Println(utf8.RuneLen('好'))
5，FullRune(p []byte) bool判断字节切片p中的字节是否以rune的完整UTF-8编码开始。无效的编码被认为是完全的符文，因为它将转换为宽度为1的错误。
buf := []byte("街角魔族是全宇宙第1好看的动漫")
fmt.Println(utf8.FullRune(buf))
fmt.Println(utf8.FullRune(buf[:2]))
false
对于FullRune还有其几个类似方法：
FullRuneInString(s string) bool与FullRune类似，但是它的输入是一个字符串。
RuneStart(b byte) bool判断字节b是否可以是编码的、可能无效的Rune的第一个字节。第二字节和后续字节总是将前两位设置为10。
6，Valid(p []byte) bool判断字节切片p是否完全由有效的UTF-8编码符文组成。
valid := []byte("街角魔族是全宇宙第1好看的动漫")
invalid := []byte{0xff}
fmt.Println(utf8.Valid(valid))
fmt.Println(utf8.Valid(invalid))
false
对于Valid还有其几个类似方法：
ValidRune(r rune) bool判断字符r是否可以合法编码为UTF-8。超出范围的代码点或代理项的一半是非法的。
ValidString(s string) bool判断字符串s是否完全由有效的UTF-8编码的rune组成.
对于字符处理还有bytes包可供我们选择，但是由于bytes包与strings的重合率太高，这里就不再写了，不过可以给大家一个高效连接字符串的代码：
start1 := time.Now()
b := make([]byte, 100)
buf := bytes.NewBuffer(b)
for i := 0; i < 20000; i++ {
buf.WriteString("街角魔族是最好看的动漫")
end1 := time.Now()
fmt.Println(end1.Sub(start1))
start2 := time.Now()
s := ""
st := "街角魔族是最好看的动漫"
for i := 0; i < 20000; i++ {
s += st
end2 := time.Now()
fmt.Println(end2.Sub(start2))
998.4µs
1.7304787s
对于rune不知道有没有第一次接触的小伙伴感觉很蒙啊，其实这就是int32的别名，rune==int32，只不过为了不让int32这个数值类型既当爹又当妈的语义不明确，因此取了格rune这个名字来专门代表字符，还有byte也是同理，byte == uint8。
源代码⬇
type byte = uint8
type rune = int32
随便举个实例utf8.Valid(p []byte) bool用[]uint8一样运行
valid := []uint8("街角魔族是全宇宙第1好看的动漫")
invalid := []uint8{0xff}
fmt.Println(utf8.Valid(valid))
fmt.Println(utf8.Valid(invalid))
false
看到这里以后再出现字符转换，类型互换，字符操作之类的问题是不是更好解决了呢？
字符串处理，一般是可以单独立一章讲解的。看看Golang的字符串处理。
一、string、byte这两个都常见。Golang的string，底层是[]byte。对于ASCII字符，Golang默认用1字节；对于汉字，Golang使用UTF-8字符集存储，默认用三个字节。
看个例子，下面的“我爱学习”三个汉字就各占3字节。
package main
import "fmt"
func m...
golang内置类型有rune类型和byte类型。
需要知晓的是rune类型的底层类型是int32类型，而byte类型的底层类型是int8类型，这决定了rune能比byte表达更多的数。
在unicode中，一个中文占两个字节，utf-8中一个中文占三个字节，golang默认的编码是utf-8编码，因此默认一个中文占三个字节，但是golang中的字符串...
strconv 包转换错误处理
先来看一下 strconv 中是如何对错误进行处理的：
在 strconv 的包中包含着两种 error 类型的变量：ErrRange 和 ErrSyntax。
ErrRange 表示的是值超过了类型能表示的最大范围。
ErrSyntax 表示的是语法错误。
而我们返回的错误并不是一个简单的 Error，返回的错误是一个 NumError 的类型的 error 对象...
golang中存在丰富的类型，其中一部分类型如byte、rune等是基于底层的整形等基础类型实现的，熟悉类型对应的基础类型能够帮助我们了解一些coding中的小技巧，可以基于类型的基础类型直接使用。
首先了解一下一些内建类型对应的基础类型，这些都可以在源码中builtin.go中找到：
// byte is an alias for uint8 and is equivalent to uin...
golang 转换为字符串In Golang, how to convert a string to unicode rune array and do the reverse way? 在Golang中 ，如何将 字符串 转换为unicode符文数组并执行相反的方法？
Convert string s to a rune array: 将字符串s转换为符文数组：
runes := []run...
golang字符串相关操作主要使用strings包下相关操作，本文主要介绍strings包下一些常用方法的使用方法。
函数：Contain(s,str string) bool
说明：查找子串是否在指定的字符串中
package main
import (
&quot;fmt&quot;
&quot;strings&quot;
func main() {
fmt.Println(strin
昨天准备用golang做一个简单的文本分析，需要简单的对字符串进行一些操作，在查看了strings和strconv库时，我没找到截取字符串的函数，同时strings.Index返回的是子串的字节位置，例如这个例子：strings.Index("早上好，张先生！","好") 的返回值是6，而不是2（从0开始算）。
于是我自己写了一个处理中文的返回字符串子串位置的函数，思想其实很简单，首先通
golang处理中文时默认是utf8，当遇到其他如GBK字符是就会出现乱码，此处介绍golang 官方golang.org/x/text/encoding/simplifiedchinese包下的编码转换
package main
import "golang.org/x/text/encoding/simplifiedchinese"
type Charset string
const
将字符串转换为rune切片时，会得到一个新的切片，其中包含字符串的 Unicode 码位( runes )
对于无效的 UTF-8 序列，每个无效字节的rune值将为0xFFFD。
r := []rune("ABC€")
fmt.Println(r) // [65 66 67 8364]
fmt.Printf("%U\n", r) // [U+0041 U+0042 U+0043 U+20AC]
