首页|go语言入门教程pdf全面指南
本页面为go语言入门教程pdf专题首页,专为零基础至初级开发者打造,系统梳理Go语言学习路径。内容涵盖从安装配置到实战项目的完整知识体系,所有资料均经社区验证,确保权威性与实用性。我们致力于帮助开发者绕过学习陷阱,高效掌握go语言入门教程pdf中的核心概念与最佳实践。
Go语言(又称Golang)由Google于2007年设计,2009年开源发布,其设计初衷是解决大型软件系统开发中的编译慢、并发难、维护难三大痛点。经过十余年发展,Go已成为云原生、微服务、DevOps工具链的首选语言,Docker、Kubernetes、Prometheus、Terraform等知名项目均以Go编写。
本页面内容基于Go 1.22+版本编写,严格遵循官方语言规范,所有代码示例均已通过编译验证。我们不仅提供go语言入门教程pdf的文本内容,更注重知识结构的完整性与实践引导性,确保学习者在理解原理的同时,能快速动手实现。
特别说明:本页面所有导航均采用单页锚点跳转,无实际二级页面,便于快速定位内容模块,提升移动端阅读体验。内容总字数超过5000字,覆盖Go语言学习全周期关键节点,包括环境搭建、基础语法、并发模型、网络编程、Web开发、工程化实践等核心模块。
为什么选择go语言入门教程pdf?
- 语法简洁:仅25个关键字,学习曲线平缓,新手3天可上手基础开发
- 编译迅速:并发编译机制使大型项目编译时间缩短50%以上
- 内置并发:goroutine与channel机制天然支持高并发,避免传统线程模型的复杂性
- 跨平台:一次编写,编译生成各平台原生可执行文件,无JVM依赖
- 生态成熟:官方工具链完善,go mod包管理、go test测试框架、pprof性能分析器一应俱全
据2024年Stack Overflow开发者调查,Go语言连续第8年入选“最受喜爱语言”前三甲,使用率稳定在14.6%。国内大厂如腾讯、阿里、字节跳动、华为等已大规模采用Go重构核心服务,Go工程师平均年薪达35-50万元,岗位需求持续增长。
为帮助学习者建立完整知识体系,我们特别设计了以下模块化结构:环境搭建(Windows/Linux/macOS)、基础语法(变量/流程控制/函数/结构体/接口)、并发模型(goroutine/channel/同步原语)、网络编程(TCP/UDP/HTTP/WebSocket)、Web开发(gin框架/中间件/数据库/缓存)、工程化(模块化/测试/性能优化)。每个模块均配有可运行代码示例与常见问题解析,确保理论与实践无缝衔接。
本go语言入门教程pdf不依赖任何第三方视频课程,所有内容均为原创撰写,可独立作为系统学习资料使用。我们建议学习者按章节顺序阅读,配合代码实践,每完成一个模块后进行总结归纳,逐步构建个人Go知识图谱。
Go语言简介|go语言入门教程pdf核心价值
Go语言诞生于2007年,由Google工程师Robert Griesemer、Rob Pike与Ken Thompson共同设计。Ken Thompson是Unix与C语言的共同发明者,Rob Pike是Plan 9系统核心开发者,Robert Griesemer参与过V8引擎与HotSpot JVM开发。三人结合多年系统编程经验,针对C++/Java等语言在大型项目中的痛点,设计出Go语言——一种“为工程化而生”的现代编程语言。
Go语言的设计哲学可概括为:简洁、高效、实用。它摒弃了面向对象中的继承机制,采用组合(composition)实现代码复用;取消了异常处理(try/catch),改用error返回值与defer资源清理;移除构造函数与析构函数,统一通过函数初始化;不支持泛型(Go 1.18前),强调“用简单方式解决简单问题”。这些设计看似限制,实则大幅降低了语言心智负担,使开发者聚焦业务逻辑。
Go语言核心特性详解
- 并发原语:goroutine是轻量级协程,栈空间初始仅2KB(线程通常为1MB),单机可轻松创建百万级goroutine;channel作为通信机制,遵循CSP模型,避免共享内存带来的竞争条件
- 垃圾回收:Go 1.5起采用并发标记清除(CMS)GC,停顿时间低于1ms,适合低延迟系统
- 标准库丰富:net/http提供生产级Web服务器,encoding/json高效处理JSON,sync/atomic提供无锁并发原语
- 工具链完善:go build编译、go run运行、go test测试、go vet静态检查、go fmt格式化、pprof性能分析、trace追踪器——所有工具开箱即用
- 跨平台编译:通过GOOS/GOARCH环境变量,可轻松生成Android/iOS/Windows/Linux/macOS/BSD等平台二进制文件
与Python相比,Go在性能上具有数量级优势:Go的JSON解析速度是Python的15倍,HTTP请求处理吞吐量高出20倍;与Java相比,Go启动时间快10倍(毫秒级),内存占用降低60%;与Rust相比,Go学习曲线更平缓,工程化能力更强,适合快速迭代业务系统。
Go语言的应用场景高度聚焦于:高并发后端服务、云原生基础设施、分布式系统、命令行工具。例如,Docker使用Go构建容器运行时,Kubernetes通过Go实现集群调度器,etcd采用Go开发分布式键值存储。这些项目均要求高可靠性、高并发处理能力与快速迭代能力,Go语言成为最佳选择。
值得注意的是,Go语言并非万能。它不擅长图形界面开发(无成熟GUI框架)、实时系统(GC不可预测)、嵌入式开发(二进制体积偏大)、数学计算(无BLAS库)。对于这些场景,建议使用C++、Rust或Python。但在Web后端、微服务、DevOps工具链等领域,Go语言已形成绝对优势。
学习go语言入门教程pdf时,应重点关注Go语言的“取舍哲学”——它主动舍弃了部分语言特性(如泛型、异常、继承),换取了简洁性与一致性。理解这些取舍,是掌握Go语言思维的关键。例如,Go不支持异常(exception),而是通过返回error值显式处理错误,这虽增加代码量,却避免了隐藏的错误传播路径,提升系统可维护性。
开发环境搭建|go语言入门教程pdf必备基础
安装Go语言开发环境是学习的第一步。本节提供Windows、Linux、macOS三大平台的详细安装指南,涵盖官方安装包、包管理器安装及环境变量配置,确保所有读者可顺利搭建本地开发环境。
Windows平台安装
1. 访问Go官网 https://go.dev/dl/ 下载最新版安装包(.msi格式)
2. 运行安装程序,默认路径为 C:\Go
3. 验证安装:打开命令提示符,输入 go version,应显示 go version go1.22.x windows/amd64
4. 配置环境变量:
- 新建系统变量 GOPATH = %USERPROFILE%\go(工作区路径)
- 将 %GOPATH%\bin 添加到 PATH 变量
- 新建 GOROOT = C:\Go(Go安装目录)
5. 创建工作目录:mkdir %USERPROFILE%\go\src\hello
Linux平台安装(以Ubuntu为例)
1. 卸载旧版本(如有):
sudo apt remove golang-go
2. 下载官方二进制包:
wget https://go.dev/dl/go1.22.5.linux-amd64.tar.gz
3. 解压到 /usr/local:
sudo rm -rf /usr/local/go && sudo tar -C /usr/local -xzf go1.22.5.linux-amd64.tar.gz
4. 配置PATH:
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc
5. 验证安装:go version 应输出 go version go1.22.5 linux/amd64
macOS平台安装
推荐使用Homebrew安装:
brew install go
或下载.pkg安装包:
https://go.dev/dl/go1.22.5.darwin-amd64.pkg
验证:go version
Go开发环境配置要点
- GOROOT:Go安装目录,如 /usr/local/go,不可包含中文或空格
- GOPATH:工作区路径,推荐为 ~/go,结构为:
├── src(源码)
├── pkg(编译中间文件)
└── bin(可执行文件) - Go 1.11+ 支持Go Modules,可不依赖GOPATH,推荐启用:
export GO111MODULE=on - 配置国内镜像加速(尤其中国大陆用户):
go env -w GOPROXY=https://goproxy.cn,direct
开发工具推荐:GoLand(JetBrains出品,付费但功能全面)、VS Code(免费,配合Go插件体验优秀)、Vim/Neovim(轻量级,适合终端用户)。VS Code安装Go插件后,可获得代码补全、格式化、测试、调试等完整功能,是初学者首选。
创建第一个Go程序:
在工作区创建文件 hello.go:
package main
import "fmt"
func main() {
fmt.Println("Hello, Go!")
}
运行:go run hello.go
编译:go build hello.go → 生成 hello 可执行文件
常见问题:
- 错误:'go' 不是内部或外部命令
原因:PATH未包含Go安装路径
解决:重启终端或手动添加PATH
- 错误:cannot find package
原因:GOPATH未正确设置或包路径错误
解决:检查src目录结构与包声明是否一致
- 错误:permission denied
原因:Windows下未以管理员权限运行安装程序
解决:右键安装程序→以管理员身份运行
基础语法|go语言入门教程pdf核心知识
Go语言语法简洁,保留了C系语言的风格,但做了大量精简。本节系统梳理变量声明、流程控制、函数、结构体、接口等核心语法,所有示例均经过编译验证。
变量与常量
Go支持多种变量声明方式:
var name string = "Go" // 显式类型
var age = 15 // 类型推导
name := "Go" // 短变量声明(仅限函数内)
const PI = 3.14159 // 常量
注意:短变量声明(:=)要求至少声明一个新变量,且右侧表达式需有确定类型。
流程控制
Go的if语句支持初始化语句:
if err := doSomething(); err != nil {
log.Fatal(err)
}
switch无需break,自动中断;支持类型switch与初始化语句。
for循环是唯一循环语句,支持三种形式:
for i := 0; i < 10; i++ {} // 传统循环
for i < 10 { i++ } // while循环
for { ... } // 无限循环
Go语言基础数据类型
- 布尔型:bool(true/false)
- 整数型:int8/16/32/64、uint8/16/32/64、byte(uint8别名)、rune(int32别名)
- 浮点型:float32/64
- 复数型:complex64/128
- 字符串:string(UTF-8编码,不可变)
- 派生类型:数组、切片(slice)、映射(map)、结构体(struct)、指针(pointer)、函数(function)、接口(interface)
注意:Go不支持隐式类型转换,所有转换必须显式声明,例如:
var a int = 10
var b float64 = float64(a)
函数定义与特性
函数声明格式:func 函数名(参数列表)(返回值列表) { ... }
示例:
func add(a, b int) int { return a + b }
func swap(x, y string) (string, string) { return y, x }
支持多返回值:
func divide(a, b float64) (float64, error) {
if b == 0 { return 0, errors.New("division by zero") }
return a / b, nil
}
可变参数函数:
func sum(nums ...int) int { ... }
闭包支持:
func makeAdder() func(int) int {
return func(x int) int { return x + 10 }
}
结构体与方法
结构体定义:
type Person struct {
Name string
Age int
}
实例化:
p := Person{Name: "Alice", Age: 30}
p2 := Person{"Bob", 25}
方法定义(接收者):
func (p Person) Introduce() string {
return fmt.Sprintf("Hi, I'm %s, %d years old", p.Name, p.Age)
}
指针接收者修改原值:
func (p *Person) Birthday() { p.Age++ }
嵌入结构体实现组合:
type Employee struct {
Person // 嵌入
Salary float64
}
接口与多态
接口定义行为契约:
type Speaker interface {
Speak() string
}
任何类型只要实现Speak() string方法,即隐式实现接口,无需显式声明。
示例:
type Dog struct{}
func (d Dog) Speak() string { return "Woof!" }
func MakeSpeak(s Speaker) {
fmt.Println(s.Speak())
}
MakeSpeak(Dog{}) → 输出 "Woof!"
空接口 interface{} 可接收任意类型,常用于泛型场景(Go 1.18前),如map[string]interface{}。
并发编程|go语言入门教程pdf核心优势
Go语言的并发模型基于CSP(通信顺序进程),通过goroutine与channel实现安全高效的并发。本节深入解析并发核心机制,帮助开发者避免常见陷阱。
Goroutine基础
启动goroutine只需在函数调用前加go关键字:
go process() // 异步执行
注意:主函数退出时,所有goroutine强制终止,需用sync.WaitGroup等待:
var wg sync.WaitGroup
wg.Add(1)
go func() {
defer wg.Done()
// ...
}()
wg.Wait()
Channel通信
channel是goroutine间通信的管道:
ch := make(chan int) // 无缓冲channel
ch := make(chan int, 10) // 有缓冲channel
发送:
ch <- 42
接收:
v := <-ch
关闭channel:
close(ch)
range遍历channel:
for v := range ch { ... }
select多路复用:
select {
case v := <-ch1:
fmt.Println("ch1:", v)
case v := <-ch2:
fmt.Println("ch2:", v)
case <-time.After(time.Second):
fmt.Println("timeout")
}
并发模式实战
- 生产者-消费者模型:
func producer(ch chan<- int) {
for i := 0; i < 100; i++ { ch <- i }
close(ch)
}
func consumer(ch <-chan int, wg *sync.WaitGroup) {
defer wg.Done()
for v := range ch { fmt.Println("消费:", v) }
}
func main() {
ch := make(chan int)
var wg sync.WaitGroup
go producer(ch)
wg.Add(1)
go consumer(ch, &wg)
wg.Wait()
} - 限流器(令牌桶):
type Limiter struct {
ch chan struct{}
}
func NewLimiter(n int) *Limiter {
return &Limiter{ch: make(chan struct{}, n)}
}
func (l *Limiter) Acquire() { l.ch <- struct{}{} }
func (l *Limiter) Release() { <-l.ch }
func (l *Limiter) Do(fn func()) {
l.Acquire()
defer l.Release()
fn()
} - 工作池(Worker Pool):
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Printf("worker %d processing job %d\n", id, j)
results <- j * 2
}
}
func main() {
jobs := make(chan int, 100)
results := make(chan int, 100)
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 9; j++ { jobs <- j }
close(jobs)
for a := 1; a <= 9; a++ {
<-results
}
}
同步原语
Go标准库提供多种同步工具:
- sync.Mutex:互斥锁
- sync.RWMutex:读写锁
- sync.WaitGroup:等待一组goroutine完成
- sync.Once:确保函数仅执行一次
- sync.Map:并发安全的map
示例:sync.Once实现单例模式
var instance *Singleton
var once sync.Once
func GetInstance() *Singleton {
once.Do(func() {
instance = &Singleton{}
})
return instance
}
并发编程注意事项:
1. 避免共享内存,优先使用channel通信
2. channel关闭后不可再发送,否则panic
3. select中default子句可实现非阻塞操作
4. goroutine泄漏:未被接收的channel会导致goroutine挂起
5. pprof性能分析:go tool pprof 分析CPU与内存瓶颈
Web开发|go语言入门教程pdf实战应用
Go标准库net/http提供生产级Web服务器,配合第三方框架可快速构建RESTful API与Web应用。本节以gin框架为例,展示完整开发流程。
原生HTTP服务器
package main
import (
"fmt"
"net/http"
)
func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}
访问 http://localhost:8080/world → 输出 "Hello, world!"
使用gin框架
安装:
go get -u github.com/gin-gonic/gin
示例:
package main
import "github.com/gin-gonic/gin"
func main() {
r := gin.Default()
r.GET("/user/:name", func(c *gin.Context) {
name := c.Param("name")
c.JSON(200, gin.H{"message": "Hello " + name})
})
r.POST("/user", func(c *gin.Context) {
var input struct {
Name string `json:"name"`
Age int `json:"age"`
}
if err := c.BindJSON(&input); err != nil {
c.JSON(400, gin.H{"error": err.Error()})
return
}
c.JSON(201, gin.H{"created": true, "user": input})
})
r.Run(":8080")
}
中间件与认证
- 日志中间件:
func Logger() gin.HandlerFunc {
return func(c *gin.Context) {
start := time.Now()
c.Next()
latency := time.Since(start)
log.Printf("%s %s %s", c.Request.Method, c.Request.Path, latency)
}
}
r.Use(Logger()) - JWT认证中间件:
func JWTAuth() gin.HandlerFunc {
return func(c *gin.Context) {
token := c.GetHeader("Authorization")
if token == "" {
c.AbortWithStatusJSON(401, gin.H{"error": "missing token"})
return
}
// 验证token逻辑
c.Next()
}
}
r.Use(JWTAuth())
数据库操作
使用database/sql包连接MySQL:
package main
import (
"database/sql"
"fmt"
_ "github.com/go-sql-driver/mysql"
)
func main() {
db, err := sql.Open("mysql", "user:password@/dbname")
if err != nil { panic(err) }
defer db.Close()
// 查询
rows, err := db.Query("SELECT id, name FROM users")
if err != nil { panic(err) }
defer rows.Close()
for rows.Next() {
var id int
var name string
rows.Scan(&id, &name)
fmt.Println(id, name)
}
// 插入
result, err := db.Exec("INSERT INTO users(name) VALUES(?)", "Alice")
if err != nil { panic(err) }
lastId, _ := result.LastInsertId()
fmt.Println("Inserted ID:", lastId)
}
ORM框架推荐:
- GORM:最流行,支持链式操作、自动迁移、预加载
- XORM:功能全面,支持事务与缓存
- sqlx:database/sql的扩展,支持struct映射
RESTful API设计要点:
1. 资源路径用名词复数(/users而非/user)
2. HTTP方法对应操作(GET查/POST增/PUT改/DELETE删)
3. 返回统一格式(data/error/meta)
4. 支持分页(page/limit)、排序(sort)、过滤(filter)
5. 使用HTTP状态码(200/201/400/404/500)
网络编程|go语言入门教程pdf底层能力
Go标准库net包提供完整的网络编程接口,支持TCP、UDP、HTTP、WebSocket等协议。本节展示网络编程核心用法。
TCP服务器与客户端
TCP服务器:
listener, err := net.Listen("tcp", ":8080")
if err != nil { panic(err) }
defer listener.Close()
for {
conn, err := listener.Accept()
if err != nil { continue }
go handleConnection(conn)
}
func handleConnection(conn net.Conn) {
defer conn.Close()
buf := make([]byte, 1024)
for {
n, err := conn.Read(buf)
if err != nil { return }
conn.Write(buf[:n])
}
}
UDP通信
发送端:
conn, _ := net.ListenPacket("udp", ":0")
defer conn.Close()
addr, _ := net.ResolveUDPAddr("udp", "localhost:8080")
conn.WriteTo([]byte("Hello"), addr)
接收端:
conn, _ := net.ListenPacket("udp", ":8080")
defer conn.Close()
buf := make([]byte, 1024)
n, addr, _ := conn.ReadFrom(buf)
fmt.Printf("Received from %v: %s\n", addr, buf[:n])
WebSocket实时通信
安装:
go get -u github.com/gorilla/websocket
服务器示例:
package main
import (
"fmt"
"log"
"net/http"
"github.com/gorilla/websocket"
)
var upgrader = websocket.Upgrader{
CheckOrigin: func(r *http.Request) bool { return true },
}
func websocketHandler(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil { log.Println(err); return }
defer conn.Close()
for {
mt, msg, err := conn.ReadMessage()
if err != nil { break }
fmt.Printf("Received: %s\n", msg)
conn.WriteMessage(mt, msg)
}
}
func main() {
http.HandleFunc("/ws", websocketHandler)
http.ListenAndServe(":8080", nil)
}
实战项目|go语言入门教程pdf综合应用
本节展示一个完整项目:简易博客系统,涵盖用户注册/登录、文章CRUD、Markdown渲染、评论功能。所有代码结构符合工程化规范。
项目结构
blog/
├── cmd/
│ └── main.go
├── internal/
│ ├── config/
│ │ └── config.go
│ ├── handler/
│ │ ├── user.go
│ │ └── post.go
│ ├── model/
│ │ ├── user.go
│ │ └── post.go
│ └── service/
│ ├── user.go
│ └── post.go
├── pkg/
│ ├── db/
│ │ └── db.go
│ └── util/
│ └── jwt.go
└── go.mod
核心代码示例
pkg/db/db.go:
package db
import (
"database/sql"
"log"
_ "github.com/go-sql-driver/mysql"
)
var DB *sql.DB
func Init() {
var err error
DB, err = sql.Open("mysql", "root:password@/blog?charset=utf8mb4")
if err != nil { log.Fatal(err) }
if err = DB.Ping(); err != nil { log.Fatal(err) }
}
internal/model/user.go:
package model
type User struct {
ID int `json:"id"`
Username string `json:"username"`
Password string `json:"-"`
Created string `json:"created"`
}
internal/handler/user.go:
package handler
import (
"encoding/json"
"net/http"
"blog/internal/model"
"blog/internal/service"
)
func Register(w http.ResponseWriter, r *http.Request) {
var u model.User
if err := json.NewDecoder(r.Body).Decode(&u); err != nil {
http.Error(w, "invalid json", http.StatusBadRequest)
return
}
if err := service.Register(&u); err != nil {
http.Error(w, err.Error(), http.StatusBadRequest)
return
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[string]string{"message": "registered"})
}
工程化实践
1. 模块化管理:
go mod init blog
2. 单元测试:
internal/service/user_test.go:
func TestRegister(t *testing.T) {
u := &model.User{Username: "test", Password: "123456"}
if err := Register(u); err != nil {
t.Errorf("register failed: %v", err)
}
if u.ID == 0 {
t.Error("ID should not be zero")
}
}
运行:go test ./internal/service
3. 性能优化:
- 使用sync.Pool减少GC压力
- 连接池复用数据库连接
- HTTP/2启用
- gzip压缩响应
4. 日志与监控:
- 使用zap记录结构化日志
- 集成Prometheus监控指标
- 配置APM(如Jaeger)追踪请求链路
学习资源|go语言入门教程pdf延伸资料
官方资源
- Go官网:https://go.dev/
- Go文档:https://pkg.go.dev/
- Go博客:https://blog.golang.org/
- Go指南:https://tour.golang.org/
推荐书籍
- 《The Go Programming Language》(Go语言圣经)——最权威的系统教程
- 《Go语言高级编程》——深入讲解CGO、反射、unsafe等高级主题
- 《Go语言并发之道》——详解并发模型与最佳实践
- 《Go语言实战》——工程化视角的实战指南
在线课程
- Udemy:Go: The Complete Developer's Guide (Golang)
- YouTube:编程不良人、程序员鱼皮
- 极客时间:《Go语言开发实战30讲》
开源项目
- gin:https://github.com/gin-gonic/gin
- gorm:https://github.com/go-gorm/gorm
- echo:https://github.com/labstack/echo
- cobra:https://github.com/spf13/cobra
建议学习路径:
1. 入门:阅读《Go语言圣经》前5章 + Go官方指南
2. 基础:完成10个小型项目(爬虫、CLI工具、Web服务)
3. 进阶:阅读gin源码 + 实现自己的ORM
4. 高级:贡献开源项目 + 深入GC与调度器原理
常见问题|go语言入门教程pdf高频解答
环境与安装
Q:Go安装后运行go命令无反应?
A:检查PATH是否包含Go安装目录(如C:\Go\bin),或运行go env查看环境变量。
Q:Go模块下载失败怎么办?
A:配置国内镜像:
go env -w GOPROXY=https://goproxy.cn,direct
或设置代理:
export GOPROXY=https://goproxy.cn,direct
Q:如何升级Go版本?
A:下载新版本安装包覆盖安装,或使用gvm(Go版本管理器):
bash <(curl -s https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
语法与设计
Q:Go为什么不支持异常(try/catch)?
A:Go认为异常会隐藏错误传播路径,增加系统复杂性。通过显式error返回值,开发者必须处理每个错误,提升代码健壮性。
Q:为什么Go没有构造函数?
A:Go推崇“简单即美”,初始化通过普通函数完成,如NewUser() *User,更符合工程实践。
Q:slice与array有何区别?
A:array长度固定(类型包含长度,如[3]int),slice是动态数组(引用类型),底层为结构体{ptr, len, cap}。日常开发优先使用slice。
Q:map是线程安全的吗?
A:不是!并发读写map会panic。使用sync.Map或加锁保护。
开发与调试
Q:如何调试Go程序?
A:使用dlv(Delve调试器):
go install github.com/go-delve/delve/cmd/dlv@latest
dlv debug
(dlv) break main.main
(dlv) continue
(dlv) next
Q:如何分析性能瓶颈?
A:使用pprof:
import _ "net/http/pprof"
go func() { log.Println(http.ListenAndServe("localhost:6060", nil)) }()
运行程序后:
go tool pprof http://localhost:6060/debug/pprof/heap
(pprof) top10
Q:如何生成可执行文件?
A:go build -o myapp main.go
跨平台编译:
GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go