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语句没有使用分号来分隔，而是通过自然换行符来分隔不同的语句。

package main

import "fmt"

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

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

package main

import "fmt"

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

var关键字

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

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

var 变量名 类型

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

package main

import "fmt"

func main() {
    var a int
}

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

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。

package main

import "fmt"

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

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

空格

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

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

package main

import "fmt"

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

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

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语言支持两种类型的注释：单行注释和多行注释。

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

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

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

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

package

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

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

// test.go  
package main

import "fmt"

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

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

import

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

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

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函数将用户的输入信息格式化并输出到标准输出。

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进行条件判断与执行控制。

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代码块来执行默认操作。

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

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

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是每次循环执行完毕后的后处理语句。

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

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

package main

import "fmt"

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

    fmt.Println(sum)
}

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

package main

import "fmt"

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

    fmt.Println(sum)
}

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

package main

import "fmt"

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

    fmt.Println(sum)
}

到此这篇关于Go基础语法的使用的文章就介绍到这了,更多相关Go 基础语法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论