• Hello World

/**
 *第一行代碼 package main 定義了包名铺然。
 *你必須在源文件中非注釋的第一行指明這個(gè)文件屬于哪個(gè)包俗孝，
 *如：package main。package main表示一個(gè)可獨(dú)立執(zhí)行的程序魄健，
 *每個(gè) Go 應(yīng)用程序都包含一個(gè)名為 main 的包赋铝。
 */
package main

//告訴 Go 編譯器這個(gè)程序需要使用 fmt 包
import "fmt"
/*
func main() 是程序開(kāi)始執(zhí)行的函數(shù)。
main 函數(shù)是每一個(gè)可執(zhí)行程序所必須包含的沽瘦，
一般來(lái)說(shuō)都是在啟動(dòng)后第一個(gè)執(zhí)行的函數(shù)（如果有 init() 函數(shù)則會(huì)先執(zhí)行該函數(shù)）革骨。

當(dāng)標(biāo)識(shí)符（包括常量、變量析恋、類型良哲、函數(shù)名、結(jié)構(gòu)字段等等）以一個(gè)大寫(xiě)字母開(kāi)頭助隧，如：Group1筑凫，
那么使用這種形式的標(biāo)識(shí)符的對(duì)象就可以被外部包的代碼所使用（客戶端程序需要先導(dǎo)入這個(gè)包），
這被稱為導(dǎo)出（像面向?qū)ο笳Z(yǔ)言中的 public）并村；標(biāo)識(shí)符如果以小寫(xiě)字母開(kāi)頭巍实，
則對(duì)包外是不可見(jiàn)的，但是他們?cè)谡麄€(gè)包的內(nèi)部是可見(jiàn)并且可用的（像面向?qū)ο笳Z(yǔ)言中的 protected ）

go run Hello.go
*/
func main() {
    /*
    變量聲明

    第一種哩牍，指定變量類型棚潦，聲明后若不賦值，使用默認(rèn)值膝昆。
    var v_name v_type
    v_name = value

    第二種瓦盛，根據(jù)值自行判定變量類型洗显。
    var v_name = value

    第三種，省略var, 注意 :=左側(cè)的變量不應(yīng)該是已經(jīng)聲明過(guò)的原环，否則會(huì)導(dǎo)致編譯錯(cuò)誤挠唆。
    v_name := value，這種只能在函數(shù)體中出現(xiàn)

    // 例如
    var a int = 10
    var b = 10
    c : = 10

    var (  // 這種因式分解關(guān)鍵字的寫(xiě)法一般用于聲明全局變量
    a int
    b bool
    )


    */
    fmt.Println("Hello, World!")
}

• 數(shù)據(jù)類型

package main

import (
    "fmt"
    "reflect"
    "errors"
)

//定義結(jié)構(gòu)體
type Books struct {
    title string
    author string
    subject string
    book_id int
}

//定義接口
type Phone interface {
    call()
}

//定義結(jié)構(gòu)體
type NokiaPhone struct {
}

/*
  實(shí)現(xiàn)接口方法
  方法的簽名類似：func printBook( book *Books ) {}
  但是實(shí)現(xiàn)接口方法在方法名前面要加結(jié)構(gòu)體對(duì)象和結(jié)構(gòu)體類型
 */
func (nokiaPhone NokiaPhone) call() {
    fmt.Println("I am Nokia, I can call you!")
}



