先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Golang全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Go语言开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注go）

正文

要开始使用Golang，首先得在你的机器上安装Go编译器和工具链。
Go的官方网站提供了适用于Windows、Mac和Linux系统的安装包。
只需下载对应系统的安装程序，一般而言安装过程中会自动配置好Go的环境变量，安装完成后，你可以在命令行中运行go version来验证安装是否成功。

配置Go环境变量

Go语言的环境变量配置是其工作流的重要部分，GOPATH是最关键的环境变量之一，它定义了你的工作空间位置，是你所有Go语言项目的存放地。
此外，GOROOT环境变量则指向Go语言安装的位置。通常，你需要将$GOPATH/bin添加到PATH环境变量中，这样你就可以从任意位置运行编译后的Go程序了。
（你也可以将安装目录下的bin的文件路径直接添加到PATH环境变量中）

Go开发工具介绍

对于刚入门的Go开发者来说，选择一个合适的开发环境非常重要。
你可以选用文本编辑器如Visual Studio Code或Sublime Text，并配置相应的Go语言插件。

对于需要更全面功能的开发者，JetBrains的GoLand更不错的IDE，它具有代码补全、调试、性能分析等高级功能，不过这是一个收费软件，并且不便宜，你可能需要一些其他方式才能免费使用。

Go的基础结构

Go程序的基本结构

每个Go程序都是由包（package）组成的。最基本的Go程序是由一个名为main的包组成，它包含一个同名的main函数。这个函数是程序开始执行的入口点。所有的Go文件都应该在第一行声明它们所属的包。

包的概念和导入方式

包是Go语言的基本组织单位，每个Go文件开头通过package关键字来声明其包名。当你需要使用其他包中的函数或类型时，可以通过import语句来导入这些包。Go的工具链自带依赖管理，能自动获取远程包。

可执行程序和库文件的区别

在Go语言中，可执行程序和库文件是通过包的类型来区分的。
如果一个包声明为main，编译后将生成一个可执行文件；如果包名不是main，则编译后为库文件，其他程序可以导入并使用其中的代码。

变量与数据类型

变量的声明和初始化

在Go语言中，变量必须先声明再使用。Go提供了多种声明变量的方法，可以使用var关键字进行声明，也可以使用:=进行短变量声明（同时进行声明和初始化）。

package main

import "fmt"

func main() {
    var a int    // 声明一个int型变量a
    a = 10       // 给变量a赋值为10
    var b = 20   // 声明一个int型变量b，并初始化为20
    c := 30      // 短变量声明，同时声明和初始化变量c为30

    fmt.Println(a, b, c) // 输出变量的值
}

Go的基本数据类型

Go语言中有许多内建的数据类型，包括但不限于：

• 整型（int, int8, int16, int32, int64, uint, uintptr等）
• 浮点型（float32, float64）
• 复数类型（complex64, complex128）
• 布尔型（bool）
• 字符串（string）
• 错误类型（error）

这些数据类型支持Go语言强大的系统编程能力，为操作系统级的底层编程提供了支持。

类型转换和别名

在Go语言中，类型之间不会自动转换，必须显式进行类型转换：

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)

    fmt.Println(i, f, u) // 输出：42 42 42

    // 字符串转换为整型
    if intValue, err := strconv.Atoi("42"); err == nil {
        fmt.Println(intValue) // 输出：42
    }
}

Go语言也允许用户通过类型别名来给已存在的数据类型指定一个新名字，增加代码的可读性。

package main

import "fmt"

type Celsius float64    // 为float64起一个别名Celsius，表示摄氏温度
type Fahrenheit float64 // 为float64起一个别名Fahrenheit，表示华氏温度

// CToF 将摄氏温度转换为华氏温度
func CToF(c Celsius) Fahrenheit {
    return Fahrenheit(c\*9/5 + 32)
}

func main() {
    var c Celsius = 100
    var f Fahrenheit = CToF(c)

    fmt.Println(c, "C is", f, "F") // 输出：100 C is 212 F
}

接下来，我们来探讨Go中的控制结构。

控制结构

条件判断：if-else, switch-case

在Go语言中，条件判断是通过if-else语句实现的。Go的if语句可以包含一个初始化语句，其作用域被限定在if语句中。

