Golang語法特性總結

1.認識Golang代碼特性

package main //1.包含main函數的文件就是一個main包--當前程序的包名// import "fmt"
// import "time"
import("fmt""time"
)//3.同時包含多個包 4.強制代碼風格:函數的 { 一定和函數名在同一行，否則會出現語法錯誤//main函數
func main() {fmt.Println("hello Go!")// fmt.Println("hello Go!"); 2.加不加分號都可以，建議不加分號time.Sleep(1 * time.Second)
}

2.Golang變量聲明的四種方式

package mainimport ("fmt"
)func main() {//方法一：聲明一個變量，不初始化默認是0var a intfmt.Println("a =",a)fmt.Printf("type of a = %T\n",a)//方法二：聲明一個變量，初始化var b int = 100fmt.Println("b =",b)fmt.Printf("type of b = %T\n",b)var bb string = "abcd"fmt.Printf("bb = %s,type of bb = %T\n",bb,bb)//方法三：在初始化時可以省去數據類型，通過值自動匹配當前的變量的數據類型var c = 100fmt.Println("c =",c)fmt.Printf("type of c = %T\n",c)var cc = "abcd"fmt.Printf("cc = %s,type of cc = %T\n",cc,cc)//方法四：(常用的方法)省去var的關鍵字，直接:=自動匹配;在聲明的變量是全局變量時，方法四是不可用的會報錯e := 100fmt.Println("e =",e)fmt.Printf("type of e = %T\n",e)ee := "abcd"fmt.Printf("ee = %s,type of ee = %T\n",ee,ee)eee := 3.14fmt.Printf("eee = %s,type of eee = %T\n",eee,eee)//聲明多個變量var xx,yy int = 100,200 //相同數據類型fmt.Println("xx =",xx," yy =",yy)var mm,nn = 100,"abcd" //不同數據類型fmt.Println("mm =",mm," nn =",nn)//多行的多變量聲明var (vv int = 100jj bool = true)fmt.Println("vv =",vv," jj =",jj)
}

3.常量與iota

package main//const 來定義枚舉類型
const (//可以在const()添加一個關鍵字 iota，每行的iota都會累加1，第一行的iota的默認值是0BEIJING = iota //iota = 0SHANGHAI	   //iota = 1SHENZHEN 	   //iota = 2
)
//iota只能出現在const的括號中
const (a,b = iota+1,iota+2// 0+1,0+2c,d				   // 1+1,1+2e,f				   // 2+1,2+2g,h = iota*2,iota*3// 3*2,3*3i,k				   // 4*2,4*3
)
func main()
{//常量-具有只讀屬性const length int = 10fmt.Println("length = ",length)length = 100 //報錯-常量不可更改
}

4.Golang多返回值的三種寫法?

package main
import "fmt"func fool(a string,b int) int {fmt.Println("a = ",a)fmt.Println("b = ",b)c := 100return c
}//1.返回多個返回值-匿名
func foo2(a string,b int) (int,int) {fmt.Println("a = ",a)fmt.Println("b = ",b)return 666,777
}//2.返回多個返回值-有形參名稱
func foo3(a string,b int) (r1 int,r2 int) {fmt.Println("------------foo3-----------")fmt.Println("a = ",a)fmt.Println("b = ",b)r1 = 1000r2 = 2000return r1,r2//return;  方法3--也可以返回r1,r2
}func main() {c := fool("abc",555)fmt.Println("c = ",c)ret1,ret2 := foo2("bfr",666)fmt.Println("ret1 = ",ret1,"ret2 = ",ret2)ret3,ret4 := foo3("grx",777)fmt.Println("ret3 = ",ret3,"ret4 = ",ret4)
}

5.init函數與import導包

遞歸式導包直到最后一個包沒有依賴包->加載該包全局的常量變量->執行init函數
"主程序開始之前，加載一些配置文件、加載一些數據庫的內容、基本環境變量的初始化"

package mainimport("GolangStudy/Golang_5/lib1""GolangStudy/Golang_5/lib2"
)func main(){lib1.LibTest()lib2.LibTest()
}

