strconv，strings的学习（三）

一、strconv的学习

1.转换值添加到字符串后面

//根据 b 的值将“true”或“false”附加到 dst 并返回扩展缓冲区。
func AppendBool(dst [] byte , b bool ) [] byte

//转化为float类型
func AppendFloat(dst [] byte , f float64 , fmt byte , prec, bitSize int ) [] byte

//转化为int类型
func AppendInt(dst [] byte , i int64 , base int ) [] byte

//AppendQuote 将表示 Quote 生成的 s 的双引号 Go 字符串文字附加到 dst 并返回扩展缓冲区。
func AppendQuote(dst [] byte , s string ) [] byte

// 将表示 QuoteRune 生成的符文的单引号 Go 字符文字附加到 dst 并返回扩展缓冲区。
func AppendQuoteRune(dst [] byte , r rune ) [] byte

//将表示由 QuoteRuneToASCII 生成的符文的单引号 Go 字符文字附加到 dst 并返回扩展缓冲区。
func AppendQuoteRuneToASCII(dst [] byte , r rune ) [] byte

2.类型转换

//字符串转为int
func Atoi(s string ) ( int , error )

//报告字符串 s 是否可以不变地表示为单行反引号字符串，而没有除制表符以外的控制字符。
eg:
fmt.Println(strconv.CanBackquote("Fran & Freddie's Diner ☺"))
fmt.Println(strconv.CanBackquote("`can't backquote this`"))

//格式化输出float64
func FormatFloat(f float64, fmt byte, prec, bitSize int) string

FormatFloat 根据格式 fmt 和 precision prec 将浮点数 f 转换为字符串。假设原始值是从 bitSize 位的浮点值（float32 为 32，float64 为 64）获得的，它对结果进行四舍五入。

格式 fmt 是 'b'（-ddddp±ddd，二进制指数）、'e'（-d.dddde±dd，十进制指数）、'E'（-d.ddddE±dd，十进制指数）之一), 'f' (-ddd.dddd, 无指数), 'g' ('e' 代表大指数, 'f' 否则), 'G' ('E' 代表大指数, 'f' 否则), ' x'（-0xd.ddddp±ddd，一个十六进制小数和二进制指数），或'X'（-0Xd.ddddP±ddd，一个十六进制小数和二进制指数）。

精度 prec 控制由 'e'、'E'、'f'、'g'、'G'、'x' 和 'X' 格式打印的位数（不包括指数）。对于“e”、“E”、“f”、“x”和“X”，它是小数点后的位数。对于“g”和“G”，它是有效数字的最大数量（删除尾随零）。特殊精度 -1 使用所需的最小位数，以便 ParseFloat 将准确返回 f。


//int类型转换为2-36进制的
func FormatInt(i int64 , base int ) string
 返回给定基数中 i 的字符串表示，对于 2 <= base <= 36。结果使用小写字母 'a' 到 'z' 表示数字值 >= 10。

//unit转化为2-36进制
func FormatUint(i uint64 , base int )字符串

//int转换为字符串
func Itoa(i int) string

//string转换为bool
func ParseBool(str string) (bool, error)

//string转化为复数
func ParseComplex(s string, bitSize int) (complex128, error)

//string转为浮点
func ParseFloat(s string, bitSize int) (float64, error)

//string转为指定进制和精度的浮点
func ParseInt(s string, base int, bitSize int) (i int64, err error)

eg:
package main

import (
	"fmt"
	"strconv"
)

func main() {
	v32 := "-354634382"
	if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

	v64 := "-3546343826724305832"
	if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

//string转化为指定进制和精度的uint
func ParseUint(s string, base int, bitSize int) (uint64, error)

2.strings包的学习及使用

1.比较字符串

比较返回按字典顺序比较两个字符串的整数。如果 a==b，则结果为 0，如果 a < b，则结果为 -1，如果 a > b，则结果为 +1。

func Compare(a, b string ) int

2.s是否包含字符串substr

func Contains(s, substr string) bool

3.判断char中的每一个字节是否在s内，只要有一个在则返回true

func ContainsAny(s, chars string ) bool

func ContainsRune(s string , r rune ) bool

4.Count 计算 s 中 substr 的非重叠实例的数量。如果 substr 是空字符串，Count 返回 1 + s 中的 Unicode 代码点数。

func Count(s, substr string ) int
eg：
package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Count("cheese", "e"))
	fmt.Println(strings.Count("five", "")) // before & after each rune
}

5.不区分大小写是否相等

func EqualFold(s, t string ) bool

6.根据空白字符串进行切割，返回一个列表

func Fields(s string ) [] string

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

output:
Fields are:["foo" "bar" "baz"]

6.自定义切割方法，来根据指定函数切割string

func FieldsFunc(s string , f func( rune ) bool ) [] string
FieldsFunc 在每次运行满足 f(c) 的 Unicode 代码点 c 时拆分字符串 s，并返回 s 切片的数组。如果 s 中的所有代码点都满足 f(c) 或字符串为空，则返回一个空切片。

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

7.判断s是否以prefix开头

func HasPrefix(s, prefix string ) bool

