给 JavaScript 开发者的 Go 语言指南

约 9692 字大约 32 分钟

2025-12-07

写这篇文章，其实有些晚了，早在今年的 3 月份（2025 年），微软宣布 Typescript 官方编译器将移植到 Go，并承诺速度比当前编译器要快 10 倍。这引起了 Javascript 社区对 Go 语言的广泛关注。

因此，这篇文章旨在为对 Go 语言感到好奇或希望进一步了解的 JavaScript 开发者提供一个起点。我将尝试涵盖 Go 的核心基础概念，同时与 JavaScript/TypeScript 中的类似概念进行比较，并分享一些我作为 JavaScript 开发者思维需要适应的注意事项。

本文并不能完整的作为 Go 语言的入门教程。

JavaScript 拥有多个运行时环境，为避免混淆，示例中的 JavaScript 代码均使用 Typescript 编写，并运行在 Node.js 环境下。

基础概念

编译与执行

首先需要了解的是，Go 是一种编译型语言，因此需要先编译成本地机器码二进制文件才能执行；而 JavaScript 则是一种解释型语言，无需编译即可执行。

例如，你可以编写一个 JavaScript 文件，然后使用 node 命令直接运行它：

hello.js
console.log('Hello, world!')

然后可以直接执行它：

Terminal
node hello.js
> Hello, world!

开始使用 Go

要开始使用Go，你需要从 https://go.dev/dl/ 下载适用于你的系统的 Go 二进制发行版。

以下是 Go 语言的示例：

hello.go
package main

import "fmt"

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

要运行此程序，你需要先构建它，然后执行生成的二进制文件：

Terminal
go build hello.go

./hello
> Hello, World!

或者，你也可以直接使用 run 命令，它能够一步完成编译与执行：

Terminal
go run hello.go
> Hello, World!

由于Go编译为本地机器码，若希望代码能在不同平台上运行，就需要为不同架构编译不同的二进制文件。

Packages - 包

每个 Go 程序都由包构成，并从运行主包开始。主包中必须包含一个名为 main 的函数，该函数作为程序的入口点，当主函数返回时程序结束。

main.go

package main // 声明 main 包
// 导入其他包
import (
  "fmt"
)
// 运行 main 包时， main 函数会默认执行
func main() {
  // 在控制台打印 Hello world
  fmt.Println("Hello world")
}

可通过代码片段标题右侧的在线运行按钮来执行示例。

Go 语言中的包类似于JavaScript 中的模块，它们是一组相关的源文件集合。你可以像在 JavaScript 中导入模块一样创建和导入包。在上面的代码片段中，我们也从 Go 的标准库中导入了 fmt 包。

`go.mod`

类似于 package.json，Go 程序有一个 go.mod 文件，它作为 Go 模块的配置文件，包含了模块及其依赖项的信息。一个典型的 Go 模块文件如下所示：

go.mod
module myproject

go 1.16

require (
    github.com/gin-gonic/gin v1.7.4
    golang.org/x/text v0.3.7
)

第一行声明了模块的导入路径，作为该模块的唯一标识；
第二行指定了模块所需的最低 Go 版本；
最后列出了所有直接和间接依赖项及其具体版本。

要在 Go 中创建一个包，你需要新建一个目录，目录名即为包名，然后该目录下的所有 Go 文件通过在文件顶部声明包名来成为该包的一部分。

在Go语言中，从包中导出内容的方式也很有趣。在 JavaScript 中，如果使用 ES 模块，我们会用 export 关键字来使模块内的内容对外可用。但在 Go 语言中，如果一个名称以大写字母开头，它就会被导出。

以下示例展示了我们之前讨论的所有内容：

go playground

package main

import (
  "fmt"
  "myproject/fib"
)

func main() {
  sequence := fib.FibonacciSequence(10)

  // 这将导致一个错误
  // firstFibonacciNumber := fib.fibonacci(1)

  fmt.Println("Fibonacci sequence of first 10 numbers:")
  fmt.Println(sequence)
}

-- go.mod --
module myproject

-- fib/fib.go --
package fib

// 由于此函数未以大写字母开头，因此它不会被导出。
func fibonacci(n int) int {
    if n <= 0 {
        return 0
    }
    if n == 1 {
        return 1
    }

    return fibonacci(n-1) + fibonacci(n-2)
}

// 该函数导出，因为它以大写字母开头
func FibonacciSequence(n int) []int {
    sequence := make([]int, n)

    for i := 0; i < n; i++ {
        sequence[i] = fibonacci(i)
    }

    return sequence
}

在 go playground 中运行

在上述示例中，我们通过创建同名目录生成了另一个名为 fib 的包。此外，如果仔细观察，只有 FibonacciSequence 函数被导出，因为它以 大写字母开头，因此可以在包外部访问。

Variables - 变量

Go 是静态类型语言，即你需要声明（或推断）每个变量的类型，这些类型会在编译阶段进行检查。这与 JavaScript 不同，在 JavaScript 中变量可以持有任意类型的值，且仅在程序运行时才会进行类型评估。

例如，在 JavaScript 中，你可以这样操作：

JavaScript

let x = 5
let y = 2.5
let sum = x + y // 运行正常：7.5
// eslint-disable-next-line prefer-template
let weird = x + '2' // 同样“有效”：“52”（但可能并非你所期望！）

但在 Go 语言中，你需要非常明确地指定类型，var 相当于现代 JavaScript 中的 let：

GoLang
var x int = 5
// 或者 x := 5 这是一个简短的赋值语句。
// 可以替代具有隐式类型的变量声明。

var y float64 = 2.5

// 这将无法编译：
sum := x + y  // Error: mismatched types int and float64

// 必须显式转换：
sum := float64(x) + y

类似于 JavaScript 中的 const，Go 语言也拥有 const 关键字用于声明常量。其声明方式与变量类似，但需使用 const 关键字：

GoLang
const pi float64 = 3.14

// 或者声明时不指定类型以直接推断
const s = "hello"

但与 JavaScript 不同，Go 语言中的 const 仅能用于基本类型（字符、字符串、布尔值或数值），而不能用于其他复杂类型。

在 Go 语言中，声明变量却不使用它，并不仅仅是像某些 linter 在 JavaScript 或 TypeScript 中给出的警告那样，而是一个编译错误。

Structs and Types - 结构体与类型

正如你可以用 JavaScript 对象来表示一组字段一样，在 Go 中你也可以使用结构体来表示一组字段。

GoLang
type Person struct {
  Name string
  Age int
}

p := Person{
  Name: "John",
  Age: 32,
}

// 或创建复合结构体
type User struct {
  Person Person
  ID     string
}

u := User{
  Person: p,
  ID:     "123",
}

GoLang

package main

type Person struct {
    Name string
    Age  int
}

type User struct {
    Name     string
    Age      int
    Username string
}

func HelloPerson(p Person) {
    fmt.Println(p)
}

func main() {
    // This works fine
    HelloPerson(Person{
        Name: "John",
        Age:  32,
    })

    // 不能正常工作
    x := User{
        Name:     "John",
        Age:      32,
        Username: "john",
    }

    // Error: cannot use x (variable of struct type User) as Person value in argument to HelloPerson
    HelloPerson(x)

    // 要使其正常工作，你需要明确进行转换：
    // HelloPerson(Person{Name: x.Name, Age: x.Age})
}