Golang

golang

安裝：

http://studygolang.com/articles/1605

http://www.cnblogs.com/linuxprobe/p/5654380.html

參考：go語言編程

 變量

聲明

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

指針的使用：

package main
import "fmt"
func main() {
   var a int= 20   /* 聲明實際變量 */
   var ip *int        /* 聲明指針變量 */
   ip = &a  /* 指針變量的存儲地址   20818a220*/
   fmt.Printf("a 變量的地址是: %x\n", &a  )
   /* 指針變量的存儲地址  20818a220*/
   fmt.Printf("ip 變量儲存的指針地址: %x\n", ip )
   /* 使用指針訪問值  20 */
   fmt.Printf("*ip 變量的值: %d\n", *ip )

 

初始化

var v1 int = 10 // 正確的使用方式1
var v2 = 10 // 正確的使用方式2，編譯器能夠自動推導出v2的類型
v3 := 10 // 正確的使用方式3，編譯器能夠自動推導出v3的類型

（冒號和等號的組合:=），用於明確表達同時進行變量聲明和初始化的工做 。

變量賦值

var  v10  int
v10  =  123

多重賦值：交換

i , j = j  ,i

 

常量  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", 無類型整型和字符串常量

枚舉

大寫字母的常量 包外可見

const (
Sunday = iota
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
numberOfDays // 這個常量沒有導出
)

類型

 布爾類型： bool。
 整型： int八、 byte、 int1六、 int、 uint、 uintptr等。
 浮點類型： float3二、 float64
 複數類型： complex6四、 complex128。
 字符串： string。
 字符類型： rune。
 錯誤類型： error。
此外， Go語言也支持如下這些複合類型：
 指針（pointer）
 數組（array）
 切片（slice）
 字典（map）
 通道（chan）
 結構體（struct）
 接口（interface）

字符串：

字符串不能在初始化以後修改：

str := "Hello world" // 字符串也支持聲明時進行初始化的作法
str[0] = 'X' // 編譯錯誤

字符串遍歷：

str := "Hello,世界"
n := len(str)
for i := 0; i < n; i++ {
ch := str[i] // 依據下標取字符串中的字符，類型爲byte
fmt.Println(i, ch)
}

 

 

str := "Hello,世界"
for i, ch := range str {
fmt.Println(i, ch)//ch的類型爲rune
}

字符類型

byte類型 == int8   用於表示UTF-8字符串單個字節的值

rune表示單個unicode字符

數組

數組聲明

[32]byte 
[2*N] struct { x, y int32 } 
[1000]*float64 
[3][5]int 
[2][2][2]float64 

遍歷：

for i := 0; i < len(array); i++ {
fmt.Println("Element", i, "of array is", array[i])
}

for i, v := range array {
fmt.Println("Array element[", i, "]=", v)
}

注意：go中數組是值類型，賦值或做爲參數傳遞時會發生數據複製。

package main
import "fmt"
func modify(array [10]int) {
array[0] = 10 // 試圖修改數組的第一個元素
fmt.Println("In modify(), array values:", array)
}
func main() {
array := [5]int{1,2,3,4,5} // 定義並初始化一個數組
modify(array) // 傳遞給一個函數，並試圖在函數體內修改這個數組內容
fmt.Println("In main(), array values:", array)
}
該程序的執行結果爲：
In modify(), array values: [10 2 3 4 5]
In main(), array values: [1 2 3 4 5]

數組切片

數組的長度定義後不能改變，同時又是值類型，每次傳遞都會數據複製，而數據切片能夠管理數據。

基於數組建立

// 先定義一個數組
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
// 基於數組建立一個數組切片
var mySlice []int = myArray[:5]
------------------------------------
var mySlice []int = myArray[:]    基於myArray全部元素建立數組切片
var mySlice [] int = myArray[:5]  基於myArray前5個元素建立數組切片
var mySlice [] int = myArray[5:] 基於myArray第5個後面的全部元素建立數組切片

直接建立

建立一個初始元素個數爲5的數組切片，元素初始值爲0：
mySlice1 := make([]int, 5)
建立一個初始元素個數爲5的數組切片，元素初始值爲0，並預留10個元素的存儲空間：
mySlice2 := make([]int, 5, 10)
直接建立並初始化包含5個元素的數組切片：
mySlice3 := []int{1, 2, 3, 4, 5}

cap()函數返回的是數組切片分配的空間大小，而len()函數返回的是數組切片中當前所存儲的元素個數。數組切片支持Go語言內置的cap()函數和len()函數。

copy（）內容複製
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

// PersonInfo是一個包含我的詳細信息的類型
type PersonInfo struct {
ID string
Name string
Address string
}
變量聲明
var myMap  map[string]  PersonInfo
建立 
myMap = make(map[string] PersonInfo)
myMap = make(map[string] PersonInfo, 100)  指定存儲能力
賦值
myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}
刪除
delete(myMap, "1234")
查找
value, ok := myMap["1234"]
if ok { // 找到了
// 處理找到的value
}

 流程控制