package lib1import "fmt"//API接口
func LibTest() {fmt.Println("Lib1Test.....")
}
//init初始化函數
func init() {fmt.Println("Lib1init.....")
}

package lib2import "fmt"//API接口--大寫首字母表示對外開放該接口
func LibTest() {fmt.Println("Lib2Test.....")
}
//init初始化函數
func init() {fmt.Println("Lib2init.....")
}

運行結果：?

三種導包的方式：

//三種導包的方式
import(_ "GolangStudy/Golang_5/lib1" //_表示匿名，可以在不使用該包但是可以調用它的init函數-無法使用當錢包的方法//mylib "GolangStudy/Golang_5/lib2" //給包起別名mylib. "GolangStudy/Golang_5/lib2" // . 表示將該包直接導入main包直接使用
)func main(){//lib1.LibTest()//lib2.LibTest()//mylib.LibTest()LibTest()//同名方法容易導致歧義
}

6.Golang中指針的使用

package main
import "fmt"func swap(pa *int, pb *int) {var tem int;tem = *pa  *pa = *pb*pb = tem
}func main() {var a int = 10var b int = 20swap(&a,&b)fmt.Println("a = ",a,"b = ",b)var p *intp = &afmt.Println("p = ",p)var pp **int = &pfmt.Println("pp = ",pp)
}

7.Golang中的defer語句?

package main
import "fmt"func main(){//寫入defer關鍵字--類似C++中的析構函數--出它作用域時會調用defer fmt.Println("main end1")//先入棧defer fmt.Println("main end2")//再入棧fmt.Println("main run1")fmt.Println("main run2")
}

輸出結果：?

defer和return的執行順序

func deferFunc() int{fmt.Println("defer func called...")return 0
}
func returnFunc() int{fmt.Println("return func called...")return 0
}
func rad() int {defer deferFunc()return returnFunc()
}
func main() {rad()
}

輸出結果： return比defer先執行

8.Golang中的數組

—靜態數組
靜態數組傳參是值拷貝傳參，并且只能接收特定格式的數組確定元素類型與元素個數

package main
import "fmt"//值拷貝傳參，將實參數組拷貝給形參
func printArray(myArray [10]int) { //只能接收1、2即int[10]數據類型for index,value:=range myArray {fmt.println(index," ",value)}
}
func printArray(myArray [4]int) {  只能接收3即int[4]數據類型for index,value:=range myArray {fmt.println(index," ",value)}
}func main(){//固定長度的數組var myArray1 [10]intmyArray2 := [10]int{1,2,3,4}myArray3 := [4]int{1,2,3,4}//for i:= 0; i<10; i++for i:=0; i<len(myArray1); i++{fmt.println(myArray1[i])}for index,value:=range myArray1 {fmt.println(index," ",value)}//查看數組的數據類型fmt.printf("myArray1 types = %T\n",myArray1)fmt.printf("myArray2 types = %T\n",myArray2)fmt.printf("myArray3 types = %T\n",myArray3)
}

—動態數組(slice切片)

package main
import "fmt"//動態數組具有傳參上的優勢
//傳遞的是當前數組的指針首地址，引用傳遞
func printArray(myArray []int) {// _ 表示匿名的變量for _, value := range myArray {//不關心下標，但必須用兩個接收fmt.Println("value = ",value)}myArray[0] = 100
}func main() {myArray := []int{1,2,3,4} //動態數組,切片 slicefmt.Printf("myArray type is %T\n",myArray)//輸出：myArray type is []intprintArray(myArray)for _, value := range myArray {fmt.Println("value = ",value)}
}

—四種聲明一個切片的方式?

