1、標(biāo)識(shí)符與關(guān)鍵字

在了解數(shù)據(jù)類型之前，先了解一下go的標(biāo)識(shí)符和關(guān)鍵字

1.1 標(biāo)識(shí)符

在編程語言中標(biāo)識(shí)符就是定義的具有某種意義的詞，比如變量名、常量名、函數(shù)名等等。 Go語言中標(biāo)識(shí)符允許由字母數(shù)字和_(下劃線）組成，并且只能以字母和_開頭：abc , _ , _123, a123。

1.2 關(guān)鍵字

關(guān)鍵字是指語言預(yù)先定義好的具有特殊含義的標(biāo)識(shí)符。 關(guān)鍵字和保留字都不建議用作變量名。

Go語言有25個(gè)關(guān)鍵字：

    break        default      func         interface    select
    case         defer        go           map          struct
    chan         else         goto         package      switch
    const        fallthrough  if           range        type
    continue     for          import       return       var

Go語言中有37個(gè)保留字

    Constants:    true  false  iota  nil
 
        Types:    int  int8  int16  int32  int64  
                  uint  uint8  uint16  uint32  uint64  uintptr
                  float32  float64  complex128  complex64
                  bool  byte  rune  string  error
 
    Functions:   make  len  cap  new  append  copy  close  delete
                 complex  real  imag
                 panic  recover

2、變量

2.1 什么是變量

程序運(yùn)行過程中的數(shù)據(jù)都是保存在內(nèi)存中，想要在代碼中操作某個(gè)數(shù)據(jù)時(shí)就需要去內(nèi)存上找到這個(gè)變量，但是如果直接在代碼中通過內(nèi)存地址去操作變量的話，代碼的可讀性會(huì)非常差而且還容易出錯(cuò)，所以就利用變量將這個(gè)數(shù)據(jù)的內(nèi)存地址保存起來，以后直接通過這個(gè)變量就能找到內(nèi)存上對(duì)應(yīng)的數(shù)據(jù)了。

所以變量的本質(zhì)就是一小塊內(nèi)存，用于存儲(chǔ)數(shù)據(jù)，在程序運(yùn)行過程中數(shù)值可以改變

變量是為存儲(chǔ)特定類型的值而提供給內(nèi)存位置的名稱。在go中聲明變量有多種語法。

2.2 變量類型

變量（Variable）的功能是存儲(chǔ)數(shù)據(jù)。不同的變量保存的數(shù)據(jù)類型可能會(huì)不一樣。常見變量的數(shù)據(jù)類型有：整型、浮點(diǎn)型、布爾型等。

Go語言中的每一個(gè)變量都有自己的類型，并且變量必須經(jīng)過聲明才能開始使用。

2.3 變量聲明

Go語言中的變量需要聲明后才能使用，同一作用域內(nèi)不支持重復(fù)聲明。 并且Go語言的變量聲明后必須使用，否則無法通過編譯。

標(biāo)準(zhǔn)聲明：

Go語言的變量聲明格式為：

var 變量名 變量類型

變量聲明以關(guān)鍵字var開頭，變量類型放在變量的后面，行尾無需分號(hào)：

var name string
var age int
var isTrue bool

批量聲明：

每聲明一個(gè)變量就需要寫var關(guān)鍵字會(huì)比較繁瑣，go語言中還支持批量變量聲明：

var (
    a string
    b int
    c bool
    d float32
)

變量的初始化：

Go語言在聲明變量的時(shí)候，會(huì)自動(dòng)對(duì)變量對(duì)應(yīng)的內(nèi)存區(qū)域進(jìn)行初始化操作。每個(gè)變量會(huì)被初始化成其類型的默認(rèn)值，即零值，例如： 整型和浮點(diǎn)型變量的默認(rèn)值為0。 字符串變量的默認(rèn)值為空字符串。 布爾型變量默認(rèn)為false。 切片、函數(shù)、指針變量的默認(rèn)為nil。

當(dāng)然也可在聲明變量的時(shí)候?yàn)槠渲付ǔ跏贾怠?strong>變量初始化的標(biāo)準(zhǔn)格式如下：

var 變量名 類型 = 表達(dá)式
var name string = "golang"
var age int = 18

或者一次初始化多個(gè)變量

var name, age = "golang", 20

類型推導(dǎo)：

有時(shí)候會(huì)將變量的類型省略，這個(gè)時(shí)候編譯器會(huì)根據(jù)等號(hào)右邊的值來推導(dǎo)變量的類型完成初始化。

var name = "golang"
var age = 18

短變量聲明：

在函數(shù)內(nèi)部，可以使用更簡略的 := 方式聲明并初始化變量。

