golang(二)数据（上）

绝地灬酷狼 2022-02-25 09:48 194阅读 0赞

## 字符串 ##

字符串是不可变字节(byte)序列，本身是一个复合结构。默认以UTF-8编码存储unicode字符。它的默认值是“”，而不是nil。字符串底层就是⼀个byte数组，所以可以和\[\]byte类型互相转换。

使用“ ‘ ”定义不做转义处理的原始字符串，支持跨行。

func main() {
        s := 'line\r\n,
        line 2'
    
        println(s);
    }

输出：

line\r\n,
        line 2

字符串之中的字符是不能修改的，但是可以将其转换为可变类型(\[\]rune或\[\]byte)，完成之后再转换回来。但是不管如何转换，都需要重新分配内存，并复制数据。字符串是由byte字节组成，所以字符串的长度是byte字节的长度。rune类型用来表示utf8字符，一个rune字符由1个或多个byte组成。

func pp(format string, ptr interface{}) {
        p := reflect.ValueOf(ptr).Pointer()
        h := (*uintptr)(unsafe.Pointer(p))
        fmt.Printf(format, *h)
    }
    
    func main() {
        s :="hello,world!"
        pp("s: %x\n", &s)
    
        bs := []byte(s)
        s2 := string(bs)
    
        pp(“string to []byte, bs; %x\n”, &bs)
        pp(“[]byte to string, s2; %x\n”, &s2)
    
        rs := []rune(s)
        s3 := string(rs)
    
        pp(“string to []rune, rs; %x\n”, &rs)
        pp(“[]rune to string, s3; %x\n”, &s3)
    }

有些时候，转换会降低算法的性能，因此可以考虑使用“非安全”方法进行改善。

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)
    }

该方法利用了\[\]byte和string头结构“部分相同”，以非安全的指针类型转换来实现类型“变更”，避免了底层数组复制。在高并发压力下能有效改善执行性能。

使用+拼接字符串也会产生性能问题，每次都必须重新分配内存。可以预分配足够的内存空间，使用strings.Join函数，统计所有参数长度，并一次性完成内存分配操作。

## 数组 ##

数组是同一类型的元素集合。Go数组下标也是从0开始，因此长度为n的数组下标范围是\[0,n-1\]。整数数组中的元素默认初始化为0，字符串数组中的元素默认初始化为“”。

var a [3]int   //定义一个数组

数组的初始化有以下几种：

//数组初始化
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    
    var a [3]int = [3]int{10, 20, 30}    //定义时数组初始化
    
    a := [3]int{10, 20, 30}        //定义时数组初始化
    
    a := […]int{10, 20, 30}        //定义时数组初始化
    
    a := [3]int{10}            //定义时数组初始化，未提供初始值的自动初始化为0
    
    a := [3]int{2:10}          //定义时数组初始化，制定索引位置初始化

数组长度是类型的⼀部分

var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    var b [5]int
    b = a            //a、b是不同类型的数组，不能赋值

数组内置函数len和cap都返回第一维长度。

var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    fmt.Printf(“len:%d\n”, len(a))

数组的遍历

var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    for i := 0; i < len(a); i++ {     //遍历1
    }
    
    
    for index, val := range a {       //遍历2
    }
    
    var a [3][2]int
    a[0][0] = 10
    a[0][1] = 20
    a[1][0] = 30
    a[1][1] = 30
    a[2][0] = 30
    a[2][1] = 30
    for index, val := range a {        //二维数组遍历
    }

数组的拷贝与传参

//数组是值类型
    var a [3]int
    a[0] = 10
    a[1] = 20
    a[2] = 30
    b := a
    //b拷⻉了数组a中所有元素
    b[0] = 1000
    fmt.Println(a, b)
    
    //数组是值类型，函数传参也会拷贝
    func main() {
        var a [3]int
        a[0] = 10
        a[1] = 20
        a[2] = 30
        modify(a)
        fmt.Println(a)
    }
    func modify(b [3]int) {
        b[0] = 1000
        return
    }