前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Go-常识补充-切片-map(类似字典)-字符串-指针-结构体

Go-常识补充-切片-map(类似字典)-字符串-指针-结构体

作者头像
suwanbin
发布2019-12-12 14:37:07
1.2K0
发布2019-12-12 14:37:07
举报
文章被收录于专栏:小码农漫漫积累路

Go 常识补充

Go 命名

名字首字母大写可以在外部引用,如果是小写则不能(结构体里面的变量名也是)

打印变量类型科普

fmt.Printf("%T", a) ,注意,用的是 fmt.Printf 函数,a 指的是要查看类型的变量

代码语言:javascript
复制
package main

import "fmt"

func main() {
    fmt.Printf("%T", "asfasf")
    //string
}

_ 关键字

_ 关键字可以用来占位,把不需要的值赋给它(有点像 python 解压赋值,把不需要的值扔给 _

命名规范相关

  • go 没有规定变量 或 函数名的命名规范是驼峰体还是下划线,文件名推荐使用下划线
  • 不过一般命名都是用驼峰体(不然要暴露给外界的首字母要大写,你后面又小写,就很恶心了 Color_of_bottle

包目录规范

所有的包都必须在 gopath 路径下的 src 文件夹下

  • 目前 go 的包管理还不是很成熟,如果依赖了第三方包的不同版本,会不能兼容(只能有一个版本) 如果非要兼容两个版本,开发的时候可以暂时先把 gopath 改一下,这样就可以放另一个版本了

Go 语言架构

GOPATH 的工作区包含 bin、src 和 pkg(没有这三个文件夹时需要自己创建)

  • src ------- 源码(包含第三方的和自己项目的)
  • bin ------- 编译生成的可执行程序
  • pkg ------ 编译时生成的对象文件

切片

切片就是对数组的一个引用,其相对数组更灵活一点

切片的长度是切片中的元素数。

切片的容量是从创建切片索引(位置)开始的底层数组中元素数。

1)切片本身不拥有任何数组,只是对现有数组的引用

  • 其实就是一个内存地址,指向某个地方

2)切片的原则是前闭后开

代码语言:javascript
复制
package main

import "fmt"

func main() {
    var a = [8]int{1, 2, 3, 4, 5, 6, 7, 8}
    // 1)利用数组来创建切片
    // 切片,前闭后开,这里取的是第3到第6个,但是第6个没取到
    var b []int = a[2:5]
    fmt.Println(b)
    //[3 4 5]

    // 2)用 make 来创建切片,第二个参数5是切片长度,第三个参数6是容量
    i := make([]int, 5, 6)
    fmt.Println(i)
    //[0 0 0 0 0]

    // 切片只是对数组的一个引用,指向的是该数组
    a[3] = 111
    fmt.Println(a)
    fmt.Println(b)
    //[1 2 3 111 5 6 7 8]
    //[3 111 5]

    b[0] = 222
    fmt.Println(a)
    fmt.Println(b)
    //[1 2 222 111 5 6 7 8]
    //[222 111 5]
}

3)切片没有步长这么一说(别和 python 的列表切片搞混了)

4)切片的空值是 nil(虽然打印出来是 []

  • go 里所有的引用类型的空值是 nil

5)切片依附于底层数组,底层数组修改会影响切片,切片修改也会影响底层数组

  • 切片可以通过 内置函数 append() 来扩容,如果超过了切片的长度,切片会自动扩容,申请一个新的数组,变为原来切片容量的两倍,然后与原来的底层数组断开依附,关联新的这个数组(在没有超长扩容时,依旧会与定义时的底层数组相关联)

6)切片要修改值,直接改索引对应的值就行了(会影响到依附的数组)

代码语言:javascript
复制
package main

import "fmt"