// 全局變量m
var m = 100
 
func main() {
 n := 10
 m := 200 // 此處聲明局部變量m
 fmt.Println(m, n)
}

匿名變量：

在使用多重賦值時(shí)，如果想要忽略某個(gè)值，可以使用匿名變量（anonymous variable）。 匿名變量用一個(gè)下劃線_表示，例如：

func foo() (int, string) {
 return 10, "golang"
}
func main() {
 x, _ := foo()
 _, y := foo()
 fmt.Println("x=", x)
 fmt.Println("y=", y)
}

匿名變量不占用命名空間，不會(huì)分配內(nèi)存，所以匿名變量之間不存在重復(fù)聲明。

注意事項(xiàng)：

• 函數(shù)外的每個(gè)語句都必須以關(guān)鍵字開始（var、const、func等）
• :=不能使用在函數(shù)外，不能定義全局變量，并且左邊的變量名至少有一個(gè)是新的。
• _多用于占位，表示忽略值。
• 變量必須先定義才能使用，定義了就一定要使用。
• 變量的類型和賦值的類型必須一致。
• 變量名在同一個(gè)作用于域內(nèi)不能沖突。

3、常量

相對(duì)于變量，常量是恒定不變的值，多用于定義程序運(yùn)行期間不會(huì)改變的那些值。 常量的聲明和變量聲明非常類似，只是把var換成了const，常量在定義的時(shí)候必須賦值。

const pi = 3.1415
const e = 2.7182

聲明了pi和e這兩個(gè)常量之后，在整個(gè)程序運(yùn)行期間它們的值都不能再發(fā)生變化了。

多個(gè)常量也可以一起聲明：

const (
    pi = 3.1415
    e = 2.7182
)

const同時(shí)聲明多個(gè)常量時(shí)，如果省略了值則表示和上面一行的值相同。 例如：

const (
    n1 = 100
    n2
    n3
)

上面示例中，常量n1、n2、n3的值都是100。

常量可以作為枚舉，常量組

const (
    Unknown = 0
    Female = 1
    Male = 2
)

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

func main() {
 const (
  x uint16 = 16
  y
  s = "abc"
  z
 )
 fmt.Printf("%T,%v\n", y, y) //uint16,16
 fmt.Printf("%T,%v\n", z, z) //string,abc
}

常量的注意事項(xiàng)：

• 常量中的數(shù)據(jù)類型只可以是布爾型、數(shù)字型（整數(shù)型、浮點(diǎn)型和復(fù)數(shù)）和字符串型
• 不曾使用的常量，在編譯的時(shí)候，是不會(huì)報(bào)錯(cuò)的
• 顯示指定類型的時(shí)候，必須確保常量左右值類型一致，需要時(shí)可做顯示類型轉(zhuǎn)換。這與變量就不一樣了，變量是可以是不同的類型值

3.1 iota

iota是go語言的常量計(jì)數(shù)器，是特殊的常量，只能在常量的表達(dá)式中使用。

iota在const關(guān)鍵字出現(xiàn)時(shí)將被重置為0。const中每新增一行常量聲明將使iota計(jì)數(shù)一次(iota可理解為const語句塊中的行索引)。 使用iota能簡化定義，在定義枚舉時(shí)很有用。

const (
  n1 = iota //0
  n2        //1
  n3        //2
  n4        //3
 )

幾個(gè)常見的iota示例:

使用_跳過某些值

const (
  n1 = iota //0
  n2        //1
  _
  n4        //3
 )

iota聲明中間插隊(duì)

const (
  n1 = iota //0
  n2 = 100  //100
  n3 = iota //2
  n4        //3
 )
 const n5 = iota //0

定義數(shù)量級(jí) （這里的<<表示左移操作，1<<10表示將1的二進(jìn)制表示向左移10位，也就是由1變成了10000000000，也就是十進(jìn)制的1024。同理2<<2表示將2的二進(jìn)制表示向左移2位，也就是由10變成了1000，也就是十進(jìn)制的8。）

const (
  _  = iota
  KB = 1 << (10 * iota)
  MB = 1 << (10 * iota)
  GB = 1 << (10 * iota)
  TB = 1 << (10 * iota)
  PB = 1 << (10 * iota)
 )

多個(gè)iota定義在一行

const (
  a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2
  c, d                      //iota = 1、c = 2, d = 3
  e, f                      //iota = 2、e = 3, f = 4
 )

Go語言中有豐富的數(shù)據(jù)類型，除了基本的整型、浮點(diǎn)型、布爾型、字符串外，還有數(shù)組、切片、結(jié)構(gòu)體、函數(shù)、map、通道（channel）等。

4、基本數(shù)據(jù)類型

