golangMap

分类: glolang 发布时间: 2018-12-14 17:20:22
什么是Map?

地图是Go中的内置类型,它将值与键相关联。可以使用相应的密钥检索该值。

如何创建Map?

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

personSalary := make(map[string]int)

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

Map的零值是nil。如果您尝试将项目添加到nil映射,则会发生运行时混乱。因此,必须使用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 Map中添加了一些新项目。

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]


也可以在声明本身期间初始化地图。

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]

没有必要只有字符串类型应该是键。所有类似的类型,如布尔值,整数,浮点数,复数,字符串,......也可以是键。

访问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检索并打印员工的工资。该计划的产出Salary of jamie is 15000。


如果元素不存在会发生什么?Map将返回该元素类型的零值。在的情况下,personSalary Map,如果我们试图访问不存在的话,零值的元素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中。


如果我们想知道a key是否存在于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,ok因为joe不存在将是假的。因此该程序将输出,

joe not found  

循环的range形式for用于迭代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  

一个重要的事实是,for range对于程序的每次执行,在使用时从映射中检索值的顺序不保证是相同的。

删除项目

delete(map,key)是key从a中删除的语法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函数确定映射的长度。

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)决定了地图的长度。上述程序输出,length is 3

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。在下一行中,薪水在Map中mike更改为。迈克的薪水现在是在太。该方案的产出,18000newPersonSalary18000personSalary

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

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

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

Map平等

无法使用==运算符比较地图。它==只能用于检查Map是否存在nil。

package main

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

    map2 := map1

    if map1 == map2 {
    }
}