func main() {
    var a [8]int = [8]int{1, 2, 3, 4, 5, 6, 7, 8}
    var b []int = a[2:5]
    fmt.Println(len(b))
    fmt.Println(cap(b))
    //3
    //6

    // 内置函数 append
    b = append(b, 555)
    fmt.Println(b)
    fmt.Println(a)
    //[3 4 5 555]
    //[1 2 3 4 5 555 7 8]


    b[0] = 1111  // 切片要修改值,直接按索引改就行了
    fmt.Println(a)
    fmt.Println(b)
    //[1 2 1111 4 5 555 7 8]
    //[1111 4 5 555]

    
    
    var e []int = []int{1, 2}
    fmt.Println(e)
    fmt.Println(len(e))
    fmt.Println(cap(e))
    //[1 2]
    //2
    //2

    e = append(e, 3)
    fmt.Println(e)
    fmt.Println(len(e))
    fmt.Println(cap(e))  // 如果超过了切片的长度,切片会自动扩容,申请一个新的数组,变为原来切片容量的两倍
    //[1 2 3]
    //3
    //4

    e[2] = 99  // 切片要修改值,直接改索引对应的值就行了
    fmt.Println(e)
    fmt.Println(len(e))
    fmt.Println(cap(e))
    //[1 2 99]
    //3
    //4
}

7)切片作为函数参数传递

  • go 参数传递是 copy 传递,所以传过去也是引用,改动会影响原来的数组(间接又影响那个切片)

多维切片

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // 多维切片
    var a [][]string = make([][]string, 2, 3)
    fmt.Println(a[0])
    //[]
    //a[0] = make([]string, 2, 3)  // 定义了下面就不会打印 a[0] == nil 了
    if a[0] == nil {
        fmt.Println("a[0] == nil")
    }
    //a[0] == nil

}

切片初始化的方法

代码语言:javascript
复制
package main

import "fmt"

func main() {
    var a []int = []int{1,2,3}
    fmt.Println(a)
    fmt.Println(len(a))
    fmt.Println(cap(a))
    //[1 2 3]
    //3
    //3
}

多维切片初始化

二维切片只能放切片类型 a[0] = "xxx" => a[0][1] = "8787

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // 多维切片初始化
    var a [][]string = [][]string{{"1", "2"}, {"3", "4"}}
    fmt.Println(a)
    fmt.Println(len(a))
    fmt.Println(cap(a))
    a[0][1] = "999"
    fmt.Println(a)
    //[[1 2] [3 4]]
    //2
    //2
    //[[1 999] [3 4]]
}

6)索引只能取长度范围内的索引,(容量比长度大)要操作容量的,要用 append() 内置方法

切片删除元素(会略微影响效率 ,少用)

跳过了某些元素(即便是这样,也比 python 的效率还要高得多)

代码语言:javascript
复制
package main

import "fmt"

func main() {
    var a = []int{1, 2, 3, 4, 5, 6}
    fmt.Println(a)
    //[1 2 3 4 5 6]

    // 删除第三个元素
    a = append(a[0:2], a[3:]...)  // 前开后闭原则,索引为2的元素(即第三个元素)被忽略掉了
    fmt.Println(a)
    //[1 2 4 5 6]
}

copy 函数

可以用来把一个切片 copy 到另一个切片上,然后就可以回收底层数组占用的内存

  • 比如一个切片:容量是10000,长度为3,浪费内存
  • 此时把它 copy 到另一个切片上,让 go 的垃圾回收机制自动取回收不用的内存(那个没用的切片)
  • copy 过去的那个切片对应的底层数组又是一个新的了,所以 copy 过的切片不会影响之前那个切片