4.1 整型

整型分為以下兩個(gè)大類： 按長度分為：int8、int16、int32、int64 對(duì)應(yīng)的無符號(hào)整型：uint8、uint16、uint32、uint64

其中，uint8就是byte型，int16對(duì)應(yīng)C語言中的short型，int64對(duì)應(yīng)C語言中的long型。

注意： 在使用int和 uint類型時(shí)，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺(tái)上的差異。除非需要使用特定大小的整數(shù)，否則通常應(yīng)該使用int來表示整數(shù)。 大小:32位系統(tǒng)32位，64位系統(tǒng)64位。 范圍:-2147483648到2147483647的32位系統(tǒng)和-9223372036854775808到9223372036854775807的64位系統(tǒng)。

注意事項(xiàng) 獲取對(duì)象的長度的內(nèi)建len()函數(shù)返回的長度可以根據(jù)不同平臺(tái)的字節(jié)長度進(jìn)行變化。實(shí)際使用中，切片或 map 的元素?cái)?shù)量等都可以用int來表示。在涉及到二進(jìn)制傳輸、讀寫文件的結(jié)構(gòu)描述時(shí)，為了保持文件的結(jié)構(gòu)不會(huì)受到不同編譯目標(biāo)平臺(tái)字節(jié)長度的影響，不要使用int和 uint。

數(shù)字字面量語法（Number literals syntax）

Go1.13版本之后引入了數(shù)字字面量語法，這樣便于開發(fā)者以二進(jìn)制、八進(jìn)制或十六進(jìn)制浮點(diǎn)數(shù)的格式定義數(shù)字，例如：

v := 0b00101101， 代表二進(jìn)制的 101101，相當(dāng)于十進(jìn)制的 45。 v := 0o377，代表八進(jìn)制的 377，相當(dāng)于十進(jìn)制的 255。 v := 0x1p-2，代表十六進(jìn)制的 1 除以 2²，也就是 0.25。

而且還允許用 _ 來分隔數(shù)字，比如說： v := 123_456 表示 v 的值等于 123456。

將一個(gè)整數(shù)以不同進(jìn)制形式展示：

func main(){
 // 十進(jìn)制
 var a int = 10
 fmt.Printf("%d \n", a)  // 10
 fmt.Printf("%b \n", a)  // 1010  占位符%b表示二進(jìn)制
 
 // 八進(jìn)制  以0開頭
 var b int = 077
 fmt.Printf("%o \n", b)  // 77
 
 // 十六進(jìn)制  以0x開頭
 var c int = 0xff
 fmt.Printf("%x \n", c)  // ff
 fmt.Printf("%X \n", c)  // FF
}

4.2 浮點(diǎn)型

Go語言支持兩種浮點(diǎn)型數(shù)：float32和float64。這兩種浮點(diǎn)型數(shù)據(jù)格式遵循IEEE 754標(biāo)準(zhǔn)： float32 的浮點(diǎn)數(shù)的最大范圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點(diǎn)數(shù)的最大范圍約為 1.8e308，可以使用一個(gè)常量定義：math.MaxFloat64。

打印浮點(diǎn)數(shù)時(shí)，可以使用fmt包配合動(dòng)詞%f：

func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi)
}

4.3 復(fù)數(shù)

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

復(fù)數(shù)有實(shí)部和虛部，complex64的實(shí)部和虛部為32位，complex128的實(shí)部和虛部為64位。

4.4 布爾值

Go語言中以bool類型進(jìn)行聲明布爾型數(shù)據(jù)，布爾型數(shù)據(jù)只有true（真）和false（假）兩個(gè)值。

注意：

• 布爾類型變量的默認(rèn)值為false。
• 不允許將整型強(qiáng)制轉(zhuǎn)換為布爾型.
• 布爾型無法參與數(shù)值運(yùn)算，也無法與其他類型進(jìn)行轉(zhuǎn)換。

4.5 字符串

