一.指針
類型 *T 是指向 T 類型值的指針。其零值爲 nil。
& 操作符會生成一個指向其操作數的指針。
* 操作符表示指針指向的底層值(變量值)。
//指針-例
package main
import "fmt"
func main() {
i, j := 42, 2701
p := &i // 指向 i
fmt.Println(p) // 讀取指針 的值 輸出:0x414020
fmt.Println(*p) // 通過指針讀取 i 的值 輸出:42
*p = 21 // 通過指針設置 i 的值 輸出:21
fmt.Println(i) // 查看 i 的值
p = &j // 指向 j
*p = *p / 37 // 通過指針對 j 進行除法運算
fmt.Println(j) // 查看 j 的值 輸出:73
}
二.結構體:一個結構體（struct）就是一組字段（field）。可以看做是key_value鍵值對.
2.1 結構體字段
//結構體
//例一
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
fmt.Println(Vertex{1, 2})
}
//輸出
{1 2}
//例二
//結構體字段
//結構體字段使用點號來訪問。
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1, 2}
v.X = 4
fmt.Println(v.X) //輸出4
fmt.Println(v) //輸出{4 2}
}
2.2 結構體指針
如果我們有一個指向結構體的指針 p，那麼可以通過 (*p).X 來訪問其字段 X。不過這麼寫太囉嗦了，所以語言也允許我們使用隱式間接引用，直接寫 p.X 就可以。即 (*p).X 等同於p.x.
package main
import "fmt"
type Vertex struct {
X int
Y int
}
func main() {
v := Vertex{1, 2}
p := &v
p.X = 100
fmt.Println(v) //輸出{100 2}
(*p).X = 200
fmt.Println(v) //輸出{200 2}
}
使用 Name: 語法可以給結構體指定字段賦值
特殊的前綴 & 返回一個指向結構體的指針。
package main
import "fmt"
type Vertex struct {
X, Y int
}
var (
v1 = Vertex{1, 2} // 創建一個 Vertex 類型的結構體
v2 = Vertex{X: 1} // Y:0 被隱式地賦予
v3 = Vertex{X: 1,Y: 9} // Y:0 被隱式地賦予
v4 = Vertex{} // X:0 Y:0
p = &Vertex{1, 2} // 創建一個 *Vertex 類型的結構體（指針）
)
func main() {
fmt.Println(v1, v2, v3, v4, p)
}
//輸出
{1 2} {1 0} {1 9} {0 0} &{1 2}
三. 數組
3.1 定義
var a [10]int 表示: 類型 [n]T表示擁有 n個 T類型的值的數組。數組的長度是其類型的一部分，因此數組不能改變大小.
package main
import "fmt"
func main() {
var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1]) //輸出Hello World
fmt.Println(a) //輸出[Hello World]
primes := [6]int{2, 3, 5, 7, 11, 13}
fmt.Println(primes) //輸出[2 3 5 7 11 15]
primes = [6]int{2, 3}
fmt.Println(primes) //輸出[2 3 0 0 0 0]
}
3.2 切片
每個數組的大小都是固定的。而切片則爲數組元素提供動態大小的、靈活的視角。在實踐中，切片比數組更常用。
類型 []T 表示一個元素類型爲 T 的切片。
切片通過兩個下標來界定，即一個上界和一個下界，二者以冒號分隔：
a[low : high]
它會選擇一個半開區間，包括第一個元素，但排除最後一個元素。
以下表達式創建了一個切片，它包含 a 中下標從 1 到 3 的元素：
a[1:4]
package main
import "fmt"
func main() {
primes := [6]int{2, 3, 5, 7, 11, 13}
var s []int = primes[1:4]
fmt.Println(s) //輸出[3 5 7]
}
切片值傳遞方式爲引用傳遞
//例一
package main
import "fmt"
func main() {
names := [4]string{
"John",
"Paul",
"George",
"Ringo",
}
fmt.Println(names) //輸出[John Paul George Ringo]
a := names[0:2]
b := names[1:3]
fmt.Println(a, b) //輸出[John Paul] [Paul George]
b[0] = "XXX"
fmt.Println(a, b) //輸出[John XXX] [XXX George]
fmt.Println(names) //輸出[John XXX George Ringo]
}
//例二
package main
import "fmt"
func main() {
q := []int{2, 3, 5, 7, 11, 13}
fmt.Println(q) //輸出[2 3 5 7 11 13]
r := []bool{true, false, true, true, false, true}
fmt.Println(r) //輸出[true false true true false true]
s := []struct {
i int
b bool
}{
{2, true},
{3, false},
{5, true},
{7, true},
{11, false},
{13, true},
}
fmt.Println(s) //輸出[{2 true} {3 false} {5 true} {7 true} {11 false} {13 true}]
}
切片的默認行爲
在進行切片時，你可以利用它的默認行爲來忽略上下界。
切片下界的默認值爲 0，上界則是該切片的長度。
對於數組
var a [10]int
來說，以下切片是等價的：
a[0:10] a[:10] a[0:] a[:]
package main
import "fmt"
func main() {
s := []int{2, 3, 5, 7, 11, 13}
s = s[1:4]
fmt.Println(s) //輸出[3 5 7]
s = s[:2]
fmt.Println(s) //輸出[3 5]
s = s[1:]
fmt.Println(s) //輸出[5]
var a [10]int
fmt.Println(a) //輸出[0 0 0 0 0 0 0 0 0 0]
}