package main

import "fmt"

func main() {
    // 使用if-else进行条件判断
    if num := 9; num < 0 {
        fmt.Println(num, "is negative")
    } else if num < 10 {
        fmt.Println(num, "has 1 digit")
    } else {
        fmt.Println(num, "has multiple digits")
    }

    // 使用switch进行条件判断
    switch num := 7; num {
    case 1:
        fmt.Println("One")
    case 7:
        fmt.Println("Seven")
    default:
        fmt.Println("Unknown Number")
    }
}

循环：for

在Go语言中，所有的循环类型都可以使用for关键字来实现，包括传统的for循环以及类似其他语言中的while和until循环。

package main

import "fmt"

func main() {
    // 像while一样使用for
    sum := 1
    for sum < 1000 {
        sum += sum
    }
    fmt.Println(sum) // 输出: 1024

    // 传统的for循环
    for i := 0; i < 10; i++ {
        fmt.Println(i)
    }
}

跳转：break, continue, goto

Go支持在循环中使用break和continue来控制循环的执行。break用来退出循环体，而continue用来跳过当前循环迭代。Go也支持goto语句，但其使用并不被推荐，因为它会使得代码难以理解和维护。

package main

import "fmt"

func main() {
    // 使用break跳出循环
    for i := 0; i < 10; i++ {
        if i > 5 {
            break
        }
        fmt.Println(i)
    }

    // 使用continue跳过某次循环迭代
    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            continue
        }
        fmt.Println(i)
    }

    // 使用goto跳转
    i := 0
loop: // 标签
    if i < 5 {
        fmt.Println(i)
        i++
        goto loop // 跳转到标签位置
    }
}

函数

函数的定义和调用

在Go语言中，函数是一等公民。函数的定义形式为func关键字后跟函数名、参数列表、返回类型和函数体。

package main

import "fmt"

// 定义一个加法函数
func add(x, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13)) // 调用函数并输出结果
}

参数传递：值传递与引用传递

Go语言中的所有参数传递都是值传递。这意味着在调用函数时，实际上是传递了参数值的一个副本。如果想要在函数内部改变参数的值，必须使用指针。

来来来，接着往下看，看看用指针怎么偷梁换柱，把两个数字给掉个儿：

package main

import "fmt"

// 定义一个交换两个数的函数，这里使用指针来直接修改变量的值
func swap(x \*int, y \*int) {
    temp := \*x
    \*x = \*y
    \*y = temp
}

func main() {
    a := 20
    b := 30
    fmt.Println("交换前 a 和 b 的值：", a, b) // 交换前 a 和 b 的值： 20 30
    swap(&a, &b) // 这里传递的是变量的地址，也就是指向这些变量的指针
    fmt.Println("交换后 a 和 b 的值：", a, b) // 交换后 a 和 b 的值： 30 20
}

我们通过传递变量地址给swap函数，然后在swap函数内部通过指针去改变这些变量的值，这样改动就能在函数外部看到了。这种方式在Go中获取和修改外部变量的常用手法，就是典型的引用传递。

返回值和命名返回值

Go函数不仅可以返回单个值，还可以返回多个值。当你想从函数返回更多的信息时，这个特性就显得非常有用了。此外，Go还支持命名返回值，也就是在函数声明返回值时给它们命名，这样可以增加代码的清晰度。

package main

import "fmt"

// 定义一个分割整数的函数，返回商和余数
func divmod(a, b int) (int, int) {
    quo := a / b // 商
    rem := a % b // 余数
    return quo, rem
}

// 使用命名返回值的方式来返回多个值
func divmodNamed(a, b int) (quo, rem int) {
    quo = a / b // 商
    rem = a % b // 余数
    return // 不需要明确指定返回值，因为已经在函数签名中命名
}

func main() {
    quo, rem := divmod(7, 3)
    fmt.Println("分割7和3得到：商 =", quo, "余数 =", rem) // 分割7和3得到：商 = 2 余数 = 1

    quoNamed, remNamed := divmodNamed(7, 3)
    fmt.Println("命名返回值分割7和3得到：商 =", quoNamed, "余数 =", remNamed) // 命名返回值分割7和3得到：商 = 2 余数 = 1
}

