• Hello World

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

//告訴 Go 編譯器這個程序需要使用 fmt 包
import "fmt"
/*
func main() 是程序開始執(zhí)行的函數(shù)。
main 函數(shù)是每一個可執(zhí)行程序所必須包含的，
一般來說都是在啟動后第一個執(zhí)行的函數(shù)（如果有 init() 函數(shù)則會先執(zhí)行該函數(shù)）。

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

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

    第一種，指定變量類型，聲明后若不賦值，使用默認值。
    var v_name v_type
    v_name = value

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

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

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

    var (  // 這種因式分解關(guān)鍵字的寫法一般用于聲明全局變量
    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 {
}

/*
  實現(xiàn)接口方法
  方法的簽名類似：func printBook( book *Books ) {}
  但是實現(xiàn)接口方法在方法名前面要加結(jié)構(gòu)體對象和結(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ù)計算表達式的值。常量表達式中，函數(shù)必須是內(nèi)置函數(shù)，否則編譯不過：
    import "unsafe"
    const (
        a = "abc"
        b = len(a)
        c = unsafe.Sizeof(a)
    )

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

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

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

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

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


    var ip *int        /* 指向整型*/
    var fp *float32    /* 指向浮點型 */

    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 語言"
    Book1.author = "www.runoob.com"
    Book1.subject = "Go 語言教程"
    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ù)組的長度不可改變，在特定場景中這樣的集合就不太適用，Go中提供了一種靈活，
    功能強悍的內(nèi)置類型切片("動態(tài)數(shù)組"),與數(shù)組相比切片的長度是不固定的，可以追加元素，
    在追加時可能使切片的容量增大。

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

    也可以簡寫為

    slice1 := make([]type, len)
    也可以指定容量，其中capacity為可選參數(shù)。
    make([]T, length, capacity)
    這里 len 是數(shù)組的長度并且也是切片的初始長度。
    或者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去求一個slice的和。使用數(shù)組跟這個很類似
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }

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

    /*定義map
      聲明變量，默認 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 對，各個國家對應(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類型是一個接口類型，這是它的定義：
        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.如果變量是一個大的struct或者數(shù)組，則副本的創(chuàng)建相對會影響性能，這個時候考慮使用*T，只創(chuàng)建新的指針，這個區(qū)別是巨大的
    3.(不針對函數(shù)參數(shù)，只針對本地變量／局部變量)對于函數(shù)作用域內(nèi)的參數(shù)，如果定義成T,Go編譯器盡量將對象分配到棧上，
      而*T很可能會分配到對象上，這對垃圾回收會有影響
 */
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")
    }
    //錯誤為空
    return f*f,nil
}