【Golang学习笔记】03

要点

• string
• array
• slice
• map
• struct

string

• 以转移符的形式输出

    str := "a \x61 \u0061"      // 61代表16进制的a 以转移符的形式输出
    fmt.Println(str)

• 字符串默认为空”“

    var str2 string // 默认为 ""
    fmt.Println(str2 == "") // true

• 输出原意字符串 用 ··

    str3 := `无视\n转移符 \x61` // 原始字符串
    fmt.Println(str3)         // 无视\n转移符 \x61

• 字符串相加

    str4 := "a" + "b"   // 字符串相加
    fmt.Println(str4)   // ab

• 字符串比较

    fmt.Println("a" > "b")  // 字符串比较 ascll码比较

• 按下标输出

    str5 := "abcde"
    fmt.Printf("%c, %v, %s \n", str5[0], str5[0], str5) // 字符串索引输出 a, 97, abcde 
    //%c输出字符 %v输出value

• 切片

    str5 := "abcde"
    str6 := str5[1:3]       // 切片
    str7 := str5[ :3]
    fmt.Println(str6, str7) // bc abc

• 字符串的遍历

    for i := 0; i < len(str5); i++{
        fmt.Printf("%c; ", str5[i])
    }//a; b; c; d; e; 
    fmt.Println()
    for _,s:= range str5{
        fmt.Printf("%c; ", s)
    }//a; b; c; d; e; 

• 修改字符串的内容
  将字符串转为byte数组,然后修改相应的ascll码,在转回string（这样做比较耗性能）

    temp := []byte(str5)
    temp[0] = 50
    str8 := string(temp)
    fmt.Println(str8)

array

• 数组初始化

    var arr1 [3]int = [3]int{1,2,2:222}         //可以给其中某一个下标赋值 下标：值
    fmt.Println(arr1)                           // [1 2 222]

• 是否是同一个数组

    var arr1 [3]int = [3]int{1,2,2:222}
    arr2 := [3]int{1, 2, 222}
    fmt.Println(arr1 == arr2)// true

• 结构体数组

    type stu struct{
        name string
        age int
    }

    arr3 := []stu{
        {"a", 1},
        {"b", 2},
    }
    fmt.Println(arr3)    // [{a 1} {b 2}]

• 二维数组

    arr4 := [][2]int{
        {1,2}, {3,4}, {5, 6},
    }
    fmt.Println(arr4)       // [[1 2] [3 4] [5 6]]
    fmt.Println(len(arr4))  // 3

• 数组指针和指针数组

    var x, y *int
    z := []*int{x, y}   //指针数组
    c := &z             //数组指针

    fmt.Println(z, c)   // [ ] &[ ]

• 值的传递

// 传指针
func test(a *[3]int)  {
    a[1] = 200
}

// 传值
func test2(a [3]int)  {
    a[2] = 300
}

func main(){
    q := [3]int{1, 2, 3}
    w := q      // 值复制
    w[0] = 100
    test(&q)
    test2(q)

    fmt.Printf("%p, %v \n", &q, q)   // 0xc04204e100, [1 200 3] 
    fmt.Printf("%p, %v \n", &w, w)   // 0xc04204e120, [100 2 3] 
}

slice

一个切片是一个数组切割区间的描述。它包含了指向数组的指针，切割区间的长度，和容量（切割区间的最大长度）。

    type slice struct{
    arrPtr *ptr
    len int
    cap int 
    }

• 初始化

    a := []int{1,2,3,4,5}
    fmt.Println(len(a))   // 5
    fmt.Println(cap(a))   // 5

    b := a[1: 4]
    fmt.Println(len(b))    // 3
    fmt.Println(cap(b))    // 4

使用make(类型, 长度, 容量)

    c := make([]int, 4, 5)
    c[3] =1
    fmt.Println(c)

• append
  切片在append的时候 容量的扩增是翻倍的

    f := []int{1,2,3,4}
    fmt.Println(len(f))  // 4
    fmt.Println(cap(f))  // 4
    f = append(f, 2)
    fmt.Println(len(f))   // 5
    fmt.Println(cap(f))   // 8

• 原切片和原切片的切片使用的是同一个底层数组

    d := []int{1,2,3,4}
    e := d[1:]
    e[2] = 400
    fmt.Println(d)   // [1 2 3 400]
    fmt.Println(e)   // [2 3 400]

    但是在append后就不是了
    e = append(e, 0)    // append后使用的非同一个底层数组了
    e[0] = 400
    fmt.Println(d)   // [1 2 3 400]
    fmt.Println(e)   // [400 3 400 0]

• copy
  copy(目标,原) 将原内容一一对应的复制到目标中

    g := []int{1, 2, 3, 4, 5, 6, 7, 8}
    h := []int{100, 200, 300, 400, 500, 600}
    nn := copy(g[1:], h[0:3]) // 复制了nn个内容
    fmt.Println(nn)
    fmt.Println(g)

map

• 初始化

    m := make(map[string]int)
    m["a"] = 1
    m["b"] = 2
    fmt.Println(m, m["a"], m["c"])    //1 0

• 输出

    value := m["a"]          // 返回一个值是 value
    fmt.Println(value)       // 1

    value, had := m["b"]     // 返回两个值是 value 是否存在该值
    fmt.Println(had, value)  // true 2

    value, had = m["c"]
    fmt.Println(had, value)  // false 0

• 遍历

    for k, v := range m {       // map的遍历
        fmt.Println(k, v)
    }
    /*
    a 1
    b 2
    */

struct

type student struct{
    name string
    age int
}

• 初始化

stu1 := student{
        name:"aaa",     // 指定某个元素，可以不写齐
    }

    stu2 := student{    // 不指定元素，需要写齐全部
        "bb",
        2,
    }

    fmt.Println(stu1, stu2) // {aaa 0} {bb 2}

• 匿名结构体

    stu3 := struct{
        name string
        age int
    }{
        name: "cc",
        age: 3,
    }
    fmt.Println(stu3)

• 嵌套

stu4 := struct {
        student // 嵌套了一个已存在的结构体
        sss struct {
            // 嵌套了一个匿名结构体
            sex bool
        }
    }{
        student: student{"dd", 4},
    }
    stu4.sss.sex = false    // 没法在结构体内赋值
    fmt.Println(stu4)       // {{dd 4} {false}}

• 结构体字节数

    stt := struct{
        a int64     // 8个字节
        b int8      // 1个字节
        c int32     // 4个字节
        d int16     // 2个字节
    }{
        1,
        2,
        3,
        4,
    }
    fmt.Println(unsafe.Sizeof(stt))     // 共24个字节