Go語言數據類型

Go語言數據類型

變量

關鍵字var用來定義變量，有兩種定義方式，如下：

• 顯式定義法：

  var num int
  num = 123
  var word string
  word = "abc"

• 隱式定義法：只能在函數內部這樣定義使用

  num := 123
  word := "abc"

• 退化賦值：前提條件是--最少有一個新的變量被定義，且必須是同一作用域

  package main
  import(
  "log"
  "os"
  )
  func main(){
  f,err := os.Open("/dev/random")
  buf := make([]byte,1024)
  n,err = f.Read(buf) 
  }

• 多變量賦值

  x,y := 123,"add"

  變量命名

• 以字母或者下劃線開始，然後再由多個字母，數字和下劃線組成
• 區分大小寫
• 駝峯樣式命名
• 局部變量優先使用短名
• 專有名詞要大寫

• 避免使用系統關鍵字

  常量

  常量值必須是編譯期間可以確定的數字、符號，字符串或者布爾值。可以指定常量類型或者由編譯器通過初始化值推斷。常量是隻讀的。
  常量不像是變量一樣在運行期間分配存儲內存，通常會在編譯器預處理階段展開，作爲指令數據使用。

• 定義方法如下：

  package main
  import "fmt"
  func main(){
  const(
      a   = 120
      b
      c = "FUNK "
      d
  )
  fmt.Printf("%T,%v\n",a,b)
  fmt.Printf("%T,%v\n",c,d)
  }
  )

  枚舉

  Go沒有明確的enmu的定義，但是藉助iota來實現一組自增的枚舉類型

  package main
  import "fmt"
  func main(){
  const(
  a = iota
  b // 1
  c // 2
  d // 3
  )
  fmt.Printf("%T,%v\t%v\t%v\t",a,b,c,d)
  }

  基本類型

類型	長度	默認值	說明
bool	1	false
byte	1	0	unit8
int,unit	4,8	0	默認整數類型
int8,unit8	1	0	-128~127,0~255
int16,uint16	2	0	-32768~32767,0~65535
int32,uint32	4	0	-21億~21億，0~42億
int64,uint64	8	0
float32	4	0.0
float64	8	0.0	默認浮點類型
complex64	8
complex128	16
rune	4	0	unicode point,int32
unitptr	4,8	0	足以存指針

支持八進制，十六進制，以及科學計數法的math模塊小例子如下：

package main

import (
    "fmt"
    "math"
)
func main(){
    //二進制，八進制，十六進制以及int8長度小例子
    a,b,c := 102,0132,0x33
    fmt.Printf("0b%b,%#o,%#x\n",a,b,c)
    fmt.Println(math.MinInt8,math.MaxInt8)
    //浮點數小例子：要注意小數位的精度
    var d float32 = 12.34141592777
    var e float64 = 12.344566346516346145453453454546562111
    var f float32 = 12.6
    fmt.Println(d,e,f)
    fmt.Printf("%v---%v----%v",d,e,f)
}

引用類型

主要是特指一下的三種類型：

• slice
• map
• channel

  相比數字，數組等類型，引用類型具有更復雜的存儲結構，除了內存分配之外，他們還初始化一系列屬性，諸如指針，長度，甚至包含哈希分佈，數據隊列等

內置函數new按照指定的類型長度分配零值內存，返回指針。並不關心類型內部構造和初始化方式。而引用類型則必須使用make函數創建，編譯器會將make轉換爲目標類型專用的創建函數（指令），以確保完成內部內存分配和相關屬性的初始化。

package main
import(
    "fmt"
)
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()
    fmt.Println(m["a"])
    s := mkslice()
    fmt.Println(s[0])
}

new函數可以爲引用類型分配內存，但這是不完整創建。以字典爲例，它僅僅分配了字典類型本身所需要的內存，但沒有分配鍵值存儲的內存，也沒有初始化散列桶等內部屬性，因此無法正常工作.

package main
import(
    "fmt"
)
func main(){
    p := new(map[string]int}
    m := *p
    m["a"] = 1
    fmt.Println(m)

類型轉換

隱式轉換造成的問題要遠大於顯式轉換，除了常量，別名類型以及未命名類型外，go還強制要求使用顯式類型轉換，加上不支持操作符重載，所以我們總是能確定語句表達的明確含義。

自定義類型

使用關鍵字type定義用戶自定義數據類型，包括基於現有基礎類型的構建，或者是結構體，函數類型等。