golang读书笔记(二)

终于快把《Go in Action》读完了,越读越觉得这是一本非常经典的好书,不过是被翻译们坑了,好好的一本书,被翻译成这个鬼样子

1 自定义类型

go语言中提供了两种自定义类型的数据,分别是:

  • 结构体
  • 具有底层基础类型的定义类型

1.1 结构体

结构体的定义和使用

type user struct {
   name       string
   email      string
   ext        int
   privileged bool
}

要使用上面的结构体,并赋予初始值,可以使用下面的代码:

lisa := user {
    name:       "Lisa",
    email:      "lisa@email.com",
    ext:        123,
    privileged: true,
}

结构体的嵌套

定义一个新的结构体

type admin struct{
    person  user
    level   string
}

初始化上述结构体时可以这样:

fred := admin{
    person: user {
        name:       "Lisa",
        email:      "lisa@email.com",
        ext:        123,
        privileged: true,
    },
    level:  "super",
}

但是在使用的时候,却不必拘泥于字段,只要没有重复,就可以直接访问。

1.2 具有底层基础类型的定义类型

type Druation int64

有时,编译器并不总能获得对象的地址,例如:

package main

import "fmt"

type duration int

func (d *duration)pretty() string{
    return fmt.Sprintf("Duration: %d", *d)
}

func main(){
    duration(42).pretty()
}

在执行上述代码的时候,就会报错:

cannot call pointer method on duration(42)
cannot take the address of duration(42)

即便改成如下的代码也不行:

(&duration(42)).pretty()

2 类型的本质

如果给一个类型添加或者删除某个值,是创建一个新值,还是修改当前的值?如果是要创建一个新值,该类型的方法就使用值接收者;如果是要修改当前值,就使用指针接受者。
——《Go语言实战》

2.1 值类型

值类型主要包括:

  • 数值类型
  • 字符串类型
  • 布尔类型
  • 数组
  • struct
    上述类型的变量通常在栈上分配,栈在函数调用完后会自动释放。

对这些类型进行增加或者删除的时候,会创建一个新的值。因此把这些类型的值传递给方法或者函数的时候,应该传递一个对应值的副本。

2.2 引用类型

引用类型主要有如下几个:

  • 切片
  • 映射
  • 通道
  • 接口
  • 函数

上述类型存储的都是地址,内存通常在堆上分配,通过GC回收。

3 嵌入类型(type embedding)

package main

import (
    "fmt"
)

type user struct {
    name  string
    email string
}

func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}

type admin struct {
    user  // Embedded Type
    level string
}

func main() {
    ad := admin{
        user: user{
            name:  "john smith",
            email: "john@yahoo.com",
        },
        level: "super",
    }

    ad.user.notify()

    ad.notify()
}

其中admin为外部类型,user为内部类型。

如果外部类型不想使用内部类型的实现,可以参考下面的代码:

import (
    "fmt"
)

type notifier interface {
    notify()
}

type user struct {
    name  string
    email string
}

func (u *user) notify() {
    fmt.Printf("Sending user email to %s<%s>\n",
        u.name,
        u.email)
}

type admin struct {
    user
    level string
}

func (a *admin) notify() {
    fmt.Printf("Sending admin email to %s<%s>\n",
        a.name,
        a.email)
}

func main() {
    ad := admin{
        user: user{
            name:  "john smith",
            email: "john@yahoo.com",
        },
        level: "super",
    }
    
    sendNotification(&ad)

    ad.user.notify()

    ad.notify()
}
func sendNotification(n notifier) {
    n.notify()
}

其运行结果为:

Sending admin email to john smith<john@yahoo.com>
Sending user email to john smith<john@yahoo.com>
Sending admin email to john smith<john@yahoo.com>

从上面的代码中不难看出,简单来说就是在外部类型中重新定义一个新的方法,内部类型的方法就不会被提升。如果要想访问内部类型的方法,可以通过访问内部类型的值来进行访问。

推荐阅读更多精彩内容