需要 copy 到的切片,长度比要 copy 的切片长就 copy 过来,短就丢掉超了的那部分

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // 创建一个长度为3,容量为10000的切片
    var a = make([]int, 3, 10000)
    a[1] = 99
    a[2] = 888
    fmt.Println(a)
    //[0 99 888]

    // 创建一个长度为2,容量为4的切片
    var b = make([]int, 2, 4)
    fmt.Println(b)
    //[0 0]

    copy(b, a)  // 把 a 拷贝给 b (右边的拷贝给左边)
    fmt.Println(b)
    //[0 99]


    var c = make([]int, 5, 10000)
    c[1] = 2
    c[3] = 4
    //c[9] = 9  // 会报错,超过 c 的长度了(虽然容量还够的-->要想加用内置函数 append)
    fmt.Println(c)
    //[0 2 0 4 0]
    var d = make([]int, 2)
    fmt.Println(d)
    //[0 0]
    copy(d, c)  // 把 c 拷贝给 d (右边的拷贝给左边)
    fmt.Println(d)
    //[0 2]  //超出长度的就丢弃掉了
    fmt.Println(c)
    //[0 2 0 4 0]

}

打散切片

代码语言:javascript
复制
package main

import "fmt"

func main() {
    a := [8]int{1,2,3,4,5,6,7,8}
    b := a[:]  // 取一个内容和 a 数组一模一样的切片
    fmt.Println(b)
    //[1 2 3 4 5 6 7 8]

    printGTE6(b)
    //下面将返回大于等于6的元素
    //6
    //7
    //8

    printGTE7(1,2,34,5,6,8)
    //下面将返回大于等于7的元素
    //34
    //8
    printGTE7(b...)  // 可以利用 ... 将切片打散成一个个参数传递
    //下面将返回大于等于7的元素
    //7
    //8
}

func printGTE6(a []int)  {
    // 一个函数,接收一个数组,打印出大于等于6的元素
    fmt.Println("下面将返回大于等于6的元素")
    for _, v := range a{
        if v >= 6 {
            fmt.Println(v)
        }
    }
}

func printGTE7(a ...int)  {
    // 一个函数,接收一堆参数,打印出大于等于7的那几个参数
    fmt.Println("下面将返回大于等于7的元素")
    for _, v := range a{
        if v >= 7 {
            fmt.Println(v)
        }
    }
}

循环打印多维切片

代码语言:javascript
复制
package main

import "fmt"

func main() {
    pls := [][]string{
        {"C", "C++"},
        {"JavaScript"},
        {"Go", "Rust"},
    }
    fmt.Println(pls)
    //[[C C++] [JavaScript] [Go Rust]]

    // 遍历打印多维切片
    for _, v := range pls {
        for _,v1 := range v{
            fmt.Println(v1)
        }
    }
    //C
    //C++
    //JavaScript
    //Go
    //Rust
}

Map (类似 python 字典)

类似于 python 中的字典

1)go 是强类型语言,所以 maps 的 key 和 value 类型都是固定的

2)map 的空值是 nil 类型(说明它也是引用类型)(赋了初值就不是 nil 了)

3)map 的赋值

map 定义及初始化

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // map 定义
    //var 变量名 map[键类型]值类型
    var a map[string]string
    fmt.Println(a)
    if a == nil {
        fmt.Println("a == nil")
    }
    //map[]
    //a == nil

    // map 的初始化
    var b map[int]string = make(map[int]string)
    fmt.Println(b)
    if b == nil {
        fmt.Println("b == nil")
    }
    //map[]

    // 定义和初始化的方式二
    var c = map[int]string{1: "10", 2: "20"}
    fmt.Println(c)
    //map[1:10 2:20]

}

赋值、取值、改值

4)取的 key 不存在就会返回 值类型的零值(string “”、int 0、bool false)

