學習 A Tour of Go (中文參考 Go 之旅中文 ) 整理的筆記。介紹包、變量和函數的基本概念和使用。
包、變量和函數
1. package
$GOPATH/src/go_note/gotour/basics/package/package.go 源碼如下:
/**
* packages 的相關概念
*/
package main // 指定包名
import (
"fmt" // 包名是 fmt
"math" // 包名是 math
"math/rand" // 包名是 rand
)
func main() {
fmt.Println("My favorite number is", rand.Intn(10))
fmt.Println(math.Pi)
}1.1 包名 package
每個 Go 程序都是由包組成的，由 package 關鍵詞指定文件所屬的包，程序運行的入口是包 main 。
這個程序使用並導入了包 “fmt”, “math” 和 “math/rand”，按照慣例，包名與導入路徑的最後一個目錄一致。如: math/rand 包由 package rand 語句開始。
1.2 導入 import
這個代碼用圓括號組合了導入，這是“打包”導入語句。
同樣可以編寫多個導入語句:
import "fmt"
import "math"
import "math/rand"不過使用打包的導入語句是更好的形式
1.3 導出名
在 Go 中，首字母大寫的名稱是被導出的。在導入包之後，你只能訪問包所導出的名字，任何未導出的名字是不能被包外的代碼訪問的。
例如 Println, Pi 和 Intn 都是被導出的名稱，而名稱 pi 是不會被導出的。訪問包未導出的代碼，編譯會報 undefined 錯誤。
2. function
$GOPATH/src/go_note/gotour/basics/function/function.go, 源碼如下:
/**
* function 函數相關概念
*/
package main
import (
"fmt"
)
// 數字相加
func add(x int, y int) int {
return x + y
}
// 字符交換位置
func swap(x, y string) (string, string) {
return y, x
}
// 命名返回值
func split(sum int) (x, y int) {
x = sum * 4 / 9
y = sum - x
return
}
func main() {
fmt.Println(add(1, 2))
a, b := swap("hello", "world")
fmt.Println(a, b)
fmt.Println(split(17))
}2.1 函數參數
函數可以沒有參數或接受多個參數。add 函數接受兩個 int 類型的參數。需要注意類型在變量名後面。
當兩個或多個連續的函數命名參數是同一類型，則除了最後一個類型之外，其他都可以省略。
x string, y string可以被縮寫爲
x, y string2.2 多值返回
函數可以返回任意數量的返回值。swap 函數返回了兩個字符串。
2.3 命名返回值
Go 的返回值可以被命名，並且就像在函數體開頭聲明的變量那樣使用。返回值的名稱應當具有一定的意義，可以作爲文檔使用。沒有參數的 return 語句返回各個返回變量的當前值。這種用法被稱作“裸”返回。
3. 變量
$GOPATH/src/go_note/gotour/basics/variable/variable.go 源碼如下:
/**
* variable 變量相關概念
*/
package main
import "fmt"
var c, python, java bool // 定義變量，類型在後面
var x, y, s = 1, 2, "hello" // 初始化是使用表達式，則可以省略類型，變量從初始值中獲得類型
func main() {
var i int
fmt.Println(i, c, python, java)
a, b := 1, "hello" // `:=` 簡潔賦值語句用在明確類型的地方，用於替代 `var` 定義
fmt.Println(x, y, s, a, b)
}var 語句定義了一個變量的列表。跟函數的參數列表一樣，類型在後面，var 語句可以定義在包或函數級別。
3.1 初始化變量
變量定義可以包含初始值，每個變量對應一個。如果初始化是使用表達式，則可以省略類型，變量將從初始值中獲得類型。
3.2 短聲明變量
在函數中， := 簡潔賦值語句用在明確類型的地方，用於替代 var 定義。
:= 結構不能使用在函數外，函數外的每個語句都必須以關鍵字開始（ var 、 func 、等等）。
4. 基本類型
Go 基本類型
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的別名
rune // int32 的別名, 代表一個Unicode碼
float32 float64
complex64 complex128$GOPATH/src/go_note/gotour/basics/type/type.go 源碼如下:
/**
* go 數據類型
*/
package main
import (
"fmt"
"math"
"math/cmplx"
)
// 同導入語句一樣，變量的定義“打包”在一個語法塊中。
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)\n"
fmt.Printf(f, ToBe, ToBe) // bool(false)
fmt.Printf(f, MaxInt, MaxInt) // uint64(18446744073709551615)
fmt.Printf(f, z, z) // complex128((2+3i))
// 變量在定義時沒有明確的初始化時會賦值爲零值
var i int
var fl float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, fl, b, s) // 0 0 false ""
// 類型推導: 在定義一個變量卻並不顯式指定其類型時， 變量的類型由（等號）右側的值推導得出
var m int
n := m
fmt.Printf(f, m, m) // int(0)
fmt.Printf(f, n, n) // int(0)
// 類型轉換
x, y := 3, 4
z := math.Sqrt(float64(x*x + y*y))
u := uint(z)
fmt.Printf(f, x, x) // int(3)
fmt.Printf(f, y, y) // int(4)
fmt.Printf(f, z, z) // float64(5)
fmt.Printf(f, u, u) // uint(5)
}int，uint 和 uintptr 類型在32位的系統上一般是32位，而在64位系統上是64位。當你需要使用一個整數類型時，你應該首選 int，僅當有特別的理由才使用定長整數類型或者無符號整數類型
4.1 零值
變量在定義時沒有明確的初始化時會賦值爲零值
- int 數值類型爲 0
- bool 布爾類型爲 false
- string 字符串爲 “” （空字符串）
4.2 類型推導
在定義一個變量卻並不顯式指定其類型時（使用 := 語法或者 var = 表達式語法‘）， 變量的類型由（等號）右側的值推導得出。
當右值定義了類型時，新變量的類型與其相同：
var i int
j := i // j 也是一個 int4.3 類型轉換
表達式 T(v) 將值 v 轉換爲類型 T。
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)Go 不同類型之間的項目賦值時需要顯式轉換。
5. 常量
$GOPATH/src/go_note/gotour/basics/constant/constan.go 源碼如下:
/**
* 常量定義
*/
package main
import (
"fmt"
)
// 數值常量
const Pi = 3.14
func main() {
// 字符常量
const World = "world"
fmt.Println("Hello ", World)
fmt.Println("the value of Pi is ", Pi)
}常量的定義與變量類似，只不過使用 const 關鍵字。常量可以是字符、字符串、布爾或數字類型的值。常量不能使用 := 語法定義。一個未指定類型的常量由上下文來決定其類型。
