01Go筆記基礎資料型別

編譯

編譯之後的可執行檔案就在當前的資料夾下面

• 在當前目錄下，編譯命令go build

• 在其他的目錄下，編譯命令go build 編譯的路徑（絕對路徑）

• go install先執行go build得到一個可執行檔案，然後拷貝生成的二進位制檔案，然後執行

• go run像執行指令碼檔案一樣執行程式碼，直接出結果

  一般直接使用go build

跨平臺編譯（交叉編譯）

SET CGO_ENBALED=0 //禁用CGO
SET GOOS=linux //目標平臺是linux
SET GOARCH=amd64 //目標處理器架構是amd64

然後執行go build，這時候生成的就是的一個linux

函式外指令放置識別符號（變數、常量、函式、型別）的宣告

變數和常量

識別符號和關鍵字

識別符號

在程式語言中識別符號就是程式設計師定義的具有特殊意義的詞，比如變數名、常量名、函式名等等。 Go語言中識別符號由字母數字和_(下劃線）組成，並且只能以字母和_開頭。 舉幾個例子：abc, _, _123, a123。

關鍵字

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

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
 

變數

變數的來歷

程式執行過程中的資料都是儲存在記憶體中，我們想要在程式碼中操作某個資料時就需要去記憶體上找到這個變數，但是如果我們直接在程式碼中通過記憶體地址去操作變數的話，程式碼的可讀性會非常差而且還容易出錯，所以我們就利用變數將這個資料的記憶體地址儲存起來，以後直接通過這個變數就能找到記憶體上對應的資料了。

變數的型別

變數（Variable）的功能是儲存資料。不同的變數儲存的資料型別可能會不一樣。經過半個多世紀的發展，程式語言已經基本形成了一套固定的型別，常見變數的資料型別有：整型、浮點型、布林型等。

Go語言中的每一個變數都有自己的型別，並且變數必須經過宣告才能開始使用。

變數的宣告

Go語言中的變數必須聲明後才能使用，同一作用域內不支援重複宣告。 並且Go語言的變數聲明後必須使用。

標準宣告

格式：var 變數名 變數型別

變數宣告以關鍵字var開頭，變數型別放在變數的後面，行尾無需分號。 舉個例子：

var name string
var age int
var isOk bool

批量宣告

每宣告一個變數就需要寫var關鍵字會比較繁瑣，go語言中還支援批量變數宣告：

var (
    a string
    b int
    c bool
    d float32
)

變數的初始化

Go語言在宣告變數的時候，會自動對變數對應的記憶體區域進行初始化操作。每個變數會被初始化成其型別的預設值，例如： 整型和浮點型變數的預設值為0。 字串變數的預設值為空字串。 布林型變數預設為false。 切片、函式、指標變數的預設為nil。

當然我們也可在宣告變數的時候為其指定初始值。變數初始化的標準格式如下：var 變數名 型別 = 表示式

例子：

var name string = "Q1mi"
var age int = 18

或者一次初始化多個變數

var name, age = "Q1mi", 20

go語言中變數宣告之後必須使用，不使用則會導致編譯失敗

Println列印完之後會自動的在最後加一個換行符

go語言中會自帶一個fmt的工具，編譯的時候會自動的進行format

go語言中推薦使用駝峰命名

型別推導

有時候我們會將變數的型別省略，這個時候編譯器會根據等號右邊的值來推導變數的型別完成初始化。

var name = "Q1mi"
var age = 18

短變數宣告

在函式內部，可以使用更簡略的 := 方式宣告並初始化變數。

package main

import (
	"fmt"
)
// 全域性變數m
var m = 100

func main() {
	n := 10
	m := 200 // 此處宣告區域性變數m
	fmt.Println(m, n)
}

匿名變數

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

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

匿名變數不佔用名稱空間，不會分配記憶體，所以匿名變數之間不存在重複宣告。 (在Lua等程式語言裡，匿名變數也被叫做啞元變數。)

注意事項：

1. 函式外的每個語句都必須以關鍵字開始（var、const、func等）
2. :=不能使用在函式外。
3. _多用於佔位，表示忽略值。

go語言中變數名是在前面的，變數的型別是在後面

常量

相對於變數，常量是恆定不變的值，多用於定義程式執行期間不會改變的那些值。 常量的宣告和變數宣告非常類似，只是把var換成了const，常量在定義的時候必須賦值。

const pi = 3.1415
const e = 2.7182

聲明瞭pi和e這兩個常量之後，在整個程式執行期間它們的值都不能再發生變化了。

常量定義之後就不再發生改變了

多個常量也可以一起宣告：

const (
    pi = 3.1415
    e = 2.7182
)

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

const (
    n1 = 100
    n2
    n3
)

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

iota

iota是go語言的常量計數器，只能在常量的表示式中使用。

iota在const關鍵字出現時將被重置為0。const中每新增一行常量宣告將使iota計數一次(iota可理解為const語句塊中的行索引)。 使用iota能簡化定義，在定義列舉時很有用。

舉個例子：

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

使用_跳過某些值

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

定義數量級 （這裡的<<表示左移操作，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 //1,2
		c, d                      //2,3
		e, f                      //3,4
	)

基本資料型別

Go語言中有豐富的資料型別，除了基本的整型、浮點型、布林型、字串外，還有陣列、切片、結構體、函式、map、通道（channel）等。Go 語言的基本型別和其他語言大同小異。

整型

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

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

