Go

Go 1 保证语言规范[26]和标准库的主要部分兼容。直到目前的 Go 1.20 发布[27]，所有版本都履行了这个承诺。 每个主要的 Go 发布版本会受到支持，直到出现两个新的主要版本为止。[28]

下面是用Go写成的Hello World进程：

package main

import "fmt"

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

通过Go仅需几行代码就完成HTTP网页服务器的实现：

package main

import (
    "io"
    "net/http"
)

func hello(w http.ResponseWriter, r *http.Request) {
    io.WriteString(w, "Hello world!")
}

func main() {
    http.HandleFunc("/", hello)
    http.ListenAndServe(":8000", nil)
}

下面的例子说明了怎样用Go去实现一个像Unix中的Echo命令进程[29]：

package main

import (
    "os"
    "flag"
)

var omitNewline = flag.Bool("n", false, "don't print final newline")

const (
    Space   = " "
    Newline = "\n"
)

func main() {
    flag.Parse() // Scans the arg list and sets up flags
    var s string = ""
    for i := 0; i < flag.NArg(); i++ {
        if i > 0 {
            s += Space
        }
        s += flag.Arg(i)
    }
    if !*omitNewline {
        s += Newline
    }
    os.Stdout.WriteString(s)
}

Go有定义如下的撰写风格：

1. 每行程序结束后不需要撰写分号;。
2. 大括号{不能够换行放置。
3. if判断式和for循环不需要以小括号包覆起来。
4. 使用 tab 做排版

除了第二点外（换行会产生编译错误），在不符合上述规定时，仍旧可以编译，但使用了内置gofmt工具后，会自动整理代码，使之符合规定的撰写风格。

Go 采用 module 的概念（于 go1.11才开始激活[30]，旧版本请参阅工作区），每个项目都是一个 module ，而每个 module 底下会有个 go.mod 的文件，来管理该 module 所引用的外部库、开发版本……等等。

一个 module 的文件夹目录可能如下

go.mod
 hello/
     hello.go                
 outyet/
     main.go                 
     main_test.go           # 测试用的程序
 stringutil/
     reverse.go             
     reverse_test.go        #  测试用的程序
 bmp/
     reader.go              
     writer.go               

然后 go.mod 的内容可能为

module example.org/go-mod-sample

go 1.11

require (
	github.com/golang/example v0.0.0-20220412213650-2e68773dfca0 
	golang.org/x/image v0.1.0 
)

Go的工作区位于GOPATH，其目录结构如下[31]：

src
pkg
bin

三个目录的用途分别为

举例来说，整个项目目录可能会如下：

bin/
    hello                          # 生成的运行档
    outyet                         # 生成的运行档
pkg/
    linux_amd64/
        github.com/golang/example/
            stringutil.a           # 编译时，生成的对象文件
src/
    github.com/golang/example/
        .git/                      # 外部 Git 库的诠释数据
 hello/
     hello.go               # Git 库的代码
 outyet/
     main.go                # Git 库的代码
     main_test.go           # Git 库的代码（测试用的程序）
 stringutil/
     reverse.go             # Git 库的代码
     reverse_test.go        # Git 库的代码（测试用的程序）
    golang.org/x/image/
        .git/                      # 外部 Git 库的诠释数据
 bmp/
     reader.go              # Git 库的代码
     writer.go              # Git 库的代码

Go的主要特色在于易于使用的并行设计，叫做Goroutine，通过Goroutine能够让程序以异步的方式运行，而不需要担心一个函数导致程序中断，因此Go也非常地适合网络服务。假设有个程序，里面有两个函数：

func main() {
    // 假设 loop 是一个会重复运行十次的循环函数。
    // 循环运行完毕才会往下运行。
    loop()
    // 运行另一个循环。
    loop()
}

这个时候通过Go让其中一个函数同步运行，如此就不需要等待该函数运行完后才能运行下一个函数。

func main() {
    // 通过 `go`，我们可以把这个函数同步运行，
    // 如此一来这个函数就不会阻塞主程序的运行。
    go loop()
    // 运行另一个循环。
    loop()
}

Goroutine是类似线程的概念，属于纤程(区别于协程和线程)。线程属于系统层面，通常来说创建一个新的线程会消耗较多的资源且管理不易；而协程的主要作用是提供在一个线程内的并发性，却不能利用多个处理器线程。而 Goroutine就像轻量级的线程，一个Go程序可以运行超过数万个 Goroutine[32]，并且这些性能都是原生级的，随时都能够关闭、结束，且运行在多个处理器线程上。一个内核里面可以有多个Goroutine，通过GOMAXPROCS参数你能够限制Gorotuine可以占用几个系统线程来避免失控。

在内置的官方套件中也不时能够看见Goroutine的应用，像是net/http中用来监听网络服务的函数实际上是创建一个不断运行循环的Goroutine；同时搭配了epoll 等IO多路复用机制维护Goroutine的事件循环。