3 Go的基础语法

概述

在上一节的内容中，我们介绍了第一个Go程序，包括：安装Go环境、编写第一个Go程序、编译并运行程序等。在本节中，我们将介绍Go的基础语法。Go是一门简洁和优雅的语言，有自己特殊的一些语法规则。因此，在介绍Go编程的有关知识之前，先熟悉下Go的基础语法，是非常有必要的。

截止到2023年10月，Go的最新版本为1.21，本专栏将使用Go 1.21的语法介绍相关知识。

标识符

在Go语言中，标识符是用于命名变量、函数、结构体、接口等程序元素的名称。以下是Go语言对标识符的一些要求。

1、标识符必须以字母（a-z或A-Z）或下划线（_）开头。

2、标识符的后面可以跟字母、数字（0-9）或下划线。

3、标识符是区分大小写的，这意味着变量x和变量X被视为两个不同的标识符。

4、不能使用Go语言的关键字作为标识符，比如：break、case、const、continue等。

5、标识符的命名应具有描述性，能够清晰地表达其用途和含义；良好的命名可以提高代码的可读性和可维护性。

6、尽量避免使用单个字符作为标识符，特别是变量名；单个字符的变量名可能会导致代码的可读性降低。

7、在不同的作用域内，尽量避免使用相同名称的标识符，以确保代码的一致性和准确性。

以下是一些无效的标识符：1name（以数字开头）、case（Go语言的关键字）、i+j（+是不允许的字符）。

关键字

Go语言的关键字（Keywords）是预定义的特殊标识符，用于表示程序中的特定概念或语法结构。一共有25个关键字，分别为：break、default、func、interface、select、case、defer、go、map、struct、chan、else、goto、package、switch、const、fallthrough、if、range、type、continue、for、import、return、var。

行分隔符

在Go语言中，行分隔符通常通过换行符来表示，而不是分号。Go语言与其他一些编程语言（比如：C/C++、Java等）不同，它不需要在每行代码末尾使用分号来表示语句的结束。每个语句的结束是通过自然换行符来识别的，也就是说，当你在代码中输入一个换行符时，Go编译器会认为该语句已经结束。

在下面的示例代码中，fmt.Println语句没有使用分号来分隔，而是通过自然换行符来分隔不同的语句。

Go 复制代码

package main

import "fmt"

func main() {
    fmt.Println("Hello")
    fmt.Println("CSDN")
}

当然，如果需要将多个语句写在同一行，则必须使用分号来人为区分。但在实际开发中，我们并不鼓励这种做法。

Go 复制代码

package main

import "fmt"

func main() {
    fmt.Println("Hello");fmt.Println("CSDN")
}

var关键字

在Go语言中，var是一个关键字，用于声明一个或多个变量。使用var关键字可以声明不同类型的变量，并可以指定变量的初始值。

以下是使用var声明变量的基本语法：

var 变量名类型

在下面的示例代码中，我们声明了一个整数类型的变量。

Go 复制代码

package main

import "fmt"

func main() {
    var a int
}

可以在声明的同时初始化变量，如果给变量指定了初始值，可以省去类型，由编译器根据初始值自动推断变量的类型。当然，也可以一次声明多个变量，用逗号分隔它们即可。

Go 复制代码

package main

import "fmt"

func main() {
    var a int = 66
    var b = 88
    var c, d string
    c = "Hello"
    d = "CSDN"
    // 输出：66 88 Hello CSDN
    fmt.Println(a, b, c, d)
}

注意：如果声明的变量和import的包未被使用，将会导致编译错误，这有助于提高代码的清洁度和可读性。

:=运算符

在Go语言中，:=是一个特殊的运算符，用于声明变量并初始化它们的值，它被称为短变量声明运算符。使用 :=运算符可以同时完成变量的声明和初始化，它将根据右侧的表达式推断变量的类型，并将该类型的值赋给变量。

在下面的示例代码中，变量a被声明为整数类型，并将其初始化为66。

Go 复制代码

package main

import "fmt"

func main() {
    a := 66
    fmt.Println(a);
}

需要注意的是，:=运算符只能用于函数内部的局部变量，不能用于全局变量。在函数外部，应该使用普通的变量声明语法，即使用var关键字进行声明。另外，出现在:=运算符左侧的变量不应该是已经被声明过的，否则会导致编译错误。

