切片初始化 注意后面是{} 不是[]
//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)
}