一、变量和常量

1.1 变量

1.1.1 什么是Go语言变量

在Go语言中，变量用于存储和操作数据。Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

1.1.2 什么是变量声明

声明变量的一般形式是使用 var 关键字，声明变量的话，可以一次声明单个变量，也可以一次声明多个变量。变量的类型决定了变量可以存储的数据类型以及对变量进行操作的方法。在Go中，变量的类型可以是基本类型（如整型、浮点型、布尔型等），也可以是自定义的结构体、接口或其他复杂类型。

针对一次声明单个变量语法如下:

var name type

上面语法参数说明如下:

  • var:用于声明一个变量的关键字
  • name:标识符，用于给变量起一个唯一的名称
  • type:变量的数据类型，用于指定变量可以存储的数据的种类

示例：

package main
import "fmt"
func main() {
    var name string = "zq1"
    fmt.Println("我的名字是:", name)
}

执行命令

go run test1.go

以上实例输出结果为:

我的名字是: zq1

针对一次声明多个变量语法如下:

var name1 name2 name3 type

上面语法参数说明如下:

  • var:用于声明一个变量的关键字
  • name:标识符，用于给变量起一个唯一的名称
  • type:变量的数据类型，用于指定变量可以存储的数据的种类

示例：

package main
import "fmt"
func main() {
    var a, b int = 1, 2
    fmt.Println(a, b)
}

执行命令

go run test2.go

以上实例输出结果为:

1 2

1.1.3 变量声明的种类

1.指定变量类型，如果没有初始化，则变量默认为零值(变量没有做初始化时系统默认设置的值)。

语法如下:

var v_name v_type
v_namev = value

示例：

package main
import "fmt"
func main() {
    //声明一个变量并初始化
    var name string = "zq1"
    fmt.Println("我的名字是:", name)

    //没有初始化就为零值
    var name2 int
    fmt.Println(name2)
}

执行命令

go run test3.go

以上实例输出结果为:

我的名字是: zq1
0

2.根据值自行判定变量类型

语法如下:

var v_name value

示例：

package main
import "fmt"
func main() {
    var a = true
    fmt.Println(a)
}

执行命令

go run test1.go

以上实例输出结果为:

true

3.使用语法糖进行声明变量

语法如下:

v_name := value

示例：

package main
import "fmt"
func main() {
    b := true
    f := 3.1415926
    fmt.Println(b, f)
}

注意:如果变量已经使用 var 声明过了，再使用 := 声明变量，就产生编译错误

执行命令

go run test4.go

以上实例输出结果为:

true 3.1415926

1.1.4 什么是多变量声明

多变量声明是指在一个语句中同时声明多个变量。在Go语言中，可以使用逗号将多个变量名连接起来，并指定它们的类型。而针对全局变量和非全局变量分为两类。

1.非全局变量的多变量声明

语法如下:

#语法一
var v_name1, v_name2, v_name3 type = v1， v2, v3

#语法二
var v_name1, v_name2, v_name3 = v1， v2, v3

#语法三,出现在 := 左侧的变量不应该是已经被声明过的，否则会导致编译错误.而且这种不带声明格式的只能在函数体中出现
v_name1, v_name2, v_name3 := v1， v2, v3

示例：

package main

//语法一
var a, b int = 1, 2

//语法二
var c, d = 3, 4

//语法三
func main() {
    e, f := 5, 6
    println(a, b, c, d, e, f)
}

2.全局变量的多变量声明

语法如下:

var (
    v_name1 v_type1
    v_name2 v_type2
)

示例:

package main
import "fmt"
func main() {
    b := true
    f := 3.1415926
    fmt.Println(b, f)
}

执行命令

go run test5.go

以上实例输出结果为:

true 3.1415926

1.1.5 如何确定一个变量的类型

在Go语言中，可以使用反射（reflect）包来确定一个变量的类型。要确定一个变量的类型，可以使用反射中的reflect.TypeOf函数。该函数接收一个接口类型的值作为参数，并返回一个reflect.Type类型的值，其中包含了变量的类型信息。

示例：

package main

import (
    "fmt"
    "reflect"
)

func main() {
    var num int = 1
    var name string = "zq"
    var isMarried bool = true

    fmt.Println(reflect.TypeOf(num))
    fmt.Println(reflect.TypeOf(name))
    fmt.Println(reflect.TypeOf(isMarried))
}

执行命令

go run test6.go

以上实例输出结果为:

int
string
bool

1.2 常量

1.2.1 什么是Go语言常量

在Go语言中，常量是一种值无法改变的标识符。常量的命名规则和变量相同，通常使用驼峰命名法，且推荐使用大写字母开头以表示常量的可导出性。常量声明时必须初始化，可以直接指定一个值。常量的值可以是布尔值、数值（整数、浮点数等）或字符串等。

1.针对单个常量语法如下:

const c_name1 = 值

示例：

package main

import (
    "fmt"
)

func main() {
    const c1 = 1
    fmt.Println(c1)
}

以上实例输出结果为:

1

2.针对多个常量语法如下:

const c_name1, c_name2 = value1, value2

示例：

package main

import (
    "fmt"
)

func main() {
    const c1, c2, c3 = 1, 2, 3
    fmt.Println(c1, c2, c3)
}

以上实例输出结果为:

1 2 3

二、函数和作用域

2.1 函数

2.1.1 什么是函数

在Go语言中，函数是一段执行特定任务的代码块。函数的定义包括函数名、参数列表、返回值类型和函数体。

2.1.2 函数示例说明

下面编写函数代码进行演示：

定义一个函数 printAd() 并在 main() 函数中调用了这个函数。将下面代码粘贴到00-Functions.go文件中并保存该文件

package main

import "fmt"

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")

}

func main() {
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("程序运行结束")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - printAd() 函数的定义

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")
}

这部分代码定义了一个名为 printAd() 的函数。这个函数的目的是打印一些信息，包括你的名字和正在学习的内容。fmt.Println() 用于在终端输出内容。

部分 2 - main() 函数的定义

func main() {
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("程序运行结束")
}

这部分代码定义了 main() 函数，它是程序的入口。在 main() 函数中，做了以下几件事情：

  • 使用 fmt.Println() 输出 "程序开始运行"。

  • 调用了 printAd() 函数，这将触发在 printAd() 函数中定义的打印语句，输出 "My name is zq" 和 "我正在学习函数"。

  • 再次使用 fmt.Println() 输出 "程序运行结束"

运行上面代码

$ go run '.\00-Functions.go'
程序开始运行
My name is zq
我正在学习函数
程序运行结束

2.2 作用域

在Go语言中，变量可以有不同的作用域。根据变量所在位置不同，可以分为：

  • 包级别作用域

  • 函数级别作用域

  • 块级别作用域

2.2.1 包级别作用域

如果变量在函数外部声明，它将具有包级别的作用域，这意味着它在整个包内都可见。

定义了一个全局变量 globalName 和一个函数 printAd()，然后在 main() 函数中调用这个函数以及输出全局变量的值。将下面代码粘贴到01-Package-level scope.go文件中并保存该文件

