Maps

什么是 map ？

　　类似Python中的字典数据类型，以k:v键值对的形式。

　　map 是在 Go 中将值（value）与键（key）关联的内置类型。通过相应的键可以获取到值。

如何创建 map ？

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

// personSalary := make(map[string]int)

　　上面的代码创建了一个名为 personSalary 的 map，其中键是 string 类型，而值是 int 类型。

map 的零值是 nil。如果你想添加元素到 nil map 中，会触发运行时 panic。因此 map 必须使用 make 函数初始化。

//maps

package main

import "fmt"

func main() {

    //maps的定义

    //map的key值必须可hash

    //var a map[键值类型]value值类型

    //map的空值是nil类型

    var a map[int]string

    fmt.Println(a)

    if a==nil{

        fmt.Println("xxxx")

    }

}

map修改和添加元素

　　给 map 添加新元素的语法和数组相同

package main

import "fmt"

func main(){

    //map的赋值跟取值

    //map的初始化

    var a map[int]string=make(map[int]string)

    fmt.Println(a)

    if a==nil{

        fmt.Println("hello")

    }

    a[1]="100"

    a[2]="888"

    fmt.Println(a)

    fmt.Println(a[1])

    ////取一个不存在的key值会？返回value值的空值
　　////fmt.Println(a[9])

    //var b map[int]int=make(map[int]int)

    //b[1]=100

    //fmt.Println(b)

    ////fmt.Println(b[9])

    //if v,ok:=a[9];ok{

    //    fmt.Println("=-====",v)

    //}else {

    //    fmt.Println("该值不存在")

    //}

    //v,ok:=a[1]

    //fmt.Println(v)

    //fmt.Println(ok)

    //定义和初始化的第二种方式

    //var a =map[int]string{1:"10",2:"100"}

    ////a[1]

    //fmt.Println(a[1])

}

对应的以key:value的形式赋值，赋值和取值都是通过key来操作value的。

删除 map 中的元素

　　删除 `map` 中 `key` 的语法是 [delete(map, key)]。这个函数没有返回值。

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 的长度

　　获取 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) 函数获取了 map 的长度。程序输出 length is 3。3对k:v键值对。

Map 是引用类型

　　和 [slices]类似，map 也是引用类型。当 map 被赋值为一个新变量的时候，它们指向同一个内部数据结构。因此，改变其中一个变量，就会影响到另一变量。

package main

import "fmt"

func main(){

    //Map 是引用类型

    var a =map[int]string{1:"10",2:"100"}

    test4(a)

    fmt.Println(a)

func test4(a map[int]string)  {

    a[1]="888"

    fmt.Println(a)

}

当 map 作为函数参数传递时也会发生同样的情况。函数中对 map 的任何修改，对于外部的调用都是可见的。

Map 的相等性

　　map 之间不能使用 == 操作符判断，== 只能用来检查 map 是否为 nil。

package main

import "fmt"

func main(){

    //Map 的相等性

    map1 := map[string]int{

        "one": 1,

        "two": 2,

    }

    map2 := map1

    if map1 == map2 {  //报错

    }

    //map循环出所有元素

    //var a =map[int]string{1:"10",0:"100",10:"999"}

    ////for i:=0;i<len(a);i++{

    ////    fmt.Println(a[i])

    ////}

    ////map是无序的

    //for k,v:=range a{

    //    fmt.Println(k)

    //    fmt.Println(v)

    //}

    //补充：切片删除元素

    //var a =[]int{1,2,3,4,5,6}

    //a=append(a[0:2],a[3:]...)

    //fmt.Println(a)

}

}

上面程序抛出编译错误 invalid operation: map1 == map2 (map can only be compared to nil)。

判断两个 map 是否相等的方法是遍历比较两个 map 中的每个元素。我建议你写一段这样的程序实现这个功能

字符串

什么是字符串？

