1、標識符與關鍵字

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

1.1 標識符

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

1.2 關鍵字

關鍵字是指語言預先定義好的具有特殊含義的標識符。 關鍵字和保留字都不建議用作變量名。

Go語言有25個關鍵字：

    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)存上對應的數(shù)據(jù)了。

所以變量的本質就是一小塊內(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)不支持重復聲明。 并且Go語言的變量聲明后必須使用，否則無法通過編譯。

標準聲明：

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

var 變量名 變量類型

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

var name string
var age int
var isTrue bool

批量聲明：

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

var (
    a string
    b int
    c bool
    d float32
)

變量的初始化：

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

當然也可在聲明變量的時候為其指定初始值。變量初始化的標準格式如下：

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

或者一次初始化多個變量

var name, age = "golang", 20

類型推導：

有時候會將變量的類型省略，這個時候編譯器會根據(jù)等號右邊的值來推導變量的類型完成初始化。

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)存，所以匿名變量之間不存在重復聲明。

注意事項：

• 函數(shù)外的每個語句都必須以關鍵字開始（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ù)型、浮點型和復數(shù)）和字符串型
• 不曾使用的常量，在編譯的時候，是不會報錯的
• 顯示指定類型的時候，必須確保常量左右值類型一致，需要時可做顯示類型轉換。這與變量就不一樣了，變量是可以是不同的類型值

3.1 iota

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

iota在const關鍵字出現(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ù)組、切片、結構體、函數(shù)、map、通道（channel）等。

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

4.1 整型

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

其中，uint8就是byte型，int16對應C語言中的short型，int64對應C語言中的long型。

注意： 在使用int和 uint類型時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。除非需要使用特定大小的整數(shù)，否則通常應該使用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é)長度的影響，不要使用int和 uint。

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

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

v := 0b00101101， 代表二進制的 101101，相當于十進制的 45。 v := 0o377，代表八進制的 377，相當于十進制的 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標準： 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 復數(shù)

complex64和complex128

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

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

4.4 布爾值

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

注意：

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

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 := "你好"

字符串轉義符：

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

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

多行字符串：

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

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

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

字符串的常用操作：

4.6 byte和rune類型

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

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

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

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

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

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

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

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

修改字符串：

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

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

4.7 類型轉換

Go語言中只有強制類型轉換，沒有隱式類型轉換。該語法只能在兩個類型之間支持相互轉換的時候使用。

強制類型轉換的基本語法如下：

T(表達式)

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

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

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

5、運算符

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

• 算術運算符
• 關系運算符
• 邏輯運算符
• 位運算符
• 賦值運算符

5.1 算數(shù)運算符

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

5.2 關系運算符

5.3 邏輯運算符

5.4 位運算符

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

5.5 賦值運算符

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

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

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

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

最新評論