心平9bwburua3p / 待分类 / 数组,切片,关联数组,Range遍历

分享

   

数组,切片,关联数组,Range遍历

2017-04-14  心平9bwbu...

数组

在 Go 中,数组 是一个固定长度的数列。

代码实例

// 在 Go 中,_数组_ 是一个固定长度的数列。

package main

import "fmt"

func main() {

    // 这里我们创建了一个数组 `a` 来存放刚好 5 个 `int`。
    // 元素的类型和长度都是数组类型的一部分。数组默认是
    // 零值的,对于 `int` 数组来说也就是 `0`。
    var a [5]int
    fmt.Println("emp:", a)

    // 我们可以使用 `array[index] = value` 语法来设置数组
    // 指定位置的值,或者用 `array[index]` 得到值。
    a[4] = 100
    fmt.Println("set:", a)
    fmt.Println("get:", a[4])

    // 使用内置函数 `len` 返回数组的长度
    fmt.Println("len:", len(a))

    // 使用这个语法在一行内初始化一个数组
    b := [5]int{1, 2, 3, 4, 5}
    fmt.Println("dcl:", b)

    // 数组的存储类型是单一的,但是你可以组合这些数据
    // 来构造多维的数据结构。
    var twoD [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

运行程序

# 注意,在使用 `fmt.Println` 来打印数组的时候,会使用
# `[v1 v2 v3 ...]` 的格式显示
$ go run arrays.go
emp: [0 0 0 0 0]
set: [0 0 0 0 100]
get: 100
len: 5
dcl: [1 2 3 4 5]
2d:  [[0 1 2] [1 2 3]]

# 在典型的 Go 程序中,相对于数组而言,_slice_ 使用
# 的更多。我们将在后面讨论 slice。

切片

Slice 是 Go 中一个关键的数据类型,是一个比数组更加强大的序列接口

代码实例

// _Slice_ 是 Go 中一个关键的数据类型,是一个比数组更
// 加强大的序列接口

package main

import "fmt"

func main() {

    // 不想数组,slice 的类型仅有它所包含的元素决定(不像
    // 数组中还需要元素的个数)。要创建一个长度非零的空
    // slice,需要使用内建的方法 `make`。这里我们创建了一
    // 个长度为3的 `string` 类型 slice(初始化为零值)。
    s := make([]string, 3)
    fmt.Println("emp:", s)

    // 我们可以和数组一下设置和得到值
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])

    // 如你所料,`len` 返回 slice 的长度
    fmt.Println("len:", len(s))

    // 作为基本操作的补充,slice 支持比数组更多的操作。
    // 其中一个是内建的 `append`,它返回一个包含了一个
    // 或者多个新值的 slice。注意我们接受返回由 append
    // 返回的新的 slice 值。
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)

    // Slice 也可以被 `copy`。这里我们创建一个空的和 `s` 有
    // 相同长度的 slice `c`,并且将 `s` 复制给 `c`。
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)

    // Slice 支持通过 `slice[low:high]` 语法进行“切片”操
    // 作。例如,这里得到一个包含元素 `s[2]`, `s[3]`,
    // `s[4]` 的 slice。
    l := s[2:5]
    fmt.Println("sl1:", l)

    // 这个 slice 从 `s[0]` 到(但是包含)`s[5]`。
    l = s[:5]
    fmt.Println("sl2:", l)

    // 这个 slice 从(包含)`s[2]` 到 slice 的后一个值。
    l = s[2:]
    fmt.Println("sl3:", l)

    // 我们可以在一行代码中申明并初始化一个 slice 变量。
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)

    // Slice 可以组成多维数据结构。内部的 slice 长度可以不
    // 同,这和多位数组不同。
    twoD := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

运行程序

# 注意,slice 和数组不同,虽然它们通过 `fmt.Println` 输出
# 差不多。
$ go run slices.go
emp: [  ]
set: [a b c]
get: c
len: 3
apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

# 看看这个由 Go 团队撰写的一篇[很棒的博文](http://blog.golang.org/2011/01/go-slices-usage-and-internals.html),
# 获得更多关于 Go 中 slice 的设计和实现细节。

# 现在,我们已经看过了数组和 slice,接下来我们将看看 
# Go 中的另一个关键的内建数据类型:map。

关联数组

map 是 Go 内置关联数据类型(在一些其他的语言中称为哈希 或者字典 )。

代码实例

// _map_ 是 Go 内置[关联数据类型](http://zh.wikipedia.org/wiki/关联数组)(
// 在一些其他的语言中称为_哈希_ 或者_字典_ )。

package main

import "fmt"

func main() {

    // 要创建一个空 map,需要使用内建的 `make`:
    // `make(map[key-type]val-type)`.
    m := make(map[string]int)

    // 使用典型的 `make[key] = val` 语法来设置键值对。
    m["k1"] = 7
    m["k2"] = 13

    // 使用例如 `Println` 来打印一个 map 将会输出所有的
    // 键值对。
    fmt.Println("map:", m)

    // 使用 `name[key]` 来获取一个键的值
    v1 := m["k1"]
    fmt.Println("v1: ", v1)

    // 当对一个 map 调用内建的 `len` 时,返回的是键值对
    // 数目
    fmt.Println("len:", len(m))

    // 内建的 `delete` 可以从一个 map 中移除键值对
    delete(m, "k2")
    fmt.Println("map:", m)

    // 当从一个 map 中取值时,可选的第二返回值指示这个键
    // 是在这个 map 中。这可以用来消除键不存在和键有零值,
    // 像 `0` 或者 `""` 而产生的歧义。
    _, prs := m["k2"]
    fmt.Println("prs:", prs)

    // 你也可以通过这个语法在同一行申明和初始化一个新的
    // map。
    n := map[string]int{"foo": 1, "bar": 2}
    fmt.Println("map:", n)
}

运行程序

# 注意一个 map 在使用 `fmt.Println` 打印的时候,是以 `map[k:v k:v]`
# 的格式输出的。
$ go run maps.go 
map: map[k1:7 k2:13]
v1:  7
len: 2
map: map[k1:7]
prs: false
map: map[foo:1 bar:2]

range 遍历

range 迭代各种各样的数据结构。让我们来看看如何在我们已经学过的数据结构上使用 range 吧。

代码实例

// _range_ 迭代各种各样的数据结构。让我们来看看如何在我们
// 已经学过的数据结构上使用 `rang` 吧。

package main

import "fmt"

func main() {

    // 这里我们使用 `range` 来统计一个 slice 的元素个数。
    // 数组也可以采用这种方法。
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    fmt.Println("sum:", sum)

    // `range` 在数组和 slice 中都同样提供每个项的索引和
    // 值。上面我们不需要索引,所以我们使用 _空值定义符_
    // `_` 来忽略它。有时候我们实际上是需要这个索引的。
    for i, num := range nums {
        if num == 3 {
            fmt.Println("index:", i)
        }
    }

    // `range` 在 map 中迭代键值对。
    kvs := map[string]string{"a": "apple", "b": "banana"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }

    // `range` 在字符串中迭代 unicode 编码。第一个返回值是
    // `rune` 的起始字节位置,然后第二个是 `rune` 自己。
    for i, c := range "go" {
        fmt.Println(i, c)
    }
}

运行程序

$ go run range.go 
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
动手实践是学习 IT 技术最有效的方式! 开始实验

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多
    喜欢该文的人也喜欢 更多

    ×
    ×

    ¥.00

    微信或支付宝扫码支付:

    开通即同意《个图VIP服务协议》

    全部>>