Go 语言（又称 Golang）是一种由 Google 开发的静态类型、编译型语言，具有简洁的语法和并发编程的优势。以下是 Go 语言的入门指南，简述基础语法和常用特性的解析。
1. Go 语言基础语法
1.1 Hello World 示例
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
• package main：声明当前文件属于 main 包，Go 程序从 main 包开始执行。
• import "fmt"：导入 Go 的标准库 fmt，用于格式化和输出。
• func main()：定义 main 函数，Go 程序的执行入口。
1.2 变量声明*
Go 支持多种方式声明变量。
• 显式声明：
var x int
x = 10
• 简短声明（常用在函数内部）：
x := 10
Go 会自动推断变量类型。
1.3 数据类型
Go 支持多种数据类型，包括整数（int, int32, int64）、浮点数（float32, float64）、布尔值（bool）、字符串（string）等。
• 整型：
var a int = 5
• 浮点型：
var b float64 = 3.14
• 字符串：
var name string = "Go Language"
• 布尔值：
var isGo bool = true
2. 控制结构
2.1 条件语句
Go 使用 if 和 else 来控制流程。条件表达式没有括号。
if x > 10 {
fmt.Println("x is greater than 10")
} else {
fmt.Println("x is less than or equal to 10")
}
2.2 循环语句
Go 没有 for 和 while 之分，只有 for，它可用于多种情况。
• 基本的 for 循环：
for i := 0; i < 5; i++ {
fmt.Println(i)
}
• 无限循环：
for {
fmt.Println("Hello")
}
2.3 switch 语句
Go 中的 switch 语句类似于其他语言，但不需要 break 来跳出每个分支。
switch x {
case 1:
fmt.Println("x is 1")
case 2:
fmt.Println("x is 2")
default:
fmt.Println("x is unknown")
}
3. 函数
3.1 函数定义
Go 使用 func 关键字定义函数。
func add(a int, b int) int {
return a + b
}
• 参数类型可以在同一位置声明：
func add(a, b int) int {
return a + b
}
• 函数没有返回值时，返回 void：
func printHello() {
fmt.Println("Hello, World!")
}
3.2 多值返回
Go 支持函数返回多个值。
func swap(a, b int) (int, int) {
return b, a
}
4. 数组与切片
4.1 数组
数组大小是固定的，且数组元素的类型必须相同。
var arr [5]int
arr[0] = 1
4.2 切片
切片是 Go 的灵活数据结构，不需要事先定义大小。
var slice []int
slice = append(slice, 1, 2, 3)
5. 结构体
5.1 结构体定义
结构体是聚合数据类型，可以包含多个不同类型的字段。
type Person struct {
Name string
Age int
}
func main() {
p := Person{Name: "Alice", Age: 25}
fmt.Println(p.Name) // 输出: Alice
}
6. 接口
Go 中的接口允许你定义一组方法签名，但不需要提供具体实现。
6.1 接口定义与实现
type Speaker interface {
Speak() string
}
type Person struct {
Name string
}
func (p Person) Speak() string {
return "Hello, " + p.Name
}
func main() {
var s Speaker = Person{Name: "Alice"}
fmt.Println(s.Speak()) *// 输出: Hello, Alice***
}
Go 通过隐式实现接口，即不需要显式声明一个类型实现了某个接口，只要该类型实现了接口中的方法即可。
7. 并发与 Goroutine
Go 的并发编程通过 goroutine 和 channel 实现。
7.1 Goroutine
Goroutine 是一种轻量级线程，通过 go 关键字启动：
go func() {
fmt.Println("Concurrent Execution")
}()
7.2 Channel
Channel 用于在 Goroutine 之间传递数据：
ch := make(chan string)
go func() {
ch <- "Hello from Goroutine"
}()
msg := <-ch
fmt.Println(msg)
8. 错误处理
Go 使用 error 类型处理错误。Go 的错误处理风格不依赖异常机制，而是显式检查错误值。
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero")
}
return a / b, nil
}
总结
Go 语言的设计追求简洁和高效，适合构建高并发的网络应用。以上简单介绍了 Go 的基础语法、常用特性和并发编程的基本概念。