　　Go 语言中的字符串是一个字节切片。把内容放在双引号" "之间，我们可以创建一个字符串。让我们来看一个创建并打印字符串的简单示例。

package main

import (

    "fmt"

)

func main() {

    name := "Hello World"

    fmt.Println(name)

}

上面的程序将会输出 Hello World。

Go 中的字符串是兼容 Unicode 编码的，并且使用 UTF-8 进行编码。

其他方法：

package main

import (

    "fmt"

    "unicode/utf8"

    )

package main

import (

"fmt"

"unicode/utf8"

)

func main() {

    name := "Hello World蟒蛇"

    //name:="赵"

    //字符串长度，len统计字节数

    //在go种string类型都是utf-8编码

    fmt.Println(len(name))

    fmt.Println(utf8.RuneCountInString(name))

    //unicode是一个字符编码对照表

    //循环

    //字符串是个只读切片

    //name := "name赵"

    //for i:=0;i<len(name);i++{

    //    fmt.Println(string(name[i]))

    //    fmt.Printf("%T",name[i])

    //    fmt.Println()

    //}

    //for _,v:=range name{

    //    fmt.Println(string(v))

    //    fmt.Printf("%T",v)

    //    fmt.Println()

    //}

    //name := "name赵"

    //name[0]=99

    //fmt.Println(name[0])

    //fmt.Println(string(name[0]))

    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}// 打印的是字节数

    str := string(byteSlice)

    a:=len(str)

    b:=utf8.RuneCountInString(str)

    fmt.Println(b)

    fmt.Println(a)

    fmt.Println(str)

}

需要注意的是：字节数和字符数的区别，一个字节占用了三个字符个数；取长度的关键字：-len(str) utf8.RuneCountInString(str)

单独获取字符串的每一个字节

　　由于字符串是一个字节切片，所以我们可以获取字符串的每一个字节。

package main

import (

    "fmt"

)

func printBytes(s string) {

    for i:= 0; i < len(s); i++ {

        fmt.Printf("%x ", s[i])

    }

}

func main() {

    name := "Hello World"

    printBytes(name)

}

go中的string字符串的形式都是以utf-8的形式存入内存中，而其他语言以Unicode万国码形式，获取长度用：

字符串的 for range 循环

　　循环出来的是一个个的字符数，可以用rune的方法和for range的方法

package main

import "fmt"

func main(){    

        //循环

    //字符串是个只读切片

    // 第一种：循环字节的个数

    name := "name赵"

    //for i:=0;i<len(name);i++{

    //    fmt.Println(string(name[i]))

    //    fmt.Printf("%T",name[i])

    //    //fmt.Println()

    //}

    // 循环出来的字符的个数，一般用第二种，会乱码

    for _,v:=range name{

        fmt.Println(string(v)) //转格式

        fmt.Printf("%T",v)

        fmt.Println()

    }

    //字符串是个只读切片，只能读，不能等修改

    //name := "name赵"

    //name[0]=99

    fmt.Println(name[0])

    fmt.Println(string(name[0]))        

}

字符串是不可变的，Go 中的字符串是不可变的。一旦一个字符串被创建，那么它将无法被修改

字符只能读取，不支持修改。

用字节切片构造字符串

package main

import (

    "fmt"

"unicode/utf8"

)

    func main() {

    byteSlice := []byte{0x43, 0x61, 0x66, 0xC3, 0xA9}// 打印的是字节数

    str := string(byteSlice)

    a:=len(str)

    b:=utf8.RuneCountInString(str)

    fmt.Println(b)

    fmt.Println(a)

    fmt.Println(str)

}

指针

什么是指针？

　　指针是一种存储变量内存地址（Memory Address）的变量。

如上图所示，变量 b 的值为 156，而 b 的内存地址为 0x1040a124。变量 a 存储了 b 的地址。我们就称 a 指向了 b。

指针的声明

指针变量的类型为 *T，该指针指向一个 T 类型的变量。