func main () {//聲明slice是一個切片，并且初始化，默認值是1，2，3；長度len是3slice := []int{1,2,3}//聲明slice1是一個切片，但沒有給它分配空間var slice1 []int  //此時長度就是0slice1 = make([]int,3)//通過make給slice1分配空間，默認值是0//聲明slice2是一個切片，同時通過make給slice2分配空間，默認值是0var slice2 []int = make([]int,3)//聲明slice3是一個切片,同時分配空間，通過:=推導出slice是一個切片slice := make([]int,3)fmt.Printf("len = %d,slice = %v\n",len(slice1),slice1)//判斷一個slice是否為0if slice == nil {fmt.printf("slice是一個空切片")}else{fmt.printf("slice不是一個空切片")}
}

—切片容量的追加?

func main () {var numbers = make([]int,3,5)//開辟五個空間只初始化3個為0fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)//向numbers切片追加一個1numbers = append(numbers,1)fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)numbers = append(numbers,2)fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)numbers = append(numbers,3)//會進行2倍擴容fmt.Printf("len = %d,cap = %d,numbers = %v\n",len(numbers),cap(numbers),numbers)var numbers2 = make([]int,3)//開辟三個空間并全部初始化為0fmt.Printf("len = %d,cap = %d,numbers2 = %v\n",len(numbers2),cap(numbers2),numbers2)numbers2 = append(numbers2,1)//會進行2倍擴容fmt.Printf("len = %d,cap = %d,numbers2 = %v\n",len(numbers2),cap(numbers2),numbers2)
}

?輸出結果：

—切片的截取

func main () {s := []int{1,2,3} //len=3,cap=3//[0,2)s1 := s[0:2] //取1和2，前面省略表示從第0個開始取，后面省略表示取到最后一個fmt.Println(s1)s1[0] = 100fmt.Println(s1) //s1此時也指向s的第一個，相當于淺拷貝fmt.Println(s)//copy深拷貝，將底層數組的slice一起進行拷貝s2 := make([]int,2) //s2 = [0,0,0]copy(s2,s1)fmt.Println(s2) //可以先將s切片成s1，再進行深拷貝給s2，就可以分離
}

9.Golang中基于哈希的Map

—Map的三種聲明定義方式?

func main() {//第一種聲明方式var myMap1 map[string]string //僅僅是聲明，沒有實際的空間,并不能被使用if myMap1 == nil {fmt.Println("myMap1是一個空map")}myMap1 = make(map[string]string,10) //用make給Map開辟十個鍵值對的空間myMap1["one"] = "java"myMap1["two"] = "C++"myMap1["three"] = "python"//...當插入十個之后也會二倍擴容fmt.Println(myMap1)//打印出來是無序的//第二種聲明方式myMap2 := make(map[int]string)myMap2[1] = "java"myMap2[2] = "C++"myMap2[3] = "python"fmt.Println(myMap2)//第三種聲明方式myMap3 := map[int]string {4 : "java",5 : "C++",6 : "python",}fmt.Println(myMap3)
}

—Map的基本使用?

func printMap(cityMap map[string]string) {for key,value := range cityMap {fmt.Printf("key = %s ",key)fmt.Printf("value = %s\n",value)}cityMap["one"] = "golang"
}//指向當前map內存結構體地址的指針cityMapfunc main() {cityMap := make(map[string]string,3)//添加cityMap["one"] = "java"cityMap["two"] = "C++"cityMap["three"] = "python"//刪除delete(cityMap,"three")//修改cityMap["two"] = "php"//傳參printMap(cityMap)//遍歷for key,value := range cityMap {fmt.Printf("key = %s ",key)fmt.Printf("value = %s\n",value)}
}
//將一個map賦值給另一個時只能完成指針之間的淺拷貝，只能通過make開辟一個Map進行遍歷賦值

10.struct(類)的定義和使用?

—struct類的定義

//聲明一種行的數據類型，是Int的一個別名
type myint int 
type Book struct {title stringauth string 
}func changeBook(book Book) {//傳遞book的一個副本book.auth = "666"
}
func changeBook2(book *Book) {//傳遞指向Book結構體的指針book.auth = "777"
}func main() {// var a myint = 10// fmt.Printf("type = %T",a)var book1 Bookbook1.title = "Golang"book1.auth = "zhang3"fmt.Printf("book1 = %v",book1)
}

