GO语言基础语法
1.GO語言命令
go build 用于編譯源碼文件、代碼包、依賴包
go run 可以編譯并運行GO 源碼文件
go get 用來動態(tài)獲取遠程代碼包的
2. Goland 編輯器
配置 setting goRoot
3.GO語言基礎(chǔ)語法
a.關(guān)健字，標識符，注釋，基礎(chǔ)結(jié)構(gòu)
基礎(chǔ)結(jié)構(gòu)
//程序所屬包 *必須package main//導(dǎo)入依賴包import ("fmt" )//常量定義?string不寫也可以const NAME string ="wawa";//全局變量的聲明與賦值var mainName string = "寶貝";//一般類型聲明type wawaInt int//結(jié)構(gòu)的聲明type Learn struct {}//聲明接口type Ilearn interface{}//函數(shù)定義func learnWawa(){fmt.Print(mainName)}//main函數(shù)func main(){learnWawa()fmt.Print("Hello world!")}b. package,import別名，路徑，".","_"的使用說明
package是最基本的分發(fā)單位和工程管理中依賴關(guān)系的體現(xiàn)
每個GO語言源文件開頭都必須擁有一個package聲明，表示源碼文件所屬代碼包
要生成GO語言可執(zhí)行程序，必須要有main的package包，且必須在該包下有main()函數(shù)
同一個路徑下只能存在一個package,一個package可以拆成多個源文件組成
import原理
如果一個main導(dǎo)入其他包，包將被順序?qū)?/p>
如果導(dǎo)入的包中依賴其他包（包B），會首先導(dǎo)入B包，然后初始化B包中常量和變量，最后如果B包中有init，會自動執(zhí)行init()
所有包導(dǎo)入完成后才會對main中常量和變量進行初始化，然后執(zhí)行main中的init函數(shù)（如果存在），最后執(zhí)行main函數(shù)
如果一個包被導(dǎo)入多次則該包只會被導(dǎo)入一次
test.go package wangwawaimport "fmt"func init() {fmt.Println("this is wangwawa test") } func Test() {}test1.go
package wawaimport ("fmt""awesomeProject/wangwawa" )func init() {fmt.Println("this is wawa test1") } func Test1() {wangwawa.Test() } test2.go package wawaimport "fmt"func init() {fmt.Println("this is wawa test2") } func Test2() {Test1() } Hello.go //程序所屬包 *必須package main//導(dǎo)入依賴包import ("fmt""awesomeProject/wawa""awesomeProject/wangwawa" )//常量定義?string不寫也可以const NAME string ="wawa"//全局變量的聲明與賦值var mainName string = "寶貝"//一般類型聲明type wawaInt int//結(jié)構(gòu)的聲明type Learn struct {}//聲明接口type Ilearn interface{}func init() {fmt.Println("this is hello.go"); }//函數(shù)定義func learnWawa(){fmt.Print(mainName)}//main函數(shù)func main(){learnWawa() //只會導(dǎo)入一次 wangwawa.Test()wawa.Test2()fmt.Print("Hello world!")}運行結(jié)果：
this is wangwawa test
this is wawa test1
this is wawa test2
this is hello.go
寶貝Hello world!
引入從最里面開始往外執(zhí)行
import特殊用法
別名操作的含義是：將導(dǎo)入的包命名為另一個容易記憶的別名
點（.）操作的含義是:點（.）標識的包導(dǎo)入后，調(diào)用該包中函數(shù)時可以活力前綴包名
下劃線（_）操作含義是：導(dǎo)入該包，但不導(dǎo)入整個我，而是執(zhí)行該包中的init函數(shù)，因此無法通過包名來調(diào)用包中其他函數(shù)，使用下劃線（_）操作往往是為了注冊包里的引擎，讓外部可以方便地使用
//程序所屬包 *必須 package main//導(dǎo)入依賴包import (//f為別名//f "fmt"//可省略. "fmt"//直接調(diào)用某包下的方法_ "awesomeProject/wangwawa" )func init() {Println("this is hello.go") }//main函數(shù)func main(){Print("Hello world!")}運行結(jié)果：
this is wangwawa test
this is hello.go
Hello world!
c.GO變量，函數(shù)，可見性規(guī)則
GO語言的數(shù)據(jù)類型
數(shù)據(jù)類型，字符串類型和布爾型
- byte 等同于int8，常用來處理ascii字符
- rune 等同于int32,常用來處理unicode或utf-8字符
-
rune類型的值需要由單引號“'”包裹。例如，'A'或'郝'。這種表示方法一目了然。不過，我們還可以用另外幾種形式表示rune類型值。請看下表。 ?
派生類型
指針類型（Poiniter）
數(shù)組類型
結(jié)構(gòu)化類型（struct）
Channel類型（chan）
通道（Channel）是Go語言中一種非常獨特的數(shù)據(jù)結(jié)構(gòu)。它可用于在不同Goroutine之間傳遞類型化的數(shù)據(jù)，并且是并發(fā)安全的
函數(shù)類型（func）
切片類型（slice）
在進行“切片”操作的時候需要指定元素下界索引和元素上界索引,切片表達式的求值結(jié)果相當于以元素下界索引和元素上界索引作為依據(jù)從被操作對象上“切下”而形成的新值。注意，被“切下”的部分不包含元素上界索引指向的元素
//程序所屬包 *必須 package main//導(dǎo)入依賴包import ("fmt" )//main函數(shù) func main(){var numbers3 = [5]int{1, 2, 3, 4, 5}var slice1 = numbers3[1:4]var slice2 = slice1[1:3]//切片是1-4 4不算，所以是2, 3, 4,fmt.Println(slice1)//容量是從第一個參數(shù)開始算，所以是2345fmt.Println(cap(slice1))//2, 3, 4,切片是1-3 3不算，所以是3fmt.Println(slice2)//容量是從第一個參數(shù)開始算，所以是345fmt.Println(cap(slice2)) }//程序所屬包 *必須
package main
//導(dǎo)入依賴包
import (
?? ?"fmt"
)
func main() {
? ? var numbers4 = [...]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
? ? slice5 := numbers4[4:6:8]
? ? length := (2)
?? ?capacity := (4)
?? ?fmt.Printf("%v, %v\n", length == len(slice5), capacity == cap(slice5))
?? ?slice5 = slice5[:cap(slice5)] //5,6,7,8
?? ?slice5 = append(slice5, 11, 12, 13)
?? ?length = (7)
?? ?fmt.Printf("%v\n", length == len(slice5))
?? ?slice6 := []int{0, 0, 0}
?? ?copy(slice5, slice6)
?? ?e2 := (0)
?? ?e3 := (8)
?? ?e4 := (11)
?? ?fmt.Printf("%v, %v, %v\n", e2 == slice5[2], e3 == slice5[3], e4 == slice5[4])
?
接口類型（interface）
Map類型（map）
? ? Go語言的字典（Map）類型其實是哈希表（Hash Table）的一個實現(xiàn)。字典用于存儲鍵-元素對（更通俗的說法是鍵-值對）的無序集合。注意，同一個字典中的每個鍵都是唯一的
? ? 字典類型的字面量如下：
map[K]T? ? 其中，“K”意為鍵的類型，而“T”則代表元素（或稱值）的類型。如果我們要描述一個鍵類型為int、值類型為string的字典類型的話，應(yīng)該這樣寫：
map[int]string? ? 請注意，字典的鍵類型必須是可比較的，否則會引起錯誤。也就是說，它不能是切片、字典或函數(shù)類型。
??
? ? 字典值的字面量表示法實際上與數(shù)組和切片的字面量表示法很相似。首先，最左邊仍然是類型字面量，右邊緊挨著由花括號包裹且有英文逗號分隔的鍵值對。每個鍵值對的鍵和值之間由英文冒號分隔。以字典類型map[int]string為例，它的值的字面量可以是這樣的：
? ? 我們可以把這個值賦給一個變量：
mm := map[int]string{1: "a", 2: "b", 3: "c"}? ? 然后運用索引表達式取出字典中的值，就像這樣：
b := mm[2]? ? 注意，在這里，我們放入方括號中的不再是索引值（實際上，字典中的鍵值對也沒有索引），而是與我們要取出的值對應(yīng)的那個鍵。在上例中變量b的值必是字符串"b"。當然，也可以利用索引表達式來賦值，比如這樣：
mm[2] = b + "2"? ? 這使得字典mm中與鍵2對應(yīng)的值變?yōu)榱?#34;b2"。現(xiàn)在我們再來向mm添加一個鍵值對：
mm[4] = ""? ? 之后，在從中取出與`4`和`5`對應(yīng)的值：
d := mm[4] e := mm[5]類型零值和類型別名
類型零值不是空值，而是某個變量被聲明后的默認值，一般情況下，值類型的默認值為0，布爾型默認值為false,string默認值 為空字符串
我們可以對類型設(shè)置別名
//程序所屬包 *必須 package mainimport ("fmt""reflect""unsafe" )//int32起的別名 type wawa int32 //main函數(shù) func main(){var i int32var ii wawavar j float32var b boolvar d complex64var s stringfmt.Print("int32 默認值為")fmt.Println(i)fmt.Print("int32k數(shù)據(jù)類型值為")fmt.Println(reflect.TypeOf(i))fmt.Print("int32數(shù)據(jù)占用空間值為")fmt.Println(unsafe.Sizeof(i))fmt.Println("------------------------------")fmt.Print("int32k別名wawa 默認值為")fmt.Println(ii)fmt.Print("int32k別名wawa 數(shù)據(jù)類型值為")fmt.Println(reflect.TypeOf(ii))fmt.Print("int32k別名wawa 數(shù)據(jù)占用空間值為")fmt.Println(unsafe.Sizeof(ii))fmt.Println("------------------------------同類型下才可以相匹配（+-等")fmt.Print("float32 默認值為")fmt.Println(j)fmt.Print("bool 默認值為")fmt.Println(b)fmt.Print("complex64 默認值為")fmt.Println(d)fmt.Print("string 默認值為")fmt.Println(s) }運行結(jié)果：
int32 默認值為0
int32k數(shù)據(jù)類型值為int32
int32數(shù)據(jù)占用空間值為4
------------------------------
int32k別名wawa 默認值為0
int32k別名wawa 數(shù)據(jù)類型值為main.wawa
int32k別名wawa 數(shù)據(jù)占用空間值為4
------------------------------同類型下才可以相匹配（+-等）
float32 默認值為0
bool 默認值為false
complex64 默認值為(0+0i)
string 默認值為
類型所占存儲大小
總結(jié)
