Unicode是一种字符集，code point
UTF8是unicode的存储实现，转换为字节序列的规则
go的rune类型 可以取出字符串里的unicode

字符串是一个不可改变的字节序列。

Go string通常是用来包含人类可读的文本。

文本字符串通常被解释为采用 UTF8 编码的 Unicode 码点。

Go的字符串由单个字节连接起来。

package main

func main() {
    var city string = "我爱北京天安门"
    println(city)
    // city[0]='1' 错误，go的字符串不可变
}

Go的字符串用双引号识别，识别转义字符"\n \t"

package main

import "fmt"

func main() {
    //识别转义符
    var story string = "妖怪\n放了我师父"
    fmt.Println(story)

    //反引号，以原生形式输出，包括特殊字符，防止注入攻击
    story2 := `
你看这个灯，它又大又亮
你好
我是银角大王吧，你吃了\n吗?
`
    fmt.Println(story2)
}

Go字符串拼接

package main

import "fmt"

func main() {
    //字符串拼接，识别空格
    str3 := "你好" + "  我是孙悟空"
    fmt.Println(str3)
}

Go可以用索引取出某字节

package main

import "fmt"

func main() {
    str3 := "hello world"
    //索引取出值的码值，格式化输出
    fmt.Printf("str3=%c\n",str3[1])
    //输出str3的长度
    fmt.Println(len(str3))
}

Go多行字符串拼接

package main

import "fmt"

func main() {
    //注意 +   加号 写在上一行
    myname := "wo" + "shi" + "bei" + "jing" +
        "sha" + "he" + "yu"
    fmt.Println(myname)
}

Go遍历字符串

package main

import "fmt"

func main() {
    myname := "hello world"
    for _, ret := range myname {
        fmt.Printf("ret=%c\n", ret)
    }
}

Go修改字符串的方法

package main

import "fmt"

func main() {
    myname := "hello world"
    m1 := []rune(myname) //转化为[]int32的切片,rune是int32的别名
    m1[4] = '皮'//修改索引对应的值
    myname = string(m1)//类型强转，rune转为string
    fmt.Println(myname)
}

1.1. 字符串处理strings包

官网模块

https://golang.org/pkg/strings/

package main

import (
    "fmt"
    "strings"
)

func main() {
    str := "hello world"
    //判断是不是以某个字符串开头，返回布尔值
    res0 := strings.HasPrefix(str, "http://")
    res1 := strings.HasPrefix(str, "hello")
    fmt.Printf("res0 is %v\n", res0)
    fmt.Printf("res1 is %v\n", res1)

    //判断是不是以某个字符串结尾
    res3 := strings.HasSuffix(str, "http://")
    res4 := strings.HasSuffix(str, "world")
    fmt.Printf("res3 is %v\n", res3)
    fmt.Printf("res4 is %v\n", res4)

    //判断字符在字符串中首次出现的索引位置，没有返回-1
    res5 := strings.Index(str, "o")
    res6 := strings.Index(str, "x")
    fmt.Printf("res5 is %v\n", res5)
    fmt.Printf("res6 is %v\n", res6)

    //返回字符最后一次出现的索引位置，没有返回-1
    res7 := strings.LastIndex(str, "o")
    res8 := strings.LastIndex(str, "x")
    fmt.Printf("res7 is %v\n", res7)
    fmt.Printf("res8 is %v\n", res8)

    //字符串替换
    res9 := strings.Replace(str, "world", "golang", 2)
    res10 := strings.Replace(str, "world", "golang", 1)
    //trings.Replace("原字符串", "被替换的内容", "替换的内容", 替换次数)
    //原字符串中有2个world，才能替换2次
    fmt.Printf("res9 is %v\n", res9)
    fmt.Printf("res10 is %v\n", res10)

    //求字符在字符串中出现的次数，不存在返回0次
    countTime0 := strings.Count(str, "h")
    countTime1 := strings.Count(str, "x")
    fmt.Printf("countTime0 is %v\n", countTime0)
    fmt.Printf("countTime1 is %v\n", countTime1)

    //重复几次字符串
    res11 := strings.Repeat(str, 0)
    res12 := strings.Repeat(str, 1)
    res13 := strings.Repeat(str, 2)
    // strings.Repeat("原字符串", 重复次数)
    fmt.Printf("res11 is %v\n", res11)
    fmt.Printf("res12 is %v\n", res12)
    fmt.Printf("res13 is %v\n", res13)

    //字符串改大写
    res14 := strings.ToUpper(str)
    fmt.Printf("res14 is %v\n", res14)

    //字符串改小写
    res15 := strings.ToLower(str)
    fmt.Printf("res15 is %v\n", res15)

    //去除首尾的空格
    res16 := strings.TrimSpace(str)
    fmt.Printf("res16 is %v\n", res16)

    //去除首尾指定的字符,遍历l、d、e然后去除
    res17 := strings.Trim(str, "ld")
    fmt.Printf("res17 is %v\n", res17)

    //去除开头指定的字符
    res18 := strings.TrimLeft(str, "he")
    fmt.Printf("res18 is %v\n", res18)

    //去除结尾指定的字符,遍历d、l、r
    res19 := strings.TrimRight(str, "dlr")
    fmt.Printf("res19 is %v\n", res19)

    //用指定的字符串将string类型的切片元素结合
    str1 := []string{"hello", "world", "hello", "golang"}
    res20 := strings.Join(str1, "+")
    fmt.Printf("res20 is %v\n", res20)
}

2. Go基本数据类型转化

Golang在不同的数据类型之间赋值时需要显示转化，无法自动转换。

