【Go语言入门教程】Go语言基本语法，2024最新Golang面试笔试

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

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

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

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

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

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

正文

这句代码中，hp 为变量名，类型为 int，hp 的初始值为 100。

上面代码中，100 和 int 同为 int 类型，int 可以认为是冗余信息，因此可以进一步简化初始化的写法。

编译器推导类型的格式

在标准格式的基础上，将 int 省略后，编译器会尝试根据等号右边的表达式推导 hp 变量的类型。

var hp = 100

等号右边的部分在编译原理里被称做右值（rvalue）。

下面是编译器根据右值推导变量类型完成初始化的例子。

var attack = 40

var defence = 20

var damageRate float32 = 0.17

var damage = float32(attack-defence) * damageRate

fmt.Println(damage)

代码说明如下：

• 第 1 和 2 行，右值为整型，attack 和 defence 变量的类型为 int。
• 第 3 行，表达式的右值中使用了 0.17。由于Go语言和C语言一样，编译器会尽量提高精确度，以避免计算中的精度损失。所以这里如果不指定 damageRate 变量的类型，Go语言编译器会将 damageRate 类型推导为 float64，我们这里不需要 float64 的精度，所以需要强制指定类型为 float32。
• 第 4 行，将 attack 和 defence 相减后的数值结果依然为整型，使用 float32() 将结果转换为 float32 类型，再与 float32 类型的 damageRate 相乘后，damage 类型也是 float32 类型。

  提示：damage 变量的右值是一个复杂的表达式，整个过程既有 attack 和 defence 的运算还有强制类型转换。强制类型转换会在后面的章节中介绍。

  • 第 5 行，输出 damage 的值。

    3.4

    短变量声明并初始化

    var 的变量声明还有一种更为精简的写法，例如：

    hp := 100

    这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。

    注意：由于使用了:=，而不是赋值的=，因此推导声明写法的左值变量必须是没有定义过的变量。若定义过，将会发生编译错误。

    如果 hp 已经被声明过，但依然使用:=时编译器会报错，代码如下：

    // 声明 hp 变量

    var hp int

    // 再次声明并赋值

    hp := 10

    编译报错如下：

    no new variables on left side of :=

    意思是，在“:=”的左边没有新变量出现，意思就是“:=”的左边变量已经被声明了。

    短变量声明的形式在开发中的例子较多，比如：

    conn, err := net.Dial(“tcp”,“127.0.0.1:8080”)

    net.Dial 提供按指定协议和地址发起网络连接，这个函数有两个返回值，一个是连接对象（conn），一个是错误对象（err）。如果是标准格式将会变成：

    var conn net.Conn

    var err error

    conn, err = net.Dial(“tcp”, “127.0.0.1:8080”)

    因此，短变量声明并初始化的格式在开发中使用比较普遍。

    注意：在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错，代码如下：

    conn, err := net.Dial(“tcp”, “127.0.0.1:8080”)

    conn2, err := net.Dial(“tcp”, “127.0.0.1:8080”)

    上面的代码片段，编译器不会报 err 重复定义。

    Go语言多个变量同时赋值

    编程最简单的算法之一，莫过于变量交换。交换变量的常见算法需要一个中间变量进行变量的临时保存。用传统方法编写变量交换代码如下：

    var a int = 100

    var b int = 200

    var t int

    t = a

    a = b

    b = t

    fmt.Println(a, b)

    在计算机刚发明时，内存非常“精贵”。这种变量交换往往是非常奢侈的。于是计算机“大牛”发明了一些算法来避免使用中间变量：

    var a int = 100

    var b int = 200

    a = a ^ b

    b = b ^ a

    a = a ^ b

    fmt.Println(a, b)

    这样的算法很多，但是都有一定的数值范围和类型要求。

    到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。使用 Go 的“多重赋值”特性，可以轻松完成变量交换的任务：

    var a int = 100

    var b int = 200

    b, a = a, b

    fmt.Println(a, b)

    多重赋值时，变量的左值和右值按从左到右的顺序赋值。

    多重赋值在Go语言的错误处理和函数返回值中会大量地使用。例如使用Go语言进行排序时就需要使用交换，代码如下：

    type IntSlice []int

    func (p IntSlice) Len() int { return len§ }

    func (p IntSlice) Less(i, j int) bool { return p[i]

    func (p IntSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

    代码说明如下：

    • 第 1 行，将 IntSlice 声明为 []int 类型。
    • 第 3 行，为 IntSlice 类型编写一个 Len 方法，提供切片的长度。
    • 第 4 行，根据提供的 i、j 元素索引，获取元素后进行比较，返回比较结果。
    • 第 5 行，根据提供的 i、j 元素索引，交换两个元素的值。

      Go语言匿名变量（没有名字的变量）

      在编码过程中，可能会遇到没有名称的变量、类型或方法。虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。

      匿名变量的特点是一个下画线“”，“”本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。例如：

      func GetData() (int, int) {

      return 100, 200

      }

      func main(){

      a, _ := GetData()

      _, b := GetData()

      fmt.Println(a, b)

      }

      代码运行结果：

      100 200

      GetData() 是一个函数，拥有两个整型返回值。每次调用将会返回 100 和 200 两个数值。

      代码说明如下：

      • 第 5 行只需要获取第一个返回值，所以将第二个返回值的变量设为下画线（匿名变量）。
      • 第 6 行将第一个返回值的变量设为匿名变量。

        匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

        提示：在 Lua 等编程语言里，匿名变量也被叫做哑元变量。

        Go语言变量的作用域

        一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

        了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。

        根据变量定义位置的不同，可以分为以下三个类型：

        • 函数内定义的变量称为局部变量
        • 函数外定义的变量称为全局变量
        • 函数定义中的变量称为形式参数

          下面就来分别介绍一下。

          局部变量

          在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。

          局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

          【示例】下面的 main() 函数中使用到了局部变量 a、b、c。

          package main

          import (

          “fmt”

          )

          func main() {

          //声明局部变量 a 和 b 并赋值

          var a int = 3

          var b int = 4

          //声明局部变量 c 并计算 a 和 b 的和

          c := a + b

          fmt.Printf(“a = %d, b = %d, c = %d\n”, a, b, c)

          }

          运行结果如下所示：

          a = 3, b = 4, c = 7

          全局变量

          在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用“import”关键字引入全局变量所在的源文件之后才能使用这个全局变量。

          全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

          【示例】下面代码中，第 6 行定义了全局变量 c。

          package main

          import “fmt”

          //声明全局变量

          var c int

          func main() {

          //声明局部变量

          var a, b int

          //初始化参数

          a = 3

          b = 4

          c = a + b

          fmt.Printf(“a = %d, b = %d, c = %d\n”, a, b, c)

          }

          运行结果如下所示：

          a = 3, b = 4, c = 7

          Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

          package main

          import “fmt”

          //声明全局变量

          var a float32 = 3.14

          func main() {

          //声明局部变量

          var a int = 3

          fmt.Printf(“a = %d\n”, a)

          }

          运行结果如下所示：

          a = 3

          形式参数

          在定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。

          形式参数会作为函数的局部变量来使用。

          【示例】下面代码中第 21 行定义了形式参数 a 和 b。

          package main

          import (

          “fmt”

          )

          //全局变量 a

          var a int = 13

          func main() {

          //局部变量 a 和 b

          var a int = 3

          var b int = 4

          fmt.Printf(“main() 函数中 a = %d\n”, a)

          fmt.Printf(“main() 函数中 b = %d\n”, b)

          c := sum(a, b)

          fmt.Printf(“main() 函数中 c = %d\n”, c)

          }

          func sum(a, b int) int {

          fmt.Printf(“sum() 函数中 a = %d\n”, a)

          fmt.Printf(“sum() 函数中 b = %d\n”, b)

          num := a + b

          return num

          }

          运行结果如下所示：

          main() 函数中 a = 3

          main() 函数中 b = 4

          sum() 函数中 a = 3

          sum() 函数中 b = 4

          main() 函数中 c = 7

          Go语言整型（整数类型）

          Go语言的数值类型分为以下几种：整数、浮点数、复数，其中每一种都包含了不同大小的数值类型，例如有符号整数包含 int8、int16、int32、int64 等，每种数值类型都决定了对应的大小范围和是否支持正负符号。本节我们主要介绍一下整数类型。

          Go语言同时提供了有符号和无符号的整数类型，其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型，分别对应 8、16、32、64 bit（二进制位）大小的有符号整数，与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。

          此外还有两种整数类型 int 和 uint，它们分别对应特定 CPU 平台的字长（机器字大小），其中 int 表示有符号整数，应用最为广泛，uint 表示无符号整数。实际开发中由于编译器和计算机硬件的不同，int 和 uint 所能表示的整数大小会在 32bit 或 64bit 之间变化。

          大多数情况下，我们只需要 int 一种整型即可，它可以用于循环计数器（for 循环中控制循环次数的变量）、数组和切片的索引，以及任何通用目的的整型运算符，通常 int 类型的处理速度也是最快的。

          用来表示 Unicode 字符的 rune 类型和 int32 类型是等价的，通常用于表示一个 Unicode 码点。这两个名称可以互换使用。同样，byte 和 uint8 也是等价类型，byte 类型一般用于强调数值是一个原始的数据而不是一个小的整数。

          最后，还有一种无符号的整数类型 uintptr，它没有指定具体的 bit 大小但是足以容纳指针。uintptr 类型只有在底层编程时才需要，特别是Go语言和C语言函数库或操作系统接口相交互的地方。

          尽管在某些特定的运行环境下 int、uint 和 uintptr 的大小可能相等，但是它们依然是不同的类型，比如 int 和 int32，虽然 int 类型的大小也可能是 32 bit，但是在需要把 int 类型当做 int32 类型使用的时候必须显示的对类型进行转换，反之亦然。

          Go语言中有符号整数采用 2 的补码形式表示，也就是最高 bit 位用来表示符号位，一个 n-bit 的有符号数的取值范围是从 -2(n-1) 到 2(n-1)-1。无符号整数的所有 bit 位都用于表示非负数，取值范围是 0 到 2n-1。例如，int8 类型整数的取值范围是从 -128 到 127，而 uint8 类型整数的取值范围是从 0 到 255。

          哪些情况下使用 int 和 uint

          程序逻辑对整型范围没有特殊需求。例如，对象的长度使用内建 len() 函数返回，这个长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用 int 来表示。

          反之，在二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用 int 和 uint。

          Go语言浮点类型（小数类型）

          Go语言提供了两种精度的浮点数 float32 和 float64，它们的算术规范由 IEEE754 浮点数国际标准定义，该浮点数规范被所有现代的 CPU 支持。

          这些浮点数类型的取值范围可以从很微小到很巨大。浮点数取值范围的极限值可以在 math 包中找到：

          • 常量 math.MaxFloat32 表示 float32 能取到的最大数值，大约是 3.4e38；
          • 常量 math.MaxFloat64 表示 float64 能取到的最大数值，大约是 1.8e308；
          • float32 和 float64 能表示的最小值分别为 1.4e-45 和 4.9e-324。

            一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度，而 float64 则可以提供约 15 个十进制数的精度，通常应该优先使用 float64 类型，因为 float32 类型的累计计算误差很容易扩散，并且 float32 能精确表示的正整数并不是很大。

            var f float32 = 16777216 // 1 {range .Protos}} // Source: {{.Name}}{{end}} package {{.PackageName}} {{if gt .TotalMessages 0}} import ( "github.com/davyxu/cellnet" "reflect" _ "github.com/davyxu/cellnet/codec/pb" ) {{end}} func init() { {{range .Protos}} // {{.Name}}{{range .Messages}} cellnet.RegisterMessageMeta("pb","{{.FullName}}", reflect.TypeOf((*{{.Name}})(nil)).Elem(), {{.MsgID}}) {{end}} {{end}} }