Go基础教程涵盖了Go语言的基本编程概念。
Go是一种开源编程语言，可以轻松构建简单、可靠且高效的软件。Go是一种由Google创建的静态类型编译编程语言。
$ go version go version go1.18.1 linux/amd64
我们使用Go版本1.18。
Go标识符
标识符是变量、函数、类或参数的名称。标识符可以包含字母数字字符和下划线。变量名以数字开头是错误的。不允许在名称中使用空格。
标识符区分大小写。这意味着Name、name和NAME引用三个不同的变量。标识符也不能匹配语言关键字。
去空白
Go中的空格用于分隔程序中的标记。它还用于提高源代码的可读性。
var i int = 0
有些地方需要空格。例如在i变量和int关键字之间。在其他地方，空格是被禁止的。它们不能出现在变量标识符或语言关键字中。
var i int=1 var j int = 2 var k int = 3
令牌之间的空间量与Go编译器无关。在Go程序中应始终如一地使用空格。
Go第一个例子
我们创建了第一个示例。
$ mkdir first $ cd first
我们创建一个项目目录并重新定位到那里。
$ go mod init zetcode.com/first
我们启动一个Go模块。
package main
import "fmt"
func main() {
fmt.Println("Go first example")
}
这是一个简单的Go程序，它向控制台打印一条消息。
package main
Go代码以包的形式组织。程序开始在main包中运行。
import "fmt"
使用import关键字将包包含到程序中。fmt包包含带有函数的格式化I/O。
func main() {
在main包中，main函数是Go程序的入口点。函数是使用func关键字创建的。
fmt.Println("Go first example")
在fmt包中，我们使用Println函数来显示消息。请注意，在Java、C或C#等语言中，该语句未以分号终止。
$ go run first.go Go first example
我们使用gorun命令一次性编译和执行程序。
去评论
人类使用注释来阐明源代码。Go中有两种注释：单行注释（//）和多行注释（/**/）。
package main
import "fmt"
/*
This is comments.go
Author: Jan Bodnar
ZetCode 2020
*/
// Program starts here
func main() {
fmt.Println("Go first example")
}
在代码示例中，我们有一个多行和一个单行注释。编译器会忽略注释。
转变量
变量用于存储值。它是赋予值的标签。Go使用var关键字来声明变量列表。我们也可以使用:=简写语法来声明变量。
变量可以保存不同数据类型的值。数据类型是一组值和对这些值的允许操作。在许多情况下，Go可以从赋值的右侧推断出数据类型。
package main
import "fmt"
func main() {
var i int = 1
var w float64 = 12.5
fmt.Println(i, w)
}
在代码示例中，我们声明并初始化两个变量，然后打印它们。第一个变量保存一个整数，第二个变量保存一个浮点数。Go中的数据类型遵循变量名称。
Go类型推断
Go可以从赋值的右边推断出数据类型。
package main
import (
"fmt"
"reflect"
)
func main() {
var name = "John Doe"
var age = 34
fmt.Println(reflect.TypeOf(name))
fmt.Println(reflect.TypeOf(age))
fmt.Printf("%s is %d years old\n", name, age)
}
在代码示例中，我们定义了两个变量，但没有指定它们的数据类型。数据类型是推断出来的。
var name = "John Doe" var age = 34
为了使推理起作用，变量必须被初始化。
fmt.Println(reflect.TypeOf(name)) fmt.Println(reflect.TypeOf(age))
借助reflect包中的TypeOf函数，我们打印两个变量的数据类型。
$ go run inference.go string int John Doe is 34 years old
Go速记变量声明
在函数内部，:=短赋值语句可以代替带有隐式类型的var声明。
package main
import "fmt"
func main() {
name := "John Doe"
age := 34
fmt.Println("%s is %d years old", name, age)
}
该示例使用简写符号声明了两个变量。
去用户输入
Scanf函数扫描从标准输入读取的文本，将连续的空格分隔值存储到由格式确定的连续参数中。它返回成功扫描的项目数。
package main
import "fmt"
func main() {
var name string
fmt.Print("Enter your name: ")
fmt.Scanf("%s", &name)
fmt.Println("Hello", name)
}
该示例提示用户输入他的姓名。
var name string
我们定义一个字符串变量。
fmt.Scanf("%s", &name)
输入的值存储在name变量中。
$ go run read_input.go Enter your name: Robert Hello Robert
我们运行程序并输入名称。
Go条件
条件是使用if、elseif和else关键字创建的。
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
num := -5 + rand.Intn(10)
if num > 0 {
fmt.Println("The number is positive")
} else if num == 0 {
fmt.Println("The number is zero")
} else {
fmt.Println("The number is negative")
}
}
在此示例中，我们生成介于-5和4之间的随机值。在条件的帮助下，我们为所有三个选项打印一条消息。
$ go run conditionals.go 2 The number is positive $ go run conditionals.go 0 The number is zero $ go run conditionals.go -1 The number is negative
我们运行示例几次。
进入for循环
for语句指定块的重复执行。
package main
import "fmt"
func main() {
sum := 0
for i := 0; i < 10; i++ {
sum += i
}
fmt.Println(sum)
}
这是经典的C风格for语句。该程序计算值1..9的总和。
for i := 0; i < 10; i++ {
sum += i
}
for语句由三部分组成：初始化、条件和自增。初始化部分只执行一次。当条件为真时执行for语句的主体。如果条件返回false，则for循环终止。块中的语句执行后，for循环切换到第三部分，计数器递增。循环继续，直到条件不再为真。请注意，是否可以创建无限循环。
$ go run for_loop.go 45
值1..9的总和是45。
以下示例使用for循环和range关键字。
package main
import "fmt"
func main() {
nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println(sum)
}
此示例计算数组值的总和。
nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
我们定义了一个值数组。
for _, num := range nums {
sum += num
}
我们使用range子句遍历数组。range在每次迭代中返回索引和值。由于我们不使用索引，因此我们指定了丢弃_运算符。（TheGolang文档称其为空白标识符。）
转到switch语句
Goswitch语句提供了多路执行。将表达式或类型说明符与开关内的案例进行比较，以确定要执行的分支。与其他语言（如C、Java或PHP）不同，每个案例都由隐式中断终止；因此，我们不必明确地写出来。
当没有其他情况适合时，默认语句可用于执行的分支。默认语句是可选的。
package main
import (
"fmt"
"runtime"
)
func main() {
os := runtime.GOOS
switch os {
case "windows":
fmt.Println("Windows")
case "darwin":
fmt.Println("MAC operating system")
case "linux":
fmt.Println("Linux")
default:
fmt.Printf("%s.\n", os)
}
}
GOOS环境变量是运行程序的操作系统目标：darwin、freebsd、linux等之一。根据变量的值，我们打印操作系统版本。
$ go run get_os.go Linux
Go命令行参数
命令行参数是传递给程序的选项和数据。我们通常将参数传递给控制台程序，但有时我们也会将参数传递给GUI程序。
os.Args保存命令行参数。此切片中的第一个值是程序的名称，而os.Args[1:]保存程序的参数。通过索引操作访问各个参数。
package main
import (
"fmt"
"os"
"reflect"
)
func main() {
prg_name := os.Args[0]
fmt.Printf("The program name is %s\n", prg_name)
names := os.Args[1:]
fmt.Println(reflect.TypeOf(names))
for _, name := range names {
fmt.Printf("Hello, %s!\n", name)
}
}
该示例接收命令行参数。
prg_name := os.Args[0]
fmt.Printf("The program name is %s\n", prg_name)
我们获取并打印第一个参数，即程序名称。
names := os.Args[1:]
我们得到所有接收到的参数。
fmt.Println(reflect.TypeOf(names))
我们打印保存参数的类型（切片）。
for _, name := range names {
fmt.Printf("Hello, %s!\n", name)
}
我们仔细检查参数并从每个参数构建一条消息。
$ go build read_args.go $ ./read_args Jan Peter Lucia The program name is ./read_args []string Hello, Jan! Hello, Peter! Hello, Lucia!
我们构建程序并运行它。我们在命令行上传递程序三个名称。
转函数
函数是零个或多个输入参数到零个或多个输出参数的映射。Go函数是一等公民。函数可以分配给变量，作为参数传递给函数或从函数返回。
Go中的函数是使用func关键字创建的。我们使用return关键字从函数返回值。函数体由调用函数时执行的语句组成。主体由一对花括号{}分隔。要调用函数，我们指定其名称后跟圆括号()。函数可以带参数也可以不带参数。
package main
import "fmt"
func main() {
x := 4
y := 5
z := add(x, y)
fmt.Printf("Output: %d\n", z)
}
func add(a int, b int) int {
return a + b
}
在代码示例中，我们定义了一个将两个值相加的函数。
z := add(x, y)
我们调用add函数；它需要两个参数。计算值传递给z变量。
func add(a int, b int) int {
return a + b
}
我们定义了add函数。函数的参数用逗号分隔；每个参数名称后跟它的数据类型。在参数之后，我们指定返回值类型。调用函数时执行的语句放在花括号中。加法运算的结果用return关键字返回给调用者。
$ go run simple_fun.go Output: 9
在本教程中，我们介绍了Go语言的基础知识。
列出所有Go教程。