5)map 取值时,有两个返回值,第二个值一般取名 okok 的值为 true 表示该键存在,false 表示该键不存在

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // map 的赋值、取值、改值
    goods := map[string]uint8{"apple": 3, "bear": 2}
    fmt.Println(goods)
    //map[apple:3 bear:2]

    goods["milk"] = 4
    fmt.Println(goods)
    //map[apple:3 bear:2 milk:4]
    fmt.Println(goods["milk"])  // 取值
    //4


    goods["apple"] = 5  // 修改值
    fmt.Println(goods["apple"])
    fmt.Println(goods)
    //5
    //map[apple:5 bear:2 milk:4]

    fmt.Println(goods["laptop"])
    //0  // 因为 goods 这个 map 值的类型是 int,取不到键对应的值时,会默认返回值的零值 int 即 0

    // 那么怎么知道这个键到底存不存在呢?万一那个值凑巧等于值类型的零值呢?
    count, ok := goods["laptop"]
    fmt.Println(count, ok)
    //0 false  // ok 是 false,表示 map 中无该键 laptop,然后会把 count 赋值为 map 值类型的零值,int 类型即 0

    count, ok = goods["apple"]
    fmt.Println(count, ok)
    //5 true  // ok 是 true,表示 map 中有该键 apple,然后会把 count 赋值为 map 中该键对应的值

    if v, okLaptop := goods["laptop"]; okLaptop{
        fmt.Println("goods 中存在 laptop,有", v, "个")
    }else {
        fmt.Println("goods 中不存在 laptop")
    }
    //goods 中不存在 laptop
}

map 删除元素、参数传递

内置函数 delete()

6)删值用 内置函数 delete() 该函数没有返回值,删不存在的也不会报错(只管删,不管你 map 里原来有没有该键)

7)map 是引用类型,作为参数传给函数,改变了会影响到外部的那个 map(是引用)

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // map 的删值
    shopcart := map[string]string{"15411231": "小米电视机", "15115134": "小米9"}
    fmt.Println(shopcart)
    //map[15115134:小米9 15411231:小米电视机]

    //fmt.Println(delete(shopcart, "15411231"))  // 这个语句会直接报错,因为 delete 没有返回值,也不能被接收(包括打印)

    delete(shopcart, "15411231")
    fmt.Println(shopcart)
    //map[15115134:小米9]

    // map 的长度
    fmt.Println(shopcart)
    fmt.Println(len(shopcart))
    //map[15115134:小米9]
    //  //1

    // map 是值类型还是引用类型?作为函数参数传递后,在函数内部修改是否会影响原来的 map?
    testMap(shopcart)
    //map[15115134:小米9]
    //map[12221231:小米手环 15115134:小米9]
    fmt.Println(shopcart)
    //map[12221231:小米手环 15115134:小米9]
    // => map 是引用类型,会影响原来的 map
}

func testMap(shopcart map[string]string)  {
    fmt.Println(shopcart)
    shopcart["12221231"] = "小米手环"
    fmt.Println(shopcart)
}

map 相等比较、循环遍历

8)map 之间不能直接 == 比较,只能直接和 nil 比,要实在想比较两个 map,可以自定义规则遍历去比较

9)map 是无序的

10)map 的键的类型必须是可 hash 的

代码语言:javascript
复制
package main

import "fmt"

func main() {
    // map 的相等比较
    goodPrice := map[string]float32{"apple": 13.5, "one plus 8": 3899}
    var goodPrice2 map[string]float32
    //if goodPrice == goodPrice2{  // 直接就报错,map 之间不能直接比较
    //
    //}
    if goodPrice == nil {  // map 可以和 nil 比较
        fmt.Println("goodPrice == nil")
    }
    if goodPrice2 == nil {
        fmt.Println("goodPrice2 == nil")
    }
    //goodPrice2 == nil

    // 循环出 map 中的所有元素
    fmt.Println(goodPrice)
    for k, v := range goodPrice {  // 这里拿出的 key 不是索引,而是 map 的键
        fmt.Println(k, v)
    }
    //map[apple:13.5 one plus 8:3899]
    //apple 13.5  //这一行和下一行的打印顺序不是固定的(因为 map 是无序的)
    //one plus 8 3899

    //goodPrice3 := map[[]int]string{[]int{1,3,4}: "123"}  // 直接报错,map 的 key 必须是可 hash 的
}

字符串

字符串的定义、长度、遍历字节、字符

1)两种方式 双引号 "" 反引号 ` `