总结：

 //&取地址符号

 //* 放在类型旁边，表示指向这个类型的指针

 //* 放在变量旁边，表示解引用（反解）

例子：

//指针

package main

import "fmt"

func main() {

    //&取地址符号

    //* 放在类型旁边，表示指向这个类型的指针

    //* 放在变量旁边，表示解引用（反解）

    a:=10

    //b就是一个指针 指向int类型的指针

    //b:=&a

    //d:="sss"

    //var c *string=&d

    var b *int =&a

    fmt.Println(b)

    fmt.Println(*b) //把b对应的值给取出来

    c:=&b

    //var c **int=&b //指向int类型的指针

    fmt.Println(*(*c))

}

指针的零值（Zero Value）

指针的零值是 nil。

package main

import "fmt"

func main(){

//指针的零值（Zero Value）,nil类型

    //var a *int

    //fmt.Println(a)

}>>>nil

向函数传递指针参数

package main

import "fmt"

func change(val *int)  {

    *val = 55

}

func main()  {

    a:=58

    fmt.Println(a)

    b:=&a

    change(b)

    fmt.Println(a)

}

在上面程序中的，我们向函数 change 传递了指针变量 b，而 b 存储了 a 的地址。程序在 change 函数内使用解引用。

不要向函数传递数组的指针，而应该使用切片

　　假如我们想要在函数内修改一个数组，并希望调用函数的地方也能得到修改后的数组，一种解决方案是把一个指向数组的指针传递给这个函数。

    //向函数传递指针参数

    a := 10

    b := &a

    test6(b)

    fmt.Println(a)

    test7(a)

    fmt.Println(a)

    //不要向函数传递数组的指针，而应该使用切片

    var a [100]int

    test9(&a)

    fmt.Println(a)

    test10(a[:])

    fmt.Println(a)

    //Go 不支持指针运算

func test9(a *[4]int)  {

    (*a)[0]=999

fmt.Println(a)

}

func test10(a []int)  {

    a[0]=999

fmt.Println(a)

}

只是不建议，可以使用，但系统默认会认为是指针的地址。

Go 不支持指针运算

　　Go 并不支持其他语言（例如 C）中的指针运算。

package main

func main() {

    b := [...]int{109, 110, 111}

    p := &b

    p++

}

上面的程序会抛出编译错误：main.go:6: invalid operation: p++ (non-numeric type *[3]int)。

16. 结构体

什么是结构体？

　　类似其他语言的面向对象，一个类有属性有方法；go中可以通过其他的方法实现类的三大属性：继承，封装，多态派生的方法。

　　结构体是用户定义的类型，表示若干个字段（Field）的集合。有时应该把数据整合在一起，而不是让这些数据没有联系。这种情况下可以使用结构体。

例如，一个职员有 firstName、lastName 和 age 三个属性，而把这些属性组合在一个结构体 employee 中就很合理。

结构体的声明

格式：type 关键字解构体名字 struct{ }

package main

import "fmt"

//结构体：是一系列属性的集合

//定义一个人结构体

//type关键字 结构体名字 struct{}

type Person struct {

    name string

    sex int

    age int

}

func main() {

    //person  :=Person{}

    //定义没有初始化

    //结构体是值类型

    //var person Person

    //var person Person=Person{name:"lqz"}

    var person Person=Person{"lqz",1,19}

    //person.name="lqz"

    fmt.Println(person.name) // 获取的话直接·属性

}

创建匿名结构体

　　匿名就是没有type的结构体名，但要引用的话必须先实例化才能使用，与一般的结构体有点区别而已。

package main

import "fmt"

func main(){

    a:=struct {

        name string

        age int

        hobby string

    }{"rose",19,"music"}

    fmt.Printf(a.name)

    //fmt.Printf(a.age)

    fmt.Printf( a.hobby)

}

结构体的零值（Zero Value）