—類的封裝和方法的調用

//go語言中的類實際上是通過結構體來綁定方法
package main//方法名、類名如果首字母大寫，其它包也可以訪問
type Hero struct {Name stringAd intLevel int
}//當前括號表示該方法綁定到了Hero結構體，this表示調用對象，誰調用該方法this就指哪個對象
func (this Hero) GetName() string{return this.Name
}//this是當前調用對象的一個副本
func (this Hero) SetName(newName string) {this.Name = newName
}
//此時this就是指向當前對象的指針，就可以修改了
func (this *Hero) SetName(newName string) {this.Name = newName
}func main() {//創建一個對象hero := Hero{Name: "zhang3",Ad: 100,Level: 1}
}

—繼承的基本語法?

type Human struct {name stringsex string
}func (this *Human) Eat() {fmt.Println("human Eat().....")
}
func (this *Human) Walk() {fmt.Println("human Walk().....")
}type SuperMan struct {//Go中實際是以組合的形式實現繼承Human //Superman繼承了Human類的所有方法level int
}//重寫(覆蓋)父類方法
func (this *SuperMan) Eat() {fmt.Println("SuperMan Eat().....")
}//子類的新方法
func (this *SuperMan) Fly() {fmt.Println("SuperMan Fly().....")
}func main() {h := Human{"zhang3","female"}h.Eat()h.Walks := SuperMan{Human{"li4","female"},88}// var s SuperMan// s.name = "li4"//...s.Walk() //子類調用父類的方法s.Eat() //子類調用子類重寫的方法s.Fly() //子類調用子類的新方法
}

—interface實現多態?

package main
//面向對象的多態：定義一個接口完成多態的現象;接口定義抽象方法，子類去繼承實現重寫這個方法//interface本質上是一個指針，指向當前類型包含的函數列表
type AnimalIF interface {Sleep()GetColor() string //獲取動物的顏色GetType() string //獲取動物的類型
}//具體的值--要繼承AnimalIF interface只需要將他的三個方法實現，不需要顯式繼承
type Cat struct {color string //貓的顏色
}func (this *Cat) Sleep() {fmt.Println("cat is sleep")
}func (this *Cat) GetColor() string {return this.color
}func (this *Cat) GetType() string {return "cat"
}//具體的值--狗
type Dog struct {color string 
}func (this *Dog) Sleep() {fmt.Println("Dog is sleep")
}func (this *Dog) GetColor() string {return this.color
}func (this *Dog) GetType() string {return "Dog"
}func showAnimal(animal AnimalIF)//調用該函數，形參為父類指針，實參為子類對象實現多態
{animal.Sleep()
}func main() {// var animal AnimalIF //接口的數據類型，相當于定義了一個父類指針// animal = &Cat("green") //讓父類的指針指向一個子類對象// animal.Sleep() //指向子類對象的父類指針調用子類方法實現多態cat := Cat("green")dog := Dog("yellow")showAnimal()
}

—interface{}空接口萬能類型

//interface{} 空接口，萬能類型-》可以引用任意數據類型
package mainimport "fmt"func myFunc(arg interface{}) { //可以傳任意類型的實參fmt.Println("myFunc is called..")fmt.Println(arg)//類型斷言value,ok := arg.(string) //value是數據值，ok是errorif !ok {fmt.Println("arg is not a string")}else{fmt.Println("arg is a string")}fmt.Println(value)
}type Book struct {auth string
}func main() {book := Book{"Golang"}myFunc(book)myFunc("abcd")myFunc(888)myFunc(23.45)
}

11.Golang中反射的概念

—接口type interface { }的類型
Golang中一個變量包含一個pair即type和value對。
type分為static type(在編譯時就確定并且不會改變)和concrete type(在運行時確定并且會改變)。

var i int           // static type 為 int; 
var i interface{}   // pair()
i = 18             // concrete type 為 int
i = "Go編程時光"   // concrete type 變為 string

