Golang里面變量總的來(lái)說(shuō)分四大類型

1. bool，string

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

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

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

3. byte, rune

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

4. float32, float64, complex64, complex128

float32和float64都是浮點(diǎn)數(shù)類型，float32大約可以提供小數(shù)點(diǎn)后6位的精度，作為對(duì)比，float64可以提供小數(shù)點(diǎn)后15位的精度。如果想探究浮點(diǎn)數(shù)在計(jì)算機(jī)中的存儲(chǔ)形式可以百度一下。
complex64和complex128就是用來(lái)表示我們數(shù)學(xué)中的復(fù)數(shù)，復(fù)數(shù)實(shí)部和虛部，complex64的實(shí)部和虛部都是32位float，complex128的實(shí)部和虛部都是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)變量，因?yàn)槭窃谝粋€(gè)包下面。

定義一個(gè)變量：

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

定義多個(gè)變量

var bb,cc uint8 = 12, 13這種方式可以定義多個(gè)相同類型的變量
var z, str = 14, "string"這種方式比上一種方式更好好用，因?yàn)檫@樣可以同時(shí)定義多個(gè)不同類型的數(shù)據(jù)了。
n, x := 1, 2這種方式比上一種方式更加方便，不僅可以同時(shí)定義多個(gè)不同類型的變量同時(shí)不用寫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,我們?cè)诙x復(fù)數(shù)的時(shí)候應(yīng)該是這種形式而不是：c := 3 + 4*i，如果是這樣的形式，則編譯器會(huì)把這個(gè)i當(dāng)作是變量處理，而不是復(fù)數(shù)標(biāo)志
cmplx.Abs(c),取復(fù)數(shù)的絕對(duì)值
cmplx.Pow(math.E, 1i * math.Pi) + 1，計(jì)算e^(iπ)+1,e是數(shù)學(xué)中的自然數(shù)。
cmplx.Exp(1i * math.Pi) + 1,另外一種計(jì)算方式
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語(yǔ)言中的常量是和c語(yǔ)言中的宏常量是一樣的，本著替換的原則，所以如果在定義常量的時(shí)候編譯器不用指定類型，所以在c = int(math.Sqrt((a*a + b*b)))中就不用把(a*a + b*b)強(qiáng)轉(zhuǎn)為float64。
在定義變量的規(guī)則中對(duì)常量也是適用的，我就不多講了，自己去實(shí)踐下就知道了。

定義枚舉類型

在Go語(yǔ)言中并沒(méi)有針對(duì)枚舉類型的關(guān)鍵字的，那Go語(yǔ)言是怎么定義枚舉類型的呢？

package main

import "fmt"

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

這樣我們便定義了一個(gè)枚舉同時(shí)還可以使用iota關(guān)鍵字，表示這個(gè)枚舉類型是遞增的

package main

import "fmt"

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

更高級(jí)的定義方法：

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

iot想得到與從0開(kāi)始的給自增值，你要我們寫寫出表達(dá)式再?gòu)?fù)雜的枚舉類型都可以使用這樣的方式來(lái)定義常量。

總結(jié)

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