在divmodNamed这个函数里，我们就用到了命名返回值。它在返回的时候，就不用再写返回值的名字了，直接一个return搞定，简洁清晰。

复合类型

这些类型可以把简单的类型组合成复杂的数据结构，主要包括数组、切片、映射（map）、结构体（struct）以及它们的方法。

数组和切片

数组是一个固定长度的序列，而切片则是一个可以动态改变大小的序列。切片比数组更常用，因为它们更灵活。

package main

import "fmt"

func main() {
    // 数组的定义和初始化
    var arr [5]int
    arr[0] = 1
    arr[1] = 2
    // 省略的部分为零值
    
    // 切片的定义和初始化
    slice := []int{1, 2, 3, 4, 5} // 切片字面量
    
    // 切片操作
    fmt.Println(slice[1:3]) // 输出切片的第2个到第4个元素，不包括索引为3的元素
}

映射（map）

映射是一种无序的键值对的集合。Map是使用哈希表实现的。

package main

import "fmt"

func main() {
    // 映射的定义和初始化
    m := make(map[string]int)
    m["k1"] = 7
    m["k2"] = 13
    
    // 访问映射
    fmt.Println("map:", m)
    
    // 删除操作
    delete(m, "k2")
    fmt.Println("map:", m)
}

结构体（struct）和方法

结构体是一种聚合数据类型，它用于将不同或相同类型的数据组织成一个有意义的单元。

package main

import "fmt"

// 定义结构体
type person struct {
    name string
    age  int
}

// 定义结构体的方法
func (p person) sayHello() {
    fmt.Printf("Hi, I'm %s, %d years old.\n", p.name, p.age)
}

func main() {
    // 初始化结构体
    p := person{name: "Jack", age: 23}
    
    // 调用方法
    p.sayHello() // 输出: Hi, I'm Jack, 23 years old.
}

结构体的方法就是那些能够使用该结构体类型的变量或者实例来调用的函数。方法的声明和普通函数类似，只是在方法名前面增加了一个额外的参数，这个参数叫做接收器（receiver），它的类型就是结构体类型。

这些复合类型是Go数据组织的基石，特别是切片和映射，它们在实际开发中运用广泛，可以灵活高效地处理数据集合。结构体通过方法为Go语言提供了面向对象的能力，使得Go能够以更加结构化的方式来处理复杂的数据。

接口

接口在Go中扮演着超级重要的角色，它们让我们的代码更加灵活和模块化。

接口的定义
接口定义了一套方法签名，任何具有这些方法的类型都可以说实现了该接口。

package main

import "fmt"

// 定义一个接口
type Greeter interface {
    greet() string
}

// 实现接口的具体类型
type English struct{}

func (e English) greet() string {
    return "Hello!"
}

// 实现接口的具体类型
type Chinese struct{}

func (c Chinese) greet() string {
    return "你好！"
}

func greetSomeone(g Greeter) {
    fmt.Println(g.greet())
}

func main() {
    var e English
    var c Chinese

    greetSomeone(e) // 输出：Hello!
    greetSomeone(c) // 输出：你好！
}

转换和实现

一个类型可以实现多个接口，而一个接口也可以被多个类型实现。类型转换可以在不同的接口和类型之间进行。

package main

import "fmt"

type Walker interface {
    walk() string
}

type Talker interface {
    talk() string
}

type Human struct{}

func (h Human) walk() string {
    return "I'm walking."
}

func (h Human) talk() string {
    return "I'm talking."
}

func main() {
    var h Human
    
    // Human实现了Walker接口
    var w Walker = h
    fmt.Println(w.walk())



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）**
![img](https://img-blog.csdnimg.cn/img_convert/998e8f70f1d08a5d63f77db4c7fcc7c6.jpeg)

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
}

type Talker interface {
    talk() string
}

type Human struct{}

func (h Human) walk() string {
    return "I'm walking."
}

func (h Human) talk() string {
    return "I'm talking."
}

func main() {
    var h Human
    
    // Human实现了Walker接口
    var w Walker = h
    fmt.Println(w.walk())



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Go）**
[外链图片转存中...(img-V6dGc3QM-1713729347926)]

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**