### init 函数

Go 中的 `init()` 函数是**特殊的初始化函数**，用于包级别的初始化操作，它的执行时机有严格的规则，是 Go 程序启动流程中固定的一环。在当前包被导入 / 程序启动时，`init()` 函数会在 `main` 函数执行之前，自动被 Go 运行时调用执行，无需手动调用。

#### 执行顺序（优先级从高到低）

Go 程序的初始化执行流程是固定的：

**1、单个文件/包内规则**

-   一个**源文件**中可以写**多个 `init()` 函数**，按代码顺序**从上到下**的顺序执行
-   一个**包**下有多个文件，每个文件的 `init()` 都会执行，执行顺序由编译器的文件编译顺序决定
-   `init()` 函数**无参数、无返回值**，不能被手动调用

**2、多个文件**

-   如果程序导入了多个包，且不相互依赖，按照import顺序执行
-   不同package且相互依赖，最后被依赖的最先被执行

示例：`main` 包导入 `pkgA`，`pkgA` 导入 `pkgB`，执行顺序从最底层的`pkgB`开始执行

### Go语言执行顺序

#### 一、全局顺序

**1、初始化被依赖的包**（递归执行，深度优先）

**2、初始化当前包**（包级别 **常量**，包级别 **变量**（按声明顺序），执行包内的 `init()` 函数）

3、最后执行主文件中的main()函数

#### 二、单个 Go 文件内部执行顺序（最常用）

同一个 `.go` 文件里，执行顺序严格如下：

**1、import 导入（只触发依赖包初始化）**

**2、包级常量初始化**

**3、包级变量初始化**

**4、文件内的 init 函数（从上往下）**

**5、main 函数（如果是 main 包）**

#### 三、总结中的关键点

**1、init 函数自动执行，不能手动调用**

**2、一个文件可以写多个 init，按从上到下执行**

**3、一个包无论被导入多少次，init 只执行一次**

**4、初始化顺序：常量 → 变量 → init → main**

**5、多包依赖：深度优先，被依赖包先初始化**

### 项目根目录

在GO语言开发中，在 go run、编译二进制、docker、不同工作目录、不同系统下，是 5 个不同的路径，所以读取项目路径显得尤为重要：

#### `os.Executable`

是**最稳定、最推荐**的方法，不管是 `go run` 还是运行编译后的二进制文件，都能拿到正确路径。

```go
package main

import (
  "fmt"
  "os"
  "path/filepath"
)

// GetProjectRoot 获取项目根目录
func GetProjectRoot() (string, error) {
  // 获取当前可执行文件的绝对路径
  exePath, err := os.Executable()
  if err != nil {
    return "", err
  }

  // 获取可执行文件所在目录
  exeDir := filepath.Dir(exePath)

  // 如果是 go run 模式，exe 在临时目录，需要向上找 go.mod
  if isGoRun() {
    return findGoModDir(exeDir)
  }
  return exeDir, nil
}

// 判断是否是 go run 运行
func isGoRun() bool {
  return filepath.Base(os.Args[0]) == "go" ||
    filepath.Base(os.Args[0]) == "go.exe" ||
    filepath.HasPrefix(os.Args[0], os.TempDir())
}

// 向上查找 go.mod 所在目录 = 项目根目录
func findGoModDir(startDir string) (string, error) {
  dir := startDir
  for {
    modPath := filepath.Join(dir, "go.mod")
    if _, err := os.Stat(modPath); err == nil {
      return dir, nil
    }

    parent := filepath.Dir(dir)
    // 已经到根目录还没找到，退出
    if parent == dir {
      break
    }
    dir = parent
  }

  return "", fmt.Errorf("未找到 go.mod，不是 Go 项目")
}

func main() {
  root, err := GetProjectRoot()
  if err != nil {
    panic(err)
  }
  fmt.Println("项目根目录：", root)
}
```

#### `slices` 包

Go 1.21 提供了 `slices` 包，也可以用更简洁的方式获取

```go
package main

import (
  "log"
  "os"
  "path/filepath"

  "golang.org/x/tools/go/packages"
)

func main() {
  cfg := &packages.Config{Mode: packages.NeedModule}
  pkgs, err := packages.Load(cfg, ".")
  if err != nil {
    log.Fatal(err)
  }

  root := pkgs[0].Module.Dir
  log.Println("项目根目录：", root)
}
```

