golang入門

特點：
a.自動垃圾回收
b.豐富的內置類型
c.函數多返回值
d.錯誤處理
e.匿名函數和閉包
f.類型和接口
g.goroutine并發編程
h.反射
i.CGO調用c函數

go語言從main包中的main函數開始執行，Go語言的main()函數不能帶參數，也不能定義返回值。命令行傳入的參數在os.Args變量中保存。如果需要支持命令行開關，可使用flag包。在包聲明之后，是一系列的import語句，用于導入該程序所依賴的包。
package main
import "fmt"// 我們需要使用fmt包中的Println()函數
func main() {
fmt.Println("Hello, world. 你好，世界！ ")
}
》go run hello.go
》go build hello.go
1.變量
=賦值運算符
:= 類型推斷并附初值
a.各種變量的聲明
var v1 int
var v2 string
var v3 [10]int // 數組
var v4 []int // 數組切片
var v5 struct {
f int
}
var v6 *int // 指針
var v7 map[string]int // map，key為string類型，value為int類型
var v8 func(a int) int
const zero = 0.0

b.變量聲明時初始化
var v1 int = 10 // 正確的使用方式1
var v2 = 10 // 正確的使用方式2，編譯器可以自動推導出v2的類型
v3 := 10 // 正確的使用方式3，編譯器可以自動推導出v3的類型
go語言是一種強類型語言，在變量定義時可以指明數據類型，也可以選擇自動推導

c.變量賦值
i, j = j, i //支持多重賦值

d.匿名變量""表示
假 設GetName()函數的定義如下，它返回3個值，分別為firstName、lastName和
nickName：
func GetName() (firstName, lastName, nickName string) {
return "May", "Chan", "Chibi Maruko"
}
若只想獲得nickName，則函數調用語句可以用如下方式編寫：
, , nickName := GetName() 假 設GetName()函數的定義如下，它返回3個值，分別為firstName、lastName和
nickName：
func GetName() (firstName, lastName, nickName string) {
return "May", "Chan", "Chibi Maruko"
}
若只想獲得nickName，則函數調用語句可以用如下方式編寫：
, _, nickName := GetName()

e.常量，定義時添加const
const Pi float64 = 3.14159265358979323846
const zero = 0.0 // 無類型浮點常量
const (
size int64 = 1024
eof = -1 // 無類型整型常量
)
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重賦值
const a, b, c = 3, 4, "foo"
// a = 3, b = 4, c = "foo", 無類型整型和字符串常量

f.枚舉
下面是一個常規的枚舉表示法，其中定義了一系列整型常量：
const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays // 這個常量沒有導出
)
同Go語言的其他符號（symbol）一樣，以大寫字母開頭的常量在包外可見。
以上例子中numberOfDays為包內私有，其他符號則可被其他包訪問。

g.go語言的數據類型
? 布爾類型：bool。
? 整型：int8、uint8、byte、int16、int、uint、int32、int64、uintptr等。
? 浮點類型：float32、float64。
? 復數類型：complex64(由2個float32構成的復數類型)、complex128。 2+3i
? 字符串：string。
? 字符類型：rune。 代表單個Unicode字符。
? 錯誤類型：error。
此外，Go語言也支持以下這些復合類型：
? 指針（pointer）
? 數組（array）
? 切片（slice）
? 字典（map）
? 通道（chan）
? 結構體（struct）
? 接口（interface）

字符串取值及其遍歷
str := "Hello,世界"
n := len(str)
for i := 0; i < n; i++ {
ch := str[i] // str[i]="x";錯誤，字符串是不能重新被改變了，數組才行
fmt.Println(i, ch)
}

數組的使用
[32]byte // 長度為32的數組，每個元素為一個字節
[2N] struct { x, y int32 } // 復雜類型數組
[1000]float64 // 指針數組
[3][5]int // 二維數組
[2][2][2]float64 // 等同于2

var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

mySlice := myArray[:] //基于myArray的所有元素創建數組切片
mySlice := myArray[:5] //基于myArray的前5個元素創建數組切片
mySlice := myArray[5:] //基于從第5個元素開始的所有元素創建數組切片
mySlice := make([]int, 5) //創建一個初始元素個數為5的數組切片，元素初始值為0：
mySlice := make([]int, 5, 10) //創建一個初始元素個數為5的數組切片，元素初始值為0，并預留10個元素的存儲空間：len(mySlice)=5
cap(mySlice)=10 ,mySlice = append(mySlice, 1, 2, 3) ,任何數組都可以動態增長
mySlice := []int{1, 2, 3, 4, 5} //直接創建并初始化包含5個元素的數組切片：

for _, v := range myArray { //數組遍歷
fmt.Print(v, " ")
}
for i := 0; i <len(mySlice); i++ {
fmt.Println("mySlice[", i, "] =", mySlice[i])
}

數組復制：
slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只會復制slice1的前3個元素到slice2中
copy(slice1, slice2) // 只會復制slice2的3個元素到slice1的前3個位置

map的使用
map是一堆鍵值對的未排序集合。

var personDB map[string] PersonInfo
personDB = make(map[string] PersonInfo)
personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."}
person, ok := personDB["1234"] // ok是一個返回的bool型，返回true表示找到了對應的數據
delete(myMap, "1234") //刪除一個key

2.流程控制
a.if語句
if a < 5 {
return 0
} else {
return 1
}
b.switch..case..
switch i {
case 0:
fmt.Printf("0")
case 1:
fmt.Printf("1")
case 2:
fallthrough
default:
fmt.Printf("Default")
}

c.for
for i := 0; i < 10; i++ {
sum += i
}

d.goto
i := 0
HERE:
fmt.Println(i)
i++
if i < 10 {
goto HERE
}
}

e.函數定義
實名函數
package mymath
import "errors"
func Add(a int, b int) (ret int, err error) {
if a < 0 || b < 0 { // 假設這個函數只支持兩個非負數字的加法
err= errors.New("Should be non-negative numbers!")
return
}
return a + b, nil // 支持多重返回值
}

import "mymath"// 假設Add被放在一個叫mymath的包中
// ...
c := mymath.Add(1, 2)

匿名函數
f := func(x, y int) int {
return x + y
}

閉包函數
var j int = 5 //全局變量
a := func()(func()) {
var i int = 10
return func() {
fmt.Printf("i, j: %d, %d\n", i++, j) //閉包的記憶性
}
}()

3.面向對象編程
Go語言中的大多數類型都基于值語義而不是引用賦值語義，包括：
? 基本類型，如byte、 int、 bool、 float32、 float64和string等；
? 復合類型，如數組（array）、結構體（struct）和指針（pointer）等。