空格

在Go语言中，空格通常用于分隔标识符、关键字、运算符等，用于提高代码的可读性。

Go语言使用空格进行代码块的缩进，通常使用4个空格作为一个缩进级别。这是Go语言中代码格式化的重要组成部分，以区分不同的代码块。

Go 复制代码

package main

import "fmt"

func main() {
    a := 6
    if a > 0 {
        fmt.Println("positive")
    } else {
        fmt.Println("zero or negative")
    }
}

在变量与运算符间、运算符两侧、函数参数间等场景下使用空格，可以大大增加代码的可读性。

Go 复制代码

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func main() {
    a := 66
    b := 99
    c := add(a, b)
    fmt.Println(c)    
}

注意：使用空格可以提高代码的可读性和清晰度，但过度使用空格可能会使代码看起来过于分散。因此，在使用空格时应该保持适度，遵循良好的编码风格和规范。

注释

在Go语言中，注释是一种向代码中添加说明和解释的方式，不会影响程序的执行。Go语言支持两种类型的注释：单行注释和多行注释。

单行注释以双斜线（//）开头，可以在其后添加注释内容。单行注释可以独立占用一行，也可以出现在代码行的末尾。

Go 复制代码

// 这是注释1
a := 66
b := 99     // 这是注释2

多行注释以/*开头，以*/结尾，可以包含多行文本，通常用于说明函数、结构体等代码块的用途和行为。

Go 复制代码

/*
    第一行多行注释
    第二行多行注释
*/
a := 66

package

在Go语言中，package用于组织代码、提供命名空间。一个package可以包含多个Go源文件，并且可以是自定义的或标准库中的。通过使用package关键字，可以将相关的代码文件组合在一起，形成一个独立的模块。每个Go源文件都必须属于一个package，并且每个package都可以包含一个或多个Go源文件。

在下面的示例代码中，我们声明了test.go文件属于main package。在main package中，我们导入了fmt package，并使用fmt.Println函数打印了一条消息。

Go 复制代码

// test.go  
package main

import "fmt"

func main() {
    fmt.Println("Hello, CSDN")
}

通过将相关的代码文件组织在同一个package中，可以确保它们之间的命名冲突最小化，并且可以轻松地在其他地方引用和使用这些文件。

import

在Go语言中，import关键字用于引入外部依赖包，以便在程序中使用它们提供的函数、类型和变量等。要使用import导入包，需要指定包的完整名称，并使用符号.来指定导入的包所在的目录。比如：要导入标准库中的fmt包，可以使用以下语句：import "fmt"。这将在程序中引入fmt包，并使其中的函数和类型可用。

还可以使用别名来为导入的包指定一个自定义名称，指定别名后，可以使用别名来调用包中的函数。比如：要将fmt包导入为my_fmt，可以参考下面的示例代码。

Go 复制代码

package main

import my_fmt "fmt"

func main() {
    my_fmt.Println("Hello, CSDN")
}

输入输出

在Go语言中，输入输出是通过标准库中的fmt包来处理的，fmt包提供了许多用于格式化输入和输出的函数。要实现输入输出，可以使用fmt.Scan或fmt.Scanln函数从标准输入（通常是键盘）读取输入，并使用fmt.Print或fmt.Println函数将输出写入到标准输出（通常是屏幕）。

在下面的示例代码中，我们首先声明了两个变量name和age，分别用于保存用户输入的名字和年龄。然后，使用fmt.Print函数提示用户输入名字和年龄，并使用fmt.Scanln函数读取用户的输入。最后，使用fmt.Printf函数将用户的输入信息格式化并输出到标准输出。

Go 复制代码

package main

import "fmt"

func main() {
    var name string
    fmt.Print("请输入您的名字：")
    // 从标准输入读取名字
    fmt.Scanln(&name)

    var age int
    fmt.Print("请输入您的年龄：")
    // 从标准输入读取年龄
    fmt.Scanln(&age)
  
    // 输出信息到标准输出
    fmt.Printf("欢迎%s, 您今年%d岁。\n", name, age)  
}

注意：在上面的示例代码中，我们使用了&符号将变量的地址传递给了Scanln函数。这是因为，Scanln函数需要访问变量的内存地址来更新变量的值。

