Go 基础语法全景

1. Go 程序结构

go 复制代码

package main

import "fmt"

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

package main：程序入口包，Go 的执行必须从 main 包开始
import "fmt"：引入标准库 fmt，用于打印
func main() {}：程序入口函数
fmt.Println()：打印输出

Go 没有类，程序从 main 函数开始执行。

2. 变量和常量

显式声明

go 复制代码

var name string = "Tom"
var age int = 20

类型推导

go 复制代码

name := "Tom" // 自动推导为 string
age := 20     // 自动推导为 int

:= 语法只能在函数内部使用
Go 是静态类型语言，类型一旦确定就不能修改

常量

go 复制代码

const Pi = 3.1415
const StatusOK = 200

常量不可修改
可在全局或函数内定义

3. 基本数据类型

整数：int, int8, int16, int32, int64
浮点数 ：float32, float64
布尔：bool
字符串 ：string

go 复制代码

var x int = 10
var pi float64 = 3.14
var ok bool = true
var s string = "hello"

4. 条件语句

go 复制代码

age := 20

if age > 18 {
    fmt.Println("Adult")
} else {
    fmt.Println("Minor")
}

Go 的条件语句不需要括号，但花括号必须写
没有三元运算符

5. 循环

for 循环

go 复制代码

for i := 0; i < 5; i++ {
    fmt.Println(i)
}

类 while 循环

go 复制代码

i := 0
for i < 5 {
    fmt.Println(i)
    i++
}

无限循环

go 复制代码

for {
    fmt.Println("Loop forever")
}

Go 只有 for，没有 while 或 do-while

6. 数组和切片

数组

go 复制代码

var arr [3]int = [3]int{1, 2, 3}
fmt.Println(arr)

切片（动态长度）

go 复制代码

s := []int{1, 2, 3}
s = append(s, 4)
fmt.Println(s) // [1 2 3 4]

切片是引用数组，可动态增长
Go 中切片比数组更常用

7. Map（字典）

go 复制代码

m := map[string]int{
    "apple":  5,
    "banana": 3,
}

fmt.Println(m["apple"]) // 5
m["pear"] = 7           // 添加新键值

Map 是 key-value 结构
key 类型必须可比较（string、int 等）
value 可以是任意类型

8. 函数

基本函数

go 复制代码

func add(a int, b int) int {
    return a + b
}

sum := add(3, 4)
fmt.Println(sum) // 7

func 表示函数
(a int, b int) 是参数列表
int 是返回值类型
函数可有一个或多个返回值

多返回值函数

go 复制代码

func divide(a, b int) (int, int) {
    return a / b, a % b
}

quotient, remainder := divide(7, 3)
fmt.Println(quotient, remainder) // 2 1

函数作为值

go 复制代码

func apply(x int, f func(int) int) int {
    return f(x)
}

double := func(n int) int { return n * 2 }
fmt.Println(apply(5, double)) // 10

Go 支持函数作为参数和返回值

9. 错误处理

go 复制代码

func doSomething() error {
    return nil // 或 errors.New("something wrong")
}

err := doSomething()
if err != nil {
    fmt.Println("Error:", err)
}

Go 不用异常，而用返回值显式处理错误
nil 表示成功，非 nil 表示失败

10. 结构体和方法

go 复制代码

type Order struct {
    ID    int
    Price float64
}

func (o Order) Print() {
    fmt.Println(o.ID, o.Price)
}

order := Order{ID: 1, Price: 100.0}
order.Print()

结构体是数据容器
方法接收者 (o Order) 表示方法作用于 Order 类型
Go 没有继承，组合 + 接口是主流思路

11. 接口

go 复制代码

type Payer interface {
    Pay(amount float64)
}

type Order struct{}
func (o Order) Pay(amount float64) {
    fmt.Println("Paid", amount)
}

var p Payer = Order{}
p.Pay(100)

接口只关心能力，而不是类型
只要类型实现接口定义的方法，就满足接口

12. 并发基础

go 复制代码

go func() {
    fmt.Println("Hello from goroutine")
}()

go 启动一个轻量级并发任务

Channel 示例：

go 复制代码

ch := make(chan int)
ch <- 1       // 发送
x := <-ch     // 接收

核心理念：通过通信共享数据，而不是共享内存加锁

总结

Go 核心是函数 + 数据结构
错误处理显式化
并发通过 goroutine + channel（进阶再讲）
没有类继承，组合 + 接口是主流
语法简单、类型明确、可维护性高