Go，也称为 Golang，是一种开源的编程语言，由 Google 开发。Go 是一种静态类型、编译型、并发型的语言，它被设计为一种简单、快速、可靠和高效的语言。Go 语言的语法类似于 C 语言，但也借鉴了其他语言的一些特性，如 Python 和 Java。

Go 语言的设计目标是提供一种简单、易于学习和使用的语言，同时具有高效的执行速度和并发处理能力。Go 语言的主要特点包括：

1. 并发支持：Go 语言内置了并发支持，可以轻松地编写高并发的程序，而不需要额外的库或框架。

2. 内存管理：Go 语言有自己的垃圾收集器，可以自动管理内存，避免内存泄漏和悬垂指针等问题。

3. 快速编译：Go 语言的编译速度非常快，可以在几秒钟内编译大部分代码。

4. 简单易学：Go 语言的语法简单，易于学习和使用，同时也提供了足够的功能和扩展性。

5. 跨平台支持：Go 语言可以在各种操作系统和硬件平台上运行，包括 Windows、Linux、macOS、Android、iOS 等。

6. 开源：Go 语言是一个开源项目，可以自由下载、使用和修改。

Go 语言被广泛应用于网络编程、云计算、大数据处理、系统编程、区块链等领域。许多知名公司和组织，如 Google、Uber、Docker、Kubernetes、Cloudflare 等都在使用 Go 语言开发自己的项目和服务。

Golang

VSCode 支持在保存文件时自动格式化代码，这对于在编写 Go 语言时保持代码整洁和一致性非常有帮助。要设置 VSCode 在保存时自动格式化 Golang 代码，请按照以下步骤操作：

1. **安装 Go 语言扩展**  
   在 VSCode 中，首先确保你已经安装了官方的 Go 语言扩展。这个扩展通常是由 Go Team at Google 提供的。你可以在 VSCode 的扩展市场中搜索 `Go` 并安装它。

2. **配置 `settings.json`**  
   接下来，你需要配置 VSCode 的 `settings.json` 文件来启用保存时自动格式化的功能。你可以通过以下两种方式访问该文件：

   - 使用快捷键 `Ctrl + ,` 打开设置，然后点击右上角的 `{}` 图标，进入 `settings.json` 文件编辑界面。
   - 或者通过菜单栏选择 `文件(File) > 首选项(Preferences) > 设置(Settings)`，然后同样点击右上角的 `{}` 图标。

   在 `settings.json` 文件中，添加或确保以下设置已经被包含：

   ```json
   "[go]": {
       "editor.formatOnSave": true,
       "editor.codeActionsOnSave": {
           "source.organizeImports": true
       }
   },
   "go.formatTool": "gofmt" // 或者你可以使用其他格式化工具，如 "goimports" 或 "goreturns"
   ```

   这里的设置做了几件事情：
   - 启用在保存 Go 文件时自动格式化代码。
   - 开启保存时自动整理导入的包。
   - 设置 `gofmt` 为默认的格式化工具，`gofmt` 是 Go 语言自带的工具，你也可以选择用 `goimports` 或 `goreturns` 替换。

3. **安装必要的工具**  
   如果是首次配置，VSCode 的 Go 扩展可能会提示你安装一些必要的 Go 工具，包括格式化工具如 `gofmt` 或者 `goimports`。你应该按照提示安装这些工具。通常只需点击弹出的提示框中的安装按钮即可。

4. **测试配置**  
   配置完成后，尝试编辑一个 Go 文件并保存，VSCode 应该会自动格式化代码。如果格式化没有执行，检查一下是否所有的工具都已正确安装，并且 `settings.json` 配置是否正确。

举个例子，假设我正在编写一个 Go 程序，并且在我保存文件时，我希望代码能够自动格式化，并且所有未使用的包导入能自动删除。我安装了 Go 扩展，并按照上述步骤配置了 `settings.json`。接着，我编写了一些未经格式化的代码，并且故意保留了一些未使用的导入。当我保存文件时，VSCode 自动对代码进行了格式化，移除了多余的空格和缩进，并删除了未使用的导入。这样的自动化流程大大提高了我的开发效率，并且保持了代码的整洁性。

VSCode 如何设置在保存时格式化 golang 代码？

在 Go 语言中，数组（Array）是一种固定长度的数据结构，因此你不能直接从数组中删除元素。然而，你可以使用切片（Slice）来模拟这个行为。切片是一种可变长度的数组抽象。

要从切片中删除特定位置的元素，你有几个选择：

1. **使用 append 和切片操作符**：你可以使用两次切片和 `append` 函数将要删除的元素之前和之后的元素连接起来。这个操作不会影响原始的数组，但原始的切片会因为 `append` 而改变。

    ```go
    package main
    
    import "fmt"
    
    func main() {
        // 初始切片
        a := []int{1, 2, 3, 4, 5}
        // 删除索引为 2 的元素（即元素 3）
        a = append(a[:2], a[3:]...)
        
        fmt.Println(a) // 输出：[1 2 4 5]
    }
    ```

    在这个例子中，`a[:2]` 创建了一个包含元素 `1` 和 `2` 的新切片，`a[3:]` 创建了一个包含元素 `4` 和 `5` 的新切片。`append` 函数将这两个切片连接起来，形成一个新的切片，其中不包含元素 `3`。

2. **使用 copy**：如果你想保持原始切片不变，可以使用 `copy` 函数。这种方法会将删除元素之后的元素向前复制一位。

    ```go
    package main
    
    import "fmt"
    
    func main() {
        a := []int{1, 2, 3, 4, 5}
        // 删除索引为 2 的元素
        copy(a[2:], a[3:])
        a = a[:len(a)-1] // 缩减切片的长度
        
        fmt.Println(a) // 输出：[1 2 4 5]
    }
    ```

    在这个例子中，`copy(a[2:], a[3:])` 将切片中索引为 `3` 和 `4` 的元素复制到索引为 `2` 和 `3` 的位置，然后通过缩减切片的长度来丢弃最后一个元素。

需要注意的是，这些操作对基础数组的影响取决于切片的容量和长度。在一些情况下，为避免修改原始数组，可能需要先复制切片。而且，对于大型数据集，这些操作可能会引起性能问题，因为它们涉及到复制许多元素。

在进行删除操作时，通常还需要考虑内存泄漏的问题，尤其是当切片中包含指针或者其他需要垃圾收集的数据结构时。在这种情况下，在进行删除操作后可能需要清除无用的引用：

```go
a := []int{1, 2, 3, 4, 5}
index := 2
copy(a[index:], a[index+1:])
a[len(a)-1] = 0 // 先清零或者设置为nil
a = a[:len(a)-1]

fmt.Println(a) // 输出：[1 2 4 5]
```

这个操作将 `a[index]` 之后的所有元素向前移动一位，并在移动后将最后一个元素设置为默认值（对于整数是 `0`，对于指针是 `nil`），以防止潜在的内存泄漏。然后，它会缩减切片的长度，从而移除了最后一个元素。

**订单事宜**

如果要保持数组有序，则必须将删除索引右侧的所有元素向左移动一位。希望这可以在 Golang 中轻松完成：

    func remove(slice []int, s int) []int {
        return append(slice[:s], slice[s+1:]...)
    }
    

然而，这是低效的，因为您最终可能会移动所有元素，而成本高昂。

**顺序并不重要**

如果您不关心顺序，则可以更快地将要删除的元素替换为切片末尾的元素，然后返回 n-1 个第一个元素：

    func remove(s []int, i int) []int {
        s[i] = s[len(s)-1]
        return s[:len(s)-1]
    }
    

使用重新切片方法，清空 1 000 000 个元素的数组需要 224 秒，而使用此方法只需 0.06 纳秒。

此答案不执行**边界检查**。它需要一个有效的索引作为输入。这意味着大于或等于初始值的负值或索引`len(s)`将导致 Go 恐慌。

切片和数组的索引为 0，删除数组的第 n 个元素意味着提供输入**n-1**。要删除第一个元素，请调用**remove(s, 0)**，要删除第二个元素，请调用**remove(s, 1)**，依此类推。

这看起来有点奇怪，但这里的大多数答案都是危险的，并且掩盖了他们实际在做什么。查看关于从切片中删除项目的原始问题，正在制作切片的副本，然后将其填充。这可以确保当切片在程序中传递时不会引入细微的错误。

