golang教程之Maps

Maps

原文:https://golangbot.com/maps/

什么是map？

map是Go中的内置类型，它将值与键相关联。 可以使用相应的**检索该值。

如何创建map？

可以通过将键和值的类型传递给make函数来创建map。make(map[type of key]type of value)是创建map的语法。

personSalary := make(map[string]int)  

上面的代码行创建了一个名为personSalary的映射，它具有string键和int值。

map的初始值为nil。 如果您尝试将项目添加到map，则会发生运行时混乱。 因此，必须使用make函数初始化map。

package main

import (  
    "fmt"
)

func main() {  
    var personSalary map[string]int
    if personSalary == nil {
        fmt.Println("map is nil. Going to make one.")
        personSalary = make(map[string]int)
    }
}

在上面的程序中，personSalary是nil，因此它将使用make函数初始化。 该程序将输出的map is nil. Going to make one.

将项目添加到map

向map添加新项的语法与数组的语法相同。 下面的程序为personSalary添加了一些新项目。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := make(map[string]int)
    personSalary["steve"] = 12000
    personSalary["jamie"] = 15000
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

上面的程序输出，personSalary map contents: map[steve:12000 jamie:15000 mike:9000]

也可以在声明期间初始化map。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int {
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("personSalary map contents:", personSalary)
}

上面的程序声明了personSalary，并在声明过程中为它添加了两个元素。 之后又增加了一个键值为mike的元素。 该程序的输出

personSalary map contents: map[steve:12000 jamie:15000 mike:9000]  

没有必要只有字符串类型应该是键。 所有类似的类型，如布尔值，整数，浮点数，复数，字符串，...也可以是键。 如果您想了解有关类似类型的更多信息，请访问http://golang.org/ref/spec#Comparison_operators

访问map的项目

现在我们已经向map添加了一些元素，让我们学习如何检索它们。 map [key]是检索map元素的语法。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
}

上述程序非常简单。员工Jamie的工资被检索并打印出来。 程序输出Jamie的薪水是15000。

如果元素不存在会发生什么？map将返回该元素类型的零值。 在personSalary的情况下，如果我们尝试访问当前不存在的元素，则返回int的零值0。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    employee := "jamie"
    fmt.Println("Salary of", employee, "is", personSalary[employee])
    fmt.Println("Salary of joe is", personSalary["joe"])
}

上述程序的输出是

Salary of jamie is 15000  
Salary of joe is 0  

上面的程序将joe的工资返回为0.我们没有得到任何运行时错误，表明关键joe不存在于personSalary中。

如果我们想知道某个键是否存在于map中，该怎么办？

value, ok := map[key]  

以上是用于确定特定键是否存在于map中的语法。 如果ok为true，则键存在且其值存在于value中，否则键不存在。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    newEmp := "joe"
    value, ok := personSalary[newEmp]
    if ok == true {
        fmt.Println("Salary of", newEmp, "is", value)
    } else {
        fmt.Println(newEmp,"not found")
    }

}

在上面的程序中，在第15行中，因为joe不存在，所以肯定会错。 因此该程序将输出，

joe not found 

for循环的range形式用于迭代map的所有元素。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("All items of a map")
    for key, value := range personSalary {
        fmt.Printf("personSalary[%s] = %d\n", key, value)
    }

}

上述程序输出，

All items of a map  
personSalary[mike] = 9000  
personSalary[steve] = 12000  
personSalary[jamie] = 15000  

一个重要的事实是，当用于range时，从map中检索值的顺序不保证对于程序的每次执行是相同的。

删除项目

delete（map，key）是从map中删除键的语法。 删除功能不返回任何值。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("map before deletion", personSalary)
    delete(personSalary, "steve")
    fmt.Println("map after deletion", personSalary)

}

上述程序删除键“steve”并输出

map before deletion map[steve:12000 jamie:15000 mike:9000]  
map after deletion map[mike:9000 jamie:15000]  

map的长度

可以使用len函数确定map的长度。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("length is", len(personSalary))

}

上述程序中的len（personSalary）决定了map的长度。 上述程序输出，长度为3

map是引用类型

与切片类似，map是引用类型。 将map分配给新变量时，它们都指向相同的内部数据结构。 因此，在一个中做出的改变将反映在另一个中。

package main

import (  
    "fmt"
)

func main() {  
    personSalary := map[string]int{
        "steve": 12000,
        "jamie": 15000,
    }
    personSalary["mike"] = 9000
    fmt.Println("Original person salary", personSalary)
    newPersonSalary := personSalary
    newPersonSalary["mike"] = 18000
    fmt.Println("Person salary changed", personSalary)

}

在上面的程序第14行中，将personSalary分配给newPersonSalary。 在下一行中，mike的薪水在newPersonSalary中更改为18000。mike的薪水现在也是18000。 该程序的输出，

Original person salary map[steve:12000 jamie:15000 mike:9000]  
Person salary changed map[steve:12000 jamie:15000 mike:18000]

类似于将map作为参数传递给函数的情况。当对函数内的map进行任何更改时，调用者将可以看到它。

map判等

无法使用==运算符比较map。 ==只能用于检查map是否为nil。

package main

func main() {  
    map1 := map[string]int{
        "one": 1,
        "two": 2,
    }

    map2 := map1

    if map1 == map2 {
    }
}

上面的程序会抛出编译错误无效操作：map1 == map2（map只能比较是否为nil）。

检查两个map是否相等的一种方法是逐个比较每个映射的各个元素。 我鼓励你为此编写程序并使其工作。

我已经将我们讨论过的所有概念编译成一个程序。 你可以从github下载它。