Go 语言入门指南：基础语法和常用特性解析| 豆包MarsCode AI刷题1. Go语言的基本特点简单高效：语法简洁

1. Go语言的基本特点

简单高效：语法简洁，开发效率高。
静态类型：强类型语言，编译期检查。
内置并发：原生支持 Goroutine 和 Channel，实现高效并发编程。
自动垃圾回收：内存管理无需手动干预。
跨平台：编译后生成独立的可执行文件，跨平台运行。

2. 环境配置

安装 Go：
- Go 官方下载地址
- 安装后配置 GOPATH 和 GOROOT。
- 安装go插件后可以使用vscode编写。

创建第一个 Go 项目：


mkdir hello-world
cd hello-world
go mod init hello-world

编写代码： 创建 main.go 文件：

package main

import "fmt"

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

运行代码：
```
go run main.go
```

3. 基础语法

3.1 程序结构

package main // 声明包
import "fmt" // 导入标准库包

func main() { // 主函数
    fmt.Println("Hello, World!") // 输出内容
}

3.2 基本数据类型

类型	说明
`bool`	布尔值，`true` 或 `false`
`string`	字符串
`int`	整型（位数依平台而定）
`float32`	单精度浮点数
`float64`	双精度浮点数
`complex64`	复数
`byte`	8 位无符号整型
`rune`	Unicode 字符

3.3 变量声明

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

3.4 控制结构

if判断

if x > 0 {
    fmt.Println("Positive")
} else {
    fmt.Println("Non-positive")
}

for循环

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

switch case

	a := 2
	switch a {
	case 1:
		fmt.Println("one")
	case 2:
		fmt.Println("two")
	case 3:
		fmt.Println("three")
	case 4, 5:
		fmt.Println("four or five")
	default:
		fmt.Println("other")
	}

4. 常用特性解析

4.1 函数

函数定义与调用

func add(x int, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(3, 5))
}

多返回值

func swap(a, b string) (string, string) {
    return b, a
}

匿名函数与闭包

func main() {
    square := func(x int) int { return x * x }
    fmt.Println(square(4)) // 输出 16
}

4.2 数组与切片

数组

var arr [5]int
arr[0] = 1
fmt.Println(arr)

切片

nums := []int{1, 2, 3, 4}
nums = append(nums, 5) // 动态扩容
fmt.Println(nums)

4.3 映射（Map）

m := make(map[string]int)
m["a"] = 1
fmt.Println(m["a"])

4.4 指针（point）

指针的声明与使用：

func main() {
    var a int = 10
    var p *int = &a // 获取变量 a 的地址
    fmt.Println(*p) // 解引用，输出 10
    *p = 20         // 修改地址指向的值
    fmt.Println(a)  // 输出 20
}

4.5 Range

range 是 Go 中遍历数组、切片、映射和通道的关键字。

遍历数组或切片：

func main() {
    nums := []int{1, 2, 3}
    for i, num := range nums {
        fmt.Printf("Index: %d, Value: %d\n", i, num)
    }
}

遍历映射（Map）：

func main() {
    m := map[string]int{"a": 1, "b": 2}
    for key, value := range m {
        fmt.Printf("Key: %s, Value: %d\n", key, value)
    }
}

4.6 结构体（Struct）

结构体是 Go 中的一种自定义数据类型，用于组织复杂数据。

定义结构体：

type Person struct {
    Name string
    Age  int
}

func main() {
    p := Person{Name: "Alice", Age: 25}
    fmt.Println(p.Name, p.Age)
}

4.7 结构体方法（Struct-Method）

定义方法：

type Person struct {
    Name string
    Age  int
}

// 方法：值接收者
func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

// 方法：指针接收者（修改结构体内容）
func (p *Person) IncrementAge() {
    p.Age++
}

func main() {
    p := Person{Name: "Bob", Age: 30}
    p.Greet()
    p.IncrementAge()
    fmt.Println(p.Age) // 输出 31
}

4.8 字符串（String）

Go 中的字符串是不可变的 UTF-8 编码序列!

基本操作：

func main() {
    s := "Hello, Go"
    fmt.Println(len(s))            // 字符串长度
    fmt.Println(s[0])              // 字节访问
    fmt.Println(s + " Language")   // 字符串拼接
}

多行字符串：

s := `这是
多行
字符串`
fmt.Println(s)

4.9 JSON

Go 提供了内置的 encoding/json 包，用于处理 JSON 数据。

序列化与反序列化：

import "encoding/json"

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    p := Person{Name: "Eve", Age: 28}
    
    // 序列化
    jsonData, _ := json.Marshal(p)
    fmt.Println(string(jsonData)) // {"name":"Eve","age":28}

    // 反序列化
    var newPerson Person
    json.Unmarshal(jsonData, &newPerson)
    fmt.Println(newPerson)
}

4.10strconv

strconv 包提供了字符串与其他基本数据类型之间的转换。

常用方法：

import "strconv"

func main() {
    // 数字转字符串
    s := strconv.Itoa(123)
    fmt.Println(s)

    // 字符串转数字
    n, _ := strconv.Atoi("456")
    fmt.Println(n)
}

4.11 fmt

fmt 是 Go 中格式化 I/O 的核心包。

格式化输出：

func main() {
    a, b := 10, 20
    fmt.Printf("a: %d, b: %d\n", a, b) // 格式化输出
    fmt.Println("Hello, Go")          // 普通打印
}

格式化输入：

func main() {
    var name string
    fmt.Scanln(&name)
    fmt.Println("Hello,", name)
}

4.12 环境变量（Env）

通过 os 包操作环境变量。

读取环境变量：

import "os"

func main() {
    path := os.Getenv("PATH")
    fmt.Println(path)
}

设置环境变量：

os.Setenv("GREETING", "Hello, World")
fmt.Println(os.Getenv("GREETING"))

列出所有环境变量：

import "os"

func main() {
    for _, env := range os.Environ() {
        fmt.Println(env)
    }
}

4.13 并发编程

Goroutine

func printMessage(msg string) {
    fmt.Println(msg)
}

func main() {
    go printMessage("Hello")
    time.Sleep(1 * time.Second) // 等待 Goroutine 完成
}

Channel

func main() {
    ch := make(chan string)
    go func() {
        ch <- "Hello, Channel"
    }()
    fmt.Println(<-ch)
}

4.14 Error 处理

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

5. 项目构建与模块化

模块化管理：
- 使用 go mod 管理依赖：
```
go mod init example
```
编译与构建：
- 编译生成二进制文件：
```
go build main.go
```
- 安装：
```
go install
```