特殊整型

注意： 在使用int和 uint型別時，不能假定它是32位或64位的整型，而是考慮int和uint可能在不同平臺上的差異。

注意事項 獲取物件的長度的內建len()函式返回的長度可以根據不同平臺的位元組長度進行變化。實際使用中，切片或 map 的元素數量等都可以用int來表示。在涉及到二進位制傳輸、讀寫檔案的結構描述時，為了保持檔案的結構不會受到不同編譯目標平臺位元組長度的影響，不要使用int和 uint。

數字字面量語法（Number literals syntax）

Go1.13版本之後引入了數字字面量語法，這樣便於開發者以二進位制、八進位制或十六進位制浮點數的格式定義數字，例如：

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

而且還允許我們用 _ 來分隔數字，比如說： v := 123_456 表示 v 的值等於 123456。

我們可以藉助fmt函式來將一個整數以不同進位制形式展示。

大寫的T用來輸出一個型別，類似fmt.Printf("%T\n", c)

package main
 
import "fmt"
 
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
    // 大寫的T用來輸出一個型別
    fmt.Printf("%T\n", c)
}

浮點型

Go語言支援兩種浮點型數：float32和float64。這兩種浮點型資料格式遵循IEEE 754標準： float32 的浮點數的最大範圍約為 3.4e38，可以使用常量定義：math.MaxFloat32。 float64 的浮點數的最大範圍約為 1.8e308，可以使用一個常量定義：math.MaxFloat64。

列印浮點數時，可以使用fmt包配合動詞%f，程式碼如下：

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

go語言中預設的型別是float64

float32的值不能直接賦值給float64的變數

複數

complex64和complex128

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

複數有實部和虛部，complex64的實部和虛部為32位，complex128的實部和虛部為64位。

布林值

Go語言中以bool型別進行宣告布林型資料，布林型資料只有true（真）和false（假）兩個值。

注意：

1. 布林型別變數的預設值為false。

2. Go 語言中不允許將整型強制轉換為布林型.

3. 布林型無法參與數值運算，也無法與其他型別進行轉換。

4. 列印的時候使用%#v會將所列印的型別進行輸出

   func variableZeroValue() {
   	var a int
   	var s string
   	fmt.Printf("%d, %s\n", a, s)
   	fmt.Printf("%v, %v\n", a, s)
   	fmt.Printf("%#v, %#v\n", a, s)
   	fmt.Printf("%T", a)
   }
   
   結果顯示
   0, 
   0, 
   0, ""
   int
   

字串

Go語言中的字串以原生資料型別出現，使用字串就像使用其他原生資料型別（int、bool、float32、float64 等）一樣。 Go 語言裡的字串的內部實現使用UTF-8編碼。 字串的值為雙引號(")中的內容，可以在Go語言的原始碼中直接新增非ASCII碼字元【go語言中的字串必須使用雙引號，單引號表示的是一個字元】，例如：

s1 := "hello"
s2 := "你好"
c1 := 'h'
c2 := '你'
// 位元組：1位元組=8bit（8個二進位制位）
// 1個字元'a'=1個位元組
// 1個utf-8編碼的漢字一般佔用的是3個位元組

字串轉義符

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

舉個例子，我們要列印一個Windows平臺下的一個檔案路徑：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}

多行字串

Go語言中要定義一個多行字串時，就必須使用反引號字元：

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

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

字串的常用操作

byte和rune型別

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

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

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

1. uint8型別，或者叫 byte 型，代表了ASCII碼的一個字元。
2. rune型別，代表一個 UTF-8字元。

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

Go 使用了特殊的 rune 型別來處理 Unicode，讓基於 Unicode 的文字處理更為方便，也可以使用 byte 型進行預設字串處理，效能和擴充套件性都有照顧。

// 遍歷字串
func traversalString() {
	s := "hello沙河"
	for i := 0; i < len(s); i++ { //byte
		fmt.Printf("%v(%c) ", s[i], s[i])
	}
	fmt.Println()
	for _, r := range s { //rune
		fmt.Printf("%v(%c) ", r, r)
	}
	fmt.Println()
}

輸出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河) 

因為UTF8編碼下一個中文漢字由3~4個位元組組成，所以我們不能簡單的按照位元組去遍歷一個包含中文的字串，否則就會出現上面輸出中第一行的結果。

字串底層是一個byte陣列，所以可以和[]byte型別相互轉換。字串是不能修改的 字串是由byte位元組組成，所以字串的長度是byte位元組的長度。 rune型別用來表示utf8字元，一個rune字元由一個或多個byte組成。

修改字串

要修改字串，需要先將其轉換成[]rune或[]byte，完成後再轉換為string。無論哪種轉換，都會重新分配記憶體，並複製位元組陣列。

func changeString() {
	s1 := "big"
	// 強制型別轉換
	byteS1 := []byte(s1)
	byteS1[0] = 'p'
	fmt.Println(string(byteS1))

	s2 := "白蘿蔔"
	runeS2 := []rune(s2)
	runeS2[0] = '紅'
	fmt.Println(string(runeS2))
}

型別轉換

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

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

T(表示式)

其中，T表示要轉換的型別。表示式包括變數、複雜運算元和函式返回值等.

比如計算直角三角形的斜邊長時使用math包的Sqrt()函式，該函式接收的是float64型別的引數，而變數a和b都是int型別的，這個時候就需要將a和b強制型別轉換為float64型別。

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