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

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

1.1 標(biāo)識符

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

1.2 關(guān)鍵字

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

Go語言有25個關(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個保留字

    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 什么是變量

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

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

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

2.2 變量類型

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

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

2.3 變量聲明

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

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

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

var 變量名 變量類型

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

var name string
var age int
var isTrue bool

批量聲明：

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

var (
    a string
    b int
    c bool
    d float32
)

變量的初始化：

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

當(dāng)然也可在聲明變量的時候為其指定初始值。變量初始化的標(biāo)準(zhǔn)格式如下：

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

或者一次初始化多個變量

var name, age = "golang", 20

類型推導(dǎo)：

有時候會將變量的類型省略，這個時候編譯器會根據(jù)等號右邊的值來推導(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)
}

匿名變量：

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

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

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

注意事項：

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

3、常量

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

const pi = 3.1415
const e = 2.7182

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

多個常量也可以一起聲明：

const (
    pi = 3.1415
    e = 2.7182
)

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

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
}

常量的注意事項：

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

3.1 iota

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

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

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

幾個常見的iota示例:

使用_跳過某些值

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

iota聲明中間插隊

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

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

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

多個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ù)類型，除了基本的整型、浮點型、布爾型、字符串外，還有數(shù)組、切片、結(jié)構(gòu)體、函數(shù)、map、通道（channel）等。

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

4.1 整型

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

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

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

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

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

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

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

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

將一個整數(shù)以不同進制形式展示：

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

4.2 浮點型

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

打印浮點數(shù)時，可以使用fmt包配合動詞%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ù)有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

4.4 布爾值

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

注意：

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

4.5 字符串

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

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

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

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

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

多行字符串：

定義一個多行字符串時，就必須使用反引號字符：

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

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

字符串的常用操作：

4.6 byte和rune類型

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

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

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

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

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

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

因為UTF8編碼下一個中文漢字由3~4個字節(jié)組成，所以不能簡單的按照字節(jié)去遍歷一個包含中文的字符串

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

修改字符串：

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

func changeString() {
 s1 := "big"
 // 強制類型轉(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語言中只有強制類型轉(zhuǎn)換，沒有隱式類型轉(zhuǎn)換。該語法只能在兩個類型之間支持相互轉(zhuǎn)換的時候使用。

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

T(表達式)

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

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

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

5、運算符

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

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

5.1 算數(shù)運算符

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

5.2 關(guān)系運算符

5.3 邏輯運算符

5.4 位運算符

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

5.5 賦值運算符

5.6 運算符優(yōu)先級

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

當(dāng)然，可以通過使用括號來臨時提升某個表達式的整體運算優(yōu)先級。

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

最新評論