package main

import "fmt"

// 在func之外定义一个全局的变量
var globalName string = "xiaozhang"

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")
    fmt.Println("全局变量的值：", globalName)
}

func main() {
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("全局变量的值：", globalName)
    fmt.Println("程序运行结束")
}

注意：在Go语言中，全局变量的定义应该在import语句之前，不要将import语句放在全局变量之后

针对上面代码分为几个部分进行详细说明：

部分 1 - 包级别的全局变量和导入

package main

import "fmt"

// 在func之外定义一个全局的变量
var globalName string = "xiaozhang"

这部分代码涉及了包级别的全局变量和包的导入:

  • package main：声明这个文件属于 main 包。
  • import "fmt"：导入标准库的 fmt 包，用于格式化输出。
  • var globalName string = "xiaozhang"：定义一个全局变量 globalName 并赋值为 "xiaozhang"。这个变量在整个包内都是可见的

部分 2 - printAd() 函数的定义

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")
    fmt.Println("全局变量的值：", globalName)
}

这部分代码定义了一个名为 printAd() 的函数，用于打印一些信息

  • func printAd()：定义函数 printAd()。
  • 在函数内部，你使用 fmt.Println() 打印一些信息，包括你的名字、正在学习的内容以及全局变量的值。全局变量 globalName 在函数内部也是可见的

部分 3 - main() 函数的定义

func main() {
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("全局变量的值：", globalName)
    fmt.Println("程序运行结束")
}

这部分代码定义了 main() 函数，是程序的入口

  • func main()：定义了 main() 函数，程序从这里开始执行

运行上面代码

$ go run '.\01-Package-level scope.go'
程序开始运行
My name is zq
我正在学习函数
全局变量的值： xiaozhang
全局变量的值： xiaozhang
程序运行结束

2.2.2 函数级别作用域

在函数内部声明的变量具有函数级别的作用域，它们只能在函数内部访问。

定义了一个全局变量 globalName 和一个函数 printAd()，然后在 main() 函数中声明一个名为 name 的局部变量，并将其赋值为 "zq"。这个变量的作用域仅限于 main() 函数内部，它在其他函数中不可见。将下面代码粘贴到02-Function-level scope.go文件中并保存该文件

package main

import "fmt"

// 在func之外定义一个全局的变量
var globalName string = "xiaozhang"

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")
    fmt.Println("全局变量的值：", globalName)
}

func main() {
    var name string = "zq"
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("全局变量的值：", globalName)
    fmt.Println("函数级别作用域变量的值: ", name)
    fmt.Println("程序运行结束")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包级别的全局变量和导入

package main

import "fmt"

// 在func之外定义一个全局的变量
var globalName string = "xiaozhang"

这部分代码涉及了包级别的全局变量和包的导:

  • package main：声明这个文件属于 main 包。
  • import "fmt"：导入标准库的 fmt 包，用于格式化输出。
  • var globalName string = "xiaozhang"：定义一个全局变量 globalName 并赋值为 "xiaozhang"。这个变量在整个包内都是可见的

部分 2 - printAd() 函数的定义

// 定义一个函数，用于介绍自己
func printAd() {
    fmt.Println("My name is zq")
    fmt.Println("我正在学习函数")
    fmt.Println("全局变量的值：", globalName)
}

这部分代码定义了一个名为 printAd() 的函数，用于打印一些信息

  • func printAd()：定义函数 printAd()。
  • 在函数内部，你使用 fmt.Println() 打印一些信息，包括你的名字、正在学习的内容以及全局变量的值。全局变量 globalName 在函数内部也是可见的

部分 3 - main() 函数的定义

func main() {
    var name string = "zq"
    fmt.Println("程序开始运行")
    printAd()
    fmt.Println("全局变量的值：", globalName)
    fmt.Println("函数级别作用域变量的值: ", name)
    fmt.Println("程序运行结束")
}

这部分代码定义了 main() 函数，是程序的入口

  • func main()：定义了 main() 函数，程序从这里开始执行。
  • var name string = "zq"：在 main() 函数内部，你声明了一个名为 name 的局部变量，并赋值为 "zq"。这个变量的作用域仅限于 main() 函数内部，不能在其他函数中访问。

运行上面代码

$ go run '.\02-Function-level scope.go'
程序开始运行
My name is zq
我正在学习函数
全局变量的值： xiaozhang
全局变量的值： xiaozhang
函数级别作用域变量的值:  zq
程序运行结束

2.2.3 块级别作用域

将下面代码粘贴到03-Block-level scope.go文件中并保存该文件，这里loopVar 是在循环块内部声明的，每次迭代都会创建一个新的 loopVar。

package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        loopVar := i
        fmt.Printf("Inside loop: loopVar = %d\n", loopVar)
    }
    // fmt.Println(loopVar) // 无法访问 loopVar，会导致编译错误，因为在循环块之外
}

针对上面代码分为几个部分进行详细说明：

部分 1 - main() 函数：

func main() {
    for i := 0; i < 3; i++ {
        loopVar := i
        fmt.Printf("Inside loop: loopVar = %d\n", loopVar)
    }
    // fmt.Println(loopVar) // 无法访问 loopVar，会导致编译错误，因为在循环块之外
}

在 main() 函数中，有一个 for 循环。循环从 0 到 2，在每次迭代中创建一个新的块级别作用域。

部分 2 - 循环块内部

for i := 0; i < 3; i++ {
    loopVar := i
    fmt.Printf("Inside loop: loopVar = %d\n", loopVar)
}

在每次循环迭代中，声明一个名为 loopVar 的局部变量，并将其赋值为当前的循环迭代值 i。然后，使用 fmt.Printf 格式化输出 loopVar 的值。由于每次迭代都有一个新的作用域，所以每个 loopVar 都是独立的。

在循环块内部，输出以下内容的信息：

Inside loop: loopVar = 0
Inside loop: loopVar = 1
Inside loop: loopVar = 2

部分 3 - 循环块外部

// fmt.Println(loopVar) // 无法访问 loopVar，会导致编译错误，因为在循环块之外

在循环块外部，取消了一行代码的注释。该行代码试图访问 loopVar 变量，但是会导致编译错误。这是因为 loopVar 的作用域仅限于循环块内部，在循环块之外无法访问。

运行上面代码

$ go run '.\03-Block-level scope.go'

Inside loop: loopVar = 0
Inside loop: loopVar = 1
Inside loop: loopVar = 2

假如我们打开上面的注释,具体如下：

package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        loopVar := i
        fmt.Printf("Inside loop: loopVar = %d\n", loopVar)
    }
    fmt.Println(loopVar) // 无法访问 loopVar，会导致编译错误，因为在循环块之外
}

再次运行会发现保错，这里因为由于每个循环迭代都有一个独立的块作用域，不能在循环之外访问 loopVar，否则会导致编译错误。

三、数值、数值类型及字符串运算

3.1 数值运算

3.1.1 什么是数值

在Go语言中，"数值" 是指表示数值的数据类型，包括整数和浮点数。数值用于执行各种数学计算和操作，是计算机编程中的基本数据类型之一。

