5 分钟内学习 Go 语言？

点击上方蓝色“Golang来啦”关注我哟

加个“星标”，天天 15 分钟，掌握 Go 语言

via:
https://gist.github.com/prologic/5f6afe9c1b98016ca278f4d507e65510
作者：prologic

四哥水平有限，如有翻译或理解错误，烦请帮忙指出，感谢！

上周五的分享预告点赞已破百，成功解锁了今天的文章。

前几天看到优质文章推送，注意到这篇文章(主要是标题吸引了我)，文章非常简洁，让我们一起来回顾下相关的基础知识。

原文如下：

---

基本

作为经典的 “Hello World”，你的第一个 Go 程序非常简单：

先为我们的项目创建 workspace:

$ mkdir hello
$ cd hello

接着创建并初始化 Go module:

$ go mod init hello

使用你最喜欢的编辑器创建 main.go 文件，输入如下代码，并将文件保存在上面创建的 hello 目录下。

package main

import "fmt"

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

最后编译产生一个二进制文件：

$ go build

在 workspace 下会生成一个名为 hello 的二进制可执行文件，运行它会输出：

$ ./hello
Hello World!

变量

在 Go 语言里，你可以使用下面两种方法创建变量：

var x int

其他类型，包括 int、int32、int64、float32、float64、bool和 string 等，还有带 u 前缀的无符号整型类型，例如：uint8 与 byte 是同一种类型（ps:可以认为 type 是 uint8 的别称，见源码 type byte = uint8）

或者创建变量时直接赋值，Go 编译器能自动推导变量类型：

x := 42

通过操作符 = 赋值：

x = 1

注意： 大部分时候你都不需要使用 var 关键字，除非创建变量之后再赋值或者需要使用变量的零值。

函数

使用关键字 func 声明函数：

func hello(name string) string {
  return fmt.Sprintf("Hello %s", name)
}

函数如果有返回值，必须显示地指明返回值类型。

函数可以有多个返回值（一般返回错误和值）：

func isEven(n int) (bool, error) {
  if n <= 0 {
    return false, fmt.Errorf("error: n must be > 0")
  }
  return n % 2 == 0, nil
}

函数是 Go 语言的“一等公民”，因此支持很多函数式编程的很多特性，包括闭包、将函数作为参数传递或者返回等，例如：

func AddN(n int) func(x int) int {
  return func(x int) int {
    return x + n
  }
}

结构体

由于 Go 是一种多范式语言，因此它还通过结构体实现“面向对象”编程，使用关键字 struct 定义结构体：

type Account struct {
  Id      int
  Balance float64
}

结构体字段的定义与变量定义类似，使用操作符 . 访问字段：

account := Account{}
fmt.Printf("Balance: $%0.2f", account.Balance)

方法

结构体可以拥有自己的方法。不像其他语言，Go 语言不支持继承也没有类（我们可以通过结构体嵌套实现“继承”）。

type Account struct {
  id  int
  bal float64
}

func (a *Account) String() string {
  return fmt.Sprintf("Account[%d]: $0.2f", a.id, a.bal)
}

func (a *Account) Deposit(amt flaot64) float64 {
  a.bal += amt
  return a.bal
}

func (a *Account) Withdraw(amt float64) float64 {
  a.bal -= amt
  return a.bal
}

func (a *Account) Balance() float64 {
  return a.bal
}

这些方法称为指针接收者方法，因为第一个参数是指向 Account 结构体的指针。

你还可以像下面这样定义方法：

type Circle struct {
  Radius float64
}

func (c Circle) Area() float64 {
  return 3.14 * c.Radius * c.Radius
}

刚刚定义的是值接收者方法，在方法中对结构体修改不会影响到原结构体，是一份拷贝。

关于结构体、指针接收者方法和值接收者方法可以查看文末推荐阅读了解更多。

数组和 Slice

与其他语言类似，Go 支持数组，不同的是 Go 语言数组是固定长度的（声明长度之后不支持动态变化），与 C 语言数组类似。

可以指定大小和类型创建数组：

xs := [4]int{1, 2, 3, 4}

大多数场景你会更喜欢使用 slice，有点类似其他语言（比如 Python）中的 list，支持自动扩容。

创建 slice 时可以不用指定大小：

xs := []int{1, 2, 3, 4}

slice 也可以通过 append() 函数创建：

xs := []int{}
xs = append(xs, 1)
xs = append(xs, 2)
xs = append(xs, 3)

可以通过索引范围 slice:

xs[1]  // 2

你还可以通过“切片”操作获取数组或者 slice 的子集：

ys := xs[1:] // [2, 3]

可以使用 range 关键字迭代 数组或者 slice:

for i, x := range xs {
  fmt.Printf("xs[%d] = %d\n", i, x)
}

map

Go 语言里存储键值对的内置数据结构称为 map（类似其他语言的 hash table、hash map、字典或者关联数组）。

可以通过关键字 map 创建 map，需要分别定义键值的类型，比如定义键类型为 string、值类型为 int 的 map:

var counts map[string]int

也可以像下面这样创建 map:

counts := map[string]int{
  "Apples": 4,
  "Oranges": 7,
}

类似数组和 slice，也可以通过键访问值：

counts["Apples"]  // 4

像数组和 slice 一样，迭代 map:

for key, value := range counts {
  fmt.Printf("%s: %d\n", key, value)
}

唯一需要注意的是，map 使用之前需要先初始化，操作 nil map 将会导致 error 和 panic:

var counts map[string]int
counts["Apples"] = 7  // This will cause an error and panic!