#### 环境变量

-   通过GOPATH或者自定义项目根路径的环境变量
-   利用系统自带的环境变量和路径

### 输出打印

Go 语言通过标准库 **`fmt` 包** 实现格式化输出，核心函数是 `fmt.Print()`、`fmt.Println()`、`fmt.Printf()`，其中 **`fmt.Printf()`** 支持最灵活的格式化输出，是开发中最常用的。

| 函数                         | 作用    | 特点                   |
| -------------------------- | ----- | -------------------- |
| `fmt.Print(a...)`          | 普通输出  | 不换行，多个参数直接拼接         |
| `fmt.Println(a...)`        | 换行输出  | 自动换行，参数间加空格          |
| `fmt.Printf(format, a...)` | 格式化输出 | 按指定**占位符**格式输出，不自动换行 |

占位符以 `%` 开头，后跟类型标识，是 `fmt.Printf` 的核心。

| 占位符   | 作用                |
| ----- | ----------------- |
| `%v`  | 默认格式输出（最常用）       |
| `%+v` | 输出结构体时，**显示字段名**  |
| `%#v` | 输出 Go 语法格式的值（调试用） |
| `%T`  | 输出**值的类型**        |

代码示例：

```go
type User struct {Name string}
u := User{Name: "stark张宇"}

fmt.Printf("%v\n", u)   // {stark张宇}
fmt.Printf("%+v\n", u)  // {Name:stark张宇}
fmt.Printf("%T\n", u)   // main.User
fmt.Printf("%%\n")      // %
```

打印 布尔 / 字符串 / 指针占位符/十进制整数

| 占位符   | 作用                   |
| ----- | -------------------- |
| `%t`  | 输出布尔值：`true`/`false` |
| `%s`  | 输出字符串 / 字节切片         |
| `%q`  | 输出带**双引号**的字符串       |
| `%p`  | 输出指针地址（十六进制）         |
| `%d`  | 10 进制整数              |
| `%#v` | 打印 map               |

```go
str := "hello"
fmt.Printf("%s\n", str)  // hello
fmt.Printf("%q\n", str)  // "hello"
fmt.Printf("%p\n", &str) // 0x14000010200
fmt.Printf("map = %#v\n", m) //
fmt.Printf("执行到：%s:%d\n", __FILE__, __LINE__)
fmt.Printf("a=%v, b=%v, c=%v\n", a, b, c)
```

### 数组Array、切片Slice

它们的共同点是都属于集合类的类型，并且，它们的值也都可以用来存储某一种类型的值（或者说元素）。它们最重要的不同是：**数组类型的值的长度是固定的，而切片类型的值是可变长的。**

切片的类型字面量中只有元素的类型，而没有长度，切片的长度可以自动地随着其中元素数量的增长而增长，但不会随着元素数量的减少而减小。

**数组和切片的关系：** 可以把切片看做是对数组的一层简单的封装，因为在每个切片的底层数据结构中，一定会包含一个数组。数组可以被叫做切片的底层数组，而切片也可以被看作是对数组的某个连续片段的引用。

#### 切片的长度和容量

```go
s1 := make([]int, 5)
fmt.Printf("S1 length : %d , capacity %d ,value  %d \n ", len(s1), cap(s1), s1)
s2 := make([]int, 5, 8)
fmt.Printf("S2 length : %d , capacity %d ,value  %d \n ", len(s2), cap(s2), s2)
```

用`make`函数初始化切片时，如果不指明其容量，那么它就会和长度一致。如果在初始化时指明了容量，那么切片的实际容量也就是它了。这也正是`s2`的容量是`8`的原因。

通过调用内建函数`len`，得到数组和切片的长度，通过调用内建函数`cap`，我们可以得到它们的容量，但要注意，数组的容量永远等于其长度，都是不可变的。

Go语言 1.18+ 后 ，当执行 `append` 时，**新长度 len(s)+n > 当前容量 cap(s)** ，采用 **分段式扩容 + 内存对齐**，核心是 **小切片翻倍、大切片 1.25 倍渐进增长**。

