Go數據類型

go的數據類型分爲四大類：基礎類型、聚合類型、引用類型、接口類型

基礎類型

1. 整形(int)：就是表示整數值，不同類型不能直接比較，但是都可以和字面量比較，所謂的字面量就是直接的數值，如10 10.2

var v1 int32 =10
var v2 int =10
//編譯錯誤:invalid operation: v1 == v2 (mismatched types int32 and int)
if v1==v2{

}
//編譯通過
if v1==10{

}

整形數據類型共有int,int8,int16,int32,int64,uint,uint8,uint16,uint32,uint64,uintptr 11種

類型	描述
int8	長度爲8位的整數，表示[2^-7, 2^7-1]
byte	長度爲8位的整數，和int8同等
int16	長度爲16位的整數
int32	長度爲32位的整數
rune	長度爲32位的整數，和int32同等
int	默認長度爲32位，但是和int32之間仍需要顯示轉換
int64	長度爲64位的整數
uint8	長度爲8位的非負整數 [0, 127]
uint16	長度爲16位的非負整數
uint32	長度爲32位的非負整數
uint64	長度爲64位的非負整數
uintptr	大小不明確，但是足以完整存放指針，僅僅用於底層編程

取模運算符的餘數的符號均與被除數相同：-5 % 3 = -2; -5 % -3 = -2

2. 浮點數(float)：

類型	描述
float32	IEEE-754 32位浮點型數
float64	IEEE-754 64位浮點型數

3. 複數(complex)：

類型	描述
complex64	32 位實數和虛數
complex128	64 位實數和虛數

var x complex128 = complex(1,2) //1+2i
real(x)     //複數的實數部分：1
imag(x)     //複數的虛數部分：2

4. 布爾值(bool):bool類型不支持類型轉換，不能將其他類型轉爲bool類型。bool類型只有兩個值true和false,支持所有的邏輯運算，如：&& || !等等

5. 字符串(string):不可變的字節序列。Go語言中的字符串和java中的String類一樣，是不可變的

• len()函數獲取字符串長度
• str[i]下標獲取字符串中第i個字符
• [i:j]獲取字符串的子串，包括i，不包括j
• 可以使用==和<等符號比較字符串，比較根據字典排序
• 因爲字符串不可變，所有不能給內部字符賦值：如s[0]=’c’是不允許的
• 字符串字面量：“括起來的字符串，其中的轉義序列不起作用，回車符會被刪除，只保留換行符。
• string(65):”A”而不是65
• 中文在utf-8中表示3個字符

6. 常量：可以使用itoa生成器，默認從0開始

const(
    sunday int itoa
    monday
    tuesday
    wednesday
    thursday
    friday
    saturday
)

• 無類型常量：直接賦值，不定義類型；無類型布爾，無類型整數，無類型文字符號，無類型浮點數，無類型複數，無類型字符串，

const(
    a = 1
    b
    c = 2
    d
    // a=b=1  c=d=2
)

• 變量聲明中如果沒有顯示的定義類型，無類型常量會隱式地轉換爲改變量的默認類型,默認int,float64,string

i = 10
f = 10.2
s = "hello Go"

複合數據類型

1. 數組:數組是不可變長序列

• 數組長度在定義的時候必須是常量，也就是在編譯期間就要能夠確定數組的長度。
• 數組的長度是作爲數組數據結構的一部分，兩個不同長度數組變量不能相互賦值；
• 數組的長度取決於數組的索引最大值；

var arr [3]int
var arr [3]int = [3]int{1,2,3}
q := [...]int{1,2,3}//數組長度有初始化的個數決定
len(arr)//獲取數組的長度

• 數組可以直接設定索引和值，此時索引可以是不按照順序來的

arr := [...]int{1:1,2:2,5:5,4:4}

• 數組是可以比較的，前提是數組的長度和類型要一致，如果不一致會出現編譯錯誤，一致的情況下比較對應索引下的值是否都相等。

arr := [3]int{1,2,3}
arr2 := [3]int{4,5,6}
//arr<arr2,數組類型相同，長度相同，可以比較
arr<arr2

arr3 := [5]int{1,2,3,4,5}
//invalid operation: arr == arr3 (mismatched types [3]int and [5]int)
arr==arr3

2. slice:可變長序列，可以用來訪問數組的部分或者全部的元素，包含三個屬性：指針，長度和容量;

• cap:指的是slice起始元素到數組最後一個元素的長度

arr := [5]int{1,2,3,4,5}
//1，2，3
sli := arr[0:3]
//表示從第一元素1到數組最後一個元素5的長度，爲5
cap(sli)
//2,3
sli2 := arr[1:3]
//表示從sli2的第一個元素2到數組最後元素5的長度，爲4
cap(sli2)

• slice可以在自身的基礎上擴容，s1 := s[3:6] s2:=s1[:5]s1只有數組s中第3，4，5三個元素，s2變成了第3，4，5，6，7五個元素了。前提s中至少有這些元素。
• slice的引用不能超過被引用對象的容量，即cap,否則會出現恐慌panic: runtime error: slice bounds out of range
• slice的引用可以超過被引用對象的長度
• slice的零值是nil，如果要檢查一個slice是否爲空，直接使用len()函數，因爲slice爲空，slice可能不爲nil
• slice可以用來實現棧，入棧：stack = append(stack,v)出棧：value = stack[len(stack)-1] stack=stack[:len(stack)-1]

make([]T,lens,caps)
s []int         //不包含長度定義
s[i:j]          //從數組或者slice中獲取從i-j的數值，包括i，不包括j；
s[:j]           //從0-j
s[i:}           //從i到len(s)

var s []int     //len爲0，s==nil
s = nil         //len爲0，s==nil
s = []int(nil)  //len爲0，s==nil
s = []int{}     //len爲0，s!=nil

len(s)          //返回slice的長度
cap(s)          //返回slice的容量
append(s,v1,v2)     //返回s加上v1，v2後的slice
append(s,s2...)     //可以在slice中添加其他的slice但是需要加上...，將s2打散爲若干個元素
copy(s,s1)      //將s1中的元素賦值到s中，替換的元素個數爲兩者中最短的長度,返回複製的長度

3. map:鍵值對，使用散列表實現

• 使用delete(map,value)刪除的時候，即使方法中的鍵不存在，此方法也是安全的
• map元素不是一個變量，不能獲取其中的地址
• map中迭代的順序是不固定的，因爲使用的散列算法不同
• map使用之前必須初始化
• 當key不在map中的時候，獲取的值爲所對應類型的零值

ages := make(map[string] int)//創建一個map
ages["alice"]   = 31
ages["bob"]     = 34

ages := map[string]int{
    "alice" : 31,
    "bob"   : 34,
}
//刪除map中的元素
delete(ages,"alice")

//判斷鍵是否存在map中，如果不存在執行相應操作
if age,ok :=age["bob"]; !ok{...}

4. 結構體：將零個或者多個任意類型的命名變量組合在一起的聚合數據類型

• 通過點號來訪問數據，student.ID;也可以通過獲取成員變量的地址來獲取
• 結構體中不能包含自身類型的變量，但是可以包含自身類型指針的變量
• 成員變量的順序對於結構體很重要，如果順序改變，也就是定義了一個新的結構體
• 結構體字面量
• 結構體可以比較，可以作爲map的鍵存在
• 匿名成員
• 結構體指針可以直接訪問結構體中的成員，而不需要使用*
• 可以使用字段設置值，str := struct{x:1,y:2}

type Employee struct{
    ID int
    Name string
    Address string
    DoB time.Time
    Position string
    Salary int
    ManagerID int
}

var Bob Employee

position := &Bob.position
*position = “Senior ”+ *position

//結構體字面量，形如java的構造器
type Point struct{x,y int}
p := Point{1,2}

//通過指針初始化結構體
pp := &Point{1,2}

//匿名成員
type Point struct{
    X int
    Y int
}
type Circle struct{
    Point
    Radius int
}
type Wheel struct{
    Circle
    Spokes int
}
//
var w Wheel
w.X = 8//等價與w.Circle.Point.X = 8
w.Y = 8

5. 指針: *T表示T類型的指針，其零值爲nil

var i = 2
var intptr *int = &i
i = *intptr

6類型判斷: i.(T)判斷值i中是否是類型T,如果是，則將T類型的值賦值給i,如果不是，則會觸發一個painc，這時候需要使用val,ok:=i.(T),如果是T類型，ok返回true，如果不是返回false。還能用於switch-case結構中。前提變量i要是一個接口類型的變量，否則會報錯invalid type assertion: i.(int) (non-interface type int on left)

switch i.(type){
    case int32:
    case float64:
}

Go語言編程