Golang 通关初级（1）

录(?)[-]

1. 原文
2. Hello 世界
3. 包
4. 导入
5. 导出名
6. 函数
7. 多值返回
8. 命名返回值
9. 变量
10. 变量的初始化
11. 短变量声明
12. 基本类型
13. 零值
14. 类型转换
15. 类型推导
16. 常量
17. 数值常量
18. for
19. if
20. switch
21. defer

原文

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

零值

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

<p style="margin-top: 0px; margin-bottom: 1.1em; padding-t