Go 语言零基础入门核心知识点详解

2. 变量与数据类型

核心数据类型：

变量声明的 3 种方式：

package main
import "fmt"

func main() {
	// 方式 1：完整声明
	var name string = "小明"
	var age int = 18
	fmt.Println("方式 1:", name, age)

	// 方式 2：类型推导
	var score = 92.5 // 自动识别为 float64
	fmt.Println("方式 2:", score)

	// 方式 3：简短声明（函数内专用，最常用）
	isPass := score >= 60 // 等价于 var isPass bool = true
	fmt.Println("方式 3:", isPass)
}

避坑点：

• 简短声明 := 只能在函数内用，全局变量必须用 var；
• Go 是强类型语言，变量类型一旦确定不能改；
• 字符串拼接用 + 号。

3. 条件判断：if/else

代码示例：

package main
import "fmt"

func main() {
	score := 85
	// Go 的 if 不用加 ()，代码块必须加 {}
	if score >= 90 {
		fmt.Println("优秀")
	} else if score >= 60 {
		fmt.Println("及格")
	} else {
		fmt.Println("不及格")
	}

	// Go 特色：if 可以先执行语句，再判断
	if num := score / 10; num == 9 {
		fmt.Println("90 分以上")
	}
}

关键要点：

• if 后的条件不用括号；
• if 里可以先声明变量，变量仅在 if 块内有效；
• Go 没有三元运算符，用 if/else 替代即可。

4. 循环：for

（1）基础 for 循环：

package main
import "fmt"

func main() {
	// 打印 1-10 的数字
	for i := 1; i <= 10; i++ {
		fmt.Println(i)
	}

	// 计算 1-100 的和
	sum := 0
	for i := 1; i <= 100; i++ {
		sum += i
	}
	fmt.Println("1-100 的和：", sum)
}

（2）for 替代 while 循环：

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

关键要点：

• Go 没有 while/do-while，所有循环都用 for；
• 循环内用 break 终止循环，continue 跳过当前次循环。

5. 函数

代码示例：

package main
import "fmt"

// 定义函数：计算切片的平均分
func calculateAvg(scores []int) float64 {
	sum := 0
	// range 遍历切片，返回索引和值
	for _, score := range scores {
		sum += score
	}
	return float64(sum) / float64(len(scores))
}

func main() {
	scores := []int{80, 90, 85, 95}
	avg := calculateAvg(scores)
	fmt.Printf("平均分：%.1f\n", avg)
}

关键要点：

• 函数定义用 func，参数格式是'参数名 类型'；
• range 返回'索引 + 值'，用 _ 忽略不需要的返回值；
• Go 支持多返回值（比如返回结果 + 错误）。

三、第二部分：Go 核心特性

1. 切片（Slice）

Java 的数组长度固定，Go 的切片可以动态扩容，是 Go 最核心的容器类型。

代码示例：

package main
import "fmt"

func main() {
	// 方式 1：直接创建切片
	s1 := []int{1, 2, 3, 4}
	fmt.Println("切片 s1：", s1)

	// 方式 2：make 创建
	s2 := make([]string, 0, 5)
	s2 = append(s2, "Java", "Go", "Python")
	fmt.Println("切片 s2：", s2)

	// 切片截取（左闭右开）
	s3 := s1[1:3]
	fmt.Println("切片 s3：", s3)

	// 遍历切片
	for index, value := range s2 {
		fmt.Printf("索引：%d，值：%s\n", index, value)
	}
}

关键要点：

• 切片的 append 函数会返回新切片，必须赋值给原变量；
• 切片的'容量'是底层数组的长度，'长度'是实际元素个数。

2. 映射（Map）

代码示例：

package main
import "fmt"

func main() {
	// 方式 1：直接创建 map
	scoreMap := map[string]int{
		"小明": 90,
		"小红": 85,
		"小李": 95,
	}
	fmt.Println("小明的成绩：", scoreMap["小明"])

	// 方式 2：make 创建
	userMap := make(map[int]string, 10)
	userMap[1] = "张三"
	userMap[2] = "李四"

	// 判断 key 是否存在
	score, ok := scoreMap["小王"]
	if ok {
		fmt.Println("小王的成绩：", score)
	} else {
		fmt.Println("小王不存在")
	}

	// 删除元素
	delete(scoreMap, "小红")
	fmt.Println("删除小红后：", scoreMap)
}

关键要点：

• map 的格式是 map[键类型] 值类型；
• 获取 map 值时，用 value, ok := map[key] 判断 key 是否存在；
• map 遍历是无序的。

3. 结构体（Struct）

Go 没有'类'的概念，用结构体实现面向对象。

代码示例：

package main
import "fmt"

// 定义结构体
type Student struct {
	Name  string
	Age   int
	Score float64
}

// 给结构体绑定方法
func (s Student) PrintInfo() {
	fmt.Printf("姓名：%s，年龄：%d，成绩：%.1f\n", s.Name, s.Age, s.Score)
}

func (s *Student) UpdateScore(newScore float64) {
	s.Score = newScore
}

