golang-基础-Go语言基本语法

1. 基本结构

Go语言的程序结构由包（package）、函数（func）、变量（var）等组成。

1.1 包（Package）

所有Go代码必须归属于一个包。
package main 表示程序入口包，main 函数是程序的起点。

package main

import "fmt"

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

1.2 导入（Import）

使用 import 导入标准库或第三方包。
支持别名导入（as）和忽略导入（_）。

import (
    "fmt"
    "math"  // 标准库
    "mylib" // 自定义包
)

1.3 注释

单行注释：//
多行注释：/* ... */

// 单行注释
/*
多行注释
适用于代码块说明
*/

2. 变量与常量

2.1 变量声明

显式声明：var 关键字。
隐式声明：:= 语法糖（仅在函数内部使用）。

var a int = 10          // 显式声明
var b = 20              // 类型推断
c := 30                 // 短变量声明（仅限函数内）

// 多变量声明
var x, y int = 1, 2
d, e := 4, 5

2.2 常量

使用 const 声明，支持编译时常量表达式。

const Pi = 3.141592653589793
const Max = 100

2.3 数据类型

基本类型：
- 整型：int, int8, int16, int32, int64, uint, uintptr 等。
- 浮点型：float32, float64。
- 布尔型：bool。
- 字符串：string（UTF-8编码）。
派生类型：
- 数组、切片、映射、结构体、接口等。

var num int = 42
var pi float64 = 3.14
var isTrue bool = true
var name string = "Go"

3. 控制结构

3.1 条件语句（if-else）

支持无括号语法，if 后可直接定义变量。

age := 20
if age >= 18 {
    fmt.Println("成年人")
} else {
    fmt.Println("未成年人")
}

3.2 循环（for）

Go语言仅支持 for 循环，无 while 或 do-while。
支持传统形式、无限循环和 range 遍历。

// 传统循环
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// 无限循环
for {
    fmt.Println("Looping...")
    break
}

// 遍历切片
slice := []int{1, 2, 3}
for index, value := range slice {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

3.3 选择语句（switch）

支持类型匹配和表达式判断。

num := 2
switch num {
case 1:
    fmt.Println("One")
case 2:
    fmt.Println("Two")
default:
    fmt.Println("Unknown")
}

4. 函数

4.1 函数定义

使用 func 关键字定义函数，支持多返回值。

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

// 多返回值
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

4.2 函数参数

支持可变参数（...T）和命名返回值。

// 可变参数
func sum(nums ...int) int {
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// 命名返回值
func swap(a, b int) (x, y int) {
    x = b
    y = a
    return
}

4.3 函数作为一等公民

函数可以作为参数传递或返回值。

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

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

5. 数据结构

5.1 数组

固定长度，类型一致。

var arr [3]int = [3]int{1, 2, 3}
arr := [5]string{"a", "b", "c", "d", "e"}

5.2 切片（Slice）

动态数组，基于数组实现，支持 append 和 make。

// 初始化
s := make([]int, 3, 5) // 长度3，容量5
s = append(s, 4, 5)    // 动态扩容

// 遍历
for i, v := range s {
    fmt.Printf("Index: %d, Value: %d\n", i, v)
}

5.3 映射（Map）

键值对集合，使用 make 初始化。

// 初始化
m := make(map[string]int)
m["apple"] = 1
m["banana"] = 2

// 键存在性检查
value, exists := m["apple"]
if exists {
    fmt.Println("值存在:", value)
}

5.4 结构体（Struct）

自定义数据类型，支持嵌入（类似继承）。

type Person struct {
    Name string
    Age  int
}

// 嵌入结构体
type Employee struct {
    Person
    ID int
}

5.5 方法（Method）

为结构体或自定义类型绑定方法。

type Rectangle struct {
    Width, Height float64
}

// 为Rectangle绑定方法
func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

6. 并发编程

6.1 Goroutine

轻量级线程，通过 go 关键字启动。

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

func main() {
    go sayHello()
    time.Sleep(time.Second) // 等待goroutine执行
}

6.2 Channel

用于goroutine间通信，支持带缓冲和无缓冲通道。

// 无缓冲通道
ch := make(chan int)
go func() {
    ch <- 42 // 发送数据
}()
fmt.Println(<-ch) // 接收数据

// 带缓冲通道
ch := make(chan int, 2)
ch <- 1
ch <- 2
fmt.Println(<-ch)
fmt.Println(<-ch)

6.3 并发安全模式

使用通道实现限流或同步。

var sem = make(chan int, 3) // 最大并发数3

func handleRequest(req string) {
    sem <- 1       // 获取信号量
    defer func() { <-sem }() // 释放信号量
    fmt.Println("处理请求:", req)
    time.Sleep(time.Second)
}

func main() {
    requests := []string{"A", "B", "C", "D", "E"}
    for _, req := range requests {
        go handleRequest(req)
    }
    time.Sleep(2 * time.Second)
}
//处理请求: E
//处理请求: A
//处理请求: B
//处理请求: D
//处理请求: C

7. 接口与错误处理

7.1 接口（Interface）

隐式实现，无需显式声明。

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

7.2 错误处理

使用 error 类型返回错误，支持 panic 和 recover。

func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Result:", result)
    }
}

