Go 入门 - Go中的复杂类型

标签：切片   ack   class   tps   删除   VID   默认值   变量   cap   

主要内容来自中文版的官方教程Go语言之旅
目的为总结要点

指针

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

* 操作符表示指针指向的底层值。

fmt.Println(*p) // 通过指针 p 读取 i
*p = 21         // 通过指针 p 设置 i

这也就是通常所说的“间接引用”或“重定向”。

与 C 不同，Go 没有指针运算。

package main

import "fmt"

func main() {
    i, j := 42, 2701

    p := &i         // point to i
    fmt.Println(*p) // read i through the pointer
    fmt.Println(p)
    *p = 21         // set i through the pointer
    fmt.Println(i)  // see the new value of i

    p = &j         // point to j
    *p = *p / 37   // divide j through the pointer
    fmt.Println(j) // see the new value of j
}
// output
// 42
// 0xc420084010
// 21
// 73

结构体

结构体是一些变量的集合，可以用以下方式创建一个结构体。修改结构体可以采用.符号，指向结构体的指针也可以用同样的方法来访问。

package main
import "fmt"
type Vertex struct {
    X int
    Y int
}
func main() {
    v := Vertex{1,2}
    fmt.Println(v)
    v.X = 4
    fmt.Println(v)
    p := &v
    p.X = 8
    fmt.Println(v)
}
//output {1 2} {4 2} {8 2}

结构体与结构体的指针都可以用以下的方法初始化

package main
import "fmt"
type Vertex struct {
    X, Y int
}
var (
    v1 = Vertex{1, 2}  // has type Vertex
    v2 = Vertex{X: 1}  // Y:0 is implicit
    v3 = Vertex{}      // X:0 and Y:0
    p  = &Vertex{1, 2} // has type *Vertex
)
func main() {
    fmt.Println(v1, p, v2, v3)
}

数组与切片

数组的声明也是从做到右的，以var开头的或者短声明

var a [2] string
var a [10] int
primes := [6]{2, 3, 5, 7}

切片

类型[]T表示一个元素类型为T的切片。切片通过两个下标界定a[low:high]，这种切片会选择一个半开区间，包含第一个元素但是排除最后一个元素。切片下界的默认值是0，上界的默认值是该切片的长度。这里注意，如果制定了长度，那么得到的就是数组，在Go中数组是作为值传递的，会耗费很多的内存。

package main
import "fmt"
func main() {
    primes := [6]int{2, 3, 5, 7, 11, 13} // 这是一个数组
    var s []int = primes[1:4] // 这是在声明一个切片
    fmt.Println(s)
    names := [4]string{
        "John","Paul","George","Ringo",
    }   // 这是一个数组
    fmt.Println(names)
    a := names[0:2] // 这也是一个切片
    b := names[1:3] // 这也是一个切片
    fmt.Println(a, b) // output [John Pul] [Paul George]
    b[0] = "XXX"
    fmt.Println(a, b) // output [John XXX] [XXX George]
    fmt.Println(names) // output [John XXX George Ringo]
}

一个切片本身是底层数组的引用，多个切片可以共享一个底层数组，在一个切片上的修改可以影响到底层数组，进而影响到所有切片

切片拥有 长度 和 容量。对于切片s，长度是切片的长度，可以用len(s)获得，容量是从切片的第一个元素开始数一直到底层数组的长度，可以用cap(s)获得。
从底层数组的视角来看，切片中有意义的量只有三个，分别是起始位置，长度和容量。其中长度和容量是反映在切片自身重点，起始位置是用于锚定切片在底层数组中的位置。一旦切片建立，那么底层数组在起始位置之前的部分就会被扔掉。

在做切片的时候，其实s[low: high]中的low就选择了在当前的底层数组中的起始位置，high选择了终止位置，进而定义了长度high-low。在简历切片之后，底层数组精简原底层数组中low到末尾的部分。

nil切片是切片长度和容量都为零，且没有底层数组的切片，例如它可以这样声明var s []int。其实在这个意义上，数组自身就是长度和容量相等的切片。

切片可以包含任何类型，甚至其他的切片(多维数组)

board := [][]string{
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
        []string{"_", "_", "_"},
}

用range遍历切片

package main
import "fmt"
var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}
func main() {
    for i, v := range pow {
        fmt.Printf("2**%d = %d\n", i, v)
    }
    for _, value := range pow {
        fmt.Printf("%d\n", value)
    }
    for value, _ := range pow {
        fmt.Printf("%d\n", value)
    }
}

映射

映射将key映射到value。用make函数可以创建给定类型的映射，并将其初始化备用。

映射的零值为nil，需要注意的是nil既没有键，也不能添加键

package main
import "fmt"
type Vertex struct {
    Lat, Long float64
}
var m map[string]Vertex
func main() {
    m = make(map[string]Vertex)
    m["Bell Labs"] = Vertex{
        40.68433, -74.39967,
    }
    fmt.Println(m["Bell Labs"])
}

映射的文法和结构体类似，但是一定要有键名

package main
import "fmt"
type Vertex struct {
    Lat, Long float64
}
var m = map[string]Vertex{
    "Bell Labs": Vertex{
        40.68433, -74.39967,
    },
    "Google": Vertex{
        37.42202, -122.08408,
    },
}
func main() {
    fmt.Println(m)
}

映射可以用下标访问或修改元素

用delete函数删除元素

用双赋值可以检测某个键的是否存在

package main

import "fmt"

func main() {
    m := make(map[string]int)

    m["Answer"] = 42
    fmt.Println("The value:", m["Answer"])

    m["Answer"] = 48
    fmt.Println("The value:", m["Answer"])

    delete(m, "Answer")
    fmt.Println("The value:", m["Answer"])

    v, ok := m["Answer"]
    fmt.Println("The value:", v, "Present?", ok) // ok 是是否存在的boolean值
}

函数值

函数本身也可以作为值，称为函数值，可以作为函数的参数或者返回值

package main

import (
    "fmt"
    "math"
)

func compute(fn func(float64, float64) float64) float64 {
    return fn(3, 4)
}

func main() {
    hypot := func(x, y float64) float64 {
        return math.Sqrt(x*x + y*y)
    }
    fmt.Println(hypot(5, 12))

    fmt.Println(compute(hypot))
    fmt.Println(compute(math.Pow))
}

Go函数可以使一个闭包。闭包是一个函数值，它引用了函数体之内的变量。该函数可以访问并赋予其引用的变量的值。例如下面的例子中adder函数返回值为一个闭包。每个闭包都被绑定在各自的sum变量上。

package main

import "fmt"

func adder() func(int) int {
    sum := 0 //这是闭包的函数体之外的变量，它也被绑定在闭包内了
    return func(x int) int { //这是闭包
        sum += x
        return sum
    }
}

func main() {
    pos, neg := adder(), adder()
    for i := 0; i < 10; i++ {
        fmt.Println(
            pos(i),
            neg(-2*i),
        )
    }
}

make函数

用make函数创建切片(动态数组)，有两种用法

a := make([]int, 5) // 长度为5，容量默认为5
b := make([]int, 0, 5) // 长度为0， 容量为5

func make([]T, len, cap) []T

用make函数可以创建给定类型的映射，并将其初始化备用

Go 入门 - Go中的复杂类型

标签：切片   ack   class   tps   删除   VID   默认值   变量   cap   

原文地址：https://www.cnblogs.com/computing-n-design/p/9795090.html