　　当定义好的结构体并没有被显式地初始化时，该结构体的字段将默认赋为零值，有字段决定。

package main

import (

    "fmt"

)

type Employee struct {

    firstName, lastName string

    age, salary         int

}

func main() {

    var emp4 Employee //zero valued structure

    fmt.Println("Employee 4", emp4)

}

该程序定义了 emp4，却没有初始化任何值。因此 firstName 和 lastName 赋值为 string 的零值（""）。

而 age 和 salary 赋值为 int 的零值（0）。该程序会输出：

Employee 4 { 0 0}

结构体的指针

　　也可以创建指向结构体的指针。

package main

import "fmt"

func main(){

    //结构体指针

    p:=Person{name:"lqz"}

    //pPoint:=&p

    var pPoint *Person=&p

    //fmt.Println(pPoint)

    //fmt.Println((*pPoint).name)

    fmt.Println(pPoint.name)

}

匿名字段

　　当我们创建结构体时，字段可以只有类型，而没有字段名。这样的字段称为匿名字段

以下代码创建一个 Person 结构体，它含有两个匿名字段 string 和 int。

type Person struct {

    string

    int

}

我们接下来使用匿名字段来编写一个程序。

package main

import (

    "fmt"

)

type Person struct {

    string

    int

}

func main() {

    p := Person{"Naveen", 50}

    fmt.Println(p)

}

　　上述直接传相应的字段类型的值即可，会自动匹配字段类型。

虽然匿名字段没有名称，但其实匿名字段的名称就默认为它的类型

嵌套结构体（Nested Structs）

　　字段定义的时候，字段里嵌套另一个字段。

// 嵌套结构体

package main

import "fmt"

type Person struct{

　　name string

　　sex int

　　age int

　　hobby Hobby

}

type Hobby struct{

　　id int

　　name string

}

func main(){

//erson{name:"gai",hobby:Hobby{id:10,name:"篮球“} // 两种传参方式

p:=Person{name:"lqz",hobby:Hobby{id:10,name:"篮球"}}

p.hobby.id=102

fmt.PrintLn(P.hobby.name) // 获取属性值的方法

}

}

//变量提升过程中如果有重名的，就不提升了
//p:=Person{name:"lqz",Hobby:Hobby{10,"篮球"}}
//fmt.Println(p.Hobby.name)
//fmt.Println(p.name)

>>:篮球

提升字段（Promoted Fields）

有点类似面向对象的继承，继承类中的属性。

　　如果是结构体中有匿名的结构体类型字段，则该匿名结构体里的字段就称为提升字段。这是因为提升字段就像是属于外部结构体一样，可以用外部结构体直接访问。

type Address struct {

    city, state string

}

type Person struct {

    name string

    age  int

    Address

}

　　在上面的代码片段中，Person 结构体有一个匿名字段 Address，而 Address 是一个结构体。

现在结构体 Address 有 city 和 state 两个字段，访问这两个字段就像在 Person 里直接声明的一样，因此我们称之为提升字段。

package main

import (

    "fmt"

)

type Address struct {

    city, state string

}

type Person struct {

    name string

    age  int

    Address

}

func main() {

    var p Person

    p.name = "Naveen"

    p.age = 50

    p.Address = Address{

        city:  "Chicago",

        state: "Illinois",

    }

    fmt.Println("Name:", p.name)

    fmt.Println("Age:", p.age)

    fmt.Println("City:", p.city) //city is promoted field

    fmt.Println("State:", p.state) //state is promoted field

}

在上面代码中的第 26 行和第 27 行，我们使用了语法 p.city 和 p.state，访问提升字段 city 和 state 就像它们是在结构体 p 中声明的一样。该程序会输出：

Name: Naveen

Age: 50

City: Chicago

State: Illinois

结构体相等性（Structs Equality）

