Golang 通关初级（1）

原文

https://tour.golang.org/welcome/1

Hello， 世界

package main

import "fmt"

func main() {
    fmt.Println("Hello, 世界")
}
   
   
1
2
3
4
5
6
7
   
   
1
2
3
4
5
6
7

输出：

Hello, 世界
   
   
1
   
   
1

包

每个 Go 程序都是由包构成的。

程序从 main 包开始运行。

本程序通过导入路径 “fmt” 和 “math/rand” 来使用这两个包。

按照约定，包名与导入路径的最后一个元素一致。例如，"math/rand" 包中的源码均以 package rand 语句开始。

package main

import (
    "fmt"
    "math/rand"
)

func main() {
    fmt.Println("My favorite number is", rand.Intn(10))
}

   
   
1
2
3
4
5
6
7
8
9
10
11
   
   
1
2
3
4
5
6
7
8
9
10
11

输出：

My favorite number is 1
   
   
1
   
   
1

导入

此代码用圆括号组合了导入，这是“分组”形式的导入语句。

当然你也可以编写多个导入语句，例如：

import "fmt"
import "math"
   
   
1
2
   
   
1
2

不过使用分组导入语句是更好的形式。

package main

import(
    "fmt"
    "math"
)

func main(){

    fmt.Printf("xxxx %g  \n===", math.Sqrt(25))
}
   
   
1
2
3
4
5
6
7
8
9
10
11
   
   
1
2
3
4
5
6
7
8
9
10
11

输出：

xxxx 5  
===
   
   
1
2
   
   
1
2

导出名

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。 例如， Pizza 就是个已导出名， Pi 也同样，它导出自 math 包。

pizza 和 pi 并未以大写字母开头，所以它们是未导出的。

在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

执行代码，观察错误输出。

然后将 math.pi 改名为 math.Pi 再试着执行一次。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(math.Pi)
}
   
   
1
2
3
4
5
6
7
8
9
10
   
   
1
2
3
4
5
6
7
8
9
10

输出：

3.141592653589793
   
   
1
   
   
1

函数

函数可以没有参数或接受多个参数。

在本例中， add 接受两个 int 类型的参数。

注意类型在变量名 之后 。

package main

import "fmt"

func add(x int, y int) int {
    return x + y
}

func main() {
    fmt.Println(add(42, 13))
}
   
   
1
2
3
4
5
6
7
8
9
10
11
   
   
1
2
3
4
5
6
7
8
9
10
11

输出：

55
   
   
1
   
   
1

当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略。

在本例中，

x int, y int
   
   
1
   
   
1

被缩写为

x, y int
   
   
1
   
   
1

package main

import (
    "fmt"   
)

func main(){
    fmt.Println(add(5, 15))
}