if a < 5 {
return 0
} else {
return 1
}
關於條件語句，須要注意如下幾點：
 條件語句不須要使用括號將條件包含起來()；
 不管語句體內有幾條語句，花括號{}都是必須存在的；
 左花括號{必須與if或者else處於同一行；
 在if以後，條件語句以前，能夠添加變量初始化語句，使用;間隔；
 在有返回值的函數中，不容許將「最終的」 return語句包含在if...else...結構中，不然會編譯失敗

switch i {
case 0:
fmt.Printf("0")
case 1:
fmt.Printf("1")
case 2:
fallthrough
case 3:
fmt.Printf("3")
case 4, 5, 6:
fmt.Printf("4, 5, 6")
default:
fmt.Printf("Default")
}
在使用switch結構時，咱們須要注意如下幾點：
 左花括號{必須與switch處於同一行；
 條件表達式不限制爲常量或者整數；
 單個case中，能夠出現多個結果選項；
 與C語言等規則相反， Go語言不須要用break來明確退出一個case；
 只有在case中明確添加fallthrough關鍵字，纔會繼續執行緊跟的下一個case；
 能夠 不設定switch之 後的條 件表達式， 在此種狀況 下，整個switch結構與 多個
if...else...的邏輯做用等同。

函數

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 // 支持多重返回值
}

函數調用  c := mymath.Add(1, 2)

注意：小寫字母開頭的函數只能本包可見，大寫字母的函數才能被其餘包使用。

 

不定參數

func myfunc(args ...int) {
for _, arg := range args {
fmt.Println(arg)
}
}

 

任意類型的不定參數：

func Printf(format string, args ...interface{}) {
// ...
}

多返回值

func (file *File) Read(b []byte) (n int, err Error)

 

n, _ := f.Read(buf)

錯誤處理

func Foo(param int)(n int, err error) {
// ...
}
調用時的代碼建議按以下方式處理錯誤狀況：
n, err := Foo(0)
if err != nil {
// 錯誤處理
} else {
// 使用返回值n
}


func Stat(name string) (fi FileInfo, err error) {
var stat syscall.Stat_t
err = syscall.Stat(name, &stat)
if err != nil {
return nil, &PathError{"stat", name, err}
}
return fileInfoFromStat(&stat, name), nil
} 

 defer

//defer 執行一些清理和維護性的工做defer語句的調用是遵守
//先進後出的原則，即最後一個defer語句將最早被執行。

func CopyFile(dst, src string) (w int64, err error) {
srcFile, err := os.Open(src)
if err != nil {
return
}
defer srcFile.Close()
dstFile, err := os.Create(dstName)
if err != nil {
return
}
defer dstFile.Close()
return io.Copy(dstFile, srcFile)
}

panic()和recover() 

Go語言引入了兩個內置函數panic()和recover()以報告和處理運行時錯誤和程序中的錯

誤場景：
func panic(interface{})
func recover() interface{}