Go語言中的字符串以原生數(shù)據(jù)類型出現(xiàn)，使用字符串就像使用其他原生數(shù)據(jù)類型（int、bool、float32、float64 等）一樣。字符串的內(nèi)部實(shí)現(xiàn)使用UTF-8編碼。 字符串的值為雙引號(hào)(")中的內(nèi)容，可以在源碼中直接添加非ASCII碼字符：

s1 := "hello"
s2 := "你好"

字符串轉(zhuǎn)義符：

Go 語言的字符串常見轉(zhuǎn)義符包含回車、換行、單雙引號(hào)、制表符等，如下表所示。

func main() {
    fmt.Println("str := \"d:\\go\\go.exe\"")
}

多行字符串：

定義一個(gè)多行字符串時(shí)，就必須使用反引號(hào)字符：

s1 := `第一行
第二行
第三行
`
fmt.Println(s1)

反引號(hào)間換行將被作為字符串中的換行，但是所有的轉(zhuǎn)義字符均無效，文本將會(huì)原樣輸出。

字符串的常用操作：

4.6 byte和rune類型

組成每個(gè)字符串的元素叫做“字符”，可以通過遍歷或者單個(gè)獲取字符串元素獲得字符。 字符用單引號(hào)（'）包裹起來，如：

var a := '中'
var b := 'x'

Go 語言的字符有以下兩種：

• uint8類型，或者叫 byte 型，代表了ASCII碼的一個(gè)字符。
• rune類型，代表一個(gè) UTF-8字符。
  

當(dāng)需要處理中文、日文或者其他復(fù)合字符時(shí)，則需要用到rune類型。rune類型實(shí)際是一個(gè)int32。

Go 使用了特殊的 rune 類型來處理 Unicode，讓基于 Unicode 的文本處理更為方便，也可以使用 byte 型進(jìn)行默認(rèn)字符串處理，性能和擴(kuò)展性都有照顧。

因?yàn)閁TF8編碼下一個(gè)中文漢字由3~4個(gè)字節(jié)組成，所以不能簡單的按照字節(jié)去遍歷一個(gè)包含中文的字符串

字符串底層是一個(gè)byte數(shù)組，所以可以和[]byte類型相互轉(zhuǎn)換。字符串是不能修改的 字符串是由byte字節(jié)組成，所以字符串的長度是byte字節(jié)的長度。 rune類型用來表示utf8字符，一個(gè)rune字符由一個(gè)或多個(gè)byte組成。

修改字符串：

要修改字符串，需要先將其轉(zhuǎn)換成[]rune或[]byte，完成后再轉(zhuǎn)換為string。無論哪種轉(zhuǎn)換，都會(huì)重新分配內(nèi)存，并復(fù)制字節(jié)數(shù)組。

func changeString() {
 s1 := "big"
 // 強(qiáng)制類型轉(zhuǎn)換
 byteS1 := []byte(s1)
 byteS1[0] = 'p'
 fmt.Println(string(byteS1))
 
 s2 := "白蘿卜"
 runeS2 := []rune(s2)
 runeS2[0] = '紅'
 fmt.Println(string(runeS2))
}

4.7 類型轉(zhuǎn)換

Go語言中只有強(qiáng)制類型轉(zhuǎn)換，沒有隱式類型轉(zhuǎn)換。該語法只能在兩個(gè)類型之間支持相互轉(zhuǎn)換的時(shí)候使用。

強(qiáng)制類型轉(zhuǎn)換的基本語法如下：

T(表達(dá)式)

其中，T表示要轉(zhuǎn)換的類型。表達(dá)式包括變量、復(fù)雜算子和函數(shù)返回值等.

func sqrtDemo() {
 var a, b = 3, 4
 var c int
 // math.Sqrt()接收的參數(shù)是float64類型，需要強(qiáng)制轉(zhuǎn)換
 c = int(math.Sqrt(float64(a*a + b*b)))
 fmt.Println(c)
}

運(yùn)算符用于在程序運(yùn)行時(shí)執(zhí)行數(shù)學(xué)或邏輯運(yùn)算。

5、運(yùn)算符

Go 語言內(nèi)置的運(yùn)算符有：

• 算術(shù)運(yùn)算符
• 關(guān)系運(yùn)算符
• 邏輯運(yùn)算符
• 位運(yùn)算符
• 賦值運(yùn)算符

5.1 算數(shù)運(yùn)算符

注意： ++ （自增）和--（自減）在Go語言中是單獨(dú)的語句，并不是運(yùn)算符。

5.2 關(guān)系運(yùn)算符

5.3 邏輯運(yùn)算符

5.4 位運(yùn)算符

位運(yùn)算符對(duì)整數(shù)在內(nèi)存中的二進(jìn)制位進(jìn)行操作。

5.5 賦值運(yùn)算符

5.6 運(yùn)算符優(yōu)先級(jí)

有些運(yùn)算符擁有較高的優(yōu)先級(jí)，二元運(yùn)算符的運(yùn)算方向均是從左至右。由上至下代表優(yōu)先級(jí)由高到低：

當(dāng)然，可以通過使用括號(hào)來臨時(shí)提升某個(gè)表達(dá)式的整體運(yùn)算優(yōu)先級(jí)。

到此這篇關(guān)于Golang通脈之?dāng)?shù)據(jù)類型詳情的文章就介紹到這了,更多相關(guān)Golang 數(shù)據(jù)類型內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！