运算符

Go语言支持以下的运算符。

算术运算符：+（加法）、-（减法）、*（乘法）、/（除法）、%（取模）。

赋值运算符：=（赋值）、+=（加等于）、-=（减等于）、*=（乘等于）、/=（除等于）、%=（模等于）。

比较运算符：==（等于）、!=（不等于）、>（大于）、<（小于）、>=（大于等于）、<=（小于等于）。

逻辑运算符：&&（逻辑与）、||（逻辑或）、!（逻辑非）。

位运算符：&（按位与）、|（按位或）、^（按位异或）、~（按位取反）、<<（左移位）、>>（右移位）。

指针运算符：&（取变量地址，返回变量的指针）、*（解引用指针）。

括号运算符：()（括号运算符，用于改变运算顺序）。

类型运算符：typeOf（类型查询运算符），sizeof（大小查询运算符）。

空值运算符：nil（空值运算符，用于判断变量是否为空）。

错误运算符：error（错误运算符，用于判断变量是否为错误值）。

接收运算符：<-（接收运算符，用于通道操作）。

索引运算符：[]（索引运算符，用于访问数组、切片、映射等类型的元素）。

断言运算符：类型.(值)（断言运算符，用于将一个接口类型的值转换为具体的类型）。

类型转换运算符：类型(值)（类型转换运算符，用于将一个类型的值转换为另一个类型）。

条件控制

在Go语言中，可以使用if、else if、else进行条件判断与执行控制。

Go 复制代码

package main

import "fmt"

func main() {
  a := 66
  if a >= 88 {
    fmt.Println("Hello")
  } else if a > 50 && a < 88 {
    fmt.Println("CSDN")
  } else {
    fmt.Println("Other")
  }
}

还可以使用switch语句根据不同的条件执行不同的代码块，其基本语法如下。其中，condition是一个布尔表达式，value1、value2等是要比较的值。如果condition的值等于某个值，就会执行相应的代码块。如果没有匹配的值，可以选择使用default代码块来执行默认操作。

Go 复制代码

switch condition {
case value1:
    // 执行条件为value1时的代码块
case value2:
    // 执行条件为value2时的代码块
...
default:
    // 执行条件不满足时的默认代码块（可选）
}

在下面的示例代码中，我们使用switch语句来输出某个月的天数。

Go 复制代码

package main

import "fmt"

func main() {
    month := 3
    switch month {
    case 1, 3, 5, 7, 8, 10:
        fmt.Println("31 days")
    case 4, 6, 9, 11:
        fmt.Println("30 days")
    case 2:
        fmt.Println("28 days or 29 days")
    default:
        fmt.Println("invalid month")
    }
}

注意：单个case后面可以传多个值，用逗号进行分隔；当匹配多个值中的任何一个值时，就会执行后面的语句。

循环

在Go语言中，使用for语句来进行循环控制。注意：与C/C++、Java等语言不同，Go语言中没有while循环。

for循环有三种形式：第一种是基本的for循环，第二种是简化的for循环，最后一种是无限循环。

基本的for循环语法如下。其中，initialization是循环开始前的初始化语句；condition是循环条件，满足条件时继续执行循环；post是每次循环执行完毕后的后处理语句。

Go 复制代码

for initialization; condition; post {
    // 循环体
}

在下面的示例代码中，我们使用基本的for循环计算1到100相加的总和。

Go 复制代码

package main

import "fmt"

func main() {
    sum := 0
    for i := 1; i <= 100; i++ {
        sum += i
    }

    fmt.Println(sum)
}

简化的for循环只有循环条件，没有初始化语句和后处理语句。在下面的示例代码中，我们使用简化的for循环计算1到100相加的总和。

Go 复制代码

package main

import "fmt"

func main() {
    sum := 0
    i := 1
    for i <= 100 {
        sum += i
        i += 1
    }

    fmt.Println(sum)
}

无限循环直接使用for关键字即可，后面不需要带其他语句。在下面的示例代码中，我们使用无限循环计算1到100相加的总和。

Go 复制代码

package main

import "fmt"

func main() {
    sum := 0
    i := 1
    for {
        sum += i
        i += 1
        if i > 100 {
            break
        }
    }

    fmt.Println(sum)
}