8.HasSuffix 测试字符串 s 是否以后缀结尾。

func HasSuffix(s, suffix string) bool

9.Index 返回 s 中 substr 第一个实例的索引，如果 substr 不存在于 s 中，则返回 -1。

func Index(s, substr string ) int

10.返回chars串中在s匹配的第一个索引下标，如果不存在则返回-1

//会遍历所有的chars,然后返会s最小的下标索引
func IndexAny(s, chars string ) int

//返回查找的字节索引
func IndexByte(s string , c byte ) int
func IndexRune(s string , r rune ) int

eg:
fmt.Println(strings.IndexByte("golang", 'g'))

output:
0 

//返回满足函数的索引，如果没有则返回-1
func IndexFunc(s string , f func( rune ) bool ) int

eg:
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

11.Join连接一个elems的元素，用sep连接

func Join(elems [] string , sep string ) string

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

12.LastIndex 返回 s 符合substr 最后一个实例的索引，如果 substr 不存在于 s 中，则返回 -1。

func LastIndex(s, substr string ) int
func LastIndexByte(s string , c byte ) int

eg:
    fmt.Println(strings.Index("go gopher", "go"))
	fmt.Println(strings.LastIndex("go gopher", "go"))
	fmt.Println(strings.LastIndex("go gopher", "rodent"))

output:
    0 
    3 
   -1
   
//返回符合的任何一个char的最后一个索引，始终返回最大的   
func LastIndexAny(s, chars string ) int

13.基于函数返回最后一个索引

func LastIndexFunc(s string , f func( rune ) bool ) int

eg：
    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

14.函数功能映射，自定义字符串转换为指定的字符串

func Map(mapping func( rune ) rune , s string ) string

eg：
    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...

15.简短功能字符串

//重复字符串2次
strings.Repeat("na", 2)

//替换字符串的某个字符
func Replace(s, old, new string , n int ) string

eg:fmt.Println(strings.Replace("oink oink oink", "k", "ky", 2))

//替换所有
func ReplaceAll(s, old, new string )string
eg:fmt.Println(strings.ReplaceAll("oink oink oink", "oink", "moo"))

//切割字符串
func Split(s, sep string ) [] string

//切割字符串后带上切割的字符
func SplitAfter(s, sep string ) [] string

//指定切割次数
func SplitAfterN(s, sep string , n int ) [] string
n > 0：最多n个子串；最后一个子串将是未拆分的余数。
n == 0：结果为零（零子串）
n < 0：所有子串
eg:
    fmt.Printf("%q\n", strings.SplitAfterN("a,b,c", ",", 2))
output:
    ["a," "b,c"]

//指定切割次数
func SplitN(s, sep string , n int ) [] string

//返回开头字母大写的字符串
func Title(s string ) string
eg:fmt.Println(strings.Title("her royal highness"))
output:Her Royal Highness 

//转化为小写字母
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

//根据cutset进行修剪字符串
func Trim(s, cutset string ) string

eg:fmt.Print(strings.Trim("¡¡¡Hello, Gophers!!!", "!¡s"))

output:Hello, Gopher

//根据函数进行修剪字符串
func TrimFunc(s string , f func( rune ) bool ) string

eg:
    fmt.Print(strings.TrimFunc("¡¡¡Hello, Gophers!!!", func(r rune) bool {
		return !unicode.IsLetter(r) && !unicode.IsNumber(r)
	}))
output:Hello, Gophers
    
//根绝cutset修改删除前缀
func TrimLeft(s, cutset string ) string

//根据函数修改前缀
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)
	}))

//满足前缀则删除前缀，返回剩余字符串，不满足前缀，则返回原字符串
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
eg:fmt.Println(strings.TrimSpace(" \t\n Hello, Gophers \n\t\r\n"))

满足后缀则删除前缀，返回剩余字符串，不满足后缀缀，则返回原字符串
func TrimSuffix(s, suffix string ) string

16.替换器

type Replacer struct {
	// contains filtered or unexported fields
}


r := strings.NewReplacer("<", "&lt;", ">", "&gt;")
fmt.Println(r.Replace("This is <b>HTML</b>!"))

func (r *Replacer) Replace(s string) string

func (r * Replacer ) WriteString(w io . Writer , s string ) (n int , err error )
WriteString 将 s 写入 w 并执行所有替换。

17.类型生成器

type Builder struct {
	 // 包含过滤或未导出的字段
}

func main() {
	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

常用函数
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)

18.类型阅读器

type Reader struct {
	// contains filtered or unexported fields
}

func NewReader(s string) *Reader

常用方法
func (r *Reader) Len() int //Len 返回字符串未读部分的字节数。
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) //Seek 实现了 io.Seeker 接口。
func (r *Reader) Size() int64
func (r *Reader) UnreadByte() error //UnreadByte 实现了 io.ByteScanner 接口。
func (r *Reader) UnreadRune() error //UnreadRune 实现了 io.RuneScanner 接口。
func (r *Reader) WriteTo(w io.Writer) (n int64, err error)//WriteTo 实现了 io.WriterTo 接口。