func add(a, b int) int{

    return a + b    
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

20
   
   
1
   
   
1

多值返回

函数可以返回任意数量的返回值。

swap 函数返回了两个字符串。

package main

import "fmt"

func swap(x, y string) (string, string) {
    return y, x
}

func main() {
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12

输出：

world hello
   
   
1
   
   
1

命名返回值

Go 的返回值可被命名，它们会被视作定义在函数顶部的变量。

返回值的名称应当具有一定的意义，它可以作为文档使用。

没有参数的 return 语句返回已命名的返回值。也就是直接返回。

直接返回语句应当仅用在下面这样的短函数中。在长的函数中它们会影响代码的可读性。

package main

import(
    "fmt"
)

func main(){
    fmt.Println(show(22, 14))
}

func show(a, b int) (x, y int){
    x = a + b
    y = a - b
    return  
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

36 8
   
   
1
   
   
1

变量

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

就像在这个例子中看到的一样， var 语句可以出现在包或函数级别。

package main

import (
    "fmt"
)

var a, b int

func main() {
    var c bool
    fmt.Println(a, b, c)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13

输出：

0 0 false
   
   
1
   
   
1

变量的初始化

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

package main

import (
    "fmt"
)

var a int = 100

func main() {
    var i, b, d, e = 1, false, true, 3.9
    fmt.Println(a, i, b, d, e)
}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12

输出:

100 1 false true 3.9
   
   
1
   
   
1

短变量声明

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（ var 、 func 等等）， 因此 := 结构不能在函数外使用。

package main

import (
    "fmt"
)

func main() {
    var a, b int = 10, 22
    c, d, e := 12, false, 33.22
    fmt.Println(a, b, c, d, e)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12

输出：

10 22 12 false 33.22
   
   
1
   
   
1

基本类型

Go 的基本类型有：

bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // uint8 的别名

rune // int32 的别名
     // 表示一个 Unicode 码点

float32 float64

complex64 complex128
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

本例展示了几种类型的变量。 同导入语句一样，变量声明也可以“分组”成一个语法块。

int 、 uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

package main

import (
    "fmt"
    "math/cmplx"
)

var (
    ToBe   bool       = false
    MaxInt uint64     = 1<<64 - 1
    z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
    const f = "%T(%v)\n"
    fmt.Printf(f, ToBe, ToBe)
    fmt.Printf(f, MaxInt, MaxInt)
    fmt.Printf(f, z, z)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出：

bool(false)
uint64(18446744073709551615)
complex128((2+3i))
   
   
1
2
3
   
   
1
2
3

零值

没有明确初始值的变量声明会被赋予它们的 零值 。

零值是：

数值类型为 0 ， 
布尔类型为 false ， 
字符串为 “” （空字符串）。

package main

import (
    "fmt"
)

func main() {
    var a int
    var b bool
    var c string
    var d float64
    fmt.Printf("%v, %v, %q, %v\n", a, b, c, d)

}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

0, false, "", 0
   
   
1
   
   
1

类型转换

表达式 T(v) 将值 v 转换为类型 T 。

一些关于数值的转换：

var i int = 42
var f float64 = float64(i)
var u uint = uint(f)
   
   
1
2
3
   
   
1
2
3

或者，更加简单的形式：

i := 42
f := float64(i)
u := uint(f)
   
   
1
2
3
   
   
1
2
3

与 C 不同的是，Go 在不同类型的项之间赋值时需要显式转换。 试着移除例子中 float64 或 int 的转换看看会发生什么。

package main

import (
    "fmt"
    "math"
)

func main() {
    var x, y int = 3, 6
    f := float64(math.Sqrt(float64(x*x + y*y)))
    var g int = int(f)

    fmt.Println(x, y, f, g)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

3 6 6.708203932499369 6
   
   
1
   
   
1

类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法 或 var = 表达式语法）， 变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

var i int
j := i // j 也是一个 int
   
   
1
2
   
   
1
2

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int 、 float64 或 complex128 了，这取决于常量的精度：

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128
   
   
1
2
3
   
   
1
2
3

package main

import (
    "fmt"
)

func main() {
    a := 12
    b := true
    c := "xxx"
    d := 12.222
    fmt.Printf(" a %T\n b %T\n c %T \n d %T \n", a, b, c, d)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

 a int
 b bool
 c string 
 d float64 
   
   
1
2
3
4
   
   
1
2
3
4

常量

常量的声明与变量类似，只不过是使用 const 关键字。

常量可以是字符、字符串、布尔值或数值。

常量不能用 := 语法声明。

package main

import (
    "fmt"
)

const (
    f = 12i
)

func main() {
    const (
        a = 2
        b = 3.12
        c = true
        d = "sssss"
    )
    fmt.Println(a, b, c, d, f)
}


   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出：

2 3.12 true sssss (0+12i)
   
   
1
   
   
1

数值常量

数值常量是高精度的 值 。

一个未指定类型的常量由上下文来决定其类型。

（ int 类型最大可以存储一个 64 位的整数，有时会更小。）

（int 可以存放最大64位的整数，根据平台不同有时会更少。）

package main

import "fmt"

const (
    // Create a huge number by shifting a 1 bit left 100 places.
    // In other words, the binary number that is 1 followed by 100 zeroes.
    Big = 1 << 100
    // Shift it right again 99 places, so we end up with 1<<1, or 2.
    Small = Big >> 99
)

func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
    return x * 0.1
}

func main() {
    fmt.Println(needInt(Small))
    fmt.Println(needFloat(Small))
    fmt.Println(needFloat(Big))

}
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出：

21
0.2
1.2676506002282295e+29
   
   
1
2
3
   
   
1
2
3

再尝试一下输出 needInt(Big) : 
报错：

# command-line-arguments
.\compile33.go:22: constant 1267650600228229401496703205376 overflows int
   
   
1
2
   
   
1
2

for

Go 只有一种循环结构： for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行 
条件表达式：在每次迭代前求值 
后置语句：在每次迭代的结尾执行 
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

注意：和 C、Java、JavaScript 之类的语言不同，Go 的 for 语句后面没有小括号，大括号 { } 则是必须的。

package main

import (
    "fmt"
)

func main() {
    var b int
    for i := 0; i < 8; i++ {
        fmt.Printf("i = %v, b++\n", i)
        b++
    }
    fmt.Printf("b = %v\n", b)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

i = 0, b++
i = 1, b++
i = 2, b++
i = 3, b++
i = 4, b++
i = 5, b++
i = 6, b++
i = 7, b++
b = 8
   
   
1
2
3
4
5
6
7
8
9
   
   
1
2
3
4
5
6
7
8
9

初始化语句和后置语句是可选的：

package main

import "fmt"

func main() {
    sum := 1
    for ; sum < 1000; {
        sum += sum
    }
    fmt.Println(sum)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12

输出：

1024
   
   
1
   
   
1

for 也是 Go 中的 “while” 
此时你可以去掉分号：C 的 while 在 Go 中叫做 for:

package main

import (
    "fmt"
)

func main() {
    var b int
    for b < 9 {
        b++
    }
    fmt.Printf("b = %v\n", b)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

b = 9
   
   
1
   
   
1

无限循环 
如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。

package main

func main() {
    for {
    }
}

   
   
1
2
3
4
5
6
7
   
   
1
2
3
4
5
6
7

if

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(sqrt(-4), sqrt(9))
}

func sqrt(x float64) string {

    if x < 0 {
        return sqrt(-x) + "i"
    }

    return fmt.Sprint(math.Sqrt(x))
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出：

2i 3
   
   
1
   
   
1

if 的简短语句 
同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(sqrt(2, 3, 10))
    fmt.Println(sqrt(4, 5, 10))
}

func sqrt(a, b, c float64) float64 {
    if d := math.Pow(a, b); d < c {
        return d
    }
    return c
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出：

8
10
   
   
1
2
   
   
1
2

if 和 else 
在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(sqrt(2, 3, 10))
    fmt.Println(sqrt(2, 4, 11))
}

func sqrt(a, b, c float64) float64 {
    if d := math.Pow(a, b); d < c {
        return d
    } else {
        fmt.Printf("%g >= %g\n", d, c)
    }
    // 这里开始就不能使用 d 了
    return c
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出：

8
16 >= 11
11
   
   
1
2
3
   
   
1
2
3

switch

除非以 fallthrough 语句结束，否则分支会自动终止。Go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码。

package main

import (
    "fmt"
    "runtime"
)

func main() {

    switch a := runtime.GOOS; a {

    case "windows":
        fmt.Println("Windows")
        fallthrough
    case "darwin":
        fmt.Println("OS X.")
    case "linux":
        fmt.Println("Linux.")
    default:

        // freebsd, openbsd,
        // plan9...
        fmt.Printf("%s.\n", a)
    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

输出：

WWWW
OS X.
   
   
1
2
   
   
1
2

switch 的求值顺序 
switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。

（例如，

switch i { 
case 0: 
case f(): 
} 
在 i==0 时 f 不会被调用。）

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("When is Saturday?")
    today := time.Now().Weekday()

    fmt.Printf("Today is %v\nSaturday is ", today)

    switch time.Saturday {
    case today + 0:
        fmt.Println("Is Today")

    case today + 1:
        fmt.Println("Is Tomorrow")

    case today + 2:
        fmt.Println("In Two Days")

    case today + 3:
        fmt.Println("In Three Days")

    default:
        fmt.Println("Too far away.")
    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

输出：

When is Saturday?
Today is Tuesday
Saturday is Too far away.
   
   
1
2
3
   
   
1
2
3

没有条件的 switch 
没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now().Hour()
    fmt.Printf("Time now is %v\n", t)
    switch {
    case t < 12:
        fmt.Println("Good morning.")
    case t < 17:
        fmt.Println("Good afternoon.")
    default:
        fmt.Println("Good evening.")
    }
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出：

Time now is 16
Good afternoon.
   
   
1
2
   
   
1
2

defer

defer 语句会将函数推迟到外层函数返回之后执行。

推迟调用的函数其参数会立即求值，但直到外层函数返回前该函数都不会被调用。

package main

import (
    "fmt"
)

func main() {
    defer sqrt(9)

    fmt.Println("9 * 9: ")
}

func sqrt(x float64) {
    fmt.Println(x * x)
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出：

9 * 9: 
81
   
   
1
2
   
   
1
2

defer 栈 
推迟的函数调用会被压入一个栈中。 当外层函数返回时，被推迟的函数会按照后进先出的顺序调用。

更多关于 defer 语句的信息， 请阅读此博文。

package main

import "fmt"

func main() {
    fmt.Println("counting")

    for i := 0; i < 10; i++ {
        defer fmt.Println(i)
    }

    fmt.Println("done")
}

   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出：

counting
done
9
8
7
6
5
4
3
2
1
0
   
   
1
2
3
4
5
6
7
8
9
10
11
12
   
   
1
2
3
4
5
6
7
8
9
10
11
12