3.1.2 数值类型

Go语言提供了多种数值类型，包括整数、浮点数、复数和其他数值类型。

整数类型（Integers）

整数是没有小数部分的数，可以是正数、负数或零。Go语言提供了不同位数的整数类型，以满足不同范围的整数值：

  • int：根据底层平台可能是32位或64位的有符号整数类型
  • int8：8位有符号整数
  • int16：16位有符号整数
  • int32：32位有符号整数
  • int64：64位有符号整数
  • uint：根据底层平台可能是32位或64位的无符号整数类型
  • uint8：8位无符号整数
  • uint16：16位无符号整数
  • uint32：32位无符号整数
  • uint64：64位无符号整数

注意：Int和操作系统有关，假如操作系统是64位，表示int64;假如操作系统是32位，表示int32

浮点数类型（Floating-Point Numbers）

浮点数用于表示有小数部分的数，分为单精度和双精度浮点数：

  • float32：单精度浮点数，约6位小数精度
  • float64：双精度浮点数，约15位小数精度

复数类型（Complex Numbers）

Go语言还提供了复数类型，用于表示具有实部和虚部的数：

  • complex64：具有32位实部和虚部的复数
  • complex128：具有64位实部和虚部的复数

其他数值类型

除了上述基本数值类型，Go语言还提供了一些特定用途的数值类型，如字节类型 byte 和 rune 类型用于处理字符和Unicode码点。

3.1.3 基本数值运算

在Go语言中，进行数值运算的方式与大多数编程语言类似，使用标准的数学运算符，如加法、减法、乘法和除法。

将下面代码粘贴到00-Basic-Numerical-Operations.go文件中并保存该文件

package main

import "fmt"

// 数值运算函数
func numOperations(a, b int) {
    // 加法运算
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
    // 减法运算
    fmt.Printf("%d - %d = %d\n", a, b, a-b)
    // 乘法运算
    fmt.Printf("%d * %d = %d\n", a, b, a*b)
    // 除法运算,其中%.1f中的.1表示只保留一位小数
    fmt.Printf("%d / %d = %.1f\n", a, b, float64(a)/float64(b))
    // 取余运算
    fmt.Printf("%d 取余 %d = %d\n", a, b, a%b)
}