**规则：小切片（<256）：2 倍扩容，大切片（≥256）：~1.25 倍渐进增长**，这里的256有一个常见的误区，256 就是纯数字 `256`，没有任何单位（不是 KB、不是 MB），是**元素个数**，cap的切片元素容量。

```go
// 1. 容量 cap = 100 < 256 → 小切片
s1 := make([]int, 0, 100) 

// 2. 容量 cap = 300 > 256 → 大切片
s2 := make([]int, 0, 300) 
```

一个切片的底层数组永远不会被替换，当切片在扩容的时候 Go 语言一定会生成新的底层数组，但是它也同时生成了新的切片。需要注意的是在无需扩容时，`append`函数返回的是指向原底层数组的新切片，而在需要扩容时，`append`函数返回的是指向新底层数组的新切片。

只要新长度不会超过切片的原容量，那么使用`append`函数对其追加元素的时候就不会引起扩容，这只会使紧邻切片窗口右边的（底层数组中的）元素被新的元素替换掉。

#### 扩容时底层内存变化

当切片发生扩容时，判断容量不够，Go 会**申请一块新的、更大的连续内存空间**生成新底层数组，把旧数组里的所有元素复制到新数组，把新追加的元素也放进去，切片内部的指针从旧数组地址切换到新数组，旧数组只要还有引用，旧数组就会一直占内存，如果没有任何变量、切片再引用旧数组，Go 垃圾回收（GC）会在**未来某个时间自动回收**

### 字典 Map

Map这个词的本意在数学里指的是键值对的映射集合体，Go 语言的字典类型其实是一个哈希表（hash table）的特定实现，哈希表会先用哈希函数（hash function）把键值转换为哈希值。哈希值通常是一个无符号的整数，一个哈希表会持有一定数量的桶（bucket），元素就存在哈希桶中。

每个哈希桶都会把自己包含的所有键的哈希值存起来，Go 语言会用被查找键的哈希值与这些哈希值逐个对比，看看是否有相等的，如果一个相等的都没有，那么就说明这个桶中没有要查找的键值，这时 Go 语言就会立刻返回结果了。

因为上述所说字典中键的查找原理，就要求键类型的值必须要支持判等操作，要求**键类型不可以是函数类型、字典类型和切片类型，而元素却可以是任意类型的，** 否则在程序运行过程中会引发 panic。

```go
var userAge map[string]int{
  "张三": 20,
  "李四": 25,
  "王五": 22,
}

for name, age := range userAge {
  fmt.Printf("姓名：%s，年龄：%d\n", name, age)
}
```

因为每个map的键都要进行哈希值的计算和查找，所以宽度越小的类型速度通常越快，类型的宽度是指它的单个值需要占用的字节数。比如，`bool`、`int8`和`uint8`类型的一个值需要占用的字节数都是`1`，因此这些类型的宽度就都是`1`。

Go 中的 init() 函数是特殊的初始化函数，用于包级别的初始化操作，它的执行时机有严格的规则，是 Go 程序启动流程中固定的一环。在当前包被导入 / 程序启动时，init() 函数会在 main 函数执行之前，自动被 Go 运行时调用执行，无需手动调用。

Go语言必知的5个核心知识点：init、路径、输出、切片、Map

Go入门常被这5个知识点卡住：init函数的执行顺序、不同运行环境下获取项目根目录、fmt输出占位符区别、数组与切片的容量扩容机制、Map的键类型限制。本文用最简洁的代码示例，一次讲清这些基础但关键的Go语言特性，适合新手收藏反复查阅。

Go开发工程师

后端

编程语言

Go语言init函数详解：自动执行的初始化函数，执行顺序遵循常量→变量→init→main的固定流程。支持多文件多init函数，按编译顺序执行。深度优先初始化依赖包，每个包的init仅执行一次。掌握init执行机制对理解Go程序启动流程至关重要。

哈希函数

数据结构

编译器

Docker

2026采购季 | AI焕新·智启新局

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Go语言必知的5个核心知识点：init、路径、输出、切片、Map-腾讯云开发者社区-腾讯云

Go语言必知的5个核心知识点：init、路径、输出、切片、Map

Go语言必知的5个核心知识点：init、路径、输出、切片、Map

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