一、基本介紹
1、開發環境安裝-windows安裝
打開Golang官網，選擇對應版本，進行安裝，
2、環境變數配置
1）步驟
（1）首先在環境變數中添加 GOPATH，值為 go 的安裝目錄：
（2）然后在環境變數 PATH 中添加 go 安裝目錄下的 bin 檔案夾，
（3）接著添加一個環境變數 GOPATH，值為你自己希望的作業目錄，
（4）最后重啟一下 命令列工具，輸入 go version命令即可查看版本資訊
2）GOROOT
$GOROOT,便是 Go 的安裝路徑，存放 Go 的內置程式庫，通常你安裝完后，你電腦的環境變數就會設好 GOROOT 路徑，當你開發 Go 程式的時候，當你 import 內置程式庫的時候，并不需要額外安裝，而當程式運行后， 默認也會先去 GOROOT 路徑下尋找相對應的庫來運行，
3）GOPATH與Go作業區
GOPATH 是我們定義的自己的作業空間，
一個 GOPATH 作業區，一般這樣：
./
├── bin
├── pkg
└── src
├── hello_github
└── hello_router.go（1）bin：保存編譯后生成的可執行檔案，我們的作業系統使用$PATH環境變數來查找無需完整路徑即可執行的二進制應用程式，建議將此目錄:$GOPATH/bin添加到我們的全域 $PATH 變數中，
（2）pkg：它保存已安裝的包物件（比如：.a），每個目標作業系統和體系結構對都有自己的 pkg 子目錄， Go 編譯包時生成的中間檔案，用來快取提高編譯效率，
（3）src：包含源代碼(比如：.go .c .h .s等)， 該路徑決定 import 包時的匯入路徑或可執行檔案名稱，
import包的搜索順序：
GOROOT/src：該目錄保存了Go標準庫代碼，
GOPATH/src：該目錄保存了應用自身的代碼和第三方依賴的代碼，
3、Go程式開發注意事項
1）Go源檔案以“go”為擴展名
2）Go應用程式的執行入口是main()方法
3）Go語言嚴格區分大小寫
4）Go方法由一條條陳述句構成，每個陳述句后不需要分號（Go語言會在每行后自動加分號）
5）Go編譯器是一行行進行編譯的，因此我們一行就寫一條陳述句，不能把多余陳述句寫在同一行，否則會報錯，
6）Go語言定義的變數或者import的包如果沒有使用到，代碼不能編譯通過，
7）大括號都是成對出現的，缺一不可，
4、常用的轉義字符（escape char）
1）\t：一個制表位 2）\n：換行符 3）\\：一個\ 4）\"：一個” 5）\r：一個回車5、Go變數
1）使用基本步驟
（1）宣告變數（定義變數）
（2）賦值
（3）使用
2）Golang變數宣告和賦值的三種方式
（1）指定變數型別，宣告后若不賦值，使用默認值
//宣告同時賦值
var 變數名字 型別 = 運算式
//宣告時不賦值
var 變數名字 型別
（2）根據值自行判定變數型別（型別推導）
var 變數名字 = 運算式
（3）省略var，注意:=左側的變數不應該是一級宣告過的，否則會導致編譯錯誤
變數名字 := 運算式
3）多變數宣告
//可以宣告時賦值，也可以不賦值
var 變數名字1,變數名字2 型別
////宣告時需賦值
var 變數名字1,變數名字2 =值1,值2
//型別推導，需要賦值
變數名字1,變數名字2 :=值1,值2
6、資料型別
1）基本資料型別：變數存的就是值，也叫值型別，
（1）數值型
整數型別、浮點型別
（2）字符型
使用byte來保存單個字符字符
（3）布爾型（bool）
（4）字串（string）:官方將string歸屬到基本資料型別
2）派生資料型別
（1）指標（Pointer）-參考型別
指標型別：變數存的是一個地址，這個地址指向的空間存的才是值，獲取指標型別所指向的值，使用：*，
package main
import "fmt"
func main() {
i := 10
var p *int = &i
fmt.Println(p, *p)
}
（2）陣列-值型別
見陣列章節
（3）結構體（struct）-值型別
見結構體章節
（4）管道（Channel）-參考型別
（5）函式
見函式章節
（6）切片（slice）-參考型別
見切片章節
（7）介面（interface）-參考型別
見介面章節
（8）map-參考型別
見nmap章節
3）值型別與參考型別
（1）值型別：變數直接存盤值，記憶體通常在堆疊中分配，都有對應的指標型別，形式未*資料型別，比如int的對應的指標就是*int，依次類推，
（2）參考型別：變數存盤的是一個地址，這個地址對應的空間才是真正存盤資料（值），記憶體通常在堆上分配，當沒有任何變數參考這個地址時，該地址對應的資料空間就成為一個垃圾，由GC來回收，
7、函式
1）函式宣告
函式宣告包括函式名、形式引數串列、回傳值串列（可省略）以及函式體，
func name(parameter-list) (result-list) {
body
}
形式引數串列描述了函式的引數名以及引數型別，這些引數作為區域變數，其值由引數呼叫者提供，回傳值串列描述了函式回傳值的變數名以及型別，如果函式回傳一個無名變數或者沒有回傳值，回傳值串列的括號是可以省略的，如果一個函式宣告不包括回傳值串列，那么函式體執行完畢后，不會回傳任何值，
函式的型別被稱為函式的簽名，如果兩個函式形式引數串列和回傳值串列中的變數型別一一對應，那么這兩個函式被認為有相同的型別或簽名，形參和回傳值的變數名不影響函式簽名，也不影響它們是否可以以省略引數型別的形式表示，
每一次函式呼叫都必須按照宣告順序為所有引數提供實參（引數值），在函式呼叫時，Go語言沒有默認引數值，也沒有任何方法可以通過引數名指定形參，因此形參和回傳值的變數名對于函式呼叫者而言沒有意義，
在函式體中，函式的形參作為區域變數，被初始化為呼叫者提供的值，函式的形參和有名回傳值作為函式最外層的區域變數，被存盤在相同的詞法塊中，
實參通過值的方式傳遞，因此函式的形參是實參的拷貝，對形參進行修改不會影響實參，但是，如果實參包括參考型別，如指標，slice(切片)、map、function、channel等型別，實參可能會由于函式的間接參考被修改，
你可能會偶爾遇到沒有函式體的函式宣告，這表示該函式不是以Go實作的，這樣的宣告定義了函式簽名，
2）init函式
略
3）Deferred函式
見例外處理章節
4）匿名函式
擁有函式名的函式只能在包級語法塊中被宣告，通過函式字面量（function literal），我們可繞過這一限制，在任何運算式中表示一個函式值，函式字面量的語法和函式宣告相似，區別在于func關鍵字后沒有函式名，函式值字面量是一種運算式，它的值被稱為匿名函式（anonymous function），
（1）定義
func (引數串列) (回傳值串列) {
函式體
}
（2）在定義時呼叫匿名函式
（3）匿名函式做回呼函式
5）閉包
函式值不僅僅是一串代碼，還記錄了狀態，在squares中定義的匿名內部函式可以訪問和更新squares中的區域變數，這意味著匿名函式和squares中，存在變數參考，這就是函式值屬于參考型別和函式值不可比較的原因，Go使用閉包（closures）技術實作函式值，Go程式員也把函式值叫做閉包，
6）函式值
在Go中，函式被看作第一類值（first-class values）：函式像其他值一樣，擁有型別，可以被賦值給其他變數，傳遞給函式，從函式回傳，對函式值（function value）的呼叫類似函式呼叫，
8、包
包的本質就是創建不同的檔案夾來存放程式檔案，每個包一般都定義了一個不同的名字空間用于它內部的每個識別符號的訪問，每個名字空間關聯到一個特定的包，讓我們給型別、函式等選擇簡短明了的名字，這樣可以在使用它們的時候減少和其它部分名字的沖突，每個包還通過控制包內名字的可見性和是否匯出來實作封裝特性，通過限制包成員的可見性并隱藏包API的具體實作，將允許包的維護者在不影響外部包用戶的前提下調整包的內部實作，通過限制包內變數的可見性，還可以強制用戶通過某些特定函式來訪問和更新內部變數，這樣可以保證內部變數的一致性和并發時的互斥約束，當我們修改了一個源檔案，我們必須重新編譯該源檔案對應的包和所有依賴該包的其他包，
1）包的三大作用
（1）區分相同名字的函式、變數等識別符號
（2）當程式檔案很多時，可以很好的管理專案
（3）控制函式、變數等訪問范圍，即作用域
2）包的相關說明
（1）打包基本語法/宣告基本語法
package 包名
在每個Go語言源檔案的開頭都必須有包宣告陳述句，包宣告陳述句的主要目的是確定當前包被其它包匯入時默認的識別符號（也稱為包名），
（2）引入包的基本語法
import "包的路徑"
每個包是由一個全域唯一的字串所標識的匯入路徑定位，出現在import陳述句中的匯入路徑也是字串，（在import包時，路徑從$GOPATH的src下開始，不用帶src，）
3）包的匿名匯入 如果只是匯入一個包而并不使用匯入的包將會導致一個編譯錯誤，但是有時候我們只是想利用匯入包而產生的副作用：它會計算包級變數的初始化運算式和執行匯入包的init初始化函式，這時候我們需要抑制“unused import”編譯錯誤，我們可以用下劃線_來重命名匯入的包，像往常一樣，下劃線_為空白識別符號，并不能被訪問，
import _ "image/png" // register PNG decoder
9、陣列
陣列是多個相同型別資料的組合，一個陣列一旦宣告/定義了，其長度是固定的，不能動態變化，
1）基本介紹（定義和初始化）
定義：var 陣列名 [陣列大小]資料型別
以下是四種陣列初始化方式：
默認情況下，陣列的每個元素都被初始化為元素型別對應的零值，對于數字型別來說就是0，我們也可以使用陣列字面值語法用一組值來初始化陣列：
var q [3]int = [3]int{1, 2, 3}
var r = [3]int{1, 2}
p := [3]int{1, 2}
fmt.Println(r[2]) // "0"
在陣列字面值中，如果在陣列的長度位置出現的是“...”省略號，則表示陣列的長度是根據初始化值的個數來計算，因此，上面q陣列的定義可以簡化為：
b := [...]int{1, 2, 3}
var c = [...]int{1, 2, 3}
fmt.Println(b[2])
fmt.Println(c[2])
可以指定元素值對應的下標：
var names=[3]string{1:"tom",0:"jack",2:"marry"}
陣列的長度是陣列型別的一個組成部分，因此[3]int和[4]int是兩種不同的陣列型別，陣列的長度必須是常量運算式，因為陣列的長度需要在編譯階段確定，
2）陣列遍歷
（1）常規遍歷
package main
import "fmt"
func main() {
var score [5]float64 = [5]float64{1.0, 2.0, 3.0, 4.0, 5.0}
for i := 0; i < len(score); i++ {
fmt.Println(score[i])
}
}
（2）for-range結構遍歷
這個是go語言一種獨有的結構，可以用來遍歷訪問陣列的元素，
基本語法：for index,value:=range array01{}
第一個回傳值index是陣列的下標，第二個value是在該下標位置的值，它們都是僅在for回圈內部可見的區域變數，遍歷陣列元素的時候如果不想使用下標index，可以直接把下標index標記為下劃線_，index和value的名稱是不固定的，也可以自行指定，
package main
import "fmt"
func main() {
var score [5]float64 = [5]float64{1.0, 2.0, 3.0, 4.0, 5.0}
for index, value := range score {
fmt.Println(index, value)
}
}
10、切片
1）基本介紹
Slice（切片）代表變長的序列，序列中每個元素都有相同的型別，一個slice型別一般寫作[]T，其中T代表slice中元素的型別；slice的語法和陣列很像，只是沒有固定長度而已，
陣列和slice之間有著緊密的聯系，一個slice是一個輕量級的資料結構，提供了訪問陣列子序列（或者全部）元素的功能，而且slice的底層確實參考一個陣列物件，一個slice由三個部分構成：指標、長度和容量，指標指向第一個slice元素對應的底層陣列元素的地址，要注意的是slice的第一個元素并不一定就是陣列的第一個元素，長度對應slice中元素的數目；長度不能超過容量，容量一般是從slice的開始位置到底層資料的結尾位置，內置的len和cap函式分別回傳slice的長度和容量，
2）切片定義的基本語法：
var 變數名 []型別
例如：
package main
func main() {
var intArr [5]int = [...]int{1, 2, 3, 4, 5}
myslice:=intArr[1:4]
var myslice2 []int = intArr[0:3]
}
3）切片的創建
（1）方式一：定義一個切片，然后讓切片去參考一個已經創建好的陣列，
直接參考陣列，這個陣列是事先存在的，程式員是可見的，
（2）方式二：通過make來創建切片，
基本語法：var 切片名 []type=make([]type,len,[capacity])
引數說明：type：切片的型別，len：長度，capacity：容量（可選的），
package main
import "fmt"
func main() {
var myslice []int = make([]int, 4)
myslice[0] = 100
fmt.Println(myslice)
}
通過make來創建切片，make也會創建一個陣列，是由切片在底層進行維護，程式員是看不見的，
（3）方式三：定義一個切片，直接就指定具體陣列，使用原理類似make的方式
package main
import "fmt"
func main() {
var myslice []int = []int{1, 2, 3, 4, 5}
fmt.Println(myslice)
}
4）切片遍歷
（1）常規遍歷
同陣列
for i := 0; i < len(myslice); i++ {
fmt.Println(myslice[i])
}
（2）for-range結構遍歷
同陣列
for index, value := range myslice2 {
fmt.Println(index, value)
}
11、map
1）基本語法（宣告）
var map變數名 map[keytype]valuetype
key的型別通常為：int、string，
宣告是不會分配記憶體的，初始化需要make，分配記憶體后才能賦值和使用(map在使用前一定要make)，
var a map[string]string a=make(map[string]string,10) a["u01"]="jack"
2）map的三種使用方式
在Go語言中，一個map就是一個哈希表的參考，map型別可以寫為map[K]V，其中K和V分別對應key和value，map中所有的key都有相同的型別，所有的value也有著相同的型別，但是key和value之間可以是不同的資料型別，其中K對應的key必須是支持==比較運算子的資料型別，所以map可以通過測驗key是否相等來判斷是否已經存在，雖然浮點數型別也是支持相等運算子比較的，但是將浮點數用做key型別則是一個壞的想法，最壞的情況是可能出現的NaN和任何浮點數都不相等，對于V對應的value資料型別則沒有任何的限制，
（1）先宣告，再make
//宣告，這時map=nil var ages map[string]string //make(map[string],string,10)分配一個map ages=make(map[string]string,10)
（2）宣告時直接make，內置的make函式可以創建一個map：
ages := make(map[string]int) // mapping from strings to ints
或者
var ages map[string]int=make(map[string]int)
（3）宣告時直接賦值，我們也可以用map字面值的語法創建map，同時還可以指定一些最初的key/value：
var ages map[string]int=map[string]int{
"alice":31
}
或
ages := map[string]int{
"alice": 31,
"charlie": 34,
}
這相當于：
ages := make(map[string]int)
ages["alice"] = 31
ages["charlie"] = 34
因此，另一種創建空的map的運算式是map[string]int{}，
3）map的crud操作
使用內置的delete函式可以洗掉元素：
delete(ages, "alice") // remove element ages["alice"]
4）map遍歷
5）map排序
12、結構體
結構體是一種聚合的資料型別，是由零個或多個任意型別的值聚合成的物體，每個值稱為結構體的成員，用結構體的經典案例是處理公司的員工資訊，每個員工資訊包含一個唯一的員工編號、員工的名字、家庭住址、出生日期、作業崗位、薪資、上級領導等等，所有的這些資訊都需要系結到一個物體中，可以作為一個整體單元被復制，作為函式的引數或回傳值，或者是被存盤到陣列中，等等，
下面兩個陳述句宣告了一個叫Employee的命名的結構體型別，并且宣告了一個Employee型別的變數dilbert：
type Employee struct {
ID int
Name string
Address string
DoB time.Time
Position string
Salary int
ManagerID int
}
var dilbert Employee
賦值：
type Point struct{ X, Y int }
p := Point{1, 2}
var q Point = Point{12, 12}
13、方法
在函式宣告時，在其名字之前放上一個變數，即是一個方法，這個附加的引數會將該函式附加到這種型別上，即相當于為這種型別定義了一個獨占的方法，
package main
import (
"fmt"
"math"
)
type Point struct{ x, y float64 }
//func
func Distance(p, q Point) float64 {
return math.Hypot(q.x-p.x, q.y-p.y)
}
//method
func (p Point) Distance(q Point) float64 {
return math.Hypot((q.x - p.x), q.y-p.y)
}
func main() {
var p Point = Point{12, 12}
var q Point = Point{8, 8}
x := Distance(p, q)
//function call
fmt.Println(x)
//method call
y := p.Distance(q)
fmt.Println(y)
}
上面的代碼里那個附加的引數p，叫做方法的接收器（receiver），早期的面向物件語言留下的遺產將呼叫一個方法稱為“向一個物件發送訊息”，在Go語言中，我們并不會像其它語言那樣用this或者self作為接收器；我們可以任意的選擇接收器的名字，由于接收器的名字經常會被使用到，所以保持其在方法間傳遞時的一致性和簡短性是不錯的主意，這里的建議是可以使用其型別的第一個字母，比如這里使用了Point的首字母p，
在方法呼叫程序中，接收器引數一般會在方法名之前出現，這和方法宣告是一樣的，都是接收器引數在方法名字之前，
14、介面
15、錯誤處理機制
go中引入的處理方式為：defer、panic、recover GO中可以先拋出一個panic的例外，然后再defer中通過recover捕獲這個例外，然后正常處理， 1）基本介紹 （1）defer 你只需要在呼叫普通函式或方法前加上關鍵字defer，就完成了defer所需要的語法，當執行到該條陳述句時，函式和引數運算式得到計算，但直到包含該defer陳述句的函式執行完畢時，defer后的函式才會被執行，不論包含defer陳述句的函式是通過return正常結束，還是由于panic導致的例外結束，你可以在一個函式中執行多條defer陳述句，它們的執行順序與宣告順序相反， 需要注意一點：不要忘記defer陳述句后的圓括號，否則本該在進入時執行的操作會在退出時執行，而本該在退出時執行的，永遠不會被執行， （2）panic 一般而言，當panic例外發生時，程式會中斷運行，并立即執行在該go routine（可以先理解成執行緒）中被延遲的函式（defer 機制），隨后，程式崩潰并輸出日志資訊，日志資訊包括panic value和函式呼叫的堆疊跟蹤資訊，panic value通常是某種錯誤資訊，對于每個goroutine，日志資訊中都會有與之相對的，發生panic時的函式呼叫堆疊跟蹤資訊， 不是所有的panic例外都來自運行時，直接呼叫內置的panic函式也會引發panic例外；panic函式接受任何值作為引數，當某些不應該發生的場景發生時，我們就應該呼叫panic， （3）recover 內置函式，可以捕獲到例外， 如果在deferred函式中呼叫了內置函式recover，并且定義該defer陳述句的函式發生了panic例外，recover會使程式從panic中恢復，并回傳panic value，導致panic例外的函式不會繼續運行，但能正常回傳，在未發生panic時呼叫recover，recover會回傳nil， 2）錯誤處理的好處 進行錯誤處理后，程式不會輕易掛掉，如果加入預警代碼，程式會更加的健壯， 3）示例package main
import "fmt"
func test() {
//使用defer +recover來捕獲和處理例外
defer func() {
err := recover()
if err != nil { //說明捕獲到例外
fmt.Println("err:", err)
}
}()
num1 := 10
num2 := 0
res := num1 / num2
fmt.Println("rest=", res)
}
func main() {
test()
fmt.Println("main()...")
}
4）自定義錯誤
使用errors.New和panic內置函式
（1）errors.New("錯誤說明")，會回傳一個error型別的值，表示一個錯誤，
（2）panic內置函式，接收一個interface{}型別的值（也就是任何值）作為引數，可以接收error型別的變數，輸出錯誤資訊，并退出程式，
（3）示例
package main
import (
"errors"
"fmt"
)
func readConf(name string) (err error) {
if name == "config.ini" {
return nil
} else {
return errors.New("讀取檔案錯誤...")
}
}
func test() {
err := readConf("config.in1i")
if err != nil {
panic(err)
}
fmt.Println("test()...")
}
func main() {
test()
}
出處：http://www.cnblogs.com/hoaprox
如果你真心覺得文章寫得不錯，而且對你有所幫助，那就不妨小小打賞一下吧，如果囊中羞澀，不妨幫忙“推薦"一下，您的“推薦”和”打賞“將是我最大的寫作動力！
本文著作權歸作者所有，歡迎轉載，但未經作者同意必須保留此段宣告，且在文章頁面明顯位置給出原文連接.
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/440338.html
標籤：Go
下一篇：【第三十六期】B站一面