image.png
先講一下，寫這種筆記的目的：
- 自己在學的過程中能一字一句讀下來并且寫出來，便于了解加深記憶，這樣做比隻看教程記憶會更加深刻。
- 當我某些細的點遺忘的時候我可以快速查詢，因為筆記是我自己寫的我知道知識點寫在哪部分。
- 可以分享出來給其他熱愛go的入門者或者在上學的同學看，因為這邊記錄的是把官方内容精簡了些。
什麼是Golang
Go 亦稱為 Golang（譯注：按照 Rob Pike 說法，語言叫做 Go，Golang 隻是官方網站的網址），是由谷歌開發的一個開源的編譯型的靜态語言。
Golang 的主要關注點是使得高可用性和可擴充性的 Web 應用的開發變得簡便容易。（譯注：Go 的定位是系統程式設計語言，隻是對 Web 開發支援較好）
Go 語言一些優點：
- 并發是語言的一部分（并非通過标準庫實作），是以編寫多線程程式會是一件很容易的事。後續教程将會讨論到，并發是通過 Goroutines 和 channels 機制實作的。
- Golang 是一種編譯型語言。源代碼會編譯為二進制機器碼。而在解釋型語言中沒有這個過程，如 Nodejs 中的 Python。
- 語言規範十分簡潔。所有規範都在一個頁面展示，你甚至都可以用它來編寫你自己的編譯器呢。
- Go 編譯器支援靜态連結。所有 Go 代碼都可以靜态連結為一個大的二進制檔案（譯注：相對現在的磁盤空間，其實根本不大），并可以輕松部署到雲伺服器，而不必擔心各種依賴性。
安裝
Mac OS
官網下載下傳
https://golang.org/dl/安裝程式。輕按兩下開始安裝，會将 Golang 安裝到
/usr/local/go
目錄下，同時
/usr/local/go/bin
檔案夾也會被添加到
PATH
環境變量中。
(這裡隻介紹Mac OS下的安裝，其他平台請自行查閱)
建立工作區
在 Mac 或 Linux 作業系統下，Go 工作區應該設定在
$HOME/go
。是以我們要在
$HOME
目錄下建立 go 目錄。
也可以通過設定 GOPATH ，用其他目錄來作為工作區。我這邊使用的ide是這個
設定GOPATH的方式：
所有 Go 源檔案都應該放置在工作區裡的 src 目錄下。請在剛添加的 go 目錄下面建立目錄 src。
所有 Go 項目都應該依次在 src 裡面設定自己的子目錄。我們在 src 裡面建立一個目錄 hello 來放置整個 hello 項目。
建立上述目錄之後，其目錄結構如下：
go
src
hello
hello.go
hello.go中寫入代碼：
package main
import "fmt"
func main() {
fmt.Println("Hello World")
}
- 使用指令go run hello.go名運作：
Go基礎文法（一） -
使用 go install hello 指令
當你輸入 go install hello 時，go 工具會在工作區中搜尋 hello 包。接下來它會在工作區的 bin 目錄下，建立一個名為 hello（Windows 下名為 hello.exe）的二進制檔案。運作 go install hello 後，其目錄結構如下所示：
go
bin
hello
src
hello
hello.go
代碼中第一行：
package main ，每一個 Go 檔案都應該在開頭進行 package name 的聲明（譯注：隻有可執行程式的包名應當為 main）。包（Packages）用于代碼的封裝與重用，這裡的包名稱是main。
變量
變量：變量指定了某存儲單元（Memory Location）的名稱，該存儲單元會存儲特定類型的值。在 Go 中，有多種文法用于聲明變量。
package main
import (
"fmt"
"math"
)
func main() {
var age int // 變量聲明
fmt.Println("my age is", age)
age = 10 //變量指派
fmt.Println("my age is", age)
age = 30 //變量指派
fmt.Println("my age is", age)
var name string = "allen" // 聲明變量并初始化
fmt.Println("my name is", name)
var num = 29 // 可以推斷類型
fmt.Println("my num is", num)
var width, height int = 100, 50 // 聲明多個變量
fmt.Println("width is", width, "height is", height)
var a, b int //省略初始化，預設值為0
fmt.Println("width is", a, "height is", b)
//一個語句中聲名不同類型變量
var (
c = "jie"
d = 24
e int
)
fmt.Println("my c is", c, ", d is", d, "and e is", e)
m, n := "allen", 29 // 簡短聲明
fmt.Println("m name is", m, "n is", n)
//變量也可以在運作時進行指派
q, p := 145.8, 543.8
e1 := math.Min(q, p)
fmt.Println("minimum value is ", e1)
}
- 聲明單個變量 ：var name type
- 聲明變量并初始化 ： var name type = initialvalue
- 類型推斷（Type Inference） ： 如果變量有初始值，那麼 Go 能夠自動推斷具有初始值的變量的類型。是以，如果變量有初始值，就可以在變量聲明中省略 type。例：var name = initialvalue
- 聲明多個變量 ： var name1, name2 type = initialvalue1, initialvalue2。
-
一個語句中聲明不同類型的變量 ：
var (
name1 = initialvalue1,
name2 = initialvalue2
)
-
簡短聲明 : name := initialvalue，
簡短聲明要求 := 操作符左邊的所有變量都有初始值。
簡短聲明的文法要求 := 操作符的左邊至少有一個變量是尚未聲明的。
- 由于 Go 是強類型（Strongly Typed）語言，是以不允許某一類型的變量指派為其他類型的值。
類型
基本類型：
- bool
-
數字類型
int8, int16, int32, int64, int
uint8, uint16, uint32, uint64, uint
float32, float64
complex64, complex128
byte
rune
- string
有符号整型：
int：根據不同的底層平台（Underlying Platform），表示 32 或 64 位整型。除非對整型的大小有特定的需求，否則你通常應該使用 int 表示整型。
在 Printf 方法中，使用
%T
列印變量類型。
Go 的
unsafe包提供了一個
Sizeof函數，該函數接收變量并傳回它的位元組大小。
func main() {
a := true
b := false
fmt.Println("a:", a, "b:", b)
c := a && b //僅當 a 和 b 都為 true 時，操作符 && 才傳回 true
fmt.Println("c:", c)
d := a || b //當 a 或者 b 為 true 時，操作符 || 傳回 true
fmt.Println("d:", d)
var a1 int = 89
b1 := 95
fmt.Println("a1 is", a1, "and b is", b1)
fmt.Printf("type of a is %T, size of a is %d", a1, unsafe.Sizeof(a1)) // a 的類型和大小
fmt.Printf("\ntype of b is %T, size of b is %d", b1, unsafe.Sizeof(b1)) // b 的類型和大小
}
在32位系統下，位元組大小為4，64位下，位元組大小為8。
無符号整型
uint：根據不同的底層平台，表示 32 或 64 位無符号整型。
浮點型
float32：32 位浮點數
float64：64 位浮點數
package main
import (
"fmt"
)
func main() {
a, b := 5.67, 8.97 //a 和 b 的類型根據指派推斷得出,float64 是浮點數的預設類型
fmt.Printf("type of a %T b %T\n", a, b)
sum := a + b
diff := a - b
fmt.Println("sum", sum, "diff", diff)
no1, no2 := 56, 89
fmt.Println("sum", no1+no2, "diff", no1-no2)
}
a 和 b 的類型根據指派推斷得出，float64 是浮點數的預設類型。
複數類型
complex64：實部和虛部都是 float32 類型的的複數。
complex128：實部和虛部都是 float64 類型的的複數。
其他數字類型
byte 是 uint8 的别名。
rune 是 int32 的别名。
string 類型
在 Golang 中，字元串是位元組的集合。如果你現在還不了解這個定義，也沒有關系。我們可以暫且認為一個字元串就是由很多字元組成的。後面會在一個教程中深入學習字元串。
package main
import (
"fmt"
)
func main() {
first := "Zhao"
last := "Alle"
name := first +" "+ last
fmt.Println("My name is",name)
}
類型轉換
Go 有着非常嚴格的強類型特征。Go 沒有自動類型提升或類型轉換。
package main
import (
"fmt"
)
func main() {
i := 55 //int
j := 67.8 //float64
sum := i + int(j) //j is converted to int
fmt.Println(sum)
q := 10
var w float64 = float64(q) // 若沒有顯式轉換，該語句會報錯
fmt.Println("w", w)
}
把 v 轉換為 T 類型的文法是 T(v)。
指派的情況也是如此。把一個變量指派給另一個不同類型的變量，需要顯式的類型轉換。
常量
定義：在 Go 語言中，術語"常量"用于表示固定的值。
使用關鍵字
const
表示常量。
package main
func main() {
const a = 55 // 允許
a = 89 // 不允許重新指派
}
- 常量不能再重新指派為其他的值。是以上面的代碼将不能正常工作，它将出現一個編譯錯誤: cannot assign to a
- 常量的值會在編譯的時候确定。因為函數調用發生在運作時，是以不能将函數的傳回值指派給常量。
字元串常量
const a = "Hello World"
上面的例子，我們把 Hello World 配置設定給常量 a。現在常量 a 是沒有類型的。
無類型的常量有一個與它們相關聯的預設類型（上邊預設類型是string），并且當且僅當一行代碼需要時才提供它。在聲明中 var b = "Sam" ， b 需要一個類型，它從字元串常量 Sam 的預設類型中擷取。
建立一個帶類型的常量：
const c string = "Hello World"
常量c就是一個string類型的。
Go 是一個強類型的語言，在配置設定過程中混合類型是不允許的。
布爾常量
布爾常量和字元串常量用法相同，他們是兩個無類型的常量 true 和 false。
package main
func main() {
const trueConst = true
type myBool bool
var defaultBool = trueConst // 允許
var customBool myBool = trueConst // 允許
defaultBool = customBool // 不允許
}
數字常量
包含整數、浮點數和複數的常量
func main() {
const a = 5
var intVar int = a
var int32Var int32 = a
var float64Var float64 = a
var complex64Var complex64 = a
fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
}
常量a 的值是 5 ，a 的文法是通用的（它可以代表一個浮點數、整數甚至是一個沒有虛部的複數），是以可以将其配置設定給任何相容的類型。這些常量的預設類型可以被認為是根據上下文在運作中生成的。 var intVar int = a 要求 a 是 int，是以它變成一個 int 常量。 var complex64Var complex64 = a 要求 a 是 complex64，是以它變成一個複數類型。
數字表達式
func main() {
var a = 5.9/8
fmt.Printf("a's type %T value %v",a, a)
}
在上面的程式中， 5.9 在文法中是浮點型，8 是整型，5.9/8 是允許的，因為兩個都是數字常量。除法的結果是 0.7375 是一個浮點型，是以 a 的類型是浮點型。
如果内容對你有幫助，記得關注作者給個贊哦~，後續會持續更新。