1、定义结构体

    package main
    
    import "fmt"
    
    //结构体定义
    type person struct {
        name string //注意后面不能有逗号
        age  int
    }
    
    func main() {
    
        //结构体初始化
        p := person{
            name: "zzzx", //注意后面要加逗号
            age:  18,     //或者下面的}提到这儿来可以省略逗号
        }
    
        //初始化字段不一定要全部指定，比如下面也是可以的，name默认取长度为0的空字符串
        // p := person{
        //     age: 18,
        // }
    
        fmt.Println(p.name)
    }

2、类型等价定义，相当于类型重命名

type name string

name 类型与 string 等价

例子：

    package main
    
    import "fmt"
    
    type name string
    
    func main() {
        var myname name = "zzzx" //其实就是字符串类型
        l := []byte(myname)      //字符串转字节数组
        fmt.Println(len(l))      //字节长度
    }

不过，要注意的是，type绝不只是用于定义一系列的别名。还可以针对新类型定义方法。
上面的name类型可以像下面这样定义方法：

    package main
    
    import "fmt"
    
    type name string
    
    func (n name) len() int {
        return len(n)
    }
    
    func main() {
        var myname name = "zzzx"  //其实就是字符串类型
        l := []byte(myname)       //字符串转字节数组
        fmt.Println(len(l))       //字节长度
        fmt.Println(myname.len()) //调用对象的方法
    }

3、结构体内嵌匿名成员

    package main
    
    import "fmt"
    
    //结构体内嵌匿名成员定义
    type person struct {
        string //直接写类型，匿名
        age int
    }
    
    func main() {
        //结构体匿名成员初始化
        p := person{string: "zzzx", age: 18} //可以省略部分字段，如：person{string: "zzzx"}。也可以这样省略字段名：person{“zzzx”, 18}，但必须写全了，不可以省略部分字段
    
        //结构体匿名成员访问
        fmt.Println(p.string) //注意不能用强制类型转换（类型断言）：p.(string)
    }

以下是只有单个匿名成员的例子。

    package main
    
    import "fmt"
    
    //结构体内嵌匿名成员定义
    
    type person struct {
        string
    }
    
    func main() {
    
        //结构体匿名成员初始化
        p := person{string: "zzzx"} //也可这样：person{"taozs"}
    
        //结构体匿名成员访问
        fmt.Println(p.string) //注意不能用强制类型转换（类型断言）：p.(string)
    }

4、定义接口类型

    package main
    
    import (
        "fmt"
    )
    
    //接口定义
    type Personer interface {
        Run()
        Name() string
    }
    
    //实现接口，注意实现接口的不一定只是结构体，也可以是函数对象，参见下面第5条
    type person struct {
        name string
        age  int
    }
    
    func (person) Run() {
        fmt.Println("running...")
    }
    
    //接收参数person不可以是指针类型，否则不认为是实现了接口
    func (p person) Name() string {
        return p.name
    }
    
    func main() {
    
        //接口类型的变量定义
        var p Personer
    
        fmt.Println(p) //值<nil>
    
        //实例化结构体，并赋值给interface
        p = person{"zzzx", 18} //或者：&person{"taozs", 18}
        p.Run()
        fmt.Println(p.Name())
        var p2 person = p.(person) //类型断言，接口类型断言到具体类型
        fmt.Println(p2.age)
    }

另外，类型断言返回值也可以有第二个bool值，表示断言是否成功，如下：

    if p2, ok := p.(person); ok { //断言成功ok值为true
        fmt.Println(ok)
        fmt.Println(p2.age)
    }

5、定义函数类型

以下是定义一个函数类型handler

    type handler func(name string) int

针对这个函数类型可以再定义方法，如：

    func (h handler) add(name string) int {
        return h(name) + 10
    }

下面让我们详细看一下例子，其中涉及了函数、函数的方法、结构体方法、接口的使用。

    package main
    
    import (
        "fmt"
    )
    
    //定义接口
    type adder interface {
        add(string) int
    }
    
    //定义函数类型
    type handler func(name string) int
    
    //实现函数类型方法
    func (h handler) add(name string) int {
        return h(name) + 10
    }
    
    //函数参数类型接受实现了adder接口的对象（函数或结构体）
    func process(a adder) {
        fmt.Println("process:", a.add("zzzx"))
    }
    
    //另一个函数定义
    func doubler(name string) int {
        return len(name) * 2
    }
    
    //非函数类型
    type myint int
    
    //实现了adder接口
    func (i myint) add(name string) int {
        return len(name) + int(i)
    }
    
    func main() {
        //注意要成为函数对象必须显式定义handler类型
        var my handler = func(name string) int {
            return len(name)
        }
    
        //以下是函数或函数方法的调用
        fmt.Println(my("zzzx"))                   //调用函数
        fmt.Println(my.add("zzzx"))               //调用函数对象的方法
        fmt.Println(handler(doubler).add("zzzx")) //doubler函数显式转换成handler函数对象然后调用对象的add方法
    
        //以下是针对接口adder的调用
        process(my)               //process函数需要adder接口类型参数
        process(handler(doubler)) //因为process接受的参数类型是handler，所以这儿要强制转换
        process(myint(8))         //实现adder接口不仅可以是函数也可以是结构体
    
    }

