一、Go 语言基础语法
1.1 Go 程序结构
Go 程序由包（package）组成，每个 Go 文件都属于一个包。
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
package main：定义一个包名为main的包，main包是 Go 程序的入口。import "fmt"：导入标准库fmt，用于输入输出。func main()：定义main函数，为程序的入口点。
1.2 变量声明
Go 语言具有静态类型，并支持多种变量声明方式：
// 方式一：显式声明
var a int = 10
// 方式二：自动推导类型
var b = 20
// 方式三：简短声明（只能在函数内部使用）
c := 30
// 多变量声明
var d, e, f int = 1, 2, 3
g, h := "hello", true
1.3 常量
常量使用 const 关键字定义：
const Pi = 3.14
const (
A = 1
B = "Go"
)
二、数据类型
2.1 基本数据类型
- 数值类型：
int,float64,complex64,complex128 - 布尔类型：
bool - 字符串：
string
var x int = 42
var y float64 = 3.14
var s string = "Hello, Go!"
var flag bool = true
2.2 数组和切片
-
数组：固定长度。
var arr [3]int = [3]int{1, 2, 3} -
切片：动态长度。
slice := []int{1, 2, 3, 4} slice = append(slice, 5)
2.3 Map（字典）
键值对存储的数据结构。
m := map[string]int{"apple": 5, "banana": 7}
m["orange"] = 9
三、控制结构
3.1 条件语句
if num := 10; num > 5 {
fmt.Println("Greater than 5")
} else {
fmt.Println("Less than or equal to 5")
}
3.2 循环语句
Go 语言只有 for 一种循环结构：
// 基本 for 循环
for i := 0; i < 5; i++ {
fmt.Println(i)
}
// 类似 while 循环
i := 0
for i < 5 {
fmt.Println(i)
i++
}
// 无限循环
for {
fmt.Println("Infinite loop")
}
3.3 Switch 语句
switch day := 3; day {
case 1:
fmt.Println("Monday")
case 2, 3:
fmt.Println("Tuesday or Wednesday")
default:
fmt.Println("Another day")
}
四、函数和方法
4.1 函数定义
func add(x int, y int) int {
return x + y
}
4.2 多返回值
func swap(a, b string) (string, string) {
return b, a
}
x, y := swap("hello", "world")
4.3 可变参数
func sum(nums ...int) int {
total := 0
for _, num := range nums {
total += num
}
return total
}
result := sum(1, 2, 3, 4)
五、结构体和方法
5.1 结构体
type Person struct {
Name string
Age int
}
p := Person{Name: "Alice", Age: 25}
fmt.Println(p.Name)
5.2 方法
为结构体定义方法：
func (p Person) Greet() {
fmt.Printf("Hello, my name is %s\n", p.Name)
}
p.Greet()
六、接口和多态
6.1 接口定义
type Animal interface {
Speak() string
}
type Dog struct{}
func (d Dog) Speak() string {
return "Woof!"
}
func main() {
var a Animal = Dog{}
fmt.Println(a.Speak())
}
6.2 类型断言
var i interface{} = "hello"
s, ok := i.(string)
fmt.Println(s, ok) // 输出：hello true
七、并发（Goroutine 和 Channel）
7.1 Goroutine
Goroutine 是轻量级线程，由 Go 运行时调度：
go func() {
fmt.Println("Running in a goroutine")
}()
7.2 Channel（通道）
用于 Goroutine 之间的通信：
ch := make(chan int)
go func() {
ch <- 42
}()
value := <-ch
fmt.Println(value)
7.3 Select 多路复用
select {
case msg := <-ch1:
fmt.Println("Received from ch1:", msg)
case msg := <-ch2:
fmt.Println("Received from ch2:", msg)
default:
fmt.Println("No data received")
}
八、错误处理
8.1 错误处理
Go 语言使用内置的 error 接口进行错误处理：
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero")
}
return a / b, nil
}
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
九、常用工具
go fmt：格式化代码go run：编译并运行代码go build：构建可执行文件go test：测试代码go mod：依赖管理工具
十、总结
Go 语言以其简洁的语法、高效的并发机制以及简便的错误处理方式，使其在 Web 开发、分布式系统和微服务等领域大放异彩。掌握 Go 的基础语法和特性，有助于更高效地开发可靠、可扩展的软件。
