入门教程:花 5 分钟学习 Go 语言
Posted Go语言中文网
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了入门教程:花 5 分钟学习 Go 语言相关的知识,希望对你有一定的参考价值。
这是一篇外文,号称五分钟入门 Go 语言。在周刊中推荐了这篇文章,今天看到 Seekload 翻译了,推荐给新手!
上周五的分享预告点赞已破百,成功解锁了今天的文章。
前几天看到优质文章推送,注意到这篇文章(主要是标题吸引了我),文章非常简洁,让我们一起来回顾下相关的基础知识。
原文如下:
基本
作为经典的 “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 git@github.com: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: 看原文评论,作者反馈接下来还会继续更新原文,我们拭目以待,如果更新的话第一时间给大家分享。
推荐阅读
以上是关于入门教程:花 5 分钟学习 Go 语言的主要内容,如果未能解决你的问题,请参考以下文章