2)在 go 中,一个中文字符占 3 个字节长度,英文字母与数字均为1个字节长度

  • 在 go 中 string 类型采用 utf-8 编码,每个中文字符占 3 个字节,英文字母、数字、常见符号占 1 个字节
  • 其他语言中是 unicode 编码,unicode 统一用2Bytes(16 bit) 表示所有字符(有关编码的知识可以参考我的博客

3)用 utf8.RuneCountInString(name) 来统计字符串长度,内置方法 len() 统计的是字节数

4)字符串是个只读切片

可以索引取值(取到的是数字码,用 string 括起来可以变成字符),但是不能改它的值(只读)

5)byte 就是 uint8 的别名、rune 是 int32 的别名,在字符串里分别代表字节、字符

代码语言:javascript
复制
package main

import (
    "fmt"
    "unicode/utf8"
)

func main() {
    // 字符串的定义有两种
    var s1 = "i'm s1"     // 双引号的定义方式
    var s2 = `i'
am
    s2` // 反引号的定义方式,可以是多行

    fmt.Println(s1)
    //i'm s1
    fmt.Println(s2)
    //i'
    //am
    //  s2

    // 字符串的长度
    var str1 = "i am is a string 啊."
    fmt.Println(len(str1)) // len 获取到的是字符串的字节长度
    //21
    fmt.Println(utf8.RuneCountInString(str1)) // utf8.RuneCountInString 获取到的是字符个数
    //19

    // 字符串是一个只读切片
    fmt.Println(str1)
    fmt.Println(str1[0], string(str1[0]))
    //i am is a string 啊.
    //105 i

    //str1[0] = 213  // 会直接报错,不能更改字符串 (字符串是个只读切片)

    // 遍历字符串
    str2 := "1测2s"

    for i := 0; i < len(str2); i++ {
        fmt.Printf("%T ", str2[i])
        fmt.Println(i, str2[i], string(str2[i]))
    }
    //uint8 0 49 1  // int8 即 byte,代表取的是一个字节
    //uint8 1 230 æ
    //uint8 2 181 µ
    //uint8 3 139 ‹
    //uint8 4 50 2
    //uint8 5 115 s

    for i, v := range str2 {
        fmt.Printf("%T ", v)
        fmt.Println(i, v, string(v))
    }
    //int32 0 49 1  // int32 即 rune,代表取的是一个字符
    //int32 1 27979 测
    //int32 4 50 2
    //int32 5 115 s


    // 利用切片合成字符串
    byteSlice := []byte{0x43, 0x61, 0x66, 0xc3, 0xA9}
    strByByte := string(byteSlice)
    fmt.Println(byteSlice)
    //[67 97 102 195 169]
    fmt.Println(strByByte)
    //Café
    charlen := len(strByByte)
    charCount := utf8.RuneCountInString(strByByte)
    fmt.Println(charlen, charCount)
    //5 4
}

指针

1)指针是一种存储变量内存地址的变量

2)& 为取址符,可以取到后面变量的内存

3)*放在内存地址前面可以取到该内存地址所对应的值

4)指针也有类型,指定了类型就不能再指向其他类型了

5)*放在类型前面可以表示指向该类型的一个指针

指向什么类型就在什么类型前面加 **int

6)指针的零值是 nil

var a *int --> nil

代码语言:javascript
复制
package main

import "fmt"

func main()  {
    a := 10
    fmt.Println(&a)  // 1)& 为取址符,可以取到后面变量的内存地址
    //0xc00000a0b8
    fmt.Println(*&a)  // 2)*放在内存地址前面可以取到该内存地址所对应的值
    //10

    b := &a  // 等价于 var b *int = &a
    // 3)*放在类型前面可以表示指向该类型的一个指针
    fmt.Println(b)
    //0xc00005e090
    fmt.Println(*b)
    //10

    //c := "dsadasd"
    //b = &c  // 会直接报错,因为 b 指针在定义时就指向了 int 类型,现在要指向的是 string 类型,和他不是同一个类型了
    
    var e *int
    fmt.Println(e)
    if e == nil{
        fmt.Println("e == nil")
    }
    //<nil>
    //e == nil
}

