由於最近想自學區塊鏈搭建的知識，所以先入門了Go語言，以下是一些筆記，在適當位置會對我比較熟悉的Java語言做一個比較，加深記憶；
一、Go語言的特點
1. 運行效率高，開發高效，部署簡單；
2. 語言層面支持併發，易於利用多核實現併發；
3. 內置runtime（作用：性能監控，GC等）；
4.簡單易學，豐富的標準庫，強大的網絡庫；
5.內置強大的工具（gofmt），跨平臺編譯，內嵌C支持；
二、Go語言的應用
1.服務器編程，如處理日誌，數據打包，虛擬機處理，文件系統等
2.分佈式系統，數據庫代理器，中間件等；
3.網絡編程，web應用，Api應用
4.雲平臺
三、Go語言命令行工具介紹
四、Go語言基礎語法
1. 關鍵字、標識符、註釋、基礎結構
| Go語言關鍵字 | ||||
| break | default | func | interface | select |
| case | defer | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrought | if | range | type |
| continue | for | import | return | var |
| Go標識符 | |||||
| append | bool | byte | cap | close | complex |
| complex64 | complex128 | uint16 | copy | false | float32 |
| float64 | imag | int | int8 | int16 | uint32 |
| int32 | int64 | iota | len | make | new |
| nil | panic | uint64 | println | real | |
| recover | string | TRUE | uint | uint8 | uintprt |
// 單行註釋
/*
多行註釋
*/
2.基礎結構詳解
//程序第一行一定要package開頭，聲明所屬的包
package main
//導入引用
import "fmt"
//常量定義,類型放在變量名後
const NAME string = "test"
//全局變量的聲明與賦值
var a string = "eanam"
//一般類型聲明
type TestInt int
//結構聲明
type Learn struct{
}
//接口聲明
type ILearn interface{
}
//函數定義
func LearnGo() {
}
//main函數
func main() {
}
3. package的用法
（1）package是最基本的分發單位和工程管理中依賴關係的體現；
（2）每個Go語言源代碼文件開頭都擁有一個package聲明，表示源碼文件所屬的代碼包
（3）要生成Go語言可執行程序，必須要有main的package包，並且該包下有main()函數
（4）同一個路徑下只能存在一個package，一個package可以拆成多個源文件組成
4. import的用法
（1）import語句可以導入源代碼文件所依賴的package包
（2）不得導入源代碼文件中沒有用到的package，否則Go語言編譯器會報編譯錯誤
//格式1：
import "A"
import "B"
//格式2：
import （
"A"
"B"
）
5. import的原理
（1）如果一個main導入其他包，包將按順序導入；
（2）如果導入的包中有依賴其他包（包B），會首先導入B包，然後初始化B包中的常量和變量，最後如果B包中有init，會自動執行init();
（3）所有包導入完成後纔會對main中常量和變量進行初始化，然後執行main中的init函數（如果存在），最後才執行main函數；
（4）如果一個包被導入多次則該包只會被導入一次；
6. import 別名、“.”、“_”
（1）將導入的包命名爲另一個容易記憶的別名；
（2）“.”的含義是：“.”標識的包導入後，調用該包函數時可以省略前綴包名；
（3）“_”的含義是：導入該包，但不導入整個包，而是執行該包中的init函數，因此無法通過包名來調用包中的其他函數。使用“_”操作往往是爲了註冊包內的引擎，讓外部可以方便地使用。
//演示
import(
alias "fmt" //alias.Print()
. "fmt" //Print()
_ "fmt"
)
7. Go語言的數據類型
（1）數值類型、字符類型和布爾型
| 數值類型 | ||||||
| 整型 | 1 | uint8 | 無符號8位整型（0到255） | |||
| 2 | uint16 | 無符號16位整型（0到65535） | ||||
| 3 | uint32 | 無符號32位整型（0到4294967295） | ||||
| 4 | uint46 | 無符號64位整型（18446744073709551615） | ||||
| 5 | int8 | 有符號8位整型（-128到127） | ||||
| 6 | int16 | 有符號16位整型（-32768到32767） | ||||
| 7 | int32 | 有符號32位整型（-2147483648到2147483647） | ||||
| 8 | int64 | 有符號64位整型 | ||||
| 浮點型 | 1 | float32 | 32位浮點型數 | |||
| 2 | float64 | 64位浮點型數 | ||||
| 3 | complex32 | 32位實數和虛數 | ||||
| 4 | complex128 | 64位實數和虛數 | ||||
| 其他數值類型 | 1 | byte | 類似uint8 | |||
| 2 | rune | 類似int32 | ||||
| 3 | uint | 32位或64位 | ||||
| 4 | int | 與uint一樣大小 | ||||
| 5 | uintptr | 無符號整型用於存放一個指針 | ||||
（2）派生類型
| 派生類型 | ||
| 指針類型 | Pointer | |
| 數組類型 | ||
| 結構化類型 | struct | |
| Channel類型 | chan | |
| 函數類型 | func | |
| 切片類型 | slice | |
| 接口類型 | interface | |
| Map類型 | map | |
（3）類型零值和類型別名
A. 類型零值不是空值，而是某個變量被聲明後的默認值，一般情況下，值類型的默認值爲0，布爾型默認值爲
false，string默認值爲空字符
B. 我們可以對類型設置別名，如下：
type alias int
（4）類型所佔存儲大小
五、Go語言變量概念
1. 變量與常量
//變量聲明：初始化與賦值
/*
單個變量的聲明與賦值
1）變量的聲明格式：var <變量名稱> [變量類型]
2）變量的賦值格式：<變量名稱> = <值、表達式、函數等>
3）聲明和賦值同時進行：var <變量名稱> [變量類型] = <值、表達式、函數等>
4）分組聲明格式：
var(
i int
j float32
name string
)
同一行聲明多個變量和賦值：var a,b,c int = 1,2,3 或者 a,b := 1,2
全局變量的聲明必須使用var關鍵詞，局部變量可以省略
特殊變量下劃線"_"
*/
/*
變量的類型轉換：
1）Go中不存在隱式轉換，類型轉換必須是顯式的；
2）類型轉換隻能發生在兩種兼容類型之間；
3）類型轉換格式：<變量名稱> [:]= <目標類型>(<需要轉換的變量>)
*/
//變量可見性規則
/*
1）大寫字母開頭的變量的可導出，也就是其他包可以讀取的，是公共變量
2）小寫字母開頭的就是不可導出，是私有變量
*/
//常量：常量聲明與iota的使用
/*
1) 常量定義形式：
顯式：const identifier [type] = value
隱式：const identifier = value(通常叫無類型常量)
2）常量類型範圍
目前只支持布爾型、數字型（整數型、浮點型和複數）和字符串型；不支持派生類型
3）特殊常量iota的用法
iota在const關鍵字出現時將被重置爲0
const組合聲明時每增加一行常量聲明將使iota計數一次（同一行iota一樣）
iota常見使用法：
1）跳值使用法
const(
a = iota
b = iota
c int = iota
_
//可省略iota
d
)
2）插隊使用法
const(
a = iota
b = iota
c int = iota
k = 2.14
//可省略iota
d = iota
)
3）表達式隱式使用法
如果沒有顯示賦值，則會繼承上一個表達式的右式
4）單行使用法
*/
六、Go語言運算符
（1）算術運算符（++、--只能放在變量後面）
（2）關係運算符
（3）邏輯運算符
（4）按位運算符
（5）賦值運算符
七、Go語言控制語句
（1）條件語句： if-else語句
package main
import "fmt"
func main() {
a := 2
if a > 0{
if a > 3{
fmt.Println("a > 3")
}
fmt.Println("a > 0")
}else {
fmt.Println("a < 0")
}
}
（2）選擇語句：switch語句
package main
import "fmt"
func main() {
a := 2
//演示簡單匹配
switch a {
case 1:
fmt.Println(" a is 1")
case 2:
fmt.Println(" a is 2")
case 3:
fmt.Println(" a is 3")
default:
fmt.Println(" a is not in range")
}
//演示type-switch
var b interface{}
b = 3.14
switch b.(type) {
case int:
fmt.Println("b is int")
case float64:
fmt.Println("b is float64")
default:
fmt.Println("unsuitable type")
}
}
（3）循環語句：for語句
package main
import (
"fmt"
)
func main() {
//無限循環
for {
fmt.Println("this is unlinited circle")
}
//簡單用法
for i := 0; i < 10;i++{
fmt.Println("--------",i)
//time.Sleep(1*time.Second)
}
//實現佛reach效果
a := []string{"banana","peach","apple"}
for key,value := range a{
fmt.Println(key,"-",value)
}
}
（4）goto、break、continue
package main
import (
"fmt"
"time"
)
func main() {
var j = 0
i := 0
/*
goto跳到指定步驟
無限循環打印：this is code 1
*/
goto Three
fmt.Println("demo is start")
One:
fmt.Println("this is code 1")
time.Sleep(1*time.Second)
goto One
/*break停止當前循環
打印兩次break demo
*/
for {
fmt.Println("break demo")
i++
if i == 2 {
fmt.Println("doing break")
break
}
}
/*continue結束本次循環，直接進入下一輪循環
不打印continue demo2，
*/
Three:
for {
j++
if j == 2 {
fmt.Println("doing continue")
continue
}
fmt.Println("continue demo",j)
time.Sleep(1*time.Second)
}
}