type Reader interface {ReadBook()
}type Writer interface {WriteBook()
}//具體類型
type Book struct {
}func (this *Book) ReadBook() {fmt.Println("Read a book.")
}func (this *Book) WriteBook() {fmt.Println("Write a book.")
}func main() {b := &Book{}  //type:*Book  value:0xc000012028var r Reader  //concrete type:nil,static type：Reader  value:nilr = b         //concrete type:Book*,static type Reader  value:0xc000012028r.ReadBook()  //Reader - Book* 多態var w Writer  //concrete type:nil,static type：Writer  value:nilw = r.(Writer)//類型斷言,檢查r是否實現了Writer，并將Book*給ww.WriteBook()
}

—reflect.ValueOf 和 reflect.TypeOf?

package mainimport "fmt"
import "reflect"type User struct {Id int//一個filedName string//第二個filedAge int		//第三個filed
}func (this *User) Call() {fmt.Println("User is called ...")fmt.Println("%v\n",this)
}func main() {user := User{1,"bfr",18}DoF(user)
}func DoF(input interface{}) {//獲取input的typeinputType := reflect.TypeOf(input)fmt.Println("inputType :",inputType.Name())//?直接打印出當前類型的名稱？//獲取input的valueinputValue := reflect.ValueOf(input)fmt.Println("inputValue :",inputValue)//通過type獲取里面重要字段//通過inputType可以獲取NumFiled，進行遍歷，就能得到每個filedfor i := 0;i < inputType.NumField(); i++ {field := inputType.Field(i)value := inputValue.Field(i).Interface()//?獲取字段的值fmt.Printf("%s: %v = %v\n",field.Name,field.Type,value)//ID,int,1}//通過Type獲取里面的方法，調用for i:=0; i<inputType.NumMethod(); i++ { //遍歷User有多少個方法m := inputType.Method(i)fmt.Printf("%s: %v\n",m.Name,m.Type)}
}

12.結構體標簽?

package main
import "fmt"
import "reflect"//在不同包中有不同的解釋說明
type resume struct {Name string `info:"name" doc:"我的名字"`Sex string `info:"sex"`
}func findTag(str interface{}) {t := reflect.TypeOf(str).Elem()//Elem當前結構體的全部元素for i := 0; i < t.NumField(); i++ {taginfo := t.Field(i).Tag.Get("info")tagdoc := t.Field(i).Tag.Get("doc")fmt.Println("info: ",taginfo," dac:",tagdoc)}
}func main() {var res resumefindTag(&res)
}

//結構體標簽-key已知，value未知
type Movie struct {Title string `json:"title"` //在json中顯示的字段Year int	`json:"year"`Price int	`json:"price"`Actors []string  `json:"actors"`
}func main() {movie := Movie{"喜劇之王",2000,10,[]string{"xingye","zbz"}}//編碼的過程 將結構體->jsonjsonStr,err := json.Marshal(movie)//Marshal可以將結構體轉化為json格式if err != nil {fmt.Println("json marshal error",err)}else{fmt.Printf("josnStr = %s\n",jsonStr)}//解碼的過程 json->結構體myMovie := Movie{}err = json.Unmarshal(jsonStr,&myMovie)//將json字符串解析給myMovie結構體if err != nil {fmt.Println("json unmarshal error",err)return}
}

13.Golang中的協程:goroutine

—協程的演變發展

—單進程的操作系統只能順序執行任務，一旦某個任務阻塞，其它任務都不能處理。
—多進程/多線程解決了，CPU調度器進行輪詢調度切換進程/線程?，當某個時間片到了就會切換。但是進程/線程間切換具有成本，一旦數量過大，CPU的使用效率就會大大降低。進程占4GB左右,線程占用4MB左右，也有高內存占用的弊端。
—將一個線程拆分，一半在用戶層面供用戶調用(協程:co-routine)，一半在內核層供CPU調度。
? ? —N : 1，如果有一個協程阻塞，那它的下一個協程就會受到影響。操作系統感知不到用戶級協程的存在，無法將阻塞的協程與線程分離，線程資源被完全占用?
? ? —M : N，利用多核，一個CPU綁定多個線程；解決了某個協程阻塞影響其它協程的問題；通過優化寫成調度器優化效率，CPU不做調度。

