05.Go-基礎資料類型

在靜态類型語言(C++/Java/Golang 等)中規定在建立一個變量或者常量時，必須要指定出相應的資料類型，否則無法給變量配置設定記憶體。

5.1 整形

整型分兩大類

• 有符号整型：int8、int16、int32、int64、int。
• 無符号整型：uint8、uint16、uint32、uint64、uint。

示例程式：

package main

import (
	"fmt"
	"math"
	"unsafe"
)

// 有符号整型
func Integer() {
	var num8 int8 = 127
	var num16 int16 = 32767
	var num32 int32 = math.MaxInt32
	var num64 int64 = math.MaxInt64
	var num int = math.MaxInt
	fmt.Printf("num8的類型是 %T, num8的大小 %d, num8是 %d\n",
		num8, unsafe.Sizeof(num8), num8)
	fmt.Printf("num16的類型是 %T, num16的大小 %d, num16是 %d\n",
		num16, unsafe.Sizeof(num16), num16)
	fmt.Printf("num32的類型是 %T, num32的大小 %d, num32是 %d\n",
		num32, unsafe.Sizeof(num32), num32)
	fmt.Printf("num64的類型是 %T, num64的大小 %d, num64是 %d\n",
		num64, unsafe.Sizeof(num64), num64)
	fmt.Printf("num的類型是 %T, num的大小 %d, num是 %d\n",
		num, unsafe.Sizeof(num), num)
}

// 無符号整型
func unsignedInteger() {
	var num8 uint8 = 128
	var num16 uint16 = 32768
	var num32 uint32 = math.MaxUint32
	var num64 uint64 = math.MaxUint64
	var num uint = math.MaxUint
	fmt.Printf("num8的類型是 %T, num8的大小 %d, num8是 %d\n",
		num8, unsafe.Sizeof(num8), num8)
	fmt.Printf("num16的類型是 %T, num16的大小 %d, num16是 %d\n",
		num16, unsafe.Sizeof(num16), num16)
	fmt.Printf("num32的類型是 %T, num32的大小 %d, num32是 %d\n",
		num32, unsafe.Sizeof(num32), num32)
	fmt.Printf("num64的類型是 %T, num64的大小 %d, num64是 %d\n",
		num64, unsafe.Sizeof(num64), num64)
	fmt.Printf("num的類型是 %T, num的大小 %d, num是 %d\n",
		num, unsafe.Sizeof(num), num)
}

func main() {
	Integer()
	println("---------------------------------------")
	unsignedInteger()
}
           

Tips：

• 除非對整型的大小有特定的需求，否則你通常應該使用

  int

  表示整型寬度，在

  32

  位系統下是

  32

  位，而在

  64

  位系統下是

  64

  位。表示範圍：在

  32

  位系統下是

  -2147483648

  ~

  2147483647

  ，而在

  64

  位系統是

  -9223372036854775808

  ~

  9223372036854775807

  。
• 對于

  int8

  ，

  int16

  等這些類型後面有跟一個數值的類型來說，它們能表示的數值個數是固定的。是以，在有的時候：例如在二進制傳輸、讀寫檔案的結構描述(為了保持檔案的結構不會受到不同編譯目标平台位元組長度的影響)等情況下，使用更加精确的

  int32

  和

  int64

  是更好的。

5.2 浮點型

浮點型表示存儲的資料是實數，如 3.145。關于浮點型的說明，如表所示。

類型	位元組數	說明
float32	4	32 位的浮點型
float64	8	64 位的浮點型

示例程式：

func showFloat() {
	var num1 float32 = math.MaxFloat32
	var num2 float64 = math.MaxFloat64
	fmt.Printf("num1的類型是%T,num1是%g\n", num1, num1)
	fmt.Printf("num2的類型是%T,num1是%g\n", num2, num2)
}

func main() {
     showFloat()
}
           

Tips：

• 通過上面的程式，我們知道浮點數能表示的數值很大，但是浮點數的精度卻沒有那麼大：

  • float32

    的精度隻能提供大約

    6

    個十進制數(表示小數點後

    6

    位)的精度。

  • float64

    的精度能提供大約

    15

    個十進制數(表示小數點後

    15

    位)的精度。

5.3 字元

字元串中的每一個元素叫作“字元”，定義字元時使用單引号。Go 語言的字元有兩種，如表所示。

類 型	字 節 數	說 明
byte	1	表示 UTF-8 字元串的單個位元組的值，表示的是 ASCII 碼表中的一個字元，uint8 的别名類型
rune	4	表示單個 unicode 字元，int32 的别名類型

聲明示例如下：

package main

import "fmt"

func showChar() {
     var x byte = 65
     var y uint8 = 65
     fmt.Printf("x = %c\n", x)   // x = A
     fmt.Printf("y = %c\n", y)   // y = A
}