func main() {
    /*
    type 可選
    const identifier [type] = value

    常量可以用len(), cap(), unsafe.Sizeof()函數(shù)計(jì)算表達(dá)式的值嘱吗。常量表達(dá)式中玄组，函數(shù)必須是內(nèi)置函數(shù)，否則編譯不過(guò)：
    import "unsafe"
    const (
        a = "abc"
        b = len(a)
        c = unsafe.Sizeof(a)
    )

    在每一個(gè)const關(guān)鍵字出現(xiàn)時(shí)谒麦，被重置為0俄讹，然后再下一個(gè)const出現(xiàn)之前，每出現(xiàn)一次iota绕德，其所代表的數(shù)字會(huì)自動(dòng)增加1患膛。
    iota 可以被用作枚舉值：
    const (
    a = iota //0
    b = iota //1
    c = iota //2
    )
    簡(jiǎn)寫(xiě)
    const (
    a = iota
    b
    c
    )
    const (
            a = iota   //0
            b          //1
            c          //2
            d = "ha"   //獨(dú)立值，iota += 1
            e          //"ha"   iota += 1
            f = 100    //iota +=1
            g          //100  iota +=1
            h = iota   //7,恢復(fù)計(jì)數(shù)
            i          //8
    )

    */
    const a, b, c = 1, false, "str" //多重賦值
    fmt.Println(a, b, c)

    var n [10]int /* n 是一個(gè)長(zhǎng)度為 10 的數(shù)組 */
    var i,j int

    /* 為數(shù)組 n 初始化元素 */
    for i = 0; i < 10; i++ {
        n[i] = i + 100 /* 設(shè)置元素為 i + 100 */
    }

    /* 輸出每個(gè)數(shù)組元素的值 */
    for j = 0; j < 10; j++ {
        fmt.Printf("Element[%d] = %d\n", j, n[j] )
    }


    var ip *int        /* 指向整型*/
    var fp *float32    /* 指向浮點(diǎn)型 */

    var intp int = 10
    var floatp float32 = 32.0

    ip = &intp
    fp = &floatp

    fmt.Printf("變量地址: %x:%x\n", ip,fp  )

    var  ptr *int

    if ptr != nil {
        fmt.Printf("ptr 的值為 : %x\n", ptr  )
    }

    /*
      type Books struct {
               title string
               author string
               subject string
               book_id int
            }
     */
    var Book1 Books        /* 聲明 Book1 為 Books 類型 */

    /* book 1 描述 */
    Book1.title = "Go 語(yǔ)言"
    Book1.author = "www.runoob.com"
    Book1.subject = "Go 語(yǔ)言教程"
    Book1.book_id = 6495407

    /* 打印 Book1 信息 */
    fmt.Printf( "Book 1 title : %s\n", Book1.title)
    fmt.Printf( "Book 1 author : %s\n", Book1.author)
    fmt.Printf( "Book 1 subject : %s\n", Book1.subject)
    fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)

    printBook(&Book1)

    /*定義切片
    Go 數(shù)組的長(zhǎng)度不可改變耻蛇，在特定場(chǎng)景中這樣的集合就不太適用踪蹬，Go中提供了一種靈活，
    功能強(qiáng)悍的內(nèi)置類型切片("動(dòng)態(tài)數(shù)組"),與數(shù)組相比切片的長(zhǎng)度是不固定的臣咖，可以追加元素跃捣，
    在追加時(shí)可能使切片的容量增大。

    你可以聲明一個(gè)未指定大小的數(shù)組來(lái)定義切片：
    var identifier []type
    定義數(shù)組是var balance [10] float32或者var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
    也就是說(shuō)數(shù)組,[]中括號(hào)里必須要有東西夺蛇，那怕是省略號(hào)
    切片不需要說(shuō)明長(zhǎng)度疚漆。
    或使用make()函數(shù)來(lái)創(chuàng)建切片:
    var slice1 []type = make([]type, len)

    也可以簡(jiǎn)寫(xiě)為

    slice1 := make([]type, len)
    也可以指定容量，其中capacity為可選參數(shù)刁赦。
    make([]T, length, capacity)
    這里 len 是數(shù)組的長(zhǎng)度并且也是切片的初始長(zhǎng)度娶聘。
    或者s :=[] int {1,2,3 }
     */

    var balance = [...]int {1,2,3 }
    fmt.Println(reflect.TypeOf(balance))

    s :=[] int {1,2,3 }
    fmt.Println(reflect.TypeOf(s))

    s = balance[:]
    int_s := append(s, 4)
    fmt.Println(s,int_s)

    //循環(huán)

    //這是我們使用range去求一個(gè)slice的和。使用數(shù)組跟這個(gè)很類似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }

    fmt.Println("sum:", sum)
    //在數(shù)組上使用range將傳入index和值兩個(gè)變量甚脉。上面那個(gè)例子我們不需要使用該元素的序號(hào)趴荸，
    // 所以我們使用空白符"_"省略了。有時(shí)侯我們確實(shí)需要知道它的索引宦焦。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }
    //range也可以用在map的鍵值對(duì)上。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    //range也可以用來(lái)枚舉Unicode字符串顿涣。第一個(gè)參數(shù)是字符的索引波闹，第二個(gè)是字符（Unicode的值）本身。
    for i, c := range "go" {
        fmt.Println(i, c)
    }

    /*定義map
      聲明變量涛碑，默認(rèn) map 是 nil
      var map_variable map[key_data_type]value_data_type

      使用 make 函數(shù)
      map_variable := make(map[key_data_type]value_data_type)
     */

    var countryCapitalMap map[string]string
    /* 創(chuàng)建集合 */
    countryCapitalMap = make(map[string]string)

    /* map 插入 key-value 對(duì)精堕，各個(gè)國(guó)家對(duì)應(yīng)的首都 */
    countryCapitalMap["France"] = "Paris"
    countryCapitalMap["Italy"] = "Rome"
    countryCapitalMap["Japan"] = "Tokyo"
    countryCapitalMap["India"] = "New Delhi"

    /* 使用 key 輸出 map 值 */
    for country := range countryCapitalMap {
        fmt.Println("Capital of",country,"is",countryCapitalMap[country])
    }

    /* 查看元素在集合中是否存在 */
    captial, ok := countryCapitalMap["United States"]
    /* 如果 ok 是 true, 則存在，否則不存在 */
    if(ok){
        fmt.Println("Capital of United States is", captial)
    }else {
        fmt.Println("Capital of United States is not present")
    }

    /* 刪除Map元素 */
    delete(countryCapitalMap,"France");
    fmt.Println("Entry for France is deleted")

    fmt.Println("刪除元素后 map")

    /* 打印 map */
    for country := range countryCapitalMap {
        fmt.Println("Capital of",country,"is",countryCapitalMap[country])
    }

    //異常處理

    /*
        error類型是一個(gè)接口類型蒲障，這是它的定義：
        type error interface {
            Error() string
        }
     */

    f, e := Sqrt(1)
    fmt.Println(f,e==nil)

    f, e = Sqrt(-1)
    fmt.Println(f,e==nil)

}

/*
    1.不想變量被修改歹篓。 如果你不想變量被函數(shù)和方法所修改瘫证，那么選擇類型T。相反庄撮，如果想修改原始的變量背捌，則選擇*T
    2.如果變量是一個(gè)大的struct或者數(shù)組，則副本的創(chuàng)建相對(duì)會(huì)影響性能洞斯，這個(gè)時(shí)候考慮使用*T毡庆，只創(chuàng)建新的指針，這個(gè)區(qū)別是巨大的
    3.(不針對(duì)函數(shù)參數(shù)烙如，只針對(duì)本地變量／局部變量)對(duì)于函數(shù)作用域內(nèi)的參數(shù)么抗，如果定義成T,Go編譯器盡量將對(duì)象分配到棧上，
      而*T很可能會(huì)分配到對(duì)象上亚铁，這對(duì)垃圾回收會(huì)有影響
 */
func printBook( book *Books ) {
    fmt.Printf( "Book title : %s\n", book.title);
    fmt.Printf( "Book author : %s\n", book.author);
    fmt.Printf( "Book subject : %s\n", book.subject);
    fmt.Printf( "Book book_id : %d\n", book.book_id);
}

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    //錯(cuò)誤為空
    return f*f,nil
}