?第一個go程序
package mainimport "fmt"func main() {/* 這是我的第一個簡單的程序 */fmt.Println("Hello, World!")
}- 第一行代碼 package main 定義了包名。你必須在源文件中非注釋的第一行指明這個文件屬于哪個包，如：package main。package main表示一個可獨立執行的程序，每個 Go 應用程序都包含一個名為 main 的包。
- 下一行 import "fmt" 告訴 Go 編譯器這個程序需要使用 fmt 包（的函數，或其他元素），fmt 包實現了格式化 IO（輸入/輸出）的函數。
- 下一行 func main() 是程序開始執行的函數。main 函數是每一個可執行程序所必須包含的，一般來說都是在啟動后第一個執行的函數（如果有 init() 函數則會先執行該函數）。
- 下一行 /*...*/ 是注釋，在程序執行時將被忽略。單行注釋是最常見的注釋形式，你可以在任何地方使用以 // 開頭的單行注釋。多行注釋也叫塊注釋，均已以 /* 開頭，并以 */ 結尾，多行注釋一般用于包的文檔描述或注釋成塊的代碼片段。
- 下一行 fmt.Println(...) 可以將字符串輸出到控制臺，并在最后自動增加換行字符 \n。
- 當標識符（包括常量、變量、類型、函數名、結構字段等等）以一個大寫字母開頭，如：Group1，那么使用這種形式的標識符的對象就可以被外部包的代碼所使用（客戶端程序需要先導入這個包），這被稱為導出（像面向對象語言中的 public）；標識符如果以小寫字母開頭，則對包外是不可見的，但是他們在整個包的內部是可見并且可用的（像面向對象語言中的 protected ）。
數據類型
Go語言的基本類型有：
- bool
- string
- int、int8、int16、int32、int64
- uint、uint8、uint16、uint32、uint64、uintptr
- byte // uint8 的別名
- rune // int32 的別名 代表一個 Unicode 碼
- float32、float64
- complex64、complex128
變量
Go語言是靜態類型語言，因此變量（variable）是有明確類型的，編譯器也會檢查變量類型的正確性。
1）聲明變量的一般形式是使用 var 關鍵字：var name type
Go和許多編程語言不同，它在聲明變量時將變量的類型放名稱后。這樣做的好處就是可以避免像C語言中那樣含糊不清的聲明形式，例如：
int* a, b;?。其中只有 a 是指針而 b 不是。如果你想要這兩個變量都是指針，則需要將它們分開書寫。而在 Go 中，則可以和輕松地將它們都聲明為指針類型：var a, b *int
多變量聲明
var (a intb stringc []float32d func() boole struct {x int}
)?
2）除 var 關鍵字外，還可使用更加簡短的變量定義和初始化語法。
名字 := 表達式
需要注意的是，簡短模式（short variable declaration）有以下限制：
- 定義變量，同時顯式初始化。
- 不能提供數據類型。
- 只能用在函數內部。
和 var 形式聲明語句一樣，簡短變量聲明語句也可以用來聲明和初始化一組變量：
i, j := 0, 1
3）根據值自行判定變量類型。
package main
import "fmt"
func main() {var d = truefmt.Println(d)
}算術運算符
package mainimport "fmt"func main() {var a int = 21var b int = 10var c intc = a + bfmt.Printf("第一行 - c 的值為 %d\n", c )c = a - bfmt.Printf("第二行 - c 的值為 %d\n", c )c = a * bfmt.Printf("第三行 - c 的值為 %d\n", c )c = a / bfmt.Printf("第四行 - c 的值為 %d\n", c )c = a % bfmt.Printf("第五行 - c 的值為 %d\n", c )a++fmt.Printf("第六行 - a 的值為 %d\n", a )a=21 // 為了方便測試，a 這里重新賦值為 21a--fmt.Printf("第七行 - a 的值為 %d\n", a )
}第一行 - c 的值為 31
第二行 - c 的值為 11
第三行 - c 的值為 210
第四行 - c 的值為 2
第五行 - c 的值為 1
第六行 - a 的值為 22
第七行 - a 的值為 20位運算符
位運算符對整數在內存中的二進制位進行操作。
下表列出了位運算符 &, |, 和 ^ 的計算：
?
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
?
假定 A = 60; B = 13; 其二進制數轉換為：
A = 0011 1100B = 0000 1101-----------------A&B = 0000 1100A|B = 0011 1101A^B = 0011 0001
?
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 參與運算的兩數各對應的二進位相與。 | (A & B) 結果為 12, 二進制為 0000 1100 |
| | | 參與運算的兩數各對應的二進位相或 | (A | B) 結果為 61, 二進制為 0011 1101 |
| ^ | 參與運算的兩數各對應的二進位相異或，當兩對應的位相異時，結果為1。 | (A ^ B) 結果為 49, 二進制為 0011 0001 |
| << | 左移n位就是乘以2的n次方。 其功能把"<<"左邊的運算數的各二進位全部左移若干位，由"<<"右邊的數指定移動的位數，高位丟棄，低位補0。 | A << 2 結果為 240 ，二進制為 1111 0000 |
?賦值運算符
下表列出了所有Go語言的賦值運算符。
| 運算符 | 描述 | 實例 |
|---|---|---|
| = | 簡單的賦值運算符，將一個表達式的值賦給一個左值 | C = A + B 將 A + B 表達式結果賦值給 C |
| += | 相加后再賦值 | C += A 等于 C = C + A |
| -= | 相減后再賦值 | C -= A 等于 C = C - A |
| *= | 相乘后再賦值 | C *= A 等于 C = C * A |
| /= | 相除后再賦值 | C /= A 等于 C = C / A |
| %= | 求余后再賦值 | C %= A 等于 C = C % A |
| <<= | 左移后賦值 | C <<= 2 等于 C = C << 2 |
| >>= | 右移后賦值 | C >>= 2 等于 C = C >> 2 |
| &= | 按位與后賦值 | C &= 2 等于 C = C & 2 |
| ^= | 按位異或后賦值 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或后賦值 | C |= 2 等于 C = C | 2 |
?
其他運算符
?
| 運算符 | 描述 | 實例 |
|---|---|---|
| & | 返回變量存儲地址 | &a; 將給出變量的實際地址。 |
| * | 指針變量。 | *a; 是一個指針變量 |
以下實例演示了其他運算符的用法：
實例
package mainimport "fmt"func main() {var a int = 4var b int32var c float32var ptr *int/* 運算符實例 */fmt.Printf("第 1 行 - a 變量類型為 = %T\n", a );fmt.Printf("第 2 行 - b 變量類型為 = %T\n", b );fmt.Printf("第 3 行 - c 變量類型為 = %T\n", c );/* & 和 * 運算符實例 */ptr = &a /* 'ptr' 包含了 'a' 變量的地址 */fmt.Printf("a 的值為 %d\n", a);fmt.Printf("*ptr 為 %d\n", *ptr);
}以上實例運行結果：
第 1 行 - a 變量類型為 = int 第 2 行 - b 變量類型為 = int32 第 3 行 - c 變量類型為 = float32 a 的值為 4 *ptr 為 4
運算符優先級
由上至下代表優先級由高到低：
| 優先級 | 運算符 |
|---|---|
| 5 | * / % << >> & &^ |
| 4 | + - | ^ |
| 3 | == != < <= > >= |
| 2 | && |
| 1 | || |
循環
普通for循環
package mainimport "fmt"func main() {sum := 0for i := 0; i <= 10; i++ {sum += i}fmt.Println(sum)
}?foreach
這種格式的循環可以對字符串、數組、切片等進行迭代輸出元素。
package main
import "fmt"func main() {strings := []string{"google", "runoob"}for i, s := range strings {fmt.Println(i, s)}numbers := [6]int{1, 2, 3, 5} for i,x:= range numbers {fmt.Printf("第 %d 位 x 的值 = %d\n", i,x)}
}?
函數
func function_name( [parameter list] ) [return_types] {函數體
}- func：函數由 func 開始聲明
- function_name：函數名稱，函數名和參數列表一起構成了函數簽名。
- parameter list：參數列表，參數就像一個占位符，當函數被調用時，你可以將值傳遞給參數，這個值被稱為實際參數。參數列表指定的是參數類型、順序、及參數個數。參數是可選的，也就是說函數也可以不包含參數。
- return_types：返回類型，函數返回一列值。return_types 是該列值的數據類型。有些功能不需要返回值，這種情況下 return_types 不是必須的。
- 函數體：函數定義的代碼集合。
/* 函數返回兩個數的最大值 */
func max(num1, num2 int) int {/* 聲明局部變量 */var result intif (num1 > num2) {result = num1} else {result = num2}return result
}返回多個值
package mainimport "fmt"func swap(x, y string) (string, string) {return y, x
}func main() {a, b := swap("Google", "Runoob")fmt.Println(a, b)
}引用傳參
package mainimport "fmt"func main() {/* 定義局部變量 */var a int = 100var b int= 200fmt.Printf("交換前，a 的值 : %d\n", a )fmt.Printf("交換前，b 的值 : %d\n", b )/* 調用 swap() 函數* &a 指向 a 指針，a 變量的地址* &b 指向 b 指針，b 變量的地址*/swap(&a, &b)fmt.Printf("交換后，a 的值 : %d\n", a )fmt.Printf("交換后，b 的值 : %d\n", b )
}func swap(x *int, y *int) {var temp inttemp = *x /* 保存 x 地址上的值 */*x = *y /* 將 y 值賦給 x */*y = temp /* 將 temp 值賦給 y */
}數組
聲明：
語法格式如下：
var variable_name [SIZE] variable_type
以上為一維數組的定義方式。例如以下定義了數組 balance 長度為 10 類型為 float32：
var balance [10] float32
初始化：
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化數組中 {} 中的元素個數不能大于 [] 中的數字。
如果忽略 [] 中的數字不設置數組大小，Go 語言會根據元素的個數來設置數組的大小：
var balance = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
該實例與上面的實例是一樣的，雖然沒有設置數組的大小。
balance[4] = 50.0
初始化二維數組：
a = [3][4]int{ {0, 1, 2, 3} , /* 第一行索引為 0 */{4, 5, 6, 7} , /* 第二行索引為 1 */{8, 9, 10, 11}, /* 第三行索引為 2 */
}注意：以上代碼中倒數第二行的 } 必須要有逗號，因為最后一行的 } 不能單獨一行，也可以寫成這樣：
a = [3][4]int{ {0, 1, 2, 3} , /* 第一行索引為 0 */{4, 5, 6, 7} , /* 第二行索引為 1 */{8, 9, 10, 11}} /* 第三行索引為 2 */指針
和c一樣
package mainimport "fmt"func main() {var a int= 20 /* 聲明實際變量 */var ip *int /* 聲明指針變量 */ip = &a /* 指針變量的存儲地址 */fmt.Printf("a 變量的地址是: %x\n", &a )/* 指針變量的存儲地址 */fmt.Printf("ip 變量儲存的指針地址: %x\n", ip )/* 使用指針訪問值 */fmt.Printf("*ip 變量的值: %d\n", *ip )
}a 變量的地址是: 20818a220
ip 變量儲存的指針地址: 20818a220
*ip 變量的值: 20空指針判斷：
if(ptr != nil) /* ptr 不是空指針 */ if(ptr == nil) /* ptr 是空指針 */
多重指針：?
package mainimport "fmt"func main() {var a intvar ptr *intvar pptr **inta = 3000/* 指針 ptr 地址 */ptr = &a/* 指向指針 ptr 地址 */pptr = &ptr/* 獲取 pptr 的值 */fmt.Printf("變量 a = %d\n", a )fmt.Printf("指針變量 *ptr = %d\n", *ptr )fmt.Printf("指向指針的指針變量 **pptr = %d\n", **pptr)
}變量 a = 3000
指針變量 *ptr = 3000
指向指針的指針變量 **pptr = 3000?
?
)