7.3 Panic与Recover

panic 触发异常，recover 捕获并恢复。

func safeDivide(a, b float64) (float64, error) {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    if b == 0 {
        panic("division by zero")
    }
    return a / b, nil
}

8. 适用场景与代码示例

8.1 高性能网络服务

Go的并发模型使其在处理高并发请求时表现优异。

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, Go Web!")
}

func main() {
    http.HandleFunc("/", helloHandler)
    fmt.Println("Server starting on :8080")
    http.ListenAndServe(":8080", nil)
}

8.2 DevOps工具开发

编译为单一可执行文件，跨平台部署。

package main

import (
    "fmt"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        fmt.Println("Usage: mytool <filename>")
        return
    }
    fmt.Println("Processing file:", os.Args[1])
}

8.3 云原生基础设施

Docker、Kubernetes等项目均使用Go开发。

package main

import (
    "fmt"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
)

func main() {
    config, _ := rest.InClusterConfig()
    clientset, _ := kubernetes.NewForConfig(config)
    pods, _ := clientset.CoreV1().Pods("default").List(context.TODO(), metav1.ListOptions{})
    fmt.Println("Pods in default namespace:")
    for _, pod := range pods.Items {
        fmt.Println(pod.Name)
    }
}

8.4 数据处理与大数据

并发处理海量数据。

package main

import (
    "fmt"
    "sync"
)

func processChunk(data []int, wg *sync.WaitGroup) {
    defer wg.Done()
    for _, v := range data {
        fmt.Println("Processing:", v)
    }
}

func main() {
    data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    var wg sync.WaitGroup
    chunkSize := 3
    for i := 0; i < len(data); i += chunkSize {
        end := i + chunkSize
        if end > len(data) {
            end = len(data)
        }
        wg.Add(1)
        go processChunk(data[i:end], &wg)
    }
    wg.Wait()
}

8.5 区块链与IoT

高性能和并发能力支持分布式系统开发。

package main

import (
    "fmt"
    "time"
)

type Block struct {
    Data      string
    Timestamp int64
}

func mineBlock(data string) Block {
    timestamp := time.Now().UnixNano()
    fmt.Printf("Mining block with data: %s\n", data)
    time.Sleep(1 * time.Second) // 模拟挖矿耗时
    return Block{Data: data, Timestamp: timestamp}
}

func main() {
    var blocks []Block
    data := []string{"A", "B", "C", "D"}
    for _, d := range data {
        blocks = append(blocks, mineBlock(d))
    }
    fmt.Println("Blockchain created with", len(blocks), "blocks")
}

9. 总结

Go语言凭借简洁的语法、高效的并发模型和强大的标准库，在以下领域表现突出：

高性能网络服务：微服务、RESTful API。
云原生基础设施：Docker、Kubernetes。
DevOps工具：命令行工具、自动化脚本。
大数据处理：并发数据管道、流式计算。
区块链与IoT：分布式系统、设备后端。