　　结构体是值类型。如果它的每一个字段都是可比较的，则该结构体也是可比较的。如果两个结构体变量的对应字段相等，则这两个变量也是相等的。

练习：

通过map为数组添加三个元素，执行代码map[0](9)得到9，map[1](9得到81，mapp[2](9)得到729.

//-map内放函数

//-通过map实现set

func main() {

    var m map[int]func(a int)int=make(map[int]func(a int)int)

    m[1]= func(a int) int {

        return a

    }

    m[2]= func(a int) int {

        return a*a

    }

    m[3]= func(a int) int {

        return a*a*a

    }

    fmt.Println(m[1](9))

    fmt.Println(m[2](9))

    fmt.Println(m[3](9))

}

map 实现set类型，增加删除修改元素，判断元素是否存在，获取len 等

func main() {

    //集合

    //可以放值，如果重复了，放不进去

    //可以获取长度

    //判断一个值是否在集合内

    //把集合内所有元素打印出来

    var m map[string]bool=make(map[string]bool)

    m["lqz"]=true

    m["egon"]=true

    m["lqz"]=true

    fmt.Println(len(m))

    //"aa"是否在集合内

    if m["aa"]{

        fmt.Println("在里面")

    }else {

        fmt.Println("不再")

    }

    for k,_:=range m{

        fmt.Println(k)

    }

}

巴特西

Go-map-字符串-指针-结构体

Maps

什么是 map ？

如何创建 map ？

map修改和添加元素

给 map 添加新元素的语法和数组相同

对应的以key:value的形式赋值，赋值和取值都是通过key来操作value的。

删除 map 中的元素

删除 `map` 中 `key` 的语法是 [delete(map, key)]。这个函数没有返回值。

获取 map 的长度

Map 是引用类型

Map 的相等性

字符串

什么是字符串？

单独获取字符串的每一个字节

字符串的 for range 循环

字符串是不可变的，Go 中的字符串是不可变的。一旦一个字符串被创建，那么它将无法被修改

用字节切片构造字符串

指针

什么是指针？

指针的声明

例子：

指针的零值（Zero Value）

向函数传递指针参数

不要向函数传递数组的指针，而应该使用切片

Go 不支持指针运算

16. 结构体

什么是结构体？

结构体的声明

格式：type 关键字解构体名字 struct{ }

创建匿名结构体

结构体的零值（Zero Value）

结构体的指针

匿名字段

嵌套结构体（Nested Structs）

提升字段（Promoted Fields）

结构体相等性（Structs Equality）

最新文章

热门文章

巴特西

Go-map-字符串-指针-结构体

Maps

什么是 map ？

如何创建 map ？

map修改和添加元素

给 map 添加新元素的语法和数组相同

对应的以key:value的形式赋值，赋值和取值都是通过key来操作value的。

删除 map 中的元素

删除 map 中 key 的语法是 [delete(map, key)]。这个函数没有返回值。

获取 map 的长度

Map 是引用类型

Map 的相等性

字符串

什么是字符串？

单独获取字符串的每一个字节

字符串的 for range 循环

字符串是不可变的，Go 中的字符串是不可变的。一旦一个字符串被创建，那么它将无法被修改

用字节切片构造字符串

指针

什么是指针？

指针的声明

例子：

指针的零值（Zero Value）

向函数传递指针参数

不要向函数传递数组的指针，而应该使用切片

Go 不支持指针运算

16. 结构体

什么是结构体？

结构体的声明

格式：type 关键字 解构体名字 struct{ }

创建匿名结构体

结构体的零值（Zero Value）

结构体的指针

匿名字段

嵌套结构体（Nested Structs）

提升字段（Promoted Fields）

结构体相等性（Structs Equality）

最新文章

热门文章

　　给 map 添加新元素的语法和数组相同

　　删除 `map` 中 `key` 的语法是 [delete(map, key)]。这个函数没有返回值。

格式：type 关键字解构体名字 struct{ }