—Golang對協程的處理
co-routine -> goroutine；將占用內存優化到KB單位(可以大量生產)，(可以靈活調度)。
? ?—通過優化調度器實現靈活調度

package mainimport "fmt"
import "time"func newTask() {i:=0for { i++fmt.Printf("new Goroutine : i = %d\n",i) time.Sleep(1 * time.Second)}
}func main() {//創建一個go程 去執行newTask()流程go newTask()time.Sleep(10*time.Second)fmt.Println("main goroutine exit")// i:=0// for { //死循環main// 	i++// 	fmt.Printf("main goruntine: i = %d\n",i)// 	time.Sleep(1*time.Second)// }
}

package mainimport "fmt"
import "time"
import "runtime"func main() {//調匿名無參goroutinego func() {//匿名方法，直接用Go承載一個形參為空返回值為空的一個函數defer fmt.Println("A.defer")func() {//僅僅是函數定義defer fmt.Println("B.defer")//return runtime.Goexit()fmt.Println("B")}()fmt.Println("A")}()//調用//調匿名有參goroutinego func(a int,b int) bool { //并不是阻塞操作，是一個異步操作，不能拿到返回值fmt.Println("a = ",a," b = ",b)return true}(10,20)time.Sleep(1*time.Second)
}

?14.channel-go語言中協程間通信的機制

—構成死鎖：
1.無緩存channel、只寫不讀或只讀不寫、導致主線程阻塞。
2.有緩存channel、已滿只寫不讀或為空只讀不寫、導致主線程阻塞。

package main
import "fmt"
//import "time"func main() {c := make(chan int,3)//帶有緩沖的channelfmt.Println("len(c) = ",len(c)," cap(c) = ",cap(c))go func() {defer fmt.Println("子go程結束")for i:=0;i<6;i++{c <- ifmt.Println("running...:","i = ",i," len(c) = ",len(c)," cap(c) = ",cap(c))}}()//time.Sleep(2 * time.Second)// for i:=0;i<2;i++ {// 	num := <-c //從c中接收數據，并賦值給num// 	fmt.Println("num =",num)// }fmt.Println("main 結束")
}

—close關閉channel?
關閉channel后，無法向channel再發送數據(再發會引發 panic 錯誤后導致接收立即返回零值)
關閉channel后，仍舊具有緩存，等讀端讀完了才會返回。
簡單var聲明一個channel數據類型，沒有進行make，稱為nil channel。無論收發都會阻塞。

package main
import "fmt"
func main() {c := make(chan int)go func() {for i:=0;i<5;i++ {c <- i}//close可以關閉一個channelclose(c)}()for {//ok=true表示channel沒有關閉if data,ok := <-c; ok { //原子性操作?：確保通道接收與狀態檢查在同一個代碼塊中完成fmt.Println(data)}else{break}}fmt.Println("Main Finished..")
}

—channel 和 range?
嘗試從c中讀數據，range會阻塞等待這個結果；c中有數據range就會返回并進入本輪for循環，沒有數據就會阻塞

//可以使用range來迭代不斷操作channel
for data := range c { fmt.Println(data)}

—channel 和 select
單流體下的一個go只能監視一個channel狀態，阻塞監聽，select可以解決一個go監聽多個channel狀態，如果某個channel可讀或可寫它就會立刻返回。一般會循環進行select監控多個channel。

package mainimport "fmt"func fibo(c,quit chan int){x,y := 1,1         //1,1->1; 1,2->1; for{select{case c <- x: //只要func可讀這邊就可寫//如果c可寫，則該case就會進來t := xx = yy = t+ycase <-quit: //只要quit被寫入這邊就可讀就退出fmt.Println("quit")return}}
}func main() {c := make(chan int)quit := make(chan int)go func() {for i := 0; i < 6; i++{fmt.Println(<-c)//讀c}quit <- 0 //循環結束退出}()//main gofibo(c,quit)
}