GO入門筆記

時間 2019-12-08

標籤入門筆記简体版

原文原文鏈接

GO筆記整理

Golang內置關鍵字python

//Go內置關鍵字（25個均爲小寫）
/* break default func interface select case defer go map struct chan else goto package switch const fallthrough if range type continue for import return var */
"內置函數名也不能用於變量聲明"
複製代碼

Go程序的通常結構

Go程序是經過 package 來組織的（與python相似）ide
只有 package 名稱爲 main 的包能夠包含 main 函數函數
一個可執行程序有且僅有一個 main 包測試
經過 ==import== 關鍵字來導入其它非 main 包ui
經過 ==const== 關鍵字來進行常量的定義spa
經過在函數體外部使用 ==var== 關鍵字來進行全局變量的聲明與賦值指針
經過 ==type== 關鍵字來進行==結構(struct)==或==接口(interface)==的聲明code
經過 ==func== 關鍵字來進行函數的聲明接口

GO的數據類型彙總給

int,float uint complex bool   //足夠保存指針的 32 位或 64 位整數型：uintptr

array struct string
slice map chan
interface
func 複製代碼

###變量string

// 聲明變量的三種方式
var str string = "I am Dean"   // 變量名 變量類型 = 值
var str = "I am Dean"    // 自行判斷類型
str := "I am Dean"       // 最簡便寫法,===>> 不可用於聲明全局變量 

/*其餘須要注意的=+++++++++++++++++++++++++++++++++++++++++++++*/
var (            // 全局變量聲明必須使用var關鍵字
	a = 1
    b,c = 2,3          // 並行聲明變量
)
var a,b,c,d int //如沒有賦值,則取初始值 數字=0 bool=false string=''
// ===================================================================
/*1==>GO中不存在隱式轉換,全部類型轉換必須顯式聲明 2==>轉換隻發生在兩種相互兼容的類型之間 3==>類型轉換的格式: <ValueA>[:] = <TypeOfValueA>(<ValueB>) */
a:=1.1
b:=int(a)
fmt.Println(b)
// 下面的會報錯 cannot convert c (type bool) to type int
c:=true
d:=int(c)
fmt.Println(d)
// 測試如下代碼打印的值
	var aa int  = 66
	bb := string(aa)
	fmt.Println(bb)

複製代碼

常量

常量的值在編譯的時候就已肯定不可更改
常量定義格式基本與變量相同
等號右側必須是常量或者是常量表達式
常量表達式中的函數必須是==內置函數==

const a int = 1
const b = 'A'
const (
	text = '123'
    length = len(text)
    num = b*20
)
// iota是常量的計數器,從0開始,組中每定義一個常量自動遞增1
// 但沒遇到一個const關鍵字,iota就會歸零
const (
	aa = iota
	a = 1
	b
	c = iota
	d = iota
)
const (
	Monday = iota
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
    Sunday 
)
// 預測 aa,a,b,c,d的值 分析出要點
func main() {
	fmt.Println(aa,a,b,c,d)
}
複製代碼

運算符

運算符
Go中的運算符均是從左至右結合
優先級（從高到低）

^      !                                               （一元運算符）
*       /    %    <<    >>    &      &^
+      -     |      ^                                （二元運算符）
==   !=   <    <=    >=    >
<-                                              // （專門用於channel）
&&
||
複製代碼

數據類型

//float32 float64
// uint8 / int8 
// bool
// byte (uint8別名)
// int/uint

複製代碼

結構struct

type jiegou struct {
    name string
    age int
}
// 匿名結構
func main() {
    a := &struct {
        Name string
        Age int
    }{
        Name: "dean",
        Age:19,
    }
}
// 匿名結構
type person struct {
    Name string
    Age int
    Contact struct {
        Phone,City string
    }
}

func main() {
    a := person{Name: "dean",Age:19}
    a.Contact.Phone = "13356424532"
    a.Contact.City = "ruishi"
}
//匿名字段 靠順序對應字段類型
type person struct {
    string
    int
}
func main() {
    a:= person{"joe", 19}
    fmt.Pringln(a)
}

複製代碼

method(相似於class的def)

概念:method是附屬在一個給定的類型上,語法和函數的聲明幾乎同樣,只是func後面增長了一個recvier(這個def給哪一個class的意思)

//格式
func (r ReveiverType) funcName(parameters) (results){
    //
}
//示例1
func main() {
    r1 := Rectangle{12,2}
    r1.area()
}
type Rectangle struct {
    width, height float64
}

func (r Rectangle) area() float64 {
    return r.width * r.height
}
//示例2
func main() {
    a:=A{}
    a.Print()
    fmt.Println(a.Name)
    
    b:=B{}
    b.Print()
    fmt.Println(b.Name)
} // 輸出結果是 A AA B 這是指針和無指針的對比

type A struct {
    Name string
}
type B struct {
    Name string
}
func (a *A) Print() {
    a.Name="AA"
    fmt.Pringln("A")
}
func (b B) Print() {
    a.Name="BB"
    fmt.Pringln("B")
}
// 示例3
type TZ int
func main() {
    var a TZ
    a.Print()  //輸出TZ
    
    (*TZ).Print(&a) // 一樣能夠輸出TZ 
}
func (a *TZ) Print() {
    fmt.Pringln("TZ")
}

複製代碼

接口interface

type Shaper interface {
	Area() float32
}
type Square struct{
    side float32
}
func (sq *Square) Area() float32 {
	return sq.side * sq.side
}
func main() {
	sq1 := new(Square)
	sq1.side = 5
	var areaIntf Shaper
	areaIntf = sq1
    //使用 類型斷言 來測試在某個時刻 varI 是否包含類型 T 的值
    if t,ok := areaIntf.(*Square); ok{   // t,ok := 接口變量.(*某個類型)
		fmt.Println(t,ok)
		fmt.Printf("The type of areaIntf is :%T\n", t)
	}
}
複製代碼