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指的是有無符號，也就是有無正負(fù)號，int類型會根據(jù)你操作系統(tǒng)的字?jǐn)?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語言使用那么的復(fù)雜。后會深究這個類型。

3. byte, rune

byte類型你可以看作是uint8的一個別名，byte和uint8表示的范圍是一樣的，也可以叫做字節(jié)類型，byte,最大能表示的范圍也就是一個字節(jié)的空間大小。
rune是一個新的數(shù)據(jù)類型，因為你在其他的語言中并沒有見過這種類型，相對來說也比較陌生，但是我舉個例子你就能完全明白了，在c語言中，有char這個類型，是用來便是一個ASCII字符的，但是是隨著編程知識的普及，很多國家的人們都在學(xué)習(xí)編程，編寫程序，但是語言就成為來一大障礙，僅僅用ASCII編碼是遠(yuǎn)遠(yuǎn)不能滿足人們的需求的，故Go語言就是用了Unicode編碼，rune也就相當(dāng)于是在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ù)學(xué)中的復(fù)數(shù)，復(fù)數(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ù)外部定義的變量并不是全局變量，應(yīng)該是叫做包內(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關(guān)鍵字了。

complex 復(fù)數(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,我們在定義復(fù)數(shù)的時候應(yīng)該是這種形式而不是：c := 3 + 4*i，如果是這樣的形式，則編譯器會把這個i當(dāng)作是變量處理，而不是復(fù)數(shù)標(biāo)志
cmplx.Abs(c),取復(fù)數(shù)的絕對值
cmplx.Pow(math.E, 1i * math.Pi) + 1，計算e^(iπ)+1,e是數(shù)學(xué)中的自然數(shù)。
cmplx.Exp(1i * math.Pi) + 1,另外一種計算方式
fmt.Printf("%0.3f", cmplx.Exp(1i * math.Pi) + 1)格式化輸出復(fù)數(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語言中并沒有針對枚舉類型的關(guān)鍵字的，那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關(guān)鍵字，表示這個枚舉類型是遞增的

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開始的給自增值，你要我們寫寫出表達(dá)式再復(fù)雜的枚舉類型都可以使用這樣的方式來定義常量。

總結(jié)

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