向函数传递指针参数

用了指针做参数传递,可以不考虑函数参数的传递是值传递还是引用传递(拿着内存地址,直接就能改了)

7)拿指针来传递参数,修改指针会将其指向的变量一同修改

代码语言:javascript
复制
package main

import "fmt"

func main()  {
    a := 10
    b := &a

    fmt.Println(a)
    //10
    changePoint(b)  // 利用指针去修改值
    fmt.Println(a)
    //11

    fmt.Println(a)
    //11
    changeNum(*b)
    fmt.Println(a)
    //11
}

func changePoint(point *int)  {
    *point++  // 指针会更改指向内存地址上的值
}

func changeNum(num int)  {
    num++
}

传递数组指针 (最好是用切片)

8)指针也可以传递数组,但最好还是使用切片来传递数组

用切片做函数参数可以不用指定切片大小,而用指针做函数参数需要指定指针指向类型(数组类型需要指定大小)

代码语言:javascript
复制
package main

import "fmt"

func main() {
    a := [5]int{1, 2, 3, 4, 5}
    aPoint := &a
    ArgPoint(aPoint)
    //[999 2 3 4 5]

    aSlice := a[:]
    ArgSlice(aSlice)
    //[888 2 3 4 5]
}
func ArgPoint(point *[5]int) {  // 如果使用 指针 做函数参数,需要指定指针所指定类型的大小,很不方便
    (*point)[0] = 999
    fmt.Println(*point)
}

func ArgSlice(slice []int) {  // 如果是用 切片 做函数参数,则不需要关心该参数的大小
    slice[0] = 888
    fmt.Println(slice)
}

// 所以,我们优先选择用切片来当做函数参数,而不是指针!

9)Go 不支持指针运算

指针运算很危险,用不好会闪退,内存溢出等

结构体

go 可以说有面向对象,也可以说没有面向对象(作者说,你觉得有就有,你觉得没有就没有)

1)结构体是一系列属性的集合(没有方法)

结构体零值

2)结构体是值类型

3)结构体的属性也是无序的

4)初始化可以指名道姓地传(指名道姓可以少传),也可以按位置传(必须所有属性都传)

代码语言:javascript
复制
package main

import "fmt"

//type 结构体名 struct {
//  属性名1 属性名1的类型
//  属性名2 属性名2的类型
//  属性名3 属性名3的类型
//}
type Person struct {
    name string
    //sex, age int  // 是下面两行的简写
    sex int
    age int
}
func main()  {
    person := Person{}  // 等价于 var person Person = Person{}
    fmt.Println(person)
    fmt.Println(person.name)
    fmt.Println(person.sex)
    //{ 0 0}
    //  // 这是空字符串,不是没值(因为 string 类型的零值是 "" 空字符串)
    //0

    var person2 Person = Person{name: "swb"}  // 初始化可以指名道姓地传(指名道姓可以少传)
    var person3 Person = Person{"swb", 1, 18}  // 也可以按位置传(必须所有属性都传)

    fmt.Println(person2)
    //{swb 0 0}
    fmt.Println(person3)
    //{swb 1 18}

    // 取属性、修改属性
    fmt.Println(person2.name)
    //swb
    person2.age = 66
    fmt.Println(person2.age)
    //66
}

匿名结构体

5)匿名结构体定义完了必须 立马实例化并赋值给一个对象

代码语言:javascript
复制
package main

import "fmt"

func main()  {
    a := struct {
        name string
        age int
    }{"swb", 18}
    fmt.Println(a.name)
    //swb
}

结构体指针

6)可以直接用地址点属性(官方做了处理)

代码语言:javascript
复制
package main

import "fmt"

type Person struct {
    name string
    //sex, age int  // 是下面两行的简写
    sex int
    age int
}