func main() {
    numOperations(1, 2)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入和包级别注释

package main

import "fmt"

// 数值运算函数
func numOperations(a, b int) {
    // ...
}

func main() {
    numOperations(1, 2)
}

这部分代码涉及到包的导入和包级别的注释:

  • package main：声明这个文件属于 main 包。
  • import "fmt"：导入标准库的 fmt 包，用于格式化输出。
  • // 数值运算函数：这是一个包级别的注释，描述下面定义的 numOperations 函数的作用

部分 2 - numOperations() 函数的定义

// 数值运算函数
func numOperations(a, b int) {
    // ...
}

这部分代码定义了一个名为 numOperations() 的函数，用于执行各种数值运算:

  • func numOperations(a, b int)：定义了 numOperations 函数，接受两个整数参数 a 和 b

部分 3 - numOperations() 函数内的数值运算和输出

func numOperations(a, b int) {
    // 加法运算
    fmt.Printf("%d + %d = %d\n", a, b, a+b)
    // 减法运算
    fmt.Printf("%d - %d = %d\n", a, b, a-b)
    // 乘法运算
    fmt.Printf("%d * %d = %d\n", a, b, a*b)
    // 除法运算,其中%.1f中的.1表示只保留一位小数
    fmt.Printf("%d / %d = %.1f\n", a, b, float64(a)/float64(b))
    // 取余运算
    fmt.Printf("%d 取余 %d = %d\n", a, b, a%b)
}

这部分代码定义了 numOperations() 函数内的具体数值运算和输出:

  • 在函数内部，你使用 fmt.Printf() 来格式化输出各种数值运算的结果，使用 %d 表示整数，使用 %f 表示浮点数，%.1f 表示保留一位小数的浮点数

部分 4 - main() 函数的定义和函数调用

func main() {
    numOperations(1, 2)
}

这部分代码定义了 main() 函数，是程序的入口:

  • func main()：定义了 main() 函数，程序从这里开始执行。
  • 在 main() 函数内部，你调用了 numOperations(1, 2)，将参数 1 和 2 传递给 numOperations 函数来执行数值运算

运行上面代码

$ go run .\00-Basic-Numerical-Operations.go
1 - 2 = -1
1 * 2 = 2
1 / 2 = 0.5
1 取余 2 = 1

3.1.4 其他数值运算

除了基本的加法、减法、乘法和除法，Go语言还提供了其他数值运算功能，如自增和自减等。

将下面代码粘贴到01-Other-Numerical-Operations.go文件中并保存该文件

package main

import "fmt"

func main() {

    // 自增运算
    a := 0
    a++

    // 自减运算
    b := 10
    b--

    fmt.Println("Counter:", a)
    fmt.Println("Countdown:", b)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

package main

import "fmt"

  • package main：声明这个文件属于 main 包，是Go程序的入口

  • import "fmt"：导入标准库的 fmt 包，用于格式化输出

部分 2 - main() 函数的定义

func main() {
    // ...
}
  • func main()：定义了 main() 函数，是程序的入口

部分 3 - 自增运算和自减运算

    // 自增运算
    a := 0
    a++

    // 自减运算
    b := 10
    b--

这部分代码展示了自增和自减运算的使用:

  • a := 0：声明变量 a 并初始化为值 0
  • a++：自增运算，将变量 a 的值加1
  • b := 10：声明变量 b 并初始化为值 10
  • b--：自减运算，将变量 b 的值减1

部分 4 - 打印输出

    fmt.Println("Counter:", a)
    fmt.Println("Countdown:", b)

这部分代码使用 fmt.Println() 函数打印输出自增和自减运算的结果

  • fmt.Println("Counter:", a)：输出变量 a 的值，附带标签 "Counter"
  • fmt.Println("Countdown:", b)：输出变量 b 的值，附带标签 "Countdown"

运行上面代码

$ go run .\01-Other-Numerical-Operations.go
Counter: 1
Countdown: 9

3.1.5 数值运算函数

Go语言还提供了许多数学函数，这些函数存储在 math 包中。可以使用这些函数来执行各种高级数学计算，如平方根、指数、对数等。

将下面代码粘贴到02-Numerical-Operation-Functions.go文件中并保存该文件

package main

import (
    "fmt"
    "math"
)

func main() {
    //平方根运算
    squareRoot := math.Sqrt(25)

    // 指数运算，即计算2的三次方
    exponentiation := math.Pow(2, 3)

    // 自然对数，数学中用ln表示
    naturalLog := math.Log(10)

    fmt.Println("平方根的运算结果:", squareRoot)
    fmt.Println("指数的运算结果:", exponentiation)
    fmt.Println("自然对数的运算结果:", naturalLog)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

package main

import (
    "fmt"
    "math"
)
  • package main：声明这个文件属于 main 包，是Go程序的入口
  • import (...)：使用括号导入多个包，这里导入了 fmt 和 math 包

部分 2 - main() 函数的定义

func main() {
    // ...
}
  • func main()：定义了 main() 函数，是程序的入口

部分 3 - 平方根运算、指数运算和自然对数运算

//平方根运算
squareRoot := math.Sqrt(25)

// 指数运算，即计算2的三次方
exponentiation := math.Pow(2, 3)

// 自然对数，数学中用ln表示
naturalLog := math.Log(10)

这部分代码进行了平方根运算、指数运算和自然对数运算

  • squareRoot := math.Sqrt(25)：使用 math.Sqrt() 函数计算 25 的平方根
  • exponentiation := math.Pow(2, 3)：使用 math.Pow() 函数计算 2 的 3 次方（2^3）
  • naturalLog := math.Log(10)：使用 math.Log() 函数计算以自然对数为底的 10 的对数

部分 4 - 打印输出

    fmt.Println("平方根的运算结果:", squareRoot)
    fmt.Println("指数的运算结果:", exponentiation)
    fmt.Println("自然对数的运算结果:", naturalLog)

运行上面代码

$ go run .\02-Numerical-Operation-Functions.go
平方根的运算结果: 5
指数的运算结果: 8
自然对数的运算结果: 2.302585092994046

3.2 字符串运算

3.2.1 什么是字符串

在Go语言中，字符串是一个由字节组成的序列，通常用来表示文本数据。字符串是不可变的，这意味着一旦创建，就不能直接修改字符串中的字符。Go语言的字符串类型使用UTF-8编码，可以表示各种国际化字符和符号。

3.2.2 字符串拼接

在Go语言中，字符串运算通常涉及字符串的拼接、截取、查找、替换等操作。

字符串拼接是将多个字符串连接成一个新的字符串。可以使用 + 运算符来进行字符串拼接。

将下面代码粘贴到04-String-Concatenation.go文件中并保存该文件

package main

import (
    "fmt"
    "reflect"
)

// 字符串运算-字符串拼接
func stringOperation(a, b string) {
    fmt.Printf("a和b拼接的结果：%s\n", a+b)
    ab := a + b
    fmt.Printf("ab: %s,类型是：%s", ab, reflect.TypeOf(ab))
}

func main() {
    stringOperation("1", "2")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

import (
    "fmt"
    "reflect"
)

导入了两个包：

  • fmt 包用于格式化输出
  • reflect 包用于在运行时获取变量的类型信息

部分 2 - stringOperation 函数定义

func stringOperation(a, b string) {
    fmt.Printf("a和b拼接的结果：%s\n", a+b)
    ab := a + b
    fmt.Printf("ab: %s,类型是：%s", ab, reflect.TypeOf(ab))
}

这部分定义了一个名为 stringOperation 的函数。函数接受两个参数 a 和 b，它们都是字符串类型。函数的主要目的是将两个输入字符串拼接在一起，然后输出拼接结果和拼接后字符串的类型。

在函数体内，首先使用 fmt.Printf 打印拼接后的字符串，并使用占位符 %s 将结果格式化为字符串输出。然后使用 a + b 将两个输入字符串拼接成新的字符串 ab。接着使用 reflect.TypeOf 获取 ab 的类型，然后再次使用 fmt.Printf 打印出 ab 的值和类型。

部分 3 - main 函数定义

func main() {
    stringOperation("1", "2")
}

这部分定义了 main 函数，是程序的入口点。在 main 函数中，调用了之前定义的 stringOperation 函数，并传递了两个字符串参数 "1" 和 "2"。这样，stringOperation 函数将被执行，输出拼接结果和拼接后字符串的类型。

运行上面代码

$ go run .\04-String-Concatenation.go
a和b拼接的结果： 12
ab: 12,类型是：string

当然除了使用 + 运算符来进行字符串拼接，还可以通过fmt.Sprintf来实现字符串拼接。

将下面代码粘贴到05-String-Concatenation.go文件中并保存该文件

package main

import (
    "fmt"
)

// fmt.Sprintf实现字符串拼接
func stringSprintf(firstName, secondName string) {
    fullName := fmt.Sprintf("%s%s", secondName, firstName)
    fmt.Println("你的全名是：", fullName)
}

func main() {
    stringSprintf("q", "z")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 包的导入

import (
    "fmt"
)

这部分代码用于导入所需的包,导入了 fmt 包，这个包提供了格式化的输入和输出功能

部分 2 - stringOperation 函数定义

func stringSprintf(firstName, secondName string) {
    fullName := fmt.Sprintf("%s%s", secondName, firstName)
    fmt.Println("你的全名是：", fullName)
}

这个部分定义了一个名为 stringSprintf 的函数。这个函数接受两个字符串参数，firstName 和 secondName，这些参数代表名字的不同部分。函数使用 fmt.Sprintf 函数将这两个名字部分拼接在一起，而不添加额外的空隙。拼接的结果被赋值给变量 fullName。最后，使用 fmt.Println 打印输出全名。

部分 3 - main 函数定义

func main() {
    stringSprintf("q", "z")
}

这部分定义了 main 函数，是整个程序的入口点。在 main 函数中，调用了 stringSprintf 函数，传递了 "q" 和 "z" 作为参数。这样，stringSprintf 函数将会被执行，输出格式化后的全名 "qz"。

运行上面代码

$ go run .\05-String-Concatenation.go
你的全名是： zq

四、关系和逻辑运算符

主要以下几方面介绍Go语言中的关系运算符:

  • ==：等于。比较两个值是否相等
  • !=：不等于。比较两个值是否不相等
  • <：小于。判断左边的值是否小于右边的值
  • >：大于。判断左边的值是否大于右边的值
  • <=：小于等于。判断左边的值是否小于等于右边的值
  • >=：大于等于。判断左边的值是否大于等于右边的值

主要以下几方面介绍Go语言中的逻辑运算符:

  • &&：逻辑与（AND）。当所有条件都为 true 时，结果为 true，否则为 false
  • ||：逻辑或（OR）。只要有一个条件为 true，结果为 true，否则为 false
  • !：逻辑非（NOT）。将 true 转换为 false，将 false 转换为 true

4.1 关系运算符

关系运算符用于比较两个值之间的关系，返回一个布尔值 (true 或 false)。

将下面代码粘贴到00-Relational-operators.go文件中并保存该文件

package main

import "fmt"

func main() {
    // 大于,其中字符串也可以基于字符的 Unicode 值比较大小
    fmt.Println(5 > 10)        //false
    fmt.Println("zq" > "zqzq") //false
    // 小于
    fmt.Println(5 < 10)        //true
    fmt.Println("zq" < "zqzq") //true
    //小于等于
    fmt.Println(5 <= 5)         //true
    fmt.Println("zq" <= "zqzq") //true
    //大于等于
    fmt.Println(10 >= 5)        //true
    fmt.Println("zq" >= "zqzq") //false
    //等于
    fmt.Println(5 == 5)         //true
    fmt.Println("zq" == "zqzq") //false
    //不等于
    fmt.Println(5 != 5)         //false
    fmt.Println("zq" != "zqzq") //true
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包和主函数

package main

import "fmt"

func main() {
}
  • package main：定义了这个文件属于名为 "main" 的包。在 Go 中，所有可执行的程序都必须包含一个名为 "main" 的包。
  • import "fmt"：导入了标准库中的 "fmt" 包，该包提供了格式化输入输出的功能。
  • func main()：定义了程序的主函数。程序从这里开始执行。所有的主要逻辑都在这个函数中

部分 2 - 大于和小于比较

    fmt.Println(5 > 10)        // false
    fmt.Println("zq" > "zqzq") // false
    fmt.Println(5 < 10)        // true
    fmt.Println("zq" < "zqzq") // true

这部分代码展示了大于和小于比较运算符的使用，对数字和字符串进行比较:

  • 5 > 10 为 false，因为 5 并不大于 10。
  • "zq" > "zqzq" 为 false，因为根据字符串的 Unicode 值，"zq" 的值要小于 "zqzq"

部分 3 - 小于等于和大于等于比较

    fmt.Println(5 <= 5)         // true
    fmt.Println("zq" <= "zqzq") // true
    fmt.Println(10 >= 5)        // true
    fmt.Println("zq" >= "zqzq") // false

这部分代码展示了小于等于和大于等于比较运算符的使用:

  • 5 <= 5 为 true，因为 5 等于 5。
  • "zq" <= "zqzq" 为 true，因为根据字符串的 Unicode 值，"zq" 小于等于 "zqzq"。
  • 10 >= 5 为 true，因为 10 大于等于 5。
  • "zq" >= "zqzq" 为 false，因为根据字符串的 Unicode 值，"zq" 并不大于等于 "zqzq"

部分 4 - 等于和不等于比较

    fmt.Println(5 == 5)         // true
    fmt.Println("zq" == "zqzq") // false
    fmt.Println(5 != 5)         // false
    fmt.Println("zq" != "zqzq") // true

这部分代码展示了等于和不等于比较运算符的使用:

  • 5 == 5 为 true，因为 5 等于 5。
  • "zq" == "zqzq" 为 false，因为这两个字符串的内容不相等。
  • 5 != 5 为 false，因为 5 等于 5。
  • "zq" != "zqzq" 为 true，因为这两个字符串的内容不相等

运行上面代码

$ go run .\00-Relational-operators.go
false
false
true
true
true
true
true
false
true
false
false
true

4.2 逻辑关系运算符

逻辑运算符用于组合条件，判断多个条件的复合结果。

将下面代码粘贴到01-Logical-operators.go文件中并保存该文件

package main

import (
    "fmt"
    "reflect"
)

func main() {
    n1 := 1
    n2 := 1
    n3 := 3
    //逻辑与
    fmt.Println(n1 == n2 && n2 == n3) //false
    //逻辑非
    fmt.Println(!(n1 == n2 && n2 == n3)) //true
    //逻辑或
    fmt.Println(n1 == n2 || reflect.TypeOf(n3).Kind() == reflect.String) //true
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
    "fmt"
    "reflect"
)

这部分代码用于导入所需的包:

  • fmt 包，它提供了格式化的输入和输出
  • reflect 包，用于在运行时获取变量的类型信息

部分 2 - main 函数定义

func main() {
    n1 := 1
    n2 := 1
    n3 := 3

    // 逻辑与
    fmt.Println(n1 == n2 && n2 == n3)        // false

    // 逻辑非
    fmt.Println(!(n1 == n2 && n2 == n3))     // true

    // 逻辑或
    fmt.Println(n1 == n2 || reflect.TypeOf(n3).Kind() == reflect.String) // true
}

这是主要的执行部分，包含了 main 函数。在 main 函数中，你定义了三个变量 n1、n2 和 n3，并分别赋值为 1、1 和 3。然后，展示了如何使用逻辑运算符来判断不同的条件情况。

部分 3 - 逻辑运算符的使用

// 逻辑与
fmt.Println(n1 == n2 && n2 == n3)        // false

// 逻辑非
fmt.Println(!(n1 == n2 && n2 == n3))     // true

// 逻辑或
fmt.Println(n1 == n2 || reflect.TypeOf(n3).Kind() == reflect.String) // true

在这一部分，使用了三种不同的逻辑运算符展示了不同的条件情况:

  • n1 == n2 && n2 == n3：使用逻辑与判断是否同时满足 n1 等于 n2 和 n2 等于 n3，结果是 false。
  • !(n1 == n2 && n2 == n3)：使用逻辑非对上一个表达式的结果取反，结果是 true。
  • n1 == n2 || reflect.TypeOf(n3).Kind() == reflect.String：使用逻辑或判断是否满足 n1 等于 n2 或者 n3 的类型是字符串，结果是 true

运行上面代码

$ go run .\01-Logical-operators.go
false
true
true

五、if-else、if-else if-else语句

5.1 if-else语句

if-else 语句用于在条件为真时执行一个代码块，而在条件为假时执行另一个代码块。

if-else语句基本语法：

if condition {
    // 如果 condition 为真，则执行这里的代码
} else {
    // 如果 condition 为假，则执行这里的代码
}
  • condition 是一个表达式，当其值为 true 时，会执行 if 代码块中的内容，否则会执行 else 代码块中的内容。
  • else 部分是可选的，可以只使用 if 语句

将下面代码粘贴到00-Flow-control-if-else.go文件中并保存该文件

package main

import "fmt"

func printPrice(weather string) {
    defaultPrice := 10
    // if 表达式 {代码块} else {代码块}
    if weather == "sunny" {
        // 成立就执行下面的代码
        fmt.Println("今天是晴天，雨伞的价格是: ", defaultPrice)
    } else {
        // 不成立就执行else里面的代码，当然else也可以不设置
        fmt.Println("今天不是晴天，雨伞的价格是: ", defaultPrice+10)
    }

}
func main() {
    // 晴天
    weather := "sunny"
    printPrice(weather)

    // 不是晴天
    weather = "rain"
    printPrice(weather)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包和主函数

package main

import "fmt"

func main() {
}
  • package main：定义了这个文件属于名为 "main" 的包。在 Go 中，所有可执行的程序都必须包含一个名为 "main" 的包。
  • import "fmt"：导入了标准库中的 "fmt" 包，该包提供了格式化输入输出的功能。
  • func main()：定义了程序的主函数。程序从这里开始执行。所有的主要逻辑都在这个函数中

部分 2 - printPrice 函数定义部分

func printPrice(weather string) {
    defaultPrice := 10
    if weather == "sunny" {
        fmt.Println("今天是晴天，雨伞的价格是: ", defaultPrice)
    } else {
        fmt.Println("今天不是晴天，雨伞的价格是: ", defaultPrice+10)
    }
}

在这部分代码中，定义了一个名为 printPrice 的函数。这个函数接受一个名为 weather 的字符串参数，表示天气情况。通过使用 if-else 结构，你根据 weather 判断天气情况，然后输出相应的雨伞价格。函数内部的 if 条件判断和输出语句展示了在函数中使用条件语句的方法。

部分 3 - main 函数部分

func main() {
    weather := "sunny"
    printPrice(weather)

    weather = "rain"
    printPrice(weather)
}

在 main 函数部分，展示了主程序的逻辑。首先，将 weather 设置为 "sunny"，然后调用 printPrice 函数，打印出晴天下的雨伞价格。接着，将 weather 设置为 "rain"，再次调用 printPrice 函数，打印出雨天下的雨伞价格。这部分代码演示了如何在主程序中调用函数，根据不同的参数值执行函数内部的不同代码块。

运行上面代码

$ go run .\00-Flow-control-if-else.go
今天是晴天，雨伞的价格是:  10
今天不是晴天，雨伞的价格是:  20

5.2 if-else if-else语句

if-else if-else 结构用于多个条件判断。程序会按顺序检查每个条件，然后执行第一个满足条件的代码块。

if-else if-else语句基本语法：

if condition1 {
    // 如果 condition1 为真，则执行这里的代码
} else if condition2 {
    // 如果 condition2 为真，则执行这里的代码
} else {
    // 如果以上条件都不满足，则执行这里的代码
}
  • condition1、condition2、condition3 等是多个条件表达式，它们会被逐一检查。
  • 如果其中任何一个条件为真，那么与其对应的代码块会被执行。
  • 如果没有一个条件为真，那么会执行 else 代码块中的内容。

注意事项：

  • if-else if-else 语句可以根据需要包含多个条件分支，但最终只会执行一个匹配的代码块。
  • 条件的比较顺序很重要。如果多个条件都能为真，那么只会执行第一个匹配的代码块。
  • 可以在 else 块中省略条件，表示如果以上所有条件都不满足，将执行 else 块中的代码。
  • if-else if-else 结构在处理多个互斥条件时非常有用，可以使代码逻辑更清晰易读。

将下面代码粘贴到01-Flow-control-if-else-if-else.go文件中并保存该文件

package main

import "fmt"

func printPriceWithWeather(weather string) {
    defaultPrice := 10
    // if 表达式 {代码块} else {代码块} if 表达式 {代码块} else {代码块}
    if weather == "lightRain" {
        // 成立就执行下面的代码
        fmt.Println("今天天气是小雨，雨伞的价格是: ", defaultPrice+5)
    } else if weather == "heavyRain" {
        // 不成立就执行else里面的代码，当然else也可以不设置
        fmt.Println("今天天气是大雨，雨伞的价格是: ", defaultPrice+10)
    } else if weather == "rainStorm" {
        fmt.Println("今天天气是暴雨，雨伞的价格是: ", defaultPrice+20)
    } else {
        fmt.Println("今天不是雨天，雨伞的价格是: ", defaultPrice)
    }
}
func main() {
    // 小雨
    printPriceWithWeather("lightRain")
    // 大雨
    printPriceWithWeather("heavyRain")
    // 暴雨
    printPriceWithWeather("rainStorm")
    // 以上情况都不是
    printPriceWithWeather("")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包和主函数

package main

import "fmt"

func main() {
}
  • package main：定义了这个文件属于名为 "main" 的包。在 Go 中，所有可执行的程序都必须包含一个名为 "main" 的包。
  • import "fmt"：导入了标准库中的 "fmt" 包，该包提供了格式化输入输出的功能。
  • func main()：定义了程序的主函数。程序从这里开始执行。所有的主要逻辑都在这个函数中

部分 2 - printPrice 函数定义部分

func printPriceWithWeather(weather string) {
    defaultPrice := 10
    // 使用 if-else if-else 结构来根据不同的天气情况执行不同的代码块
    if weather == "lightRain" {
        fmt.Println("今天天气是小雨，雨伞的价格是: ", defaultPrice+5)
    } else if weather == "heavyRain" {
        fmt.Println("今天天气是大雨，雨伞的价格是: ", defaultPrice+10)
    } else if weather == "rainStorm" {
        fmt.Println("今天天气是暴雨，雨伞的价格是: ", defaultPrice+20)
    } else {
        fmt.Println("今天不是雨天，雨伞的价格是: ", defaultPrice)
    }
}

在这部分中，定义了一个名为 printPriceWithWeather 的函数，用于根据天气情况输出雨伞价格。函数使用 if-else if-else 结构进行多条件判断。根据不同的 weather 值，会输出不同的文本信息，展示了如何使用条件语句根据不同条件执行不同代码块。

部分 3 - main 函数部分

func main() {
    // 小雨
    printPriceWithWeather("lightRain")
    // 大雨
    printPriceWithWeather("heavyRain")
    // 暴雨
    printPriceWithWeather("rainStorm")
    // 以上情况都不是
    printPriceWithWeather("")
}

在 main 函数中，你演示了对 printPriceWithWeather 函数的不同输入情况的测试：

  • 调用 printPriceWithWeather("lightRain") 输出小雨情况的雨伞价格。
  • 调用 printPriceWithWeather("heavyRain") 输出大雨情况的雨伞价格。
  • 调用 printPriceWithWeather("rainStorm") 输出暴雨情况的雨伞价格。
  • 调用 printPriceWithWeather("") 输出不在以上情况中的默认情况。

运行上面代码

$ go run .\01-Flow-control-if-else-if-else.go
今天天气是小雨，雨伞的价格是:  15
今天天气是大雨，雨伞的价格是:  20
今天天气是暴雨，雨伞的价格是:  30
今天不是雨天，雨伞的价格是:  10

六、switch

当需要基于某个表达式的不同值执行不同的代码块时，Go 语言中的 switch 语句非常有用。它允许你在一个代码块中比较一个表达式的值与一系列可能的值，然后根据匹配的情况执行相应的代码。

switch语句的基本语法：

switch expression {
case value1:
    // 执行当 expression 等于 value1 时的代码
case value2:
    // 执行当 expression 等于 value2 时的代码
// ...
default:
    // 如果上述情况都不匹配，则执行 default 代码
}
  • expression 是你要比较的表达式。
  • 每个 case 后面跟着一个要与 expression 进行比较的值。
  • 如果 expression 的值等于某个 case 后面的值，那么对应的代码块会被执行。
  • 如果没有一个 case 与 expression 的值匹配，那么会执行 default 代码块（可选的）

注意事项：

  • 每个 case 和 default 后面的代码块不需要使用花括号 {}，它们是自动包含的。如果需要多行代码，仍然需要使用花括号。
  • Go 语言的 switch 语句默认自带 "break"，在匹配到一个 case 后会自动跳出 switch 语句。如果你想要执行多个 case，可以使用 fallthrough 关键字。

将下面代码粘贴到02-Flow-control-switch.go文件中并保存该文件

package main

import "fmt"

func printPriceWithSwitch(weather string) {
    defaultPrice := 10
    switch weather {
    case "lightRain":
        fmt.Println("今天天气是小雨，雨伞的价格是: ", defaultPrice+5)
    case "heavyRain":
        fmt.Println("今天天气是大雨，雨伞的价格是: ", defaultPrice+10)
    case "rainStorm":
        fmt.Println("今天天气是暴雨，雨伞的价格是: ", defaultPrice+20)
    default:
        fmt.Println("今天不是雨天，雨伞的价格是: ", defaultPrice)
    }
}

func main() {
    // 小雨
    printPriceWithSwitch("lightRain")
    // 大雨
    printPriceWithSwitch("heavyRain")
    // 暴雨
    printPriceWithSwitch("rainStorm")
    // 以上情况都不是
    printPriceWithSwitch("")
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包和主函数

package main

import "fmt"

func main() {
}
  • package main：定义了这个文件属于名为 "main" 的包。在 Go 中，所有可执行的程序都必须包含一个名为 "main" 的包。
  • import "fmt"：导入了标准库中的 "fmt" 包，该包提供了格式化输入输出的功能。
  • func main()：定义了程序的主函数。程序从这里开始执行。所有的主要逻辑都在这个函数中

部分 2 - printPrice 函数定义部分

func printPriceWithSwitch(weather string) {
    defaultPrice := 10
    switch weather {
    case "lightRain":
        fmt.Println("今天天气是小雨，雨伞的价格是: ", defaultPrice+5)
    case "heavyRain":
        fmt.Println("今天天气是大雨，雨伞的价格是: ", defaultPrice+10)
    case "rainStorm":
        fmt.Println("今天天气是暴雨，雨伞的价格是: ", defaultPrice+20)
    default:
        fmt.Println("今天不是雨天，雨伞的价格是: ", defaultPrice)
    }
}

在这部分代码中，定义了一个名为 printPriceWithSwitch 的函数。函数使用 switch 语句根据输入的 weather 值匹配不同的情况。对于每个匹配的 case，会输出对应的天气情况和雨伞价格。如果没有匹配的情况，会执行 default 分支，输出默认的雨伞价格。

部分 3 - main 函数部分

在 main 函数中，演示了对 printPriceWithSwitch 函数的不同输入情况的测试：

  • 调用 printPriceWithSwitch("lightRain") 输出小雨情况的雨伞价格。
  • 调用 printPriceWithSwitch("heavyRain") 输出大雨情况的雨伞价格。
  • 调用 printPriceWithSwitch("rainStorm") 输出暴雨情况的雨伞价格。
  • 调用 printPriceWithSwitch("") 输出不在以上情况中的默认情况。

运行上面代码

$ go run .\02-Flow-control-switch.go
今天天气是小雨，雨伞的价格是:  15
今天天气是大雨，雨伞的价格是:  20
今天天气是暴雨，雨伞的价格是:  30
今天不是雨天，雨伞的价格是:  10

七、for循环

在 Go 语言中，for 循环是最常用的控制结构之一，它用于重复执行一段代码块，直到指定的条件不再满足。for 循环可以用于不同的情况，例如遍历数组、切片、映射等数据结构，以及执行指定次数的重复操作。

7.1 单次循环

for 循环语句基本语法

for 初始化语句; 条件语句; 后续语句 {
    // 循环体代码
}
  • 初始化语句 用于初始化循环变量。
  • 条件语句 是一个用于判断是否继续循环的表达式，当条件为真时循环继续执行，当条件为假时循环停止。
  • 后续语句 在每次循环结束后执行，通常用于更新循环变量的值

将下面代码粘贴到03-for-loop-1.go文件中并保存该文件

package main

import "fmt"

func main() {
    count := 0
    for num := 1; num <= 100; num++ {
        if num%2 == 0 {
            fmt.Println("发现一个偶数:", num)
            count++
        }
    }
    fmt.Printf("1到100一共有偶数:%d个\n", count)
}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"
  • import "fmt"：导入了标准库中的 "fmt" 包，该包提供了格式化输入输出的功能。

部分 2 - main函数

func main() {
    // ... 代码部分 ...
}

这是程序的主函数，是代码执行的入口。主要逻辑代码将在这个函数中执行。

部分 3 - 变量和初始化

count := 0

这段代码定义了一个名为 count 的整数变量，并初始化为 0。这个变量将被用来记录偶数的数量。

部分 4 - for循环

for num := 1; num <= 100; num++ {
    // ... 循环体部分 ...
}

这个 for 循环从 1 开始，每次循环迭代时递增 num 的值，直到 num 的值小于等于 100。这个循环会遍历从 1 到 100 的数字

部分 5 - 条件语句

if num%2 == 0 {
    // ... 条件成立时执行的代码 ...
    count++
}

在每次循环迭代中，这个条件语句判断当前的 num 是否是偶数（即能被 2 整除）。如果条件成立，会执行打印偶数的信息并将 count 计数器增加 1。

部分 6 - 输出偶数信息

fmt.Println("发现一个偶数:", num)

如果当前的 num 是偶数，就会打印出 "发现一个偶数:" 后跟偶数的值。

部分 7 - 偶数计数器增加

count++

如果当前的 num 是偶数，这行代码会将计数器 count 增加 1，用来统计偶数的数量。

部分 8 - 输出偶数数量

fmt.Printf("1到100一共有偶数:%d个\n", count)

这行代码使用 fmt.Printf 函数输出从 1 到 100 之间的偶数数量，使用 %d 占位符将计数器 count 的值嵌入输出字符串中。

运行上面代码

go run .\03-for-loop-1.go
发现一个偶数: 2
发现一个偶数: 4
发现一个偶数: 6
发现一个偶数: 8
发现一个偶数: 10
发现一个偶数: 12
发现一个偶数: 14
发现一个偶数: 16
发现一个偶数: 18
发现一个偶数: 20
发现一个偶数: 22
发现一个偶数: 24
发现一个偶数: 26
发现一个偶数: 28
发现一个偶数: 30
发现一个偶数: 32
发现一个偶数: 34
发现一个偶数: 36
发现一个偶数: 38
发现一个偶数: 40
发现一个偶数: 42
发现一个偶数: 44
发现一个偶数: 46
发现一个偶数: 48
发现一个偶数: 50
发现一个偶数: 52
发现一个偶数: 54
发现一个偶数: 56
发现一个偶数: 58
发现一个偶数: 60
发现一个偶数: 62
发现一个偶数: 64
发现一个偶数: 66
发现一个偶数: 68
发现一个偶数: 70
发现一个偶数: 72
发现一个偶数: 74
发现一个偶数: 76
发现一个偶数: 78
发现一个偶数: 80
发现一个偶数: 82
发现一个偶数: 84
发现一个偶数: 86
发现一个偶数: 88
发现一个偶数: 90
发现一个偶数: 92
发现一个偶数: 94
发现一个偶数: 96
发现一个偶数: 98
发现一个偶数: 100
1到100一共有偶数:50个

当然你如果想查看100之内有多少个奇数，只需要将上面代码稍微修改一下即可

将下面代码粘贴到03-for-loop-2.go文件中并保存该文件

package main

import "fmt"

func main() {
    count := 0
    for num := 1; num <= 100; num++ {
        if num%2 != 0 {
            fmt.Println("发现一个奇数:", num)
            count++
        }
    }
    fmt.Printf("1到100一共有奇数:%d个\n", count)
}

运行上面代码

$ go run .\03-for-loop-2.go
发现一个奇数: 1
发现一个奇数: 3
发现一个奇数: 5
发现一个奇数: 7
发现一个奇数: 9
发现一个奇数: 11
发现一个奇数: 13
发现一个奇数: 15
发现一个奇数: 17
发现一个奇数: 19
发现一个奇数: 21
发现一个奇数: 23
发现一个奇数: 25
发现一个奇数: 27
发现一个奇数: 29
发现一个奇数: 31
发现一个奇数: 33
发现一个奇数: 35
发现一个奇数: 37
发现一个奇数: 39
发现一个奇数: 41
发现一个奇数: 43
发现一个奇数: 45
发现一个奇数: 47
发现一个奇数: 49
发现一个奇数: 51
发现一个奇数: 53
发现一个奇数: 55
发现一个奇数: 57
发现一个奇数: 59
发现一个奇数: 61
发现一个奇数: 63
发现一个奇数: 65
发现一个奇数: 67
发现一个奇数: 69
发现一个奇数: 71
发现一个奇数: 73
发现一个奇数: 75
发现一个奇数: 77
发现一个奇数: 79
发现一个奇数: 81
发现一个奇数: 83
发现一个奇数: 85
发现一个奇数: 87
发现一个奇数: 89
发现一个奇数: 91
发现一个奇数: 93
发现一个奇数: 95
发现一个奇数: 97
发现一个奇数: 99
1到100一共有奇数:50个

7.2 无限循环

在 Go 语言中，可以使用 for 循环来创建无限循环，也就是循环将永远执行，直到手动使用 break 关键字终止。无限循环通常在需要不间断执行一段代码的场景中使用，比如服务器应用程序、并发编程、或者需要在程序运行期间等待某些事件的发生。

for 无限循环语句基本语法：

for {
    // 无限循环体代码
}

将下面代码粘贴到03-for-loop-3.go文件中并保存该文件

package main

import (
    "fmt"
    "time"
)

func main() {
    // 每2秒输出信息：开始学习了
    for {
        timeNow := time.Now()
        // 2006-01-02-15-04-05是Go语言的诞生时间
        fmt.Println("当前时间:", timeNow.Format("2006-01-02-15-04-05"))
        fmt.Println("开始学习了")
        time.Sleep(time.Second * 2)
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import (
    "fmt"
    "time"
)

在这个部分，导入了 "fmt" 和 "time" 包，分别用于格式化输出和处理时间。 部分 2 - 无限循环

for {
    // 循环体
}

这是一个无限循环，循环体内的代码会不断执行。

部分 3 - 获取当前时间

timeNow := time.Now()

这行代码获取了当前时间

部分 4 - 格式化输出时间

fmt.Println("当前时间:", timeNow.Format("2006-01-02-15-04-05"))

这行代码使用 timeNow.Format 将时间以 "2006-01-02-15-04-05" 格式进行格式化，并输出 "当前时间:" 后跟格式化后的时间。

部分 5 - 输出学习信息

fmt.Println("开始学习了")

这行代码输出 "开始学习了" 信息。

部分 6 - 休眠

time.Sleep(time.Second * 2)

这行代码让程序休眠 2 秒，然后继续下一次循环。

运行上面代码

$ go run .\03-for-loop-3.go
当前时间: 2023-08-16-11-08-55
开始学习了
当前时间: 2023-08-16-11-08-57
开始学习了
当前时间: 2023-08-16-11-08-59
开始学习了
...
...
...

7.3 循环控制语句-break

在 Go 语言中，break 和 continue 是两种常用的循环控制语句，用于在循环中进行控制流的调整。

  • break 语句用于提前终止循环，即使循环条件仍然满足。它通常在满足某些条件时，想要立即退出循环的情况下使用
  • continue 语句用于跳过当前循环迭代，继续执行下一次迭代。它通常在某些条件下，希望跳过当前迭代并执行下一次迭代的情况下使用。

循环控制语句-break的基本语法：

for 初始化语句; 条件语句; 后续语句 {
    // 循环体
    if 条件 {
        break
    }
}

将下面代码粘贴到03-for-loop-4.go文件中并保存该文件

package main

import "fmt"

func main() {
    for i := 0; i < 10; i++ {
        if i == 5 {
            fmt.Println("数字5已经找到了")
            break
        }
        fmt.Println("现在的数值是:", i)
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出。

部分 2 - for循环

for i := 0; i < 10; i++ {
    // 循环体
}

这是一个 for 循环，它会在 i 从 0 到 9 变化的过程中循环执行

部分 3 - if条件判断

if i == 5 {
    fmt.Println("数字5已经找到了")
    break // 当 i 等于 5 时终止循环
}

在每次迭代中，当 i 的值等于 5 时，输出 "数字5已经找到了" 并使用 break 语句终止循环。

部分 4 - 循环体

fmt.Println("现在的数值是:", i)

在不满足 if 条件的情况下，输出当前 i 的值。

运行上面代码

$ go run .\03-for-loop-4.go
现在的数值是: 0
现在的数值是: 1
现在的数值是: 2
现在的数值是: 3
现在的数值是: 4
数字5已经找到了

7.4 循环控制语句-continue

在 Go 语言中，break 和 continue 是两种常用的循环控制语句，用于在循环中进行控制流的调整。

  • break 语句用于提前终止循环，即使循环条件仍然满足。它通常在满足某些条件时，想要立即退出循环的情况下使用
  • continue 语句用于跳过当前循环迭代，继续执行下一次迭代。它通常在某些条件下，希望跳过当前迭代并执行下一次迭代的情况下使用。

循环控制语句-continue的基本语法：

for 初始化语句; 条件语句; 后续语句 {
    if 条件 {
        continue
    }
    // 循环体
}

将下面代码粘贴到03-for-loop-5.go文件中并保存该文件

package main

import "fmt"

func main() {
    for i := 1; i < 10; i++ {
        if i == 5 {
            fmt.Println("数字5已经找到了")
            continue
        }
        fmt.Println("现在的数字是:", i)
    }

}

针对上面代码分为几个部分进行详细说明：

部分 1 - 导入包

import "fmt"

这里导入了 "fmt" 包，用于格式化输出。

部分 2 - for循环

for i := 0; i < 10; i++ {
    // 循环体
}

这是一个 for 循环，它会在 i 从 0 到 9 变化的过程中循环执行

部分 3 - if条件判断

if i == 5 {
    fmt.Println("数字5已经找到了")
    continue // 当 i 等于 5 时跳过当前迭代
}

在每次迭代中，当 i 的值等于 5 时，输出 "数字5已经找到了" 并使用 continue 语句跳过当前迭代，继续执行下一次迭代。

部分 4 - 循环体

fmt.Println("现在的数字是:", i)

在不满足 if 条件的情况下，输出当前 i 的值。

运行上面代码

go run .\03-for-loop-5.go
现在的数字是: 1
现在的数字是: 2
现在的数字是: 3
现在的数字是: 4
数字5已经找到了
现在的数字是: 6
现在的数字是: 7
现在的数字是: 8
现在的数字是: 9