摘要：語言中變量的聲明必須使用空格隔開如可見性規(guī)則語言中，使用大小寫來決定該常量變量類型接口結(jié)構(gòu)或函數(shù)是否可以被外部包所調(diào)用。

1.包聲明 2.引入包 3.函數(shù) 4.變量 5.語句 & 表達式 6.注釋

 // 當(dāng)前程序的包名
package main

// 導(dǎo)入其他包
import . "fmt"

// 常量定義
const PI = 3.14

// 全局變量的聲明和賦值
var name = "gopher"

// 一般類型聲明
type newType int

// 結(jié)構(gòu)的聲明
type gopher struct{}

// 接口的聲明
type golang interface{}

// 由main函數(shù)作為程序入口點啟動
func main() {
    Println("Hello World!")
}

//前面加個點表示省略調(diào)用，那么調(diào)用該模塊里面的函數(shù)，可以不用寫模塊名稱了:
import . "fmt"
func main (){
    Println("hello,world")
}

通過 const 關(guān)鍵字來進行常量的定義。
通過在函數(shù)體外部使用 var 關(guān)鍵字來進行全局變量的聲明和賦值。
通過 type 關(guān)鍵字來進行結(jié)構(gòu)(struct)和接口(interface)的聲明。
通過 func 關(guān)鍵字來進行函數(shù)的聲明。
Go 語言中變量的聲明必須使用空格隔開
如：var age int;

Go語言中，使用大小寫來決定該常量、變量、類型、接口、結(jié)構(gòu)或函數(shù)是否可以被外部包所調(diào)用。
函數(shù)名首字母小寫即為 private :
func getId() {}

函數(shù)名首字母大寫即為 public :
func Printf() {}

func main() {
    fmt.Print("a", "b", 1, 2, 3, "c", "d", "
")
    fmt.Println("a", "b", 1, 2, 3, "c", "d")
    fmt.Printf("ab %d %d %d cd
", 1, 2, 3)
    // ab1 2 3cd
    // a b 1 2 3 c d
    // ab 1 2 3 cd

    if err := percent(30, 70, 90, 160); err != nil {
        fmt.Println(err)
    }
    // 30%
    // 70%
    // 90%
    // 數(shù)值 160 超出范圍（100）
}

3.1 Println深度理解：

  package main  
  
import (  
    "fmt"  
    "strings"  
)  
  
func main() {  
    str := "這里是 www
.runoob
.com"  
    fmt.Println("-------- 原字符串 ----------")  
    fmt.Println(str)  
    // 去除空格  
    str = strings.Replace(str, " ", "", -1)  
    // 去除換行符  
    str = strings.Replace(str, "
", "", -1)  
    fmt.Println("-------- 去除空格與換行后 ----------")  
    fmt.Println(str)  
}
輸出結(jié)果為：

-------- 原字符串 ----------
這里是 www
.runoob
.com
-------- 去除空格與換行后 ----------
這里是www.runoob.com

Go 程序可以由多個標(biāo)記組成，可以是關(guān)鍵字，標(biāo)識符，常量，字符串，符號。

1.布爾型:布爾型的值只可以是常量 true 或者 false。
2.數(shù)字類型:整型 int8~64、uint8~64、 和 uintptr。和浮點型 float32~64，complex64~128，Go語言還支持其他數(shù)字類型
byte類似 uint8 rune類似 int32 uint32 或 64 位 int與 uint 一樣大小 uintptr 無符號整型，用于存放一個指針。
3.字符串類型:字符串就是一串固定長度的字符連接起來的字符序列。Go的字符串是由單個字節(jié)連接起來的。
Go語言的字符串的字節(jié)使用UTF-8編碼標(biāo)識Unicode文本。
4.派生類型:
(a) 指針類型（Pointer）(b) 數(shù)組類型(c) 結(jié)構(gòu)化類型(struct)
(d) Channel 類型(e) 函數(shù)類型(f) 切片類型(g) 接口類型（interface）(h) Map 類型

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

var v_name v_type
v_name = value

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

var v_name = value

第三種，省略var, 注意 :=左側(cè)的變量不應(yīng)該是已經(jīng)聲明過的，否則會導(dǎo)致編譯錯誤。

v_name := value

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

多變量聲明

package main

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

var c, d int = 1, 2
var e, f = 123, "hello"

//這種不帶聲明格式的只能在函數(shù)體中出現(xiàn)
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}
//輸出為：0 0 0 false 1 2 123 hello 123 hello

多個相同類型的聲明可以簡寫為：

const c_name1, c_name2 = value1, value2

常量還可以用作枚舉：

const (
    Unknown = 0
    Female = 1
    Male = 2
)

iota，特殊常量，可以認為是一個可以被編譯器修改的常量。
在每一個const關(guān)鍵字出現(xiàn)時，被重置為0，然后再下一個const出現(xiàn)之前，每出現(xiàn)一次iota，其所代表的數(shù)字會自動增加1。
iota 可以被用作枚舉值：

  func main() {
                  const (
        aa = iota
        bb = iota
        cc = iota
    )
    fmt.Println("aa=,bb=,cc=", aa, bb, cc)
    //0 1 2
    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
    )
    fmt.Println(a, b, c, d, e, f, g, h, i)
    //0 1 2 ha ha 100 100 7 8
    const (
        j = 1 << iota
        k = 3 << iota
        l
        m
    )

    fmt.Println("j=", j)
    fmt.Println("k=", k)
    fmt.Println("l=", l)
    fmt.Println("m=", m)
    /*iota 表示從 0 開始自動加 1，所以 i=1<<0, j=3<<1（<< 表示左移的意思），
    即：i=1, j=6，這沒問題，關(guān)鍵在 k 和 l，從輸出結(jié)果看 k=3<<2，l=3<<3。
    簡單表述:
    i=1：左移 0 位,不變?nèi)詾?1;
    j=3：左移 1 位,變?yōu)槎M制 110, 即 6;
    k=3：左移 2 位,變?yōu)槎M制 1100, 即 12;
    l=3：左移 3 位,變?yōu)槎M制 11000,即 24。*/
        }