Go中的字符串使用----strings和strconv

Go中的字符串操作

字符串是工作中最常用的，值得我们专门的练习一下。在Go中使用strings包来操作字符串，这也是内置的包哈，不像Java中要么手写，要么引入common-lang 或者 别的第三方。另外涉及到字符串与其他类型之间的转换使用了strconv包来操作。

strings包

1. 字符串包含关系

strings.Contains(s, substr string) bool

判断s串中是否包含substr串。

2. 判断子字符串或字符在父字符串中出现的位置（索引）

strings.Index(s, str string) int

判断str字符串在s字符串中出现的第一个索引位置，-1 表示字符串 s 不包含字符串 str

strings.LastIndex(s, str string) int

LastIndex返回子字符串str在s中最后一次出现的索引位置。

如果要查询非ASCII编码的字符在父字符串中的位置，建议使用如下方法：

strings.IndexRune(s string, r rune) int

3. 字符串替换

strings.Replace(str, old, new, n) string

4. 前缀和后缀

判断字符串 s 是否以 prefix 开头
strings.HasPrefix(s, prefix string) bool
判断字符串 s 是否以 suffix 结尾
strings.HasSuffix(s, suffix string) bool

5. 统计字符串出现次数

strings.Count(s, str string) int

计算字符串 str 在字符串 s 中出现的非重叠次数

6. 重复字符串并返回一个新串

strings.Repeat(s, count int) string

将s字符串重复count次，并返回新的字符串。

7. 修改字符串，替换某些字符

剔除字符串开头和结尾的空白符号
strings.TrimSpace(s)
替换指定的字符
strings.Trim(s, "\n")
剔除开头或者结尾的字符串，该方法只在开头或者结尾剔除指定的字符
strings.TrimLeft(a,"")
strings.TrimRight(a,"")

8. 分割字符串

strings.Fields(s)

会将字符串以“”空白字符作为分割线，分为字符数组。如果字符串只包含空白符号，则返回一个长度为 0 的 slice。

strings.Split(s, sep)

自定义分割符号来对指定字符串进行分割 ,返回字符数组。

8. 修改字符串大小写

将字符串中的字符全部转为小写
strings.ToLower(s) string
将字符串中的字符全部转为大写
strings.ToUpper(s) string

9. 拼接slice到字符串

strings.Join(sl []string, sep string) string

c := [4]string{"a","b",":","c"}
join := strings.Join(d, "")
输出：
ab:c

Join 用于将元素类型为 string 的 slice 使用分割符号来拼接组成一个字符串 。

strconv-字符串与其它类型的转换

包strconv主要实现对字符串和基本数据类型之间的转换。基本数据类型包括：布尔、整型（包括有/无符号、二进制、八进制、十进制和十六进制）和浮点型等。

1.字符串和整型变量之间的转换

func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (n uint64, err error)
func Atoi(s string) (i int, err error)

将字符串解析为整数，ParseInt 支持正负号，ParseUint 不支持正负号。

base 表示进位制（2 到 36），如果 base 为 0，则根据字符串前缀判断，前缀 0x 表示 16 进制，前缀 0 表示 8 进制，否则是 10 进制。

bitSize 表示结果的位宽（包括符号位），0 表示最大位宽，取值 0、8、16、32 和 64 分别代表 int、int8、int16、int32 和 int64。

Atoi 是 ParseInt 的便捷版，内部通过调用 ParseInt(s, 10, 0) 来实现的。

在 ParseInt/ParseUint 的实现中，如果字符串表示的整数超过了 bitSize 参数能够表示的范围，则会返回 ErrRange，同时会返回 bitSize 能够表示的最大或最小值。

2.整型转为字符串类型

func FormatUint(i uint64, base int) string    // 无符号整型转字符串
func FormatInt(i int64, base int) string    // 有符号整型转字符串
func Itoa(i int) string

其中，Itoa 内部直接调用 FormatInt(i, 10) 实现的。base 参数可以取 2~36（0-9，a-z）。

区别sprintf和itoa :

除了使用strconv包之外，我们的fmt也是可以将int打印为string：

fm := fmt.Sprintf("%d", 111)

那么这两种方式该如何选择呢，其实我们可以看一下他们的效率：

func testTime()  {
	now := time.Now()
	for i :=0;i < 100000;i++{
		fmt.Printf("%d",i)
	}
	fmt.Println("=====================")
	fmt.Println(time.Now().Sub(now))
	newTime := time.Now()
	for i :=0;i < 100000;i++{
		strconv.Itoa(i)
	}
	fmt.Println("=====================")
	fmt.Println(time.Now().Sub(newTime))
}

func main() {
	testTime()
}

效果还是很明显：
162ms
=====================
3ms

另外Go跟Java中不同的是通过 s := string(77)这种方式得到的不是“77”而是77对应的ascii码值，M。

3.字符串和布尔值之间的转换

// 接受 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False 等字符串；
// 其他形式的字符串会返回错误
func ParseBool(str string) (value bool, err error)
// 直接返回 "true" 或 "false"
func FormatBool(b bool) string
// 将 "true" 或 "false" append 到 dst 中
// 这里用了一个 append 函数对于字符串的特殊形式：append(dst, "true"...)
func AppendBool(dst []byte, b bool)

4.字符串和浮点数之间的转换

// FormatFloat 将浮点数 f 转换为字符串形式
// f：要转换的浮点数
// fmt：格式标记（b、e、E、f、g、G）
// prec：精度（数字部分的长度，不包括指数部分）
// bitSize：指定浮点类型（32:float32、64:float64），结果会据此进行舍入。
//
// 格式标记：
// 'b' (-ddddp±ddd，二进制指数)
// 'e' (-d.dddde±dd，十进制指数)
// 'E' (-d.ddddE±dd，十进制指数)
// 'f' (-ddd.dddd，没有指数)
// 'g' ('e':大指数，'f':其它情况)
// 'G' ('E':大指数，'f':其它情况)
//
// 如果格式标记为 'e'，'E'和'f'，则 prec 表示小数点后的数字位数
// 如果格式标记为 'g'，'G'，则 prec 表示总的数字位数（整数部分+小数部分）
// 参考格式化输入输出中的旗标和精度说明
func FormatFloat(f float64, fmt byte, prec, bitSize int) string

// 将字符串解析为浮点数，使用 IEEE754 规范进行舍入。
// bigSize 取值有 32 和 64 两种，表示转换结果的精度。
// 如果有语法错误，则 err.Error = ErrSyntax
// 如果结果超出范围，则返回 ±Inf，err.Error = ErrRange
func ParseFloat(s string, bitSize int) (float64, error)

func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int)

示例：

v := 3.1415926535

s32 := strconv.FormatFloat(v, 'E', -1, 32)
fmt.Printf("%T, %v\n", s32, s32)

s64 := strconv.FormatFloat(v, 'E', -1, 64)
fmt.Printf("%T, %v\n", s64, s64)

s := "0.12345678901234567890"

f, err := strconv.ParseFloat(s, 32)
fmt.Println(f, err)
fmt.Println(float32(f), err)

f, err = strconv.ParseFloat(s, 64)
fmt.Println(f, err)

结果：
string, 3.1415927E+00
string, 3.1415926535E+00
0.12345679104328156 <nil>
0.12345679 <nil>
0.12345678901234568 <nil>