Golang里面變量總的來說分四大類型

1. bool，string

bool：指布爾類型，也就是true, false
string: 字符串類型

2. (u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr

int 和 uint, 其中有u和沒有u指的是unsigned指的是有無符號，也就是有無正負號，int類型會根據(jù)你操作系統(tǒng)的字數(shù)來判斷是32位還是64位，如果你的操作系統(tǒng)是64位的，那么在定義int的時候就是64位，也就是你定義int的時候編譯器會根據(jù)你的操作系統(tǒng)來給這個變量自動分配多大的空間大小。
(u)int8, (u)int16, (u)int32, (u)int64這些后面的8, 16, 32, 64這些是指你定義的變量的大小，8 就是8位，這里的8位指的是二進制中的8位，同理16, 32, 64也是一樣的道理，位數(shù)越多，變量能便是的范圍越大。
uintptr是指針類型，Go語言也是具有指針這一特性的，但是并沒有像c語言使用那么的復雜。后會深究這個類型。

3. byte, rune

byte類型你可以看作是uint8的一個別名，byte和uint8表示的范圍是一樣的，也可以叫做字節(jié)類型，byte,最大能表示的范圍也就是一個字節(jié)的空間大小。
rune是一個新的數(shù)據(jù)類型，因為你在其他的語言中并沒有見過這種類型，相對來說也比較陌生，但是我舉個例子你就能完全明白了，在c語言中，有char這個類型，是用來便是一個ASCII字符的，但是是隨著編程知識的普及，很多國家的人們都在學習編程，編寫程序，但是語言就成為來一大障礙，僅僅用ASCII編碼是遠遠不能滿足人們的需求的，故Go語言就是用了Unicode編碼，rune也就相當于是在Unicode編碼下的字符類型。
rune的長度是32位的，我們都知道unicode是2字節(jié)的，但是互聯(lián)網(wǎng)中很多時候都是使用的UTF-8編碼，所以我們rune類型采用了4字節(jié)的存儲空間，如果后期Go會升級成UTF-8編碼提供了可能。
在c語言中，我們都知道char是可以和整型混用的，舉個例子：printf("%c",97);輸出的是小寫字母a。那么rune類型也是可以類似的使用的。

4. float32, float64, complex64, complex128

float32和float64都是浮點數(shù)類型，float32大約可以提供小數(shù)點后6位的精度，作為對比，float64可以提供小數(shù)點后15位的精度。如果想探究浮點數(shù)在計算機中的存儲形式可以百度一下。
complex64和complex128就是用來表示我們數(shù)學中的復數(shù)，復數(shù)實部和虛部，complex64的實部和虛部都是32位float，complex128的實部和虛部都是64位float。

Golang的變量定義方式

package main

import "fmt"

var bb uint8 = 12
var xx = 12
var (
  cc = 12
  q, w = 12, 12
  b string = "false"
)
func variableZoreValue() {
  var a int
  var b string
  fmt.Println(a, b)
}

func variableInitialValue() {
  var a int = 1
  n, x := 1, 2
  var s string = "abc"
  fmt.Println(a, s)
  fmt.Println(n, x)
}
func main() {
  variableZoreValue()
  variableInitialValue()
  fmt.Println(bb, xx, cc, q, w, b)
}

我們定義的變量可以在函數(shù)內(nèi)也可以在函數(shù)外，在函數(shù)外部定義的變量并不是全局變量，應該是叫做包內(nèi)變量，因為是在一個包下面。

定義一個變量：

var a int這種定義方式指明了變量的類型，沒有初始化，但是我們的編譯器會幫你初始化為0
var a int = 16這種方式是相比上一種方式多了初始化。
var a = 12這種方式?jīng)]有指定類型，但是初始化了一個值12，這種方式編譯器會自動的識別是那種類型，就像python里面一樣，不需要指定類型。
a := 12這種方式和上一種類似，但是更加方便，不用寫前面的var了。

定義多個變量

var bb,cc uint8 = 12, 13這種方式可以定義多個相同類型的變量
var z, str = 14, "string"這種方式比上一種方式更好好用，因為這樣可以同時定義多個不同類型的數(shù)據(jù)了。
n, x := 1, 2這種方式比上一種方式更加方便，不僅可以同時定義多個不同類型的變量同時不用寫var關鍵字了。

complex 復數(shù)類型

package main

import (
  "fmt"
  "math/cmplx"
  "math"
)

func complexVariable() {
  c := 3 + 4i
  fmt.Println("|3 + 4i|=",cmplx.Abs(c))
  fmt.Println(cmplx.Pow(math.E, 1i * math.Pi) + 1)
  fmt.Println(cmplx.Exp(1i * math.Pi) + 1)
  fmt.Printf("%0.3f", cmplx.Exp(1i * math.Pi) + 1)
}
func main() {
  complexVariable()
}

c := 3 + 4i,我們在定義復數(shù)的時候應該是這種形式而不是：c := 3 + 4*i，如果是這樣的形式，則編譯器會把這個i當作是變量處理，而不是復數(shù)標志
cmplx.Abs(c),取復數(shù)的絕對值
cmplx.Pow(math.E, 1i * math.Pi) + 1，計算e^(iπ)+1,e是數(shù)學中的自然數(shù)。
cmplx.Exp(1i * math.Pi) + 1,另外一種計算方式
fmt.Printf("%0.3f", cmplx.Exp(1i * math.Pi) + 1)格式化輸出復數(shù)。

常量的定義

package main

import (
  "fmt"
  "math"
)
c consts() {
  var filename = "1.txt"
  const a, b = 3, 4
  var c int = 0
  c = int(math.Sqrt((a*a + b*b)))
  fmt.Println(filename, c)
}
func main() {
  consts()
}

Go語言中的常量是和c語言中的宏常量是一樣的，本著替換的原則，所以如果在定義常量的時候編譯器不用指定類型，所以在c = int(math.Sqrt((a*a + b*b)))中就不用把(a*a + b*b)強轉(zhuǎn)為float64。
在定義變量的規(guī)則中對常量也是適用的，我就不多講了，自己去實踐下就知道了。

定義枚舉類型

在Go語言中并沒有針對枚舉類型的關鍵字的，那Go語言是怎么定義枚舉類型的呢？

package main

import "fmt"

func enums() {
  const(
    c = 0
    cpp = 1
    java = 2
    python = 3
  )
  fmt.Println(c, cpp, java, python)
}
func main() {
  enums()
}

這樣我們便定義了一個枚舉同時還可以使用iota關鍵字，表示這個枚舉類型是遞增的

package main

import "fmt"

func enums() {
  const(
    c = iota
    cpp
    java
    python
  )
  fmt.Println(c, cpp, java, python)
}
func main() {
  enums()
}

更高級的定義方法：

// 定義b kb mb gb tb pb
const(
  b = 1  (10 * iota)
  kb
  mb
  gb
  tb
  pb
)

iot想得到與從0開始的給自增值，你要我們寫寫出表達式再復雜的枚舉類型都可以使用這樣的方式來定義常量。

總結(jié)

在Go語言的變量常量定義中，變量的類型標識是寫的變量名的后邊，編譯器可以自動推測你需要定義變量的類型的，前提是你要初始化變量，沒有char只有rune，原生態(tài)的支持復數(shù)這種類型。