func main() {
	stu1 := Student{Name: "小明", Age: 18, Score: 90.0}
	stu1.PrintInfo()
	stu1.UpdateScore(95.0)
	stu1.PrintInfo()
}

关键要点：

• 结构体属性名首字母大写才能被其他包访问；
• 方法的接收者分两种：值接收者和指针接收者；
• Go 没有继承，用'结构体嵌套'实现复用。

4. 错误处理：error

Go 没有 try/catch，用返回值 error 处理错误。

代码示例：

package main
import "fmt"

func divide(a, b int) (int, error) {
	if b == 0 {
		return 0, fmt.Errorf("除数不能为 0")
	}
	return a / b, nil
}

func main() {
	result, err := divide(10, 0)
	if err != nil {
		fmt.Println("出错了：", err)
		return
	}
	fmt.Println("结果：", result)
}

关键要点：

• Go 的错误处理是'显式'的，必须手动判断 err != nil；
• 自定义错误用 fmt.Errorf 或 errors.New。

四、第三部分：Go 实战入门

1. 写第一个 HTTP 接口

代码示例：

package main
import (
	"fmt"
	"net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	fmt.Fprintf(w, `{"code":200,"msg":"你好，Go HTTP！"}`)
}

func studentHandler(w http.ResponseWriter, r *http.Request) {
	id := r.URL.Query().Get("id")
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	fmt.Fprintf(w, `{"code":200,"data":{"id":"%s","name":"小明","age":18}}`, id)
}

func main() {
	http.HandleFunc("/hello", helloHandler)
	http.HandleFunc("/student", studentHandler)
	fmt.Println("服务器启动：http://localhost:8080")
	err := http.ListenAndServe(":8080", nil)
	if err != nil {
		fmt.Println("服务器启动失败：", err)
	}
}

关键要点：

• Go 内置 net/http 库，不用装任何框架就能写接口；
• 接口函数格式固定：func(w http.ResponseWriter, r *http.Request)。

2. Go 主流框架：Gin

（1）安装 Gin：

go get -u github.com/gin-gonic/[email protected]

（2）Gin 写接口示例：

package main
import (
	"github.com/gin-gonic/gin"
	"net/http"
)

type Student struct {
	ID    int     `json:"id"`
	Name  string  `json:"name"`
	Age   int     `json:"age"`
	Score float64 `json:"score"`
}

func main() {
	r := gin.Default()

	r.GET("/hello", func(c *gin.Context) {
		c.JSON(http.StatusOK, gin.H{"code": 200, "msg": "你好，Gin！"})
	})

	r.Run(":8080")
}

关键要点：

• Gin 的 gin.H 是快捷的 map 类型；
• 结构体的 json:"id" 标签用来指定 JSON 字段名。

3. 操作 MySQL（主流库：gorm v2）

（1）安装 gorm 和 MySQL 驱动：

go get -u gorm.io/[email protected]
go get -u gorm.io/driver/mysql

（2）gorm 操作数据库示例：

package main
import (
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

type Student struct {
	ID    int     `gorm:"primaryKey;autoIncrement" json:"id"`
	Name  string  `gorm:"size:20;not null" json:"name"`
	Age   int     `gorm:"default:0" json:"age"`
	Score float64 `json:"score"`
}

func main() {
	dsn := "root:password@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		panic("连接数据库失败：" + err.Error())
	}

	db.AutoMigrate(&Student{})

	stu := Student{Name: "小明", Age: 18, Score: 90.0}
	result := db.Create(&stu)
	if result.Error != nil {
		fmt.Println("新增失败：", result.Error)
	} else {
		fmt.Println("新增成功，ID：", stu.ID)
	}
}

关键要点：

• gorm 是 Go 的 ORM 框架，不用写 SQL 就能操作数据库；
• 结构体标签 gorm:"primaryKey" 指定数据库表的字段属性。

五、核心避坑清单

1. ❌ 左大括号换行 → ✅ Go 强制要求左大括号和函数名/if/for 同行；
2. ❌ 忽略未使用的变量 → ✅ Go 不允许定义变量但不用，用 _ 忽略；
3. ❌ 简短声明 := 用在函数外 → ✅ 全局变量必须用 var 声明；
4. ❌ 结构体属性名小写 → ✅ 小写属性无法被外部包访问；
5. ❌ 忘记判断 error → ✅ 所有 IO/数据库/网络操作都要判断 err != nil；
6. ❌ 用 Java 的思维写 Go → ✅ Go 没有类/继承/异常，用结构体/嵌套/error 替代；
7. ❌ 手动管理内存 → ✅ Go 有自动垃圾回收。

六、总结

1. 基础语法极简：Go 只有一种循环、没有类/继承/异常，核心是变量、切片、结构体、函数；
2. 核心特性突出：切片、map、error 是 Go 的灵魂；
3. 实战门槛低：内置 HTTP 库能直接写接口，Gin 框架让接口开发更高效；
4. 趋势：Go 是云原生、高并发后端的首选，学会基础语法 +Gin+gorm 就能应对企业场景。