go chapter1

​

切片初始化 注意后面是{} 不是[]
//slice := []int[1,2,3,4,5,6]
slice := []int{1,2,3,4,5,6}
s2 := make([]int, 0, 5)
s2 := make([]int{1,2,3,4,5}, 5, 5) 不可
go 的数组 大小 固定

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
我们也可以通过字面量在声明数组的同时快速初始化数组：

balance := [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
如果数组长度不确定，可以使用 … 代替数组的长度，编译器会根据元素个数自行推断数组的长度：

var balance = […]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
或
balance := […]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
引入切片 大小不定 可变、

var

iota

fallthrough
rune  == int32

fmt.Printf(“第 1 行 - a 变量类型为 = %T\n”, a );
   fmt.Printf(“第 2 行 - b 变量类型为 = %T\n”, b );

array = []int{1,2,3,4,5,6,7,8,9}

// 从array取，左指针索引为0，右指针为5，切片是从array切的,
// 而且cap函数只计算左指针到原array最后的值的个数
slice = array[0:5] // slice ==> {1, 2, 3, 4, 5}
cap(slice) // == 9，因为左指针索引为0，到结尾有9个数，cap为9

slice = slice[2:] // slice ==> {3, 4, 5}
cap(slice) // == 7 左指针偏移了2步，所以cap为9-2=7

初遇unsafe.Sizeof()时，以为Go语言中的sizeof和C语言的sizeof不太一样，对于算出的值也是一脸懵逼。深入了解才发现两者并没有区别，是自己误解了。

package main
    import (
    “fmt”
    “unsafe”
    )
    func main(){
    var test string = “abc”
    a := len(test)
    b := unsafe.Sizeof(test)
    fmt.Println(a,b)
    }

最终的运算结果是：3，16

对于接触过python的同学来说，3很容易理解，但是16从何而来呢？

原来是因为unsafe.Sizeof返回的是数据类型的大小，而string在Go中并不是直存类型，它是一个结构体类型：

type StringHeader struct {
            Data uintptr
            Len  int
    }

在64位系统上uintptr和int都是8字节，加起来就16了。

1.

Go 如何判断变量类型
2018-09-21

Go 中判断变量的类型不是太方便。

var.(type)
reflect
var.(type)
通过 var.(type) 可以判断变量类型，不过必须在 switch 中使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func Type(i interface{}) {

switch i.(type) {
case string:
    fmt.Println("string")
case int:
    fmt.Println("int")
case bool:
    fmt.Println("bool")
default:
    fmt.Println("default")
}

}
reflect
也可以通过反射的方式来获取变量类型

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
“fmt”
“reflect”
)

func main() {

t := reflect.TypeOf("Hello World")
fmt.Println(t)

}
​