我们发现，订阅本专栏的同学们都在非常积极的学习和讨论，这让我们非常欣慰，并且和你一样干劲十足。不过，我在留言中发现，大家的基础好像都不太一样，大致可以分为这么几类。

零基础的同学：可能正准备入行或者刚刚对编程感兴趣，可以熟练操作电脑，但是对计算机、操作系统以及网络方面的知识不太了解。
无编程经验或者编程经验较少的同学：可能正在从事其他的技术相关工作，也许可以熟练编写脚本，但是对程序设计的通用知识和技巧还不太了解。
有其他语言编程经验的同学：可能已成为程序员或软件工程师，可以用其他的编程语言熟练编写程序，但是对 Go 语言还不太了解。
有一定 Go 语言编程经验的同学：已有 Go 语言编程基础，写过一些 Go 语言程序，但是急需进阶却看不清途径。
基于以上分类，我为大家制定了一份 Go 语言学习路径。不论你属于上面的哪一类，都可以按照此路径去学习深造。具体请看下面的思维导图。

（长按保存大图）

2. 学习前，你需要有哪些基础知识储备？

在这个专栏里，我会假设你有一定的计算机基础，比如，知道操作系统是什么、环境变量怎么设置、命令行怎样使用，等等。

另外，我还会假定你具备一点点编程知识，比如，知道程序是什么、程序通常会以怎样的形式存在，以及程序与操作系统和计算机有哪些关系，等等。

对了，还有在这个早已成熟的移动互联网时代，想学编程的你，一定也应该知道那些最最基本的网络知识。

我在本专栏里只会讨论 Go 语言的代码和程序，而不会提及太多计算机体系结构或软件工程方面的事情。所以你即使没有专门学过计算机系统或者软件工程也没有关系，我会尽量连带讲一些必要的基础概念和知识。

从 2018 年开始，随着 Google 逐渐重回中国，Go 语言的官方网站在 Google 中国的域名下也有了镜像，毕竟中国是 Go 语言爱好者最多的国家，同时也是 Go 语言使用最广泛的一片土地。如果你在国内，可以敲入这个网址来访问 Go 语言的官网。

这个专栏专注于 Go 语言的核心知识，因此我并不会深入说明所有关于语法和命令的细枝末节。如果你想去全面了解 Go 语言的所有语法，那么可以去 Go 语言官网的语言规范页面仔细查阅。

当然了，这里的语言规范是全英文的，如果你想看汉化的内容也是有选择的，我记得先后有几拨国内的 Go 语言爱好者自发组织翻译过。不过我都没有仔细看过，不知道质量如何，所以在这里就不特别推荐了。

对于从事计算机和软件开发相关工作的同学，我强烈建议你们要有意地训练快速阅读英文文档的能力，不论是否借助字典和翻译工具。

不过，如果你想专门学习一下 Go 命令方面的知识和技巧，那么我推荐你看看我之前写的免费开源教程《Go 命令教程》。这份教程的内容虽然稍显陈旧，但是帮助你学会使用 Go 语言自带的常用命令和工具肯定是没问题的。

好了，其实即使你是个编程小白也不用过于担心，我们会一起帮助你的。至于我刚刚说的 Go 语言规范和 Go 命令教程，你也可以在学习本专栏的过程中根据实际需要去有针对性的阅读。

3. 这里有一份基础知识列表，请查收

如果你阅读本专栏的第一个模块时感觉有些吃力，那可能是你还没有熟悉 Go 语言的一些基础概念和知识。我为你精心制作了一张 Go 语言基础知识的导图，里面几乎包含了入门 Go 语言所需的所有知识点。

（长按保存大图）

有了这些，你是否已经感觉学习本专栏会更加轻松了呢？

总之，教程、资料和助推就交给我和极客时间的编辑、运营们来共同负责。而你需要做的，就是保存好这一份对 Go 语言学习的决心，你可以自己去尝试整理一份 Go 语言的学习笔记，遇见不懂的地方，你也可以在文章下面留言，我们一起讨论。