使用之前必须使用 make() 函数初始化：

counts := make(map[string]int)
counts["Apples"] = 7

关于数组、slice 和 map 更详细的用法可以查看文末推荐阅读掌握。

流控制

for

Go 语言里面只有一种循环结构，在之前的章节里或许你也看到了：

sum := 0
for i := 0; i < 10; i++ {
  sum += i
}

for 循环语句由三部分组成：

• 初始化语句：第一次迭代之前执行；

• 条件表达式：每次迭代之前都会执行；

• post 语句：每次迭代之后都会执行；

如果忽略循环条件，得到的是无限循环：

for {
}
// This line is never reached!

if-else

Go 语言支持 if-else 语句：

N := 42
func Guess(n int) string {
  if n == 42 {
    return "You got it!"
  } else if n < N {
    return "Too low! Try again..."
  } else {
    return "Too high! Try again..."
  }
}        

注意：可以忽略最后一个 else，直接像这样返回 return "Too high~ Try again…"，两者是等价的。

switch

Go 语言提供的 switch 语句可以代替 if-else，比如：

func FizzBuzz(n int) string {
  switch n {
  case n % 15 == 0:
    return "FizzBuzz"
  case n % 3 == 0:
    return "Fizz"
  case n % 5 == 0:
    return "Buzz"
  default:
    return fmt.Sprintf("%d", n)
  }
}

defer

关键字 defer 可以定义延迟函数，在调用函数返回之前调用，通常在调用函数执行结束之前自动关闭资源(比如文件句柄、数据库连接等)，像下面这样：

package main

import (
  "os"
  "fmt"
)

func Goodbye(name string) {
  fmt.Printf("Goodbye %s", name)
}

func Hello(name string) {
  defer Goodbye(name)
  fmt.Printf("Hello %s", name)
}

func main() {
  user := os.Getenv("User")
  Hello(user)
}

执行会输出：

$ ./hello
Hello prologic
Goodbye prologic

关于 defer 语句的详细使用方法可以阅读文末推荐阅读掌握。

错误处理

Go 语言里 Errors 代表的是值，比如，使用 os.Open 打开一个文件，如果成功的话会返回一个指向文件的指针和 nil；否则返回 nil 指针和具体的错误。

f, err := os.Open("/path/to/file")

类似其他值类型一样检查错误：

f, err := os.Open("/path/to/file")
if err == nil {
  // do something with f
}

Go 语言里，通常的做法是检查函数是否返回非 nil 错误，是的话就直接返回，比如：

func AppendFile(fn, text string) error {
  f, err := os.OpenFile(fn, os.O_CREATE|os.O_APPEND|os.WR_ONLY, 0644)
  if err != nil {
    return fmt.Errorf("error opening file for writing: %w", err)
  }
  defer f.Close()

  if _, err := f.Write([]byte(text)); err != nil {
    return fmt.Errorf("error writing text to fiel: %w", err)
  }

  return nil
}

创建和导入包

Go 支持 module(包管理)，允许你创建并导入相关包，在刚开始的基本章节中，我们已经知道如何在启动新项目时使用 go mod init 创建模块。

Go 的包仅仅是一个包含源代码目录：

创建 Go 包的第一步是创建一个目录，就像下面这样：

$ mkdir shapes

使用命令 go mod init 初始化：

$ cd shapes
$ go mod init github.com/prologic/shapes

现在让我们一起使用你最喜欢的编辑器创建一个 circle.go 模块：

package shapes

type Circle struct {
  Radius float64
}

func (c Circle) String() string {
  return fmt.Sprintf("Circle(%0.2f)", c.Radius)
}

func (c Circle) Area() float64 {
  return 3.14 * c.Radius * c.Radius
}

需要特别注意的是，包里的函数、结构体、变量和常量的首字母必须是大写才是可导出的；否则即使你导入了相关包也无法访问。

现在，在 Git 上创建名为 shapes 的仓库并 push 你的包代码：

$ git init
$ git commit -a -m "Initial Commit"
$ git remote add origin [email protected]:prologic/shapes.git
$ git push -u origin master

这样的话，你就可以使用全路径 github.com/prologic/shapes 导入 shapes 包，编译时会根据路径自动拉取并构建包。

例如：

我们使用 github.com/prologic/shapes 包做一个例子：

$ mkdir hello
$ go mod init hello

编写 main.go：

package main

import (
  "fmt"

  "github.com/prologic/shapes"
)

func main() {
  c := shapes.Circle{Radius: 5}
  fmt.Printf("Area of %s: %0.2f\n", c, c.Area())
}

编译：

$ go build

运行二进制文件：

$ ./hello
Area of Circle(5.00): 78.50

Congratulations!

Now you're a Gopher!

ps: 看原文评论，作者反馈接下来还会继续更新原文，我们拭目以待，如果更新的话第一时间给大家分享。

推荐阅读：

结构体、方法：

Go 面向对象式编程

Golang 面向对象编程

Go 面向对象编程（译）

包罗万象的结构体

教女朋友写方法

教女朋友写方法（续）

数组、map 和 slice:

我是数组

Go Map

如果 map 不是引用变量，那是什么？

Go slice 全面指南

非懂不可的Slice（一）

非懂不可的Slice（二）

defer:

深入理解 Defer 函数

5 年 Gopher 都不知道的 defer 细节，你别再掉进坑里！

---

这是持续翻译的第 13/100 篇优质文章。
如果你有想交流的话题，欢迎留言。

---

如果我的文章对你有所帮助，点赞、转发都是一种支持！

给个[在看]，是对四哥最大的支持