func sizeOfChar() {
    var x byte = 65
    fmt.Printf("x = %c\n", x)
    fmt.Printf("x 占用 %d 個位元組\n", unsafe.Sizeof(x))

    var y rune = 'A'
    fmt.Printf("y = %c\n", y)
    fmt.Printf("y 占用 %d 個位元組\n", unsafe.Sizeof(y))
}

func main() {
    showChar();
    sizeOfChar();
}
           

Tips：

• 由此可見， byte 類型隻能表示 2⁸個值，是以你想表示其他一些值，例如中文的話，就得使用 rune 類型

  var y rune = '牛'
             

5.4 字元串

字元串在 Go 語言中是以基本資料類型出現的，使用字元串就像使用其他原生基本資料類型 int、float32、float64、bool 一樣。

示例程式：

var study string  	 		// 定義名為str的字元串類型變量
study = "《Go語言極簡一本通》"		// 将變量指派

study2 := "《從0到Go語言微服務架構師》"		// 以自動推斷方式初始化
           

有些字元串沒有現成的文字代号，是以隻能用轉義字元來表示。常用的轉義字元如表所示。

轉 義 字 符	含 義
\r	回車符 return，傳回行首
\n	換行符 new line, 直接跳到下一行的同列位置
\t	制表符 TAB
\'	單引号
\"	雙引号
\\	反斜杠

定義多行字元串的方法如下。

• 雙引号書寫字元串被稱為字元串字面量（string literal），這種字面量不能跨行。
• 多行字元串需要使用反引号“`”，多用于内嵌源碼和内嵌資料。
• 在反引号中的所有代碼不會被編譯器識别，而隻是作為字元串的一部分。

多行字元串定義方式如例所示：

package main
import "fmt"

func main() {
  var s1 string
	s1 = `
    		study := 'Go語言微服務架構核心22講'
    		fmt.Println(study)
			`
	fmt.Println(s1)
}
           

5.3 布爾類型

關于 布爾(bool) 類型，無非就是兩個值：true 或者 false 。

示例程式：

func showBool(){
	a := true
	b := false
	fmt.Println("a=", a)
	fmt.Println("b=", b)
	fmt.Println("true && false = ", a && b)
	fmt.Println("true || false = ", a || b)
}

func main() {
    showBool()
}
           

Tip：

• 如果你學過其他程式設計語言或許會發現，布爾型可以參與數值運算，也可以與其他類型進行轉換。但是在 Go 中，真值是用

  true

  表示，并且 不與

  1

  相等；同樣的，假值是用

  false

  表示，并且 不與 相等。

5.4 複數型

複數型用于表示數學中的複數，如 1+2j、1-2j、-1-2j 等。在 Go 語言中提供了兩種精度的複數類型：complex64 和 complex128 ，分别對應 float32 和 float64 兩種浮點數精度，如表所示。

類 型	字 節 數	說 明
complex64	8	64 位的複數型，由 float32 類型的實部和虛部聯合表示
complex128	16	128 位的複數型，由 float64 類型的實部和虛部聯合表示

func showComplex() {
	// 内置的 complex 函數用于建構複數
	var x complex64 = complex(1, 2)
	var y complex128 = complex(3, 4)
	var z complex128 = complex(5, 6)
	fmt.Println("x = ", x)
	fmt.Println("y = ", y)
	fmt.Println("z = ", z)

	// 内建的 real 和 imag 函數分别傳回複數的實部和虛部
	fmt.Println("real(x) = ", real(x))
	fmt.Println("imag(x) = ", imag(x))
	fmt.Println("y * z = ", y*z)
}

func main() {
   showComplex()
}
           

• x := 1 + 2i
  y := 3 + 4i
  z := 5 + 6i
             

5.5 fmt 格式輸出

格式	含義
%%	一個%字面量
%b	一個二進制整數值(基數為 2)，或者是一個(進階的)用科學計數法表示的指數為 2 的浮點數
%c	字元型。可以把輸入的數字按照 ASCII 碼相應轉換為對應的字元
%d	一個十進制數值(基數為 10)
%f	以标準記數法表示的浮點數或者複數值
%o	一個以八進制表示的數字(基數為 8)
%p	以十六進制(基數為 16)表示的一個值的位址，字首為 0x,字母使用小寫的 a-f 表示
%q	使用 Go 文法以及必須時使用轉義，以雙引号括起來的字元串或者位元組切片[]byte，或者是以單引号括起來的數字
%s	字元串。輸出字元串中的字元直至字元串中的空字元（字元串以'\0‘結尾，這個'\0'即空字元）
%t	以 true 或者 false 輸出的布爾值
%T	使用 Go 文法輸出的值的類型
%x	以十六進制表示的整型值(基數為十六)，數字 a-f 使用小寫表示
%X	以十六進制表示的整型值(基數為十六)，數字 A-F 使用小寫表示