兼容类型之间可以转换，语法Type(value)

语法：

T(v)  将v转化为T类型
T  数据类型 如 int32 int64 float32
V  需转化的变量

类型转化注意点：

1）Go中数据类型的转换可以从 数值范围大 > 数值范围小，反之也可，注意别溢出

2）被转化的变量存储的数值，变量本身的数据类型没变化

package main

import "fmt"

func main() {
    var num1 int32 = 100
    var num2 float32 = float32(num1)    //num2强转为浮点型
    fmt.Printf("num1=%v  num2=%v\n", num1, num2)     //%v 值的默认格式
    fmt.Printf("num1类型是：%T", num1)//本身的类型 没有变化
}

3）不同类型变量之间的计算

package main

import "fmt"

func main() {
    var n1 int32 = 12
    var n2 int64 = 10

    //n3:=n1+n2 //不同类型之间无法计算,需要强转
    n3 := int64(n1) + n2
    fmt.Println(n3)
}

3. Go基本数据类型与string转化

开发中经常将数据类型转成string

方法1：

fmt.Sprintf("%参数",表达式)

package main

import "fmt"

func main() {
    var num1 int = 66
    var num2 float64 = 25.25
    var b bool = true
    var myChar byte = 'c'

    //%q 单引号
    //%d 十进制表示
    str1 := fmt.Sprintf("%d", num1)
    fmt.Printf("str1 type %T str=%q\n", str1, str1)

    //%f 有小数点
    str2 := fmt.Sprintf("%f", num2)
    fmt.Printf("str2 type %T str2=%q\n", str2, str2)

    //%t 布尔值
    str3 := fmt.Sprintf("%t", b)
    fmt.Printf("str3 type %T str3=%q\n", str3, str3)

    //%c Unicode码对应的字符
    str4 := fmt.Sprintf("%c", myChar)
    fmt.Printf("str4 type %T str4=%q\n", str4, str4)
}

方法2：

Strconv包

包strconv实现基本数据类型转化字符串类型

func Itoa(i int) string            //int转化string
func FormatBool(b bool) string        //bool转string
func FormatFloat(f float64, fmt byte, prec, bitSize int) string    //float转string
func FormatInt(i int64, base int) string    //int64转化string

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num1 int = 99
    var num2 float64 = 66.66
    var b1 bool = true

    str1 := strconv.FormatInt(int64(num1), 10)
    fmt.Printf("str1类型是%T str1=%q\n", str1, str1)

    //参数解释
    // f 格式
    // 10 小数位保留10位
    // 64  表示float64
    //浮点数转stirng
    str2 := strconv.FormatFloat(num2, 'f', 10, 64)
    fmt.Printf("str2类型是%T str2=%q\n", str2, str2)
    //bool转string
    str3 := strconv.FormatBool(b1)
    fmt.Printf("str3类型是%T str3=%q\n", str3, str3)

    //Itoa，将int转为string
    var num3 int64 = 1123
    str4 := strconv.Itoa(int(num3))//必须强转int()
    fmt.Printf("str4类型是%T str4=%q\n", str4, str4)

    //将int64转为stirng
    var n1 int64 = 99
    s1 := strconv.FormatInt(n1, 10)
    fmt.Printf("%T %#v\n", s1, s1)
}

3.1.1. string类型转基本数据类型

官方函数介绍

https://golang.org/pkg/strconv/

package main

import (
    "fmt"
    "strconv"
)

func main() {
    /*
        ParseBool，ParseFloat，ParseInt和ParseUint将字符串转换为值
        如转换失败，返回新类型默认值
    */
    var str1 string = "true"
    var b1 bool
    /*
        strconv.ParseBool(str1)函数返回2个值（value bool,err error)
    */
    b1, _ = strconv.ParseBool(str1)
    fmt.Printf("b 值类型= %T  b值=%v\n", b1, b1)

    var str2 string = "1234"
    var num1 int64
    //func ParseInt（s string，base int，bitSize int）（i int64，err error）
    num1, _ = strconv.ParseInt(str2, 10, 64)
    fmt.Printf("num1类型：%T num2值：%v\n", num1, num1)

    var str3 string = "123.456"
    var float1 float64
    //func ParseFloat（s string，bitSize int）（float64，error）
    float1, _ = strconv.ParseFloat(str3, 64)
    fmt.Printf("float1类型：%T  float1值：%v", float1, float1)
}

3.2. 非安全转换字符串

要修改字符串，都要将其转化为可变类型[]rune或[]byte，待完成后再转换回来。

不管如何转换，都需重新分配内存，并且复制数据。

非安全方式转换

func toString(bs []byte)string{
  return *(*string)(unsafe.Pointer(&bs))
}
func main(){
  bs:=[]byte("hello,world!")
  s:=toString(bs)
    printDataPointer("bs: %x\n",&bs)
    printDataPointer("s: %x\n",&s)
}

#结果
bs:c82003fec8
s:c82003fec8

解释：

[]byte和string头部结构，部分相同，以非安全的指针类型转换来实现`变更`，从而避免了底层数组复制。
在很多web Framework中都有此类做法，在高并发下，此法能有效改善性能。
unsafe需谨慎，有一定风险。

3.3. 动态构建字符串

用加法操作符拼接字符串时，每次都需重新分配内存，构建超大字符串时，性能极差。

改进思路预分配足够内存空间。

使用strings.Join函数，它会统计所有参数长度，一次性完成内存分配。

bytes.Buffer也是类似操作。

少量字符串格式化拼接，使用fmt.Sprintf方法