1. package main
    3. import (
    4.     "fmt"
    5.     "strings"
    6. )
    8. func main() {
    10.     /*
    11.         测试指针使用
    12.     */
    13.     i, j := 42, 2701
    14.     p := &i
    15.     fmt.Println(*p)
    16.     *p = 21
    17.     fmt.Println(i) // 修改了i的值，说明确实指向的是地址
    19.     p = &j
    20.     *p = *p / 37
    21.     fmt.Println(j == *p) // 返回值是true，说明确实修改的是地址
    23.     /*
    24.         测试结构体的使用，打印结果：{1 2}
    25.     */
    26.     fmt.Println(Vertex{1, 2})
    27.     //访问结构体字段
    28.     v := Vertex{4, 5}
    29.     fmt.Println(v.X * v.Y)
    30.     //结构体指针  （其实就是为了可以改变结构体里的值）
    31.     pp := &v //居然不能用上面的p来直接等于该地址
    32.     (*pp).X = 12345
    33.     pp.Y = 67890 //两种引用方式
    34.     fmt.Println(v)
    35.     //结构体的各种缺省赋值
    36.     w := Vertex{1, 0}
    37.     ww := Vertex{X: 1}
    38.     www := Vertex{}
    39.     pp = &Vertex{0, 0}
    40.     fmt.Println(w == ww, www == *pp, pp) //都是true，所以w,ww这些都是比较的值吗，确实，因为输出的都是数组似的
    41.     // 创建结构体类型的指针
    42.     ptr := &Vertex{2, 4}
    43.     ptr.X = 3
    44.     fmt.Println(ptr, ptr.X == 3, ptr.Y)
    45.     fmt.Println(v1, v2, p)    //{1 2} {0 2} 0xc0000b0070 访问到TestStruct那一层的指针地址
    46.     fmt.Println(v11, v22, pp) //{1 2} {0 2} &{0 0}
    48.     /*
    49.         数组，定义了长度不可变
    50.     */
    51.     var arr [12]int
    52.     for i := 0; i < 12; i++ {
    53.         arr[i] = i
    54.         fmt.Print(arr[i], " ")
    55.     }
    56.     primes := []int{0, 1, 2, 3, 4, 5, 6} //这里是否一定要指明长度？ 这样不指明长度是切片写法，指创建了一个数组，构建了一个引用该数组的切片
    57.     fmt.Println(primes)
    59.     /*
    60.         切片：半开区间 切片不存储任何数据，只是描述了底层数组中的一段 共享改变
    61.               len代表元素的个数，cap代表容量
    62.               长度所指向数组中的元素个数
    63.               容量是指切片第一个元素到底层数组元素最后一个元素的个数
    64.               append方法，如果切片的底层数组不能容纳切片所有给定值时，切片会分配一个更大容量的数组，返回的切片会指向这个新数组
    65.     */
    66.     var slice []int = primes[2:5]              // primes[2:5]就创建了一个切片
    67.     fmt.Println(slice, len(slice), cap(slice)) //output: [2 3 4] 3 5
    68.     //slice bounds out of range
    69.     // slice = primes[99:100]
    70.     slice = primes[6:7]
    71.     fmt.Println(slice) //output: [6]
    72.     // 可以缺省上下界
    73.     slice = primes[:]
    74.     fmt.Println(slice, len(slice), cap(slice))
    75.     // 空的切片
    76.     var emptySlice []int                                      // 这个未定义长度的就是切片。其零值是nil，其无底层数组
    77.     fmt.Println(emptySlice, len(emptySlice), cap(emptySlice)) //emptyS[0]是错误写法 ，其零值是 nil
    78.     if emptySlice == nil {
    79.         fmt.Println("nil")
    80.     }
    81.     // 空的数组
    82.     var emptyArray [0]int
    83.     fmt.Println(emptyArray)
    84.     // if emptyArray[0]==0{ 这个也不能说去访问emptyArray[0],但我不清楚在底层是否有实际数组
    85.     //     fmt.Println("0")
    86.     // }
    87.     // make 创建切片  make 函数会分配一个元素为零值的数组并返回一个引用了它的切片
    88.     makeSlice := make([]int, 6) //指定长度
    89.     fmt.Println(makeSlice, len(makeSlice), cap(makeSlice))
    90.     makeSlice1 := make([]int, 2, 5)                           //长度为2 ， 容量为 5
    91.     fmt.Println(makeSlice1, len(makeSlice1), cap(makeSlice1)) // [0 0] 2 5
    92.     makeSlice1 = makeSlice1[:cap(makeSlice1)]
    93.     fmt.Println(makeSlice1, len(makeSlice1), cap(makeSlice1))
    94.     makeSlice1 = makeSlice1[1:]
    95.     fmt.Println(makeSlice1, len(makeSlice1), cap(makeSlice1))
    96.     // 切片的切片 (二维)
    97.     board := [][]string{
    98.         []string{"_", "_", "_"},
    99.         []string{"_", "_", "_"},
    100.         []string{"_", "_", "_"},
    101.     }
    102.     board[0][0] = "x"
    103.     board[0][1] = "o"
    104.     board[1][0] = "x"
    105.     board[2][0] = "o"
    106.     board[1][1] = "x"
    107.     board[2][2] = "o"
    108.     for i := 0; i < len(board); i++ {
    109.         fmt.Printf("%s\n", strings.Join(board[i], " "))
    110.     }
    111.     //Range 使用for循环遍历切片时候，每次迭代都会返回两个值，第一个值为当前元素的下标，第二个值为该下标所对应元素的一份副本
    112.     for i, j := range board {
    113.         for m, n := range j {
    114.             fmt.Println("board[", i, " ", m, "]", n)
    115.         }
    116.     }
    117.     //Range 使用时可以忽略其 下标或下标所对应元素的副本
    118.     for i := range board {
    119.         fmt.Printf("%d ", i)
    120.     }
    121.     for _, j := range board {
    122.         fmt.Println(j)
    123.     }
    124.     for i := range board {
    125.         fmt.Println(i)
    126.     }
    127.     //映射  make函数会返回给定类型的映射，并将其初始化备用
    128.     var m map[string]Vertex = make(map[string]Vertex) //make也可以用在键值对的映射里面
    129.     m["Bell Labs"] = Vertex{1, 2}
    130.     fmt.Println(m["Bell Labs"])
    132.     //多个映射
    133.     var mm = map[string]Vertex{
    134.         "Bell Labs": Vertex{1, 2},
    135.         "Google":    Vertex{3, 4},
    136.     }
    137.     fmt.Println(mm)
    138.     var mmm = map[int]Vertex{
    139.         1: {1, 2},
    140.         2: {3, 4}, //可以省略掉类型
    142.     }
    143.     fmt.Println(mmm)
    144.     for _, j := range mmm {
    145.         fmt.Println(j)
    146.     }
    147.     //在映射m中插入或修改元素
    148.     ss := make(map[string]int)
    149.     ss["answer"]=42
    150.     fmt.Println("the value",ss["answer"])
    151.     ss["answer"]=48
    152.     fmt.Println("the value",ss["answer"])
    153.     delete(ss,"answer")
    154.     fmt.Println("the value",ss["answer"])
    155.     elem,ok := ss["answer"]
    156.     fmt.Println(elem,ok) // 0,false  elem 没在 m中返回 false
    157.     ss["yes"]=2
    158.     elem,ok = ss["yes"]
    159.     fmt.Println(elem,ok)  //2,true   elme 在 m 中，所以返回其elme 值，并ok为true
    161.     // strings.Fields方法可以切分字符串
    162.     var str = make(map[string]int)
    163.     var s = "This is a test,but is not noly a test"
    164.     var c = strings.Fields(s)
    165.     for _,j := range c {
    166.         str[j] ++
    167.     }
    168.     fmt.Println(str)
    182. }
    184. // Vertex 是结构体
    185. type Vertex struct {
    186.     X int
    187.     Y int
    188. }
    190. //TestStruct 使用结构体文法通过直接列出字段的值来分配一个结构体
    191. type TestStruct struct {
    192.     x, y int //非导出字段，不可从包外面访问。类似不可以从该结构体外面访问？
    193. }
    195. //TestPipeStruct 测试导出字段的结构体（与上面相对应）
    196. type TestPipeStruct struct {
    197.     X, Y int
    198. }
    200. var (
    201.     v1 = TestStruct{1, 2}
    202.     v2 = TestStruct{y: 2}
    203.     p  = &TestStruct{1, 2}
    204. )
    205. var (
    206.     v11 = TestPipeStruct{1, 2}
    207.     v22 = TestPipeStruct{Y: 2}
    208.     pp  = &TestPipeStruct{1, 2}
    209. )