func main() {
    p := Person{name: "swb"}
    var pPoint *Person = &p
    fmt.Println(pPoint)
    //&{swb 0 0}  // 这其实是一种 显示 优化,让我们知道内存地址存的是啥
    fmt.Println((*pPoint).name)
    //swb
    fmt.Println(pPoint.name)  // 结构体指针做了优化,可以直接用结构体指针 点 结构体属性 => pPoint.name
    //swb
}

结构体匿名字段

代码语言:javascript
复制
package main

import "fmt"

// 结构体匿名字段
type Person struct {
    string
    int
    //age int  // 如果有两个 int 类型的属性,可以这么弄
}

func main()  {
    //p := Person{"swb", 19}
    p := Person{string: "swb", int: 19}  // 匿名字段的属性内名也可以用作 键

    fmt.Println(p.string)
    //swb
}

很奇葩,但是有用处,可以用作变量提升

表示字段没有名字

p := Person{}

结构体嵌套

代码语言:javascript
复制
package main

import "fmt"

// 结构体嵌套
type Person struct {
    name     string
    sex, age int
    hobby    Hobby
}

type Hobby struct {
    id   int
    name string
}

func main() {
    p := Person{}
    fmt.Println(p)
    //{ 0 0 {0 }}  // 零值状态,依旧是取该类型的零值 => {"" 0 0 {0 ""}} 字符串类型的零值是 "" 打印的时候,看不出来

    p2 := Person{name: "swb", hobby: Hobby{id: 1, name: "学习"}}
    fmt.Println(p2.hobby.name)
    //学习
    fmt.Println(p2)
    //{swb 0 0 {1 学习}}
}

结构体嵌套 + 匿名字段

代码语言:javascript
复制
package main

import "fmt"

// 结构体嵌套 + 匿名字段 --> 变量提升
type Person struct {
    name     string
    sex, age int
    Hobby
}

type Hobby struct {
    id   int
    name string
}

func main() {
    p := Person{}
    fmt.Println(p)
    //{ 0 0 {0 }}  // 零值状态,依旧是取该类型的零值 => {"" 0 0 {0 ""}} 字符串类型的零值是 "" 打印的时候,看不出来

    p2 := Person{name: "swb", Hobby: Hobby{id: 1, name: "学习"}}
    fmt.Println(p2.Hobby.name)  // 重名变量,不提升
    //学习
    fmt.Println(p2.id)  // 可以直接取到 Hobby 中的 id,变量 id 被提升了
    //1
    fmt.Println(p2)
    //{swb 0 0 {1 学习}}
}

7)变量提升过程中,如果有重名的,(重名的那个变量)就不提升了

(有点 python 中的继承)

结构体相等比较

结构体之间可不可以比较要根据里面字段来的,里面字段都可以比较,那就可以比较(比如里面有切片字段,那就不可比较了)

作业

把 map 做成有序的

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
原始发表:2019-12-12 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • Go 常识补充
    • Go 命名
      • 打印变量类型科普
        • _ 关键字
          • 命名规范相关
            • 包目录规范
            • 切片
              • 多维切片
                • 切片初始化的方法
                  • 多维切片初始化
                    • 切片删除元素(会略微影响效率 ,少用)
                      • copy 函数
                        • 打散切片
                          • 循环打印多维切片
                          • Map (类似 python 字典)
                            • map 定义及初始化
                              • 赋值、取值、改值
                                • map 删除元素、参数传递
                                  • map 相等比较、循环遍历
                                  • 字符串
                                    • 字符串的定义、长度、遍历字节、字符
                                    • 指针
                                      • 向函数传递指针参数
                                        • 传递数组指针 (最好是用切片)
                                    • 结构体
                                      • 结构体零值
                                        • 匿名结构体
                                          • 结构体指针
                                            • 结构体匿名字段
                                              • 结构体嵌套
                                                • 结构体嵌套 + 匿名字段
                                                  • 结构体相等比较
                                                  • 作业
                                                  领券
                                                  问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档