下面是一些代码，比较用户在此线程中的答案和原始帖子。这是一个可以在其中乱搞此代码的[go 游乐场。](https://play.golang.org/p/mYaU_Oobzs2)

基于附加的删除
-------

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        return append(s[:index], s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeIndex := RemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
        fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]
    
        removeIndex[0] = 999
        fmt.Println("all: ", all) //[999 1 2 3 4 6 7 9 9]
        fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
    }
    

在上面的示例中，您可以看到我创建了一个切片并手动用数字 0 到 9 填充它。然后我们从所有切片中删除索引 5 并将其指定为删除索引。然而，当我们现在打印出所有内容时，我们发现它也已被修改。这是因为切片是指向底层数组的指针。将其写出也会`removeIndex`导致`all`被修改，区别在于，`all`有一个元素不再可以从 访问`removeIndex`。接下来我们更改一个值`removeIndex`，我们可以看到`all`它也被修改了。[《Effective go》](https://golang.org/doc/effective_go.html#slices)对此进行了更详细的介绍。

我不会详细介绍下面的示例，但它对我们的目的做了同样的事情。这只是说明使用副本没有什么不同。

    package main
    
    import (
        "fmt"
    )
    
    func RemoveCopy(slice []int, i int) []int {
        copy(slice[i:], slice[i+1:])
        return slice[:len(slice)-1]
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeCopy := RemoveCopy(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
        fmt.Println("removeCopy: ", removeCopy) //[0 1 2 3 4 6 7 8 9]
    
        removeCopy[0] = 999
        fmt.Println("all: ", all) //[99 1 2 3 4 6 7 9 9]
        fmt.Println("removeCopy: ", removeCopy) //[999 1 2 3 4 6 7 8 9]
    }
    

问题原答案
-----

查看原始问题，它不会修改从中删除项目的切片。对于大多数访问此页面的人来说，使该线程中的原始答案成为迄今为止最好的答案。

    package main
    
    import (
        "fmt"
    )
    
    func OriginalRemoveIndex(arr []int, pos int) []int {
        new_arr := make([]int, (len(arr) - 1))
        k := 0
        for i := 0; i < (len(arr) - 1); {
            if i != pos {
                new_arr[i] = arr[k]
                k++
            } else {
                k++
            }
            i++
        }
    
        return new_arr
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        originalRemove := OriginalRemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("originalRemove: ", originalRemove) //[0 1 2 3 4 6 7 8 9]
    
        originalRemove[0] = 999
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("originalRemove: ", originalRemove) //[999 1 2 3 4 6 7 8 9]
    }
    

正如您所看到的，此输出符合大多数人的预期，也可能是大多数人想要的。的修改`originalRemove`不会引起变化，`all`删除索引并分配索引的操作也不会引起变化！极好的！

这段代码有点长，所以上面的内容可以改为这样。

正确答案
----

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        ret := make([]int, 0)
        ret = append(ret, s[:index]...)
        return append(ret, s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        removeIndex := RemoveIndex(all, 5)
    
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]
    
        removeIndex[0] = 999
        fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
        fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
    }
    

与原始的删除索引解决方案几乎相同，但是我们在返回之前创建了一个新切片来附加。

从切片中删除一个元素（这称为“重新切片”）：

    package main
    
    import (
        "fmt"
    )
    
    func RemoveIndex(s []int, index int) []int {
        return append(s[:index], s[index+1:]...)
    }
    
    func main() {
        all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
        fmt.Println(all) //[0 1 2 3 4 5 6 7 8 9]
        all = RemoveIndex(all, 5)
        fmt.Println(all) //[0 1 2 3 4 6 7 8 9]
    }

[`Delete`](https://pkg.go.dev/golang.org/x/exp/slices#Delete)从包中使用`slices`（从 Go 1.21 开始稳定，在较旧的 Go 版本上您必须导入`golang.org/x/exp/slices`）：

    slice := []int{1, 2, 3, 4}
    slice = slices.Delete(slice, 1, 2)
    fmt.Println(slice) // [1 3 4]
    

[去游乐场示例](https://go.dev/play/p/Va9aqo2Qblo)

`slices.Delete(s, i, j)`从 s 中删除元素 s\[i:j\]

*   即从索引 i（包括索引 i）到索引 j（不包括索引 j）的元素
*   或者如果您还记得间隔的数学符号：**\[i,j)**

注意两件事：

*   `Delete`修改原始切片的内容
*   需要重新分配`slice`，否则长度会错误

小一点（代码高尔夫），但在顺序不重要的情况下，您不需要交换值。只需用最后一个位置的副本覆盖要删除的数组位置，然后返回截断的数组。

    func remove(s []int, i int) []int {
        s[i] = s[len(s)-1]
        return s[:len(s)-1]
    }
    

相同的结果。

Golang 如何从数组中删除元素？

Golang（通常称为Go）的编译速度之所以快，主要是归功于以下几个设计决策和特性：

1. **简化的依赖模型**：Go具有明确的依赖模型，每个文件都声明了它的直接依赖项。这种模型简化了依赖关系的管理，并且使得编译器能够快速确定哪些文件需要重新编译，哪些不需要。

2. **包模型**：Go的包模型也有助于加快编译速度。每个包被编译成一个单独的二进制文件，只有当包的源文件发生变化时才需要重新编译，而不是像一些其他语言那样需要重新编译整个项目。

3. **并发编译**：Go编译器被设计成能够利用现代多核处理器。它可以并发地编译不同的文件和包，最大化利用CPU资源，从而减少编译时间。

4. **简化的语言特性**：Go的设计哲学是简洁和清晰，避免了复杂的语言特性，例如类继承。这些简化的特性意味着编译器有更少的工作要做，因此编译过程可以更快完成。

5. **快速解析的语法**：Go的语法设计使得代码可以快速且一次性解析，减少了编译过程中的回溯。这使得语法分析阶段非常高效。

6. **直接生成机器代码**：Go编译器直接生成目标平台的机器代码，而不是像其他语言（如Java或C#）那样生成中间字节码。这样可以避免运行时解释或即时编译，提高编译效率。

7. **编译器优化**：Go编译器经过了优化，以便快速处理代码。这包括对语言特性进行了优化，使得编译器能够有效地生成代码。

举个例子，如果你在一个大型Go项目中只修改了一个小的包，Go编译器会识别出只有这个包及其依赖需要重新编译。由于它可以并发编译独立的包，并且每个包编译后都是独立的二进制文件，这意味着整个编译过程只需要很短的时间就可以完成。

因此，Go的快速编译是多种因素综合作用的结果，这些因素共同构成了Go语言快速且高效编译过程的基础。

依赖性分析。

Go [FAQ](http://golang.org/doc/go_faq.html)曾经包含以下句子：

> Go 提供了一个软件构建模型，使依赖性分析变得容易，并避免了 C 风格包含文件和库的大部分开销。

虽然该短语不再出现在常见问题解答中，但该主题在[Google 的 Go](https://talks.golang.org/2012/splash.article#TOC_5.)演讲中进行了详细阐述，该演讲比较了 C/C++ 和 Go 的依赖分析方法。

这是编译速度快的主要原因。这是设计使然。

我认为并不是Go编译器_快_，而是其他编译器_慢_。

C 和 C++ 编译器必须解析大量的标头 - 例如，编译 C++“hello world”需要编译 18k 行代码，这几乎是半兆字节的源代码！

    $ cpp hello.cpp | wc
      18364   40513  433334
    

Java 和 C# 编译器在 VM 中运行，这意味着在编译任何内容之前，操作系统必须加载整个 VM，然后必须将它们从字节码 JIT 编译为本机代码，所有这些都需要一些时间。

编译速度取决于几个因素。

有些语言被设计为可以快速编译。例如，Pascal 被设计为使用单遍编译器进行编译。

编译器本身也可以优化。例如，Turbo Pascal 编译器是用手工优化的汇编程序编写的，与语言设计相结合，产生了在 286 级硬件上运行的非常快的编译器。我认为即使是现在，现代 Pascal 编译器（例如 FreePascal）也比 Go 编译器更快。

Go 编译器比大多数 C/C++ 编译器快得多的原因有多种：

*   **主要原因**：大多数 C/C++ 编译器的设计都非常糟糕（从编译速度的角度来看）。此外，从编译速度的角度来看，C/C++ 生态系统的某些部分（例如程序员编写代码的编辑器）在设计时并未考虑编译速度。
    
*   **首要原因**：快速编译速度是 Go 编译器和 Go 语言的一个有意识的选择
    
*   Go 编译器比 C/C++ 编译器有更简单的优化器
    
*   与 C++ 不同，Go 没有模板，也没有内联函数。这意味着 Go 不需要执行任何模板或函数实例化。
    
*   Go 编译器会更快地生成低级汇编代码，优化器会处理汇编代码，而在典型的 C/C++ 编译器中，优化过程会处理原始源代码的内部表示。C/C++ 编译器中的额外开销来自需要生成内部表示的事实。
    
*   Go 程序的最终链接 (5l/6l/8l) 可能比链接 C/C++ 程序慢，因为 Go 编译器会遍历所有使用的汇编代码，并且可能还会执行 C/C++ 所不具备的其他额外操作链接器没有做
    
*   一些 C/C++ 编译器 (GCC) 以文本形式生成指令（将传递给汇编器），而 Go 编译器以二进制形式生成指令。需要完成额外的工作（但不多）才能将文本转换为二进制。
    
*   Go编译器仅针对少量CPU架构，而GCC编译器针对大量CPU
    
*   以高编译速度为目标的编译器（例如 Jikes）速度很快。在 2GHz CPU 上，Jikes 每秒可以编译 20000+ 行 Java 代码（增量编译模式效率更高）。

编译效率是一个主要设计目标：

> 最后，它的目的是要快速：在一台计算机上构建一个大型可执行文件最多需要几秒钟。为了实现这些目标，需要解决许多语言问题：富有表现力但轻量级的类型系统；并发和垃圾收集；严格的依赖规范；等等。[常问问题](http://golang.org/doc/faq)

关于与解析相关的特定语言功能，语言常见问题解答非常有趣：

> 其次，该语言被设计为易于分析，无需符号表即可解析。

虽然上面的大部分内容都是正确的，但有一个非常重要的点没有真正提到：依赖管理。

_Go 只需要包含您直接_导入的包（因为那些已经导入了_它们_需要的包）。这与 C/C++ 形成鲜明对比，C/C++ 中**每个文件**开始都包含 x 个标头，其中包括 y 标头等。底线：Go 的编译时间与导入包的数量呈线性关系，而 C/C++ 则需要指数时间。

Golang 的编译速度为什么这么快？

在Go语言中，可以使用标准库`net/http`来发送HTTP POST请求，并且可以用`encoding/json`库来处理JSON数据。以下是如何发送包含JSON字符串的POST请求的一个步骤示例：

1. **定义要发送的数据结构**：首先定义一个与需要发送的JSON数据对应的Go结构体。

```go
type MyData struct {
    Field1 string `json:"field1"`
    Field2 int    `json:"field2"`
}
```

2. **创建JSON字符串**：使用`json.Marshal`函数来将Go结构体转换成JSON字符串。

```go
data := MyData{
    Field1: "value1",
    Field2: 42,
}

jsonData, err := json.Marshal(data)
if err != nil {
    // 处理错误情况
    log.Fatalf("Error happened in JSON marshal. Err: %s", err)
}
```

3. **创建POST请求**：使用`http.NewRequest`函数来创建一个POST请求，并将JSON字符串作为请求体。

```go
url := "http://example.com/api/resource"
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
    // 处理错误情况
    log.Fatalf("Error occurred while creating HTTP request. Err: %s", err)
}
```

4. **添加请求头**：设置HTTP请求头`Content-Type`为`application/json`，这表明正在发送的数据类型是JSON。

```go
req.Header.Set("Content-Type", "application/json")
```

5. **发送请求并处理响应**：使用`http.Client`的`Do`方法发送请求，并处理服务器返回的响应。

```go
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
    // 处理错误情况
    log.Fatalf("Error occurred while sending the HTTP request. Err: %s", err)
}
defer resp.Body.Close()

// 检查服务器响应的HTTP状态码是否为200 OK
if resp.StatusCode == http.StatusOK {
    // 处理成功的情况，例如读取响应体
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
} else {
    // 处理服务器返回的错误
    log.Printf("Server responded with a non-200 status code: %d", resp.StatusCode)
}
```

上述代码展示了如何构建一个POST请求，其中包含JSON数据，并且发送该请求到服务器。在实际的编程实践中，通常还需要进行更多的错误检查和异常处理，以确保程序的健壮性。

我不熟悉`napping`，但是使用 Golang 的`net/http`包效果很好（[playground](http://play.golang.org/p/Qpob4Yu3wG)）：

    func main() {
        url := "http://restapi3.apiary.io/notes"
        fmt.Println("URL:>", url)
    
        var jsonStr = []byte(`{"title":"Buy cheese and bread for breakfast."}`)
        req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
        req.Header.Set("X-Custom-Header", "myvalue")
        req.Header.Set("Content-Type", "application/json")
    
        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            panic(err)
        }
        defer resp.Body.Close()
    
        fmt.Println("response Status:", resp.Status)
        fmt.Println("response Headers:", resp.Header)
        body, _ := io.ReadAll(resp.Body)
        fmt.Println("response Body:", string(body))
    }

你可以只使用`post`发布你的json。

    values := map[string]string{"username": username, "password": password}
    
    jsonValue, _ := json.Marshal(values)
    
    resp, err := http.Post(authAuthenticatorUrl, "application/json", bytes.NewBuffer(jsonValue))

如果你已经有一个结构体。

    import (
        "bytes"
        "encoding/json"
        "io"
        "net/http"
        "os"
    )
    
    // .....
    
    type Student struct {
        Name    string `json:"name"`
        Address string `json:"address"`
    }
    
    // .....
    
    body := &Student{
        Name:    "abc",
        Address: "xyz",
    }
    
    payloadBuf := new(bytes.Buffer)
    json.NewEncoder(payloadBuf).Encode(body)
    req, _ := http.NewRequest("POST", url, payloadBuf)
    
    client := &http.Client{}
    res, e := client.Do(req)
    if e != nil {
        return e
    }
    
    defer res.Body.Close()
    
    fmt.Println("response Status:", res.Status)
    // Print the body to the stdout
    io.Copy(os.Stdout, res.Body)
    

完整[要点](https://gist.github.com/ReeganExE/af2259bcdec3e8535bfaaa86a2c03e39)。

除了标准的 net/http 包之外，您还可以考虑使用我的[GoRequest](http://github.com/parnurzeal/gorequest)，它包装了 net/http，让您的生活更轻松，而无需过多考虑 json 或 struct。但您也可以在一个请求中混合搭配它们！（您可以在 gorequest github 页面中查看更多详细信息）

所以，最终你的代码将变成如下所示：

    func main() {
        url := "http://restapi3.apiary.io/notes"
        fmt.Println("URL:>", url)
        request := gorequest.New()
        titleList := []string{"title1", "title2", "title3"}
        for _, title := range titleList {
            resp, body, errs := request.Post(url).
                Set("X-Custom-Header", "myvalue").
                Send(`{"title":"` + title + `"}`).
                End()
            if errs != nil {
                fmt.Println(errs)
                os.Exit(1)
            }
            fmt.Println("response Status:", resp.Status)
            fmt.Println("response Headers:", resp.Header)
            fmt.Println("response Body:", body)
        }
    }
    

这取决于您想要如何实现。我创建这个库是因为我和你有同样的问题，我想要更短的代码，易于使用 json，并且在我的代码库和生产系统中更易于维护。

http 或 https 的 post 请求示例

        //Encode the data
           postBody, _ := json.Marshal(map[string]string{
              "name":  "Test",
              "email": "Test@Test.com",
           })
           responseBody := bytes.NewBuffer(postBody)
        //Leverage Go's HTTP Post function to make request
           resp, err := http.Post("https://postman-echo.com/post", "application/json", responseBody)
        //Handle Error
           if err != nil {
              log.Fatalf("An Error Occured %v", err)
           }
           defer resp.Body.Close()
        //Read the response body
           body, err := ioutil.ReadAll(resp.Body)
           if err != nil {
              log.Fatalln(err)
           }
           sb := string(body)
           log.Printf(sb)

Golang 如何在 post 请求中发送 json 字符串？

在 Golang 中，我们可以使用 `os` 标准库中的 `Executable` 函数来获取当前正在执行的可执行文件的完整路径，然后使用 `filepath` 标准库中的 `Dir` 函数来从完整路径中提取出目录。

下面是一个如何获取当前运行文件所在目录的示例代码：

```go
package main

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

func main() {
	// 获取当前执行的可执行文件的路径
	exePath, err := os.Executable()
	if err != nil {
		panic(err)
	}

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

	fmt.Println("当前运行文件的目录是:", exeDir)
}
```

在这个例子中，我们首先调用了 `os.Executable()` 函数来获取可执行文件的完整路径。如果调用成功，它会返回路径字符串和 `nil` 错误。如果有错误发生，我们通过 `panic` 终止程序。获取到可执行文件的完整路径后，我们使用 `filepath.Dir()` 函数来从中提取出文件所在的目录。

执行上面的程序，它将打印出当前运行的可执行文件所在的目录。这对于许多需要相对于可执行文件定位资源文件的应用程序非常有用，例如配置文件和模板。

编辑：从 Go 1.8（2017 年 2 月发布）开始，推荐的方法是[`os.Executable`](https://tip.golang.org/pkg/os/#Executable)：

> `func Executable() (string, error)`
> 
> 可执行文件返回启动当前进程的可执行文件的路径名。无法保证路径仍然指向正确的可执行文件。如果使用符号链接来启动进程，则结果可能是符号链接或其指向的路径，具体取决于操作系统。如果需要稳定的结果，path/filepath.EvalSymlinks 可能会有所帮助。

要仅获取可执行文件的目录，您可以使用[`path/filepath.Dir`](https://golang.org/pkg/path/filepath/#Dir).

[例子](https://play.golang.org/p/_aolLr7uEH)：

    package main
    
    import (
        "fmt"
        "os"
        "path/filepath"
    )
    
    func main() {
        ex, err := os.Executable()
        if err != nil {
            panic(err)
        }
        exPath := filepath.Dir(ex)
        fmt.Println(exPath)
    }
    

* * *

旧答案：

你应该能够使用[`os.Getwd`](http://golang.org/pkg/os/#Getwd)

    func Getwd() (pwd string, err error)
    

> Getwd 返回与当前目录相对应的根路径名。如果当前目录可以通过多个路径到达（由于符号链接），Getwd 可能会返回其中任何一个。

例如：

    package main
    
    import (
        "fmt"
        "os"
    )
    
    func main() {
        pwd, err := os.Getwd()
        if err != nil {
            fmt.Println(err)
            os.Exit(1)
        }
        fmt.Println(pwd)
    }

这应该可以做到：

    import (
        "fmt"
        "log"
        "os"
        "path/filepath"
    )
    
    func main() {
        dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
        if err != nil {
                log.Fatal(err)
        }
        fmt.Println(dir)
    }

使用[osext包](https://github.com/kardianos/osext)

它提供的函数`ExecutableFolder()`返回当前运行的程序可执行文件所在文件夹的绝对路径（对于 cron 作业很有用）。它是跨平台的。

[在线文档](http://godoc.org/github.com/kardianos/osext)

    package main
    
    import (
        "github.com/kardianos/osext"
        "fmt"
        "log"
    )
    
    func main() {
        folderPath, err := osext.ExecutableFolder()
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println(folderPath)
    }

我从 Node.js 转向 Go。相当于 Go 中的 Node.js`__dirname`是：

    _, filename, _, ok := runtime.Caller(0)
    if !ok {
        return errors.New("unable to get the current filename")
    }
    dirname := filepath.Dir(filename)
    

该线程中还提到了一些其他内容以及为什么它们是错误的：

*   `os.Executable()`将为您提供当前运行的可执行文件的文件路径。这相当于`process.argv[0]`在 Node.js 中。`__dirname`如果您想获取子包的 ，则情况并非如此。
*   `os.Getwd()`会给你当前的工作目录。这相当于`process.cwd()`在 Node.js 中。当您从另一个目录运行程序时，这将是错误的。

最后，我建议不要为此用例引入第三方包。这是您可以使用的包：

    package current
    
    // Filename is the __filename equivalent
    func Filename() (string, error) {
        _, filename, _, ok := runtime.Caller(1)
        if !ok {
            return "", errors.New("unable to get the current filename")
        }
        return filename, nil
    }
    
    
    // Dirname is the __dirname equivalent
    func Dirname() (string, error) {
        filename, err := Filename()
        if err != nil {
            return "", err
        }
        return filepath.Dir(filename), nil
    }
    

请注意，我已调整`runtime.Caller(1)`为 1，因为我们想要获取调用的包的目录`current.Dirname()`，而不是包含该包的目录`current`。

**更新 (12/23)**正如 @VonC[下面指出的](https://stackoverflow.com/a/72174376/145435)，当您运行`go build`并分发二进制文件时，`runtime.Caller(0)`, 将继续是_您的目录_。这可能不是您想要的。此行为与 不同`__dirname`，后者将反映文件所在位置的目录名。Go 中的这种行为没有完美的等价物。

如果你这样做：

    dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(dir)
    

当您使用 GoLand 等 IDE 运行程序时，您将获得 /tmp 路径，因为可执行文件将从 /tmp 保存并运行

我认为获取当前工作目录或“。”的最佳方法 是 ：

    import(
      "os" 
      "fmt"
      "log"
    )
    
    func main() {
      dir, err := os.Getwd()
        if err != nil {
            log.Fatal(err)
        }
      fmt.Println(dir)
    }
    

os.Getwd **()**函数将返回当前工作目录。

Golang 如何获取当前运行的文件的所在的目录？

在 Go 语言中，`=` 和 `:=` 是两种不同的运算符，它们用于变量的赋值，但各自的用途和上下文有所不同。

- `=` 是赋值运算符，它用于给已经声明的变量赋予新的值。在使用 `=` 之前，必须已经有一个变量的声明存在。例如：

```go
var x int
x = 1  // 将值 1 赋给已声明的变量 x
```
在这个例子中，`x` 首先被声明为 `int` 类型，然后我们用 `=` 将值 `1` 赋给 `x`。

- `:=` 是短变量声明运算符，它用于同时声明和初始化变量。如果在函数内部，你想声明一个新的局部变量并且立即给它赋值，你可以使用 `:=` 这样做。这样，就不需要显式地声明变量类型，因为 Go 会自动根据右侧表达式的类型来推断变量的类型。例如：

```go
x := 1  // 同时声明变量 x 并赋值为 1
```
在此例子中，我们没有显式地声明 `x` 是 `int` 类型；Go 自动推断出 `x` 的类型为 `int`，因为我们将一个整数 `1` 赋给了 `x`。

需要注意的是，`:=` 仅能用于函数内部，而 `=` 可以用于任何地方对变量进行赋值。此外，`:=` 不能用于已经声明过的变量，否则会引发编译错误。但是，如果在相同的作用域中，存在多个新的变量，并且只有其中一个是新的，则可以使用 `:=`，例如：

```go
var a int
a, b := 1, 2  // 这里 a 是之前声明的变量，而 b 是新声明的变量
```
在这个例子中，`a` 已经事先声明过了，而 `b` 是新声明的变量，所以可以使用 `:=` 运算符。

总结来说，`=` 是用于给已经存在的变量赋值的，而 `:=` 是用于声明新变量的同时给它赋值。

在Go中，`:=`是用于声明+赋值，而`=`是仅用于赋值。

例如，`var foo int = 10` 与 相同`foo := 10`。

总而言之：

*   声明一个变量，使用： `:=`。
*   更改变量的值，使用：`=`。

_有一些规则，但 TLDR 并不总是正确的。_

正如其他人已经解释的那样，`:=`既用于声明、赋值，也用于重新声明；它会自动猜测（_推断_）变量的类型。

**例如，`foo := 32`是以下形式的简写形式：**

    var foo int
    foo = 32
    
    // OR:
    var foo int = 32
    
    // OR:
    var foo = 32
    

* * *

__/_规则如下：_/__

**★ 第一条规则：**

您不能`:=`在 之外使用`funcs`。这是因为，在 func 之外，语句应该以关键字开头。

    // no keywords below, illegal.
    illegal := 42
    
    // `var` keyword makes this statement legal.
    var legal = 42
    
    func foo() {
      alsoLegal := 42
      // reason: it's in a func scope.
    }
    

* * *

**★ 第二条规则：**

您不能使用它们两次（_在同一范围内_）：

    legal := 42
    legal := 42 // <-- error
    

因为，`:=`引入了**“一个新变量”**，因此使用它两次不会重新声明第二个变量，所以它是非法的。

* * *

**★ 第三条规则：**

您可以将它们用于多变量声明和赋值：

    foo, bar   := 42, 314
    jazz, bazz := 22, 7
    

* * *

**★ 第四条规则（重新声明）：**

_如果其中一个变量是新的，您可以在_**“多变量”**声明中使用它们两次：

    foo, bar  := someFunc()
    foo, jazz := someFunc()  // <-- jazz is new
    baz, foo  := someFunc()  // <-- baz is new
    

这是合法的，因为您没有声明所有变量，您只是将新值重新分配给现有变量，并同时声明新变量。这称为_重新声明_。

* * *

**★ 第五条规则：**

您可以使用短声明在较新的作用域中声明变量，即使该变量之前已经使用相同的名称声明过：

    var foo int = 34
    
    func some() {
      // because foo here is scoped to some func
      foo := 42  // <-- legal
      foo = 314  // <-- legal
    }
    

在这里，`foo := 42`是合法的，因为，它`foo`在`some()`func 的范围内声明。`foo = 314`是合法的，因为，它只是为 分配了一个新值`foo`。

* * *

**★ 第 6 条规则：**

您可以在短语句块中声明相同的名称，例如：**if**、**for**、**switch**：

    foo := 42
    if foo := someFunc(); foo == 314 {
      // foo is scoped to 314 here
      // ...
    }
    // foo is still 42 here
    

因为，`foo`in `if foo := ...`，仅属于该`if`子句，并且位于不同的范围内。

* * *

**参考：**

*   [简短变量声明规则](https://blog.learngoprogramming.com/golang-short-variable-declaration-rules-6df88c881ee)
    
*   [Go 变量的视觉指南](https://blog.learngoprogramming.com/learn-go-lang-variables-visual-tutorial-and-ebook-9a061d29babe)

唯一的`=`就是_赋值运算符_。

`:=`[_是短变量声明_](http://golang.org/ref/spec#Short_variable_declarations)子句语法的一部分。  
👉 不过有一些规则。有关更多详细信息，请参阅[其他答案](https://stackoverflow.com/a/45654233/115363)。

`:=`是声明的简写。

    a := 10
    b := "gopher"
    

`a`将被声明为 an`int`并用 value 进行初始化，`10`其中 as`b`将被声明为字符串并用 value 进行初始化`gopher`。

他们的等价物`=`是

    var a = 10
    var b = "gopher"
    

`=`是赋值运算符。它的使用方式与任何其他语言中的使用方式相同。

当您声明变量并且存在初始值设定项时，您可以省略类型（[http://tour.golang.org/#11](http://tour.golang.org/#11)）。

:= 表示声明**和**赋值，而 = 表示简单赋值。

Golang 中的 = 和 := 运算符有什么区别？

在 Go 语言中，读写文件主要通过标准库中的 `io` 和 `os` 包来进行。以下是一些基本的文件操作步骤和示例代码。

### 文件写入

要在 Go 中写入文件，可以使用 `os` 包中的 `Create` 和 `OpenFile` 函数创建或打开一个文件，并使用 `Write` 或 `WriteString` 方法写入数据。如果文件不存在，`Create` 函数将创建文件。而 `OpenFile` 函数则可以指定不同的标志来决定模式（如只读、只写或追加）和权限。

```go
package main

import (
	"log"
	"os"
)

func main() {
	// 创建或者打开文件
	file, err := os.Create("example.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 写入字节数据
	byteSlice := []byte("Hello Golang!\n")
	_, err = file.Write(byteSlice)
	if err != nil {
		log.Fatal(err)
	}

	// 写入字符串数据
	_, err = file.WriteString("Writing string data to a file.\n")
	if err != nil {
		log.Fatal(err)
	}
}
```

### 文件读取

读取文件时，可以使用 `os.Open` 函数打开文件，并使用 `io` 包或 `bufio` 包来读取内容。`bufio` 包提供的 `Scanner` 类型通常用于读取以换行符分隔的文本文件。

```go
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

func main() {
	// 打开文件
	file, err := os.Open("example.txt")
	if err != nil {
		log.Fatal(err)
	}
	defer file.Close()

	// 使用 bufio.NewReader 来读取文件内容
	reader := bufio.NewReader(file)
	for {
		// 读取一行
		line, err := reader.ReadString('\n')
		if err != nil {
			// 如果读到文件的结尾，则跳出循环
			if err.Error() == "EOF" {
				break
			}
			log.Fatal(err)
		}
		fmt.Print(line)
	}
}
```

### 错误处理

在上述示例中，您可能注意到每次文件操作后都会有错误检查。这是因为读写文件时可能会遇到各种错误，例如文件不存在、没有足够的权限等。在 Go 中，错误处理是非常重要的，应始终检查每个可能失败的操作。

### 文件关闭

在完成文件操作后，应该使用 `defer` 语句确保文件被正确关闭。`defer` 语句会在包含它的函数结束时执行，这样可以保证即使在发生错误时文件也会被关闭。

以上就是使用 Go 语言进行文件读写的基本方法。在实际的应用中，可能还会涉及到更复杂的文件处理，例如处理大文件时可能需要分块读取，或者使用并发来加快文件处理速度等。在这些情况下，可以根据具体需求选择相应的策略和优化方法。

让我们制作一个与 Go 1 兼容的列表，列出在 Go 中读写文件的所有方法。

因为文件 API 最近发生了变化，并且大多数其他答案不适用于 Go 1。`bufio`恕我直言，他们也错过了重要的一点。

在以下示例中，我通过读取文件并将其写入目标文件来复制文件。

**从基础开始**

    package main
    
    import (
        "io"
        "os"
    )
    
    func main() {
        // open input file
        fi, err := os.Open("input.txt")
        if err != nil {
            panic(err)
        }
        // close fi on exit and check for its returned error
        defer func() {
            if err := fi.Close(); err != nil {
                panic(err)
            }
        }()
    
        // open output file
        fo, err := os.Create("output.txt")
        if err != nil {
            panic(err)
        }
        // close fo on exit and check for its returned error
        defer func() {
            if err := fo.Close(); err != nil {
                panic(err)
            }
        }()
    
        // make a buffer to keep chunks that are read
        buf := make([]byte, 1024)
        for {
            // read a chunk
            n, err := fi.Read(buf)
            if err != nil && err != io.EOF {
                panic(err)
            }
            if n == 0 {
                break
            }
    
            // write a chunk
            if _, err := fo.Write(buf[:n]); err != nil {
                panic(err)
            }
        }
    }
    

在这里我使用了`os.Open`和 ，`os.Create`它们是方便的包装器`os.OpenFile`。我们通常不需要`OpenFile`直接打电话。

注意处理 EOF。`Read`尝试填充`buf`每个调用，`io.EOF`如果这样做到达文件末尾，则返回错误。在这种情况下`buf`仍然会保存数据。随后的调用`Read`返回零作为读取的字节数，并`io.EOF`与错误相同。任何其他错误都会导致恐慌。

**使用`bufio`**

    package main
    
    import (
        "bufio"
        "io"
        "os"
    )
    
    func main() {
        // open input file
        fi, err := os.Open("input.txt")
        if err != nil {
            panic(err)
        }
        // close fi on exit and check for its returned error
        defer func() {
            if err := fi.Close(); err != nil {
                panic(err)
            }
        }()
        // make a read buffer
        r := bufio.NewReader(fi)
    
        // open output file
        fo, err := os.Create("output.txt")
        if err != nil {
            panic(err)
        }
        // close fo on exit and check for its returned error
        defer func() {
            if err := fo.Close(); err != nil {
                panic(err)
            }
        }()
        // make a write buffer
        w := bufio.NewWriter(fo)
    
        // make a buffer to keep chunks that are read
        buf := make([]byte, 1024)
        for {
            // read a chunk
            n, err := r.Read(buf)
            if err != nil && err != io.EOF {
                panic(err)
            }
            if n == 0 {
                break
            }
    
            // write a chunk
            if _, err := w.Write(buf[:n]); err != nil {
                panic(err)
            }
        }
    
        if err = w.Flush(); err != nil {
            panic(err)
        }
    }
    

`bufio`这里只是充当缓冲区，因为我们与数据没有太多关系。在大多数其他情况下（特别是文本文件），它为我们提供了[一个很好的 API](http://weekly.golang.org/pkg/bufio/)，可以轻松灵活地读写，同时它在幕后处理缓冲，这`bufio`非常有用。[](http://weekly.golang.org/pkg/bufio/)

* * *

**注意：**以下代码适用于旧版 Go 版本（Go 1.15 及之前版本）。事情已经发生了变化（自 Go 1.16 起`ioutil`已[弃用](https://pkg.go.dev/io/ioutil)）。对于新方法，请看一下[这个答案](https://stackoverflow.com/a/65970451/115363)。

**使用`ioutil`**

    package main
    
    import (
        "io/ioutil"
    )
    
    func main() {
        // read the whole file at once
        b, err := ioutil.ReadFile("input.txt")
        if err != nil {
            panic(err)
        }
    
        // write the whole body at once
        err = ioutil.WriteFile("output.txt", b, 0644)
        if err != nil {
            panic(err)
        }
    }
    

易如反掌！但仅当您确定不处理大文件时才使用它。

这是一个很好的版本（但请注意，自 Go 1.16 以来`ioutil`已[弃用）：](https://pkg.go.dev/io/ioutil)

    package main
    
    import (
      "io/ioutil"; 
      )
    
    
    func main() {
      contents,_ := ioutil.ReadFile("plikTekstowy.txt")
      println(string(contents))
      ioutil.WriteFile("filename", contents, 0644)
    }

### 新方法

从 Go 1.16 开始，使用[os.ReadFile](https://pkg.go.dev/os#ReadFile)将文件加载到内存中，并使用ioutil.ReadFile`os.WriteFile`从内存写入文件（[ioutil.ReadFile](https://pkg.go.dev/io/ioutil#ReadFile)现在调用`os.ReadFile`并已弃用）。

请小心，`os.ReadFile`因为它将整个文件读取到内存中。

    package main
    
    import "os"
    import "log"
    
    func main() {
        b, err := os.ReadFile("input.txt")
        if err != nil {
            log.Fatal(err)
        }
    
        // `b` contains everything your file has.
        // This writes it to the Standard Out.
        os.Stdout.Write(b)
    
        // You can also write it to a file as a whole.
        err = os.WriteFile("destination.txt", b, 0644)
        if err != nil {
            log.Fatal(err)
        }
    }

Golang 如何操作读写文件？

`init` 函数在 Go 语言中具有特殊意义。它在每个包完成初始化后自动执行，但在任何其他函数被调用之前执行。具体来说，`init` 函数的执行时机如下：

1. 当一个包被导入时，首先检查包是否已经导入且被初始化。如果还没有，先对该包的依赖进行初始化。
2. 然后，在包级别的变量被初始化后，该包的`init`函数会被调用。这个过程是自动的，并且是在编译时就确定下来的。
3. 如果一个包有多个`init`函数（可能分散在包的多个文件中），它们将按照它们在代码中出现的顺序被调用。
4. 如果一个包被多个其他包导入，其`init`函数只会被执行一次。

这个机制保证了无论包被导入多少次，`init`函数只运行一次，并且在程序的主函数`main`运行之前。这样的设计用于执行临时的初始化任务，比如设置包内部的数据结构，初始化变量，或者是注册必要的信息。

例如，如果有一个数据库包，你可能会在`init`函数中设置数据库的连接池：

```go
package database

import "database/sql"

var dbPool *sql.DB

func init() {
    var err error
    dbPool, err = sql.Open("postgres", "connection_string")
    if err != nil {
        log.Fatalf("Database connection failed: %s", err)
    }
}

// 其他数据库操作函数...
```

在这个例子中，无论这个数据库包被导入多少次，或在程序的哪个地方被导入，`init`函数都会确保在程序执行任何数据库操作前数据库连接已经设置好。

是的，假设你有[这个](http://play.golang.org/p/dvHymTy73F)：

    var WhatIsThe = AnswerToLife()
    
    func AnswerToLife() int { // 1
        return 42
    }
    
    func init() { // 2
        WhatIsThe = 0
    }
    
    func main() { // 3
        if WhatIsThe == 0 {
            fmt.Println("It's all a lie.")
        }
    }
    

`AnswerToLife()`保证在`init()`调用之前运行，并且`init()`保证在`main()`调用之前运行。

请记住，`init()`无论是否有 main ，它总是被调用，因此如果您导入具有函数的包`init`，它将被执行。

此外，每个包可以有多个`init()`函数；它们将按照它们在文件中显示的顺序执行（当然是在所有变量初始化之后）。如果它们跨越多个文件，它们将按词法文件名顺序执行（如[@benc](https://stackoverflow.com/users/2039413/benc)指出的）：

> 函数似乎`init()`是按词法文件名顺序执行的。Go 规范表示“鼓励构建系统以词法文件名顺序向编译器呈现属于同一包的多个文件”。似乎是`go build`这样的。

* * *

许多内部 Go 包用于`init()`初始化表等，例如[https://github.com/golang/go/blob/883bc6/src/compress/bzip2/bzip2.go#L480](https://github.com/golang/go/blob/883bc6/src/compress/bzip2/bzip2.go#L480)

看这张图。:)

`import --> const --> var --> init()`

![](https://astaxie.gitbooks.io/build-web-application-with-golang/en/images/2.3.init.png?raw=true)

1.  如果一个包导入了其他包，则首先初始化导入的包。
    
2.  然后初始化当前包的常量。
    
3.  然后初始化当前包的变量。
    
4.  最后，`init()`调用当前包的函数。
    

> 一个包可以有多个 init 函数（在单个文件中或分布在多个文件中），并且按照它们呈现给编译器的顺序调用它们。

  

> 即使从多个包导入，一个包也只会初始化一次。

对此需要添加一些内容（我会添加为评论，但在撰写本文时我还没有足够的声誉）

在同一个包中有多个 init，我还没有找到任何有保证的方法来知道它们的运行顺序。例如我有：

    package config
        - config.go
        - router.go
    

和`config.go`都`router.go`包含`init()`函数，但是当运行时`router.go`，函数首先运行（这导致我的应用程序出现恐慌）。

如果您有多个文件，每个文件都有自己的`init()`功能，请务必注意，不能保证您先获得一个文件。最好使用变量赋值，如[OneToOne](https://stackoverflow.com/users/145587/oneofone)在他的示例中所示。最好的部分是：此变量声明将发生`init()`在包中的所有函数之前。

例如
--

配置.go：

    var ConfigSuccess = configureApplication()
    
    func init() {
        doSomething()
    }
    
    func configureApplication() bool {
        l4g.Info("Configuring application...")
        if valid := loadCommandLineFlags(); !valid {
            l4g.Critical("Failed to load Command Line Flags")
            return false
        }
        return true
    }
    

路由器.go：

    func init() {
        var (
            rwd string
            tmp string
            ok  bool
        )
        if metapath, ok := Config["fs"]["metapath"].(string); ok {
            var err error
            Conn, err = services.NewConnection(metapath + "/metadata.db")
            if err != nil {
                panic(err)
            }
        }
    }
    

无论是否`var ConfigSuccess = configureApplication()`存在于`router.go`或中`config.go`，它都会在 EITHER`init()`运行之前运行。

这是另一个例子 - [https://play.golang.org/p/9P-LmSkUMKY](https://play.golang.org/p/9P-LmSkUMKY)

    package main
    
    import (
        "fmt"
    )
    
    func callOut() int {
        fmt.Println("Outside is beinge executed")
        return 1
    }
    
    var test = callOut()
    
    func init() {
        fmt.Println("Init3 is being executed")
    }
    
    func init() {
        fmt.Println("Init is being executed")
    }
    
    func init() {
        fmt.Println("Init2 is being executed")
    }
    
    func main() {
        fmt.Println("Do your thing !")
    }
    

上述程序的输出

    $ go run init/init.go
    Outside is being executed
    Init3 is being executed
    Init is being executed
    Init2 is being executed
    Do your thing !

> 该函数什么时候`init()`运行？

使用 Go 1.16（2021 年第一季度），您将准确地看到它何时运行以及运行多长时间。

请参阅[CL（更改列表）254659](https://go-review.googlesource.com/c/go/+/254659)中的[提交 7c58ef7](https://github.com/golang/go/commit/7c58ef732efd9bf0d0882bb95371ce1909924a75)，修复[问题 41378](https://github.com/golang/go/issues/41378)。[](https://go-review.googlesource.com/c/go/+/254659)[](https://github.com/golang/go/issues/41378)

> 运行时：实现`GODEBUG=inittrace=1`支持
> -----------------------------
> 
> 设置`inittrace=1`会导致运行时为每个带有 init 工作的包发出一行标准错误，总结执行时间和内存分配。
> 
> 发出的函数调试信息`init`可用于查找 Go 启动性能的瓶颈或回归。
> 
> 没有`init`功能的包（用户定义的或编译器生成的）被省略。
> 
> 不支持跟踪插件 inits，因为它们可以同时执行。这将使跟踪的实现更加复杂，同时增加对非常罕见的用例的支持。可以通过测试显式导入插件包导入的主包来单独跟踪插件初始化。
> 
>     $ GODEBUG=inittrace=1 go test
>     init internal/bytealg @0.008 ms, 0 ms clock, 0 bytes, 0 allocs
>     init runtime @0.059 ms, 0.026 ms clock, 0 bytes, 0 allocs
>     init math @0.19 ms, 0.001 ms clock, 0 bytes, 0 allocs
>     init errors @0.22 ms, 0.004 ms clock, 0 bytes, 0 allocs
>     init strconv @0.24 ms, 0.002 ms clock, 32 bytes, 2 allocs
>     init sync @0.28 ms, 0.003 ms clock, 16 bytes, 1 allocs
>     init unicode @0.44 ms, 0.11 ms clock, 23328 bytes, 24 allocs
>     ...
>     
> 
> 受到Stapelberg@google.com的启发，他使用 GDB 构建了`doInit` 一个原型来测量`init`时间。

Golang 的 Init 函数在什么时候运行？

在Go语言中，如果您想在控制台中打印结构体变量，可以使用`fmt`包中的`Println`函数或者`Printf`函数。另外，为了能够更加美观地输出结构体的内容，可以使用`%+v`这个格式化占位符，它会以字段名和相应的值的形式输出结构体信息。当然，如果你想要完整的控制输出格式，也可能需要实现`String()`方法来自定义结构体的字符串表示。下面是一个简单的例子：

首先，定义一个结构体：

```go
package main

import (
    "fmt"
)

// 定义一个示例结构体
type Person struct {
    Name string
    Age  int
    City string
}
```

然后，创建一个结构体实例并打印它：

```go
func main() {
    // 创建一个结构体实例
    p := Person{
        Name: "Alice",
        Age:  25,
        City: "New York",
    }

    // 使用 fmt 包打印结构体
    // %+v 打印包含字段名和字段值的结构体信息
    fmt.Printf("Person: %+v\n", p)

    // 或者使用 fmt.Println 也可以打印结构体的值，但不包括字段名
    fmt.Println("Person:", p)

    // 如果需要更定制化的输出，可以实现 String 方法
    fmt.Println(p.String())
}

// 实现 String 方法来自定义 Person 结构体的字符串表示形式
func (p Person) String() string {
    return fmt.Sprintf("Name: %s, Age: %d, City: %s", p.Name, p.Age, p.City)
}
```

当你运行这段代码时，控制台将输出：

```
Person: {Name:Alice Age:25 City:New York}
Person: {Alice 25 New York}
Name: Alice, Age: 25, City: New York
```

在第一个`Printf`中，`%+v`格式化占位符使得结构体的每个字段名和对应的值都被打印出来。而在使用`Println`时，只有结构体的值被打印，没有字段名。最后，通过实现`String()`方法，我们有了完全自定义的输出格式。

要打印结构体中字段的名称：

    fmt.Printf("%+v\n", yourProject)
    

从[`fmt`包装](http://golang.org/pkg/fmt/)中：

> 打印结构时，加号 ( `%+v`) 添加字段名称

假设您有一个 Project 实例（在“ `yourProject`”中）

[JSON 和 Go](http://blog.golang.org/json-and-go)一文将提供有关如何从 JSON 结构检索值的更多详细信息。

* * *

此[Go 示例页面](https://gobyexample.com/json)提供了另一种技术：

    type Response2 struct {
      Page   int      `json:"page"`
      Fruits []string `json:"fruits"`
    }
    
    res2D := &Response2{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res2B, _ := json.Marshal(res2D)
    fmt.Println(string(res2B))
    

那会打印：

    {"page":1,"fruits":["apple","peach","pear"]}
    

* * *

如果您没有任何实例，则需要**[使用反射](http://blog.golang.org/laws-of-reflection)**来显示给定结构体的字段名称，[如本例所示](http://play.golang.org/p/JKHjPu3cgB)。

    type T struct {
        A int
        B string
    }
    
    t := T{23, "skidoo"}
    s := reflect.ValueOf(&t).Elem()
    typeOfT := s.Type()
    
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d: %s %s = %v\n", i,
            typeOfT.Field(i).Name, f.Type(), f.Interface())
    }

我想推荐[go-spew](https://github.com/davecgh/go-spew)，根据他们的 github “为 Go 数据结构实现一个深度漂亮的打印机以帮助调试”

    go get -u github.com/davecgh/go-spew/spew
    

用法示例：

    package main
    
    import (
        "github.com/davecgh/go-spew/spew"
    )
    
    type Project struct {
        Id      int64  `json:"project_id"`
        Title   string `json:"title"`
        Name    string `json:"name"`
        Data    string `json:"data"`
        Commits string `json:"commits"`
    }
    
    func main() {
    
        o := Project{Name: "hello", Title: "world"}
        spew.Dump(o)
    }
    

输出：

    (main.Project) {
     Id: (int64) 0,
     Title: (string) (len=5) "world",
     Name: (string) (len=5) "hello",
     Data: (string) "",
     Commits: (string) ""
    }

我的 2 美分将是使用`json.MarshalIndent`\- 令人惊讶的是没有建议这样做，因为它是最简单的。例如：

    func prettyPrint(i interface{}) string {
        s, _ := json.MarshalIndent(i, "", "\t")
        return string(s)
    }
    

没有外部依赖，并且会产生格式良好的输出。

我认为如果您想要某种格式的输出，最好实现自定义纵梁`struct`

例如

    package main
    
        import "fmt"
    
        type Project struct {
            Id int64 `json:"project_id"`
            Title string `json:"title"`
            Name string `json:"name"`
        }
    
        func (p Project) String() string {
            return fmt.Sprintf("{Id:%d, Title:%s, Name:%s}", p.Id, p.Title, p.Name)
        }
    
        func main() {
            o := Project{Id: 4, Name: "hello", Title: "world"}
            fmt.Printf("%+v\n", o)
        }

或者，尝试使用此功能`PrettyPrint()`

    // print the contents of the obj
    func PrettyPrint(data interface{}) {
        var p []byte
        //    var err := error
        p, err := json.MarshalIndent(data, "", "\t")
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Printf("%s \n", p)
    }
    

为了使用它，除了`fmt`和之外，您不需要任何其他包`encoding/json`，只需您创建的结构的引用、指针或文字。

要使用，只需获取您的结构，在 main 或您所在的任何包中初始化它，然后将其传递到`PrettyPrint()`.

    type Prefix struct {
        Network string
        Mask    int
    }
    
    func valueStruct() {
        // struct as a value
        var nw Prefix
        nw.Network = "10.1.1.0"
        nw.Mask = 24
        fmt.Println("### struct as a pointer ###")
        PrettyPrint(&nw)
    }
    

它的输出将是

    ### struct as a pointer ###
    {
        "Network": "10.1.1.0",
        "Mask": 24
    } 
    

[尝试一下这里的](https://play.golang.org/p/YZn4hHXYdw)代码。

Golang 如何在控制台中打印结构变量?

在 Go 语言中，您可以通过将字符串转换为 `[]byte` 类型来将字符串分配给字节数组。这可以通过简单的类型转换来实现。以下是将字符串分配给字节数组的示例：

```go
package main

import (
	"fmt"
)

func main() {
	// 定义一个字符串
	str := "Hello, World!"

	// 将字符串转换为字节数组
	byteArray := []byte(str)

	// 打印字节数组
	fmt.Printf("%v\n", byteArray)

	// 以字符串形式打印字节数组，以显示其内容
	fmt.Printf("%s\n", byteArray)
}
```
在这个例子中，字符串 `"Hello, World!"` 被转换为一个字节数组 `byteArray`。`fmt.Printf` 函数首先以字节数组的形式打印，然后以字符串的形式打印出来，从而验证转换是成功的。

这个过程实际上是创建了字符串内容的一个副本，并以字节数组的形式存储。由于字符串在 Go 中是不可变的，这种转换允许您在需要的时候对得到的字节数组进行修改。

需要注意的是，字符串到字节数组的转换会考虑字符串的编码。在 Go 中，默认的字符串编码是 UTF-8，所以如果字符串中包含非 ASCII 字符，转换后的字节数组将包含相应的 UTF-8 编码字节。

Golang 如何将字符串分配给字节数组?

在Go语言中，检查文件是否存在有几种方法，但最常见和简单的方法是使用`os.Stat`函数和`os.IsNotExist`函数。下面是一个示例，展示了如何使用这两个函数来检查文件是否存在：

```go
package main

import (
    "fmt"
    "os"
)

// fileExists 检查文件是否存在，返回布尔值和可能出现的错误
func fileExists(filename string) (bool, error) {
    // 使用os.Stat获取文件信息
    info, err := os.Stat(filename)

    if os.IsNotExist(err) {
        // 如果返回的错误类型为文件不存在，则说明文件确实不存在
        return false, nil
    }

    // 如果info不为空，并且没有错误，则文件存在
    return !info.IsDir(), err
}

func main() {
    // 检查文件"example.txt"是否存在
    exists, err := fileExists("example.txt")
    if err != nil {
        // 如果有错误，打印错误并退出
        fmt.Printf("Failed to check if file exists: %v\n", err)
        return
    }

    // 根据存在标志打印相应的信息
    if exists {
        fmt.Println("File exists.")
    } else {
        fmt.Println("File does not exist.")
    }
}
```
在上述代码中，`fileExists`函数会尝试获取指定文件的信息。如果`os.Stat`函数返回一个错误，并且通过`os.IsNotExist`检查确认这个错误是因为文件不存在，则`fileExists`会返回`false`和一个`nil`错误。如果没有错误，并且`info.IsDir()`也为`false`（意味着路径不是一个目录），则函数返回`true`。

需要注意的是，文件可能因为其他原因而无法访问（例如权限问题），此时`os.Stat`会返回非`nil`的错误，这种情况下，你可能需要根据具体的错误类型来作出不同的处理。

检查文件是否不存在，相当于Python的`if not os.path.exists(filename)`：

    if _, err := os.Stat("/path/to/whatever"); errors.Is(err, os.ErrNotExist) {
      // path/to/whatever does not exist
    }
    

检查文件是否存在，相当于Python的`if os.path.exists(filename)`：

编辑：根据最近的评论

    if _, err := os.Stat("/path/to/whatever"); err == nil {
      // path/to/whatever exists
    
    } else if errors.Is(err, os.ErrNotExist) {
      // path/to/whatever does *not* exist
    
    } else {
      // Schrodinger: file may or may not exist. See err for details.
    
      // Therefore, do *NOT* use !os.IsNotExist(err) to test for file existence
    
    
    }

**Caleb Spare**的回答发布在[gonuts](https://groups.google.com/forum/#!msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J)邮件列表中。

> \[...\] 实际上并不经常需要它，并且 \[...\]`os.Stat`对于需要它的情况来说使用起来很容易。
> 
> \[...\] 例如：如果您要打开文件，则没有理由先检查它是否存在。该文件可能会在检查和打开之间消失，无论如何您都需要检查错误`os.Open`。因此，您只需在尝试打开文件后调用`os.IsNotExist(err)`，并处理该文件不存在的情况（如果需要特殊处理）。
> 
> \[...\] 您根本不需要检查是否存在路径（而且您也不应该这样做）。
> 
> *   `os.MkdirAll`无论路径是否存在都有效。（您还需要检查该调用的错误。）
>     
> *   `os.Create`您应该使用而不是使用`os.OpenFile(path, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)`。这样，如果文件已经存在，您将收到错误消息。此外，这与创建文件的其他内容不存在竞争条件，这与您事先检查是否存在的版本不同。
>     

摘自： https: [//groups.google.com/forum/#! msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J](https://groups.google.com/forum/#!msg/golang-nuts/Ayx-BMNdMFo/4rL8FFHr8v4J)

首先要考虑的是，您很少只想检查文件是否存在。在大多数情况下，您会尝试对文件（如果存在）执行某些操作。在 Go 中，任何时候你尝试对不存在的文件执行某些操作，结果都应该是一个特定的错误 ( `os.ErrNotExist`)，最好的办法是检查返回`err`值（例如，当调用类似 的函数时`os.OpenFile(...)`）是否为`os.ErrNotExist`。

**过去**推荐的方法是：

    file, err := os.OpenFile(...)
    if os.IsNotExist(err) {
        // handle the case where the file doesn't exist
    }
    

然而，自从**Go 1.13**（2019 年底发布）中**添加了，`errors.Is`**[新的建议是使用`errors.Is`](https://github.com/golang/go/blob/5ff7ec98b7727b3641df25200345b1aa50b6ff35/src/os/error.go#L90-L91)：

    file, err := os.OpenFile(...)
    if errors.Is(err, os.ErrNotExist) {
        // handle the case where the file doesn't exist
    }
    

* * *

**通常最好避免`os.Stat`在尝试对文件执行某些操作之前使用它来检查文件是否存在，因为在执行某些操作之前，文件总是有可能在一段时间内被重命名、删除等。它。**

然而，如果你同意这个警告，并且你真的只是想检查一个文件是否存在，然后不继续用它做一些有用的事情（作为一个人为的例子，假设你正在编写一个毫无意义的 CLI 工具，告诉你文件是否存在然后退出`¯\_(ツ)_/¯`），那么推荐的方法是：

    if _, err := os.Stat(filename); errors.Is(err, os.ErrNotExist) {
        // file does not exist
    } else {
        // file exists
    }

您应该使用`os.Stat()`和`os.IsNotExist()`函数，如下例所示：

    func Exists(name string) (bool, error) {
        _, err := os.Stat(name)
        if err == nil {
            return true, nil
        }
        if errors.Is(err, os.ErrNotExist) {
            return false, nil
        }
        return false, err
    }
    

edit1：修复了在某些情况下返回 true 的问题。  
edit2：从os.IsNotExist()切换到使用errors.Is()，许多人说这是[最佳实践](https://github.com/golang/go/issues/38198)，在[这里](https://stefanxo.com/go-anti-patterns-os-isexisterr-os-isnotexisterr/)

其他答案错过的是，给函数的路径实际上可能是一个目录。以下函数可确保该路径确实是一个文件。

    func fileExists(filename string) bool {
        info, err := os.Stat(filename)
        if os.IsNotExist(err) {
            return false
        }
        return !info.IsDir()
    }
    
    

另一件需要指出的事情是：此代码仍然可能导致竞争条件，即在 fileExists 函数运行时另一个线程或进程删除或创建指定的文件。

如果您担心这一点，请在线程中使用锁，序列化对此函数的访问，或者在涉及多个应用程序时使用进程间信号量。如果涉及到超出您控制范围的其他应用程序，我想您就不走运了。

Golang 如何检查某个文件是否存在？

在 Go 语言中，将 `int` 值转换为 `string` 可以通过多种方式实现。最常用的方式是使用标准库的 `strconv` 包中的 `Itoa` 函数（这是整数到 ASCII 的简写）以及 `FormatInt` 函数。这里有一些例子说明如何进行这种转换：

### 使用 `strconv.Itoa`：

`strconv.Itoa` 函数接受一个 `int` 类型的参数，并将其转换为 `string` 类型。

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    intValue := 123
    stringValue := strconv.Itoa(intValue)
    fmt.Println(stringValue) // 输出: "123"
}
```

### 使用 `strconv.FormatInt`：

`strconv.FormatInt` 函数更加灵活，它接受一个 `int64` 类型的值并且允许你指定数字的进制。如果你需要将 `int` 转换为十进制字符串，可以像这样使用：

```go
package main

import (
    "fmt"
    "strconv"
)

func main() {
    intValue := 123
    stringValue := strconv.FormatInt(int64(intValue), 10) // 第二个参数10表示十进制
    fmt.Println(stringValue) // 输出: "123"
}
```

需要注意的是 `strconv.FormatInt` 需要一个 `int64` 类型的值。如果你的整数是 `int` 类型，你需要先将其转换为 `int64`。

### 使用 `fmt.Sprintf`：

`fmt.Sprintf` 函数可以用于格式化字符串，其中包括 int 到 string 的转换。这个方法适用于各种类型的格式化操作，不仅限于整数的转换。

```go
package main

import (
    "fmt"
)

func main() {
    intValue := 123
    stringValue := fmt.Sprintf("%d", intValue)
    fmt.Println(stringValue) // 输出: "123"
}
```

在这个例子中，`%d` 是一个格式说明符，表示将一个整数格式化为十进制数的字符串。

这些是 Go 语言中将整数转换为字符串的常见方法。你可以根据你的具体需求选择合适的方法。

使用[`strconv`](http://golang.org/pkg/strconv/#Itoa)包的`Itoa`功能。

例如：

    package main
    
    import (
        "strconv"
        "fmt"
    )
    
    func main() {
        t := strconv.Itoa(123)
        fmt.Println(t)
    }
    

您可以简单地通过`+`'ing 或使用包`Join`的函数来连接字符串[`strings`](http://golang.org/pkg/strings/#Join)。

fmt.Sprintf("%v",value);
    

如果您知道值的具体类型，请使用相应的格式化程序，`%d`例如`int`

更多信息[\-fmt](http://golang.org/pkg/fmt/)

Golang相关问题