GO 類型

變量

GO變量老是有固定的數值類型，類型決定了變量內存的長度和存儲格式。咱們只能修改變量，沒法改變類型

編譯後的機器碼從不使用變量名，而是直接經過內存地址訪問目標數據

定義

關鍵字 var 用於定義變量

var x int	//自動初始化爲0
var y = false	//自動推斷爲bool類型
var x,y int

多變量賦值

var x,s = 100,"abc"
var x,y = y+3,x+2

  首先計算出全部右值，而後賦值

建議以組的方式定義變量

var(
  x , y int
  a , b = 100 ,'abc'
)

簡短模式

x := 100
a,b := 1,'abc'

簡短模式限制：

  定義變量，同時顯示初始化

  不能提供數據類型

  只能用在函數內部

例：

package main 

var x = 100	//全局變量

func main(){
  println(&x,x)
  
  x:="abc"	//從新定義和初始化同名局部變量
  println(&x,x)

}
輸出
0x49a018 100	//對比內存地址
0xc420039f68 abc

簡短模式也能夠退化賦值（變量內存地址不發生改變） 

  條件：最少有一個新變量被定義，且必須是同一做用域

編譯器將未使用局部變量看成錯誤

命名

以字母或下劃線開始，由多個字母，數字，下劃線組成

空標識符

「_」 一般做爲忽略佔位符使用,沒法讀取其內容

常量 const 

const x,y int = 123,0x22
const c = '哦'

常量定義 右值不能超出常量類型取值範圍，不然會溢出

常量能夠是某些編譯器能計算出結果的表達式

常量組不知定類型和初始值，則與上一行非空常量右值相同

例

const(
  x  uint16 = 120
  y
  s = "abc"
  z
)

枚舉 

藉助iota 標識符實現一組自增常量

const(
  x = iota //0
  y	//1
  z	//2
)
const(
  _,_ = iota,iota * 10	//0, 0*10
  a,b	//1, 1*10 
  c,d	//2, 2*10
)

中斷iotaz自增

const(
  a = iota	//0
  b	//1
  c = 100 //100
  d	//100
  e = iota	//4 恢復iota自增
  f	//5
)

自增默認數據類型 int 可顯示指定類型

建議用自定義類型實現用途明確的枚舉類型。但不能將取值範圍限定在預約義的枚舉內

數字常量不會分配存儲空間。

基本類型

長度

bool	    
byte             uint8
int,uint         32或64 依據平臺
int8,uint8       -128~127,0~255
int16,uint16     -32768~32767,0~65535
int32,uint32     -21億~21億，0~42億
int64,uint64    
float32	        
float64
complex64
complex128
rune             Unicode Code Point,int32
uintptr          足以存儲指針的uint
string
array            數組
struct           結構體
function         函數
interface        接口
map              字典
slice            切片
channel          通道

標準庫math  定義了各類數字類型的取值範圍

標準庫strconv 可在不一樣進制（字符串）間轉換

例：

package main

import "strconv"

func main(){
  a,_:=strconv.ParseInt("1100100",2,32)
  println (a)
  println("0b" + strconv.FormatInt(a,2))
}
輸出
100
0b1100100

別名：

byte   alias for uint8
rune   alias for int32

引用類型：特指 slice,map,channel

內置函數 new按指定類型長度分配零值內存，返回指針，並不關心類型內部構造和初始化方式

new 爲引用分配內存，但建立不完整。

引用類型必須使用make函數建立

例：

package main

func mkslice() []int{
  s := make([]int,0,10)
  s = append(s,100)
  return s
}
func mkmap() map[string]int {
  m := make(map[string]int)
  m["a"] = 1
  return m
}
func main(){
  m := mkmap()
  println(m["a"])
  
  s := mkslice()
  println(s[0])

}
輸出：
1
100

類型轉換

除常量，別名類型以及未命名類型

GO強制要求使用顯式類型轉換

混合類型表達式必須確保類型一致

不能將非bool類型結果看成 true/false

若是轉換目標是指針，單向通道或沒有返回值的函數類型，那麼必須使用括號

用括號，讓編譯器將*int解析爲指針類型

(*int)(p)	*(int(p))
(<-chan int)(c)	<-(chan int(c))
(func())(x)	func() x

自定義類型

使用type定義用戶自定義類型

type flags byte

多個type定義能夠合併成組

type(
  user struct{
    name string
    age uint8
  }
  event func(string) bool
)

自定義類型只代表有相同的底層數據結構，屬徹底不一樣的兩種類型

不會繼承基礎類型的其餘信息（包括方法）不能視道別名，不能隱式轉換，不能直接用於比較表達式

例：

type data int
var d data = 10
var x int = d //錯誤

 

未命名類型

數組，切片，字典，通道燈類型與具體元素類型或長度等屬性有關，故稱做未未命名類型。也能夠用type爲其提供具體的名稱，將其變爲命名類型

具備相同聲明的未命名類型稱爲同一類型

具備相同基類型的 指針

具備相同元素類型和長度的 數組（array）

具備相同元素類型 切片（slice）

具備相同鍵值類型 字典（map）

具備相同數據類型及操做方向 通道（channel）

具備形同字段序列（字段名，字段類型，標籤，以及字段順序）結構體（struct）

具備相同簽名（參數和返回值列表，不包括參數名） 函數（func）

具備相同方法集（方法名，方法簽名，不包括順序） 接口（interface）

例：

var a struct{
  x int 'x'
}
var b struct{
  x int
}
b=a //錯誤

var a func(int,string)
var b func(string,int)
a=b	//錯誤  參數順序也屬於簽名

未命名類型轉換規則

所屬類型相同

基礎類型相同，且其中一個是未命名類型

數據類型相同，將雙向通道賦值給單向通道，且其中一個爲未命名類型

將默認值 nil 賦值給切片，字典，通道，指針，函數或接口

對象實現了接口

例：

type data [2]int
var d data = [2]int{1,2}	//基礎類型相同，右爲未命名類型

a:=make(chan int,2)
var b chan <- int = a	//雙向通道轉換爲單向通道，b爲未命名類型