Go 语言入门：从 PHP 到 Go 的思维转变

<?php
// 同一个变量，先存字符串再存数组
$data = "hello";
echo strlen($data);  // 5

$data = ["a", "b", "c"];
echo count($data);   // 3

// 函数参数可以传任何类型
function process($input) {
    return $input;  // 不知道实际是字符串还是数组
}

package main

import "fmt"

// 必须明确参数和返回值类型
func process(input string) string {
    return input
}

func main() {
    var data string = "hello"
    fmt.Println(process(data))

    // 编译错误：cannot use 123 (untyped int constant) as string
    // fmt.Println(process(123))
}

// 定义接口
type Reader interface {
    Read(p []byte) (n int, err error)
}

// 任何实现 Read 方法的类型都满足 Reader
type FileReader struct{ /* ... */ }
func (f FileReader) Read(p []byte) (int, error) { /* ... */ return 0, nil }

// FileReader 自动满足 Reader
var r Reader = FileReader{}

package main

import (
    "fmt"
    "time"
)

func worker(id int) {
    fmt.Printf("Worker %d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    // 启动 1000 个 goroutine
    for i := 0; i < 1000; i++ {
        go worker(i)
    }
    time.Sleep(2 * time.Second)
}

<?php
try {
    $user = User::findOrFail($id);
    $order = Order::create($user, $data);
} catch (ModelNotFoundException $e) {
    return response()->json(['error' => 'User not found'], 404);
} catch (ValidationException $e) {
    return response()->json(['errors' => $e->errors()], 422);
} catch (\Exception $e) {
    Log::error($e);
    return response()->json(['error' => 'Server error'], 500);
}

package main

import (
    "errors"
    "fmt"
)

func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 0)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Result:", result)
}

if err != nil {
    return fmt.Errorf("failed to read config: %w", err)
}

type NotFoundError struct {
    Resource string
    ID       int
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("%s with ID %d not found", e.Resource, e.ID)
}

var ErrUserNotFound = errors.New("user not found")

// composer.json
{
    "require": {
        "laravel/framework": "^5.5",
        "guzzlehttp/guzzle": "^7.0"
    }
}

composer install    # 安装到 vendor/
composer require    # 添加新依赖

# 1. 项目必须放在 $GOPATH/src/github.com/myuser/myproject 下
mkdir -p $GOPATH/src/github.com/myuser/myproject
cd $GOPATH/src/github.com/myuser/myproject

# 2. 用 dep（见 5.3）锁定依赖版本，自动生成 vendor/ 目录
dep ensure

# 3. 部署时直接 go build 即可，无需联网拉取
go build -o myapp

# Gopkg.toml
[[constraint]]
  name = "github.com/gin-gonic/gin"
  version = "1.7.0"

[[constraint]]
  name = "github.com/go-redis/redis"
  version = "8.0.0"

dep init                # 在已有项目中初始化 dep
dep ensure              # 根据 Gopkg.toml 同步依赖到 vendor/
dep ensure -update      # 升级到符合 constraint 的最新版

public function testAdd() {
    $calc = new Calculator();
    $this->assertEquals(5, $calc->add(2, 3));
}

func TestAdd(t *testing.T) {
    calc := Calculator{}
    got := calc.Add(2, 3)
    if got != 5 {
        t.Errorf("Add(2, 3) = %d, want 5", got)
    }
}

go test ./...           # 跑所有测试
go test -race ./...     # 开启 race detector
go test -cover ./...    # 显示覆盖率

go vet ./...       # 静态检查
gofmt -w .         # 格式化代码
goimports -w .     # 整理 import

func returnsError() error {
    var p *MyError = nil
    return p  // 错误：返回的不是 nil，是带类型的 nil
}

func main() {
    err := returnsError()
    if err != nil {
        // 这里会进入！err 不是 nil，是 *MyError(nil)
        fmt.Println("Oops:", err)
    }
}

func returnsError() error {
    if somethingWrong {
        return fmt.Errorf("bad thing happened")
    }
    return nil  // 显式返回 nil
}

s := []int{1, 2, 3}
s2 := append(s, 4)
// s 和 s2 可能共享底层数组
// 修改 s2 可能影响 s

func main() {
    for i := 0; i < 3; i++ {
        defer fmt.Println(i)  // 逆序输出：2, 1, 0
    }
}

for i := 0; i < 3; i++ {
    go func() {
        fmt.Println(i)  // 多数情况输出 3, 3, 3
    }()
}

for i := 0; i < 3; i++ {
    go func(i int) {
        fmt.Println(i)
    }(i)
}