变量&函数
最近在学习golang，写下学习笔记提升记忆。
为了看起来不是那么枯燥，本学习笔记采用分析代码的形式。
首先搬出我们最经典的第一段代码:
HUGOMORE42
hello world
1
2
3
4
5
6
7
8
|
package main // 0
import "fmt" // 1实现格式化的 I/O
/* Print something */ // 2
func main() { // 3
fmt.Println("Hello, world; or καλημε ́ρα κóσμε; orこんにちは 世界") // 4
}
|
首先我们要认识到
每个Go 程序都是由包组成，程序的运行入口是包main
- 首行这个是必须的。所有的 Go 文件以 package 开头,对于独立运行的执行文件必须是 package main;
- 这是说需要将fmt加入到main。不是main 的包被称为库 末尾以 // 开头的内容是单行注释 Package fmt包含有格式化I/O函数，类似于C语言的printf和scanf
- 这也是注释，表示多行注释。
- package main 必须首先出现,紧跟着是 import。在 Go 中,package 总是首先出现, 然后是 import,然后是其他所有内容。当 Go 程序在执行的时候,首先调用的函数 是 main.main(),这是从 C 中继承而来。这里定义了这个函数
- 调用了来自于 fmt 包的函数打印字符串到屏幕。字符串由 " 包裹,并且可以包含非 ASCII 的字符。这里使用了希腊文和日文、中文"
编译和运行代码
构建 Go 程序的最佳途径是使用 go 工具。 构建 helloworld 只需要:
1
2
3
4
|
1. go build helloworld.go
# 结果是叫做 helloworld 的可执行文件。
2. ./helloworld
# Hello, world; or καλημε ́ρα κóσμε; or こんにちは世界
|
变量
Go 是静态类型语言 ,不能在运行期改变变量类型。
自动初始化为零值。如果提供初始化值,可省略变量类型,由编译器自动推断。
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
|
var x int
// 使用关键字 var 定义变量, 跟函数的参数列表一样，类型在后面。
var c, python, java bool
// 多个相同类型的变量可以写在一行。
var f float32 = 1.6
var i, j int = 1, 2
// 变量定义可以包含初始值，每个变量对应一个。
var s = "abc"
// 如果初始化是使用表达式，则可以省略类型；变量从初始值中获得类型。
```go
变量在定义时没有明确的初始化时会赋值为*零值* 。
零值是：
* 数值类型为 0 ，
* 布尔类型为 false ，
* 字符串为 "" （空字符串）。
在函数内部,可用更简略的 ":=" 式定义变量。
```go
func main() {
n, s := 12, "Hello, World!"
println(s, n)
}
|
函数外的每个语句都必须以关键字开始（ var 、 func 、等等）， := 结构不能使用在函数外。
可一次定义多个变量。
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
var x, y, z int
var s, n = "abc", 123
var (
a int
b float32
)
func main() {
n, s := 0x1234, "Hello, World!"
println(x, s, n)
}
```go
一个特殊的变量名是 \_(下划线)。任何赋给它的值都被丢弃。在这个例子中,将 35 赋值给 b,同时丢弃 34。
```go
_, b := 34, 35
```go
Go 的编译器会对声明却未使用的变量报错
```go
var s string // 全局变量没问题。
func main() {
i := 0 // Error: i declared and not used。(可使 "_ = i" 规避)
}
```go
定义完之后的变量可以被重新赋值 比如第8行，将计算结果赋值给result
#### 常量
> 常量值必须是编译期可确定的数字、字符串、布尔值。
常量的定义与变量类似，只不过使用 const 关键字
```go
const x, y int = 1, 2
const s = "Hello, World!"
// 多常量初始化 // 类型推断
// 常量组
const (
a, b = 10, 100
c bool = false
)
func main() _{
const x = 'xxx' // 未使用局部常量不会引发编译错误
}
```go
在常量中，如果不提供类型和初始化值，那么被看作和上一常量相同
```go
const (
s = "abc"
x // x = "abc"
)
```go
#### 基本类型
Go 有明确的数字类型命名, 支持 Unicode, 支持常用数据结构
|类型 | 长度 | 默认值| 说明|
|:------- |:----- | :---- | :---- |
|bool | 1 | false |
|byte | 1 | 0 | unit8
|rune | 4 | 0 | int32 的别名 代表一个Unicode 码
|int, unit | 4 或 8 | 0 | 32 或 64
|int8, unit8 | 1 | 0 | -128 ~ 127, 0~255
|int16, unit16 | 2 | 0 | -32768 ~ 32767, 0 ~ 65535
|int32, unit32 | 4 | 0 | -21亿~ 21亿, 0 ~ 42亿
|int64, unit64 | 8 | 0 |
|float32 | 4 | 0.0 |
|float64 | 8 | 0.0 |
|complex64 | 8 | |
|complex128 | 16 | |
|unitptr | 4或8 | | 足以存储指针的unit32 或unit64 整数
|array | | | 值类型
|struct | | | 值类型
|string | | "" | UTF-8 字符串
|slice | | nil | 引用类型
|map | | nil | 引用类型
|channel | | nil | 引用类型
|interface | | nil | 接口
|function | | nil | 函数
> int，uint 和 uintptr 类型在32位的系统上一般是32位，而在64位系统上是64位。当你需要使用一个整数类型时，你应该首选 int，仅当有特别的理由才使用定长整数类型或者无符号整数类型。
> 引用类型包括 slice、map 和 channel。它们有复杂的内部结构,除了申请内存外,还需要初始化相关属性
#### 类型转换
不支持隐式的类型转换
表达式 T(v) 将值 v 转换为类型 T 。
```go
var b byte = 100
// var n int = b // Error: cannot use b (type byte) as type int in assignment
var n int = int(b) // 显式转换
```go
不能将其他类型当 bool 值使用
```go
a := 100
if a { // Error: non-bool a (type int) used as if condition
println("true")
}
|
函数
首先看下面这段代码
1
2
3
4
5
6
7
8
9
10
11
|
package main
import "fmt"
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(add(42, 13))
}
|
函数定义
使用关键字 func 定义函数,左大括号不能另起一行
golang中符合规范的函数一般写成如下的形式：
1
2
3
4
5
6
|
func functionName(parameter_list) (return_value_list) {
…
}
// parameter_list 是参数列表
// return_value_list 是返回值列表 下边有详细的讲解
|
函数的特性
- 无需声明原型。 (1)
- 支持不定长变参。
- 支持多返回值。
- 支持命名返回参数。
- 支持匿名函数和闭包。
- 不支持 嵌套 (nested)、重载 (overload) 和 默认参数 (default parameter)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
func test(x int, y int, s string) (r int, s string) { // 类型相同的相邻参数可合并
n := x + y // 多返回值必须用括号。
return n, fmt.Sprintf(s, n)
}
/*
关键字 func 用于定义一个函数
test 是你函数的名字
int类型的变量x, y 和string类型的变量s作为输入参数 参数用pass-by-value方式传递,意味着它们会被复制
当两个或多个连续的函数命名参数是同一类型，则除了最后一个类型之外，其他都可以省略。
在这个例子中：
x int, y int
被缩写为
x, y int
变量 r 和 s 是这个函数的 命名返回值。在 Go 的函数中可以返回多个值
如果不想对返回的参数命名,只需要提供类型:(int, string)。 如果只有一个返回值,可以省略圆括号。如果函数是一个子过程,并且没有任何返回值,也可以省略这些内容
函数体。注意 return 是一个语句,所以包裹参数的括号是可选的
*/
|
不定长参数其实就是slice，只能有一个，且必须是最后一个
1
2
3
4
5
6
7
8
9
10
11
12
|
func test(s string, n ...int) string {
var x int
for _, i := range n {
x += i
}
return fmt.Sprintf(s, x)
}
// 使用slice 做变参时，必须展开
func main() {
s := []int{1, 2, 3}
println(test("sum: %d", s...))
}
|
函数是第一类对象,可作为参数传递
就像其他在 Go 中的其他东西一样,函数也是值而已。它们可以像下面这样赋值给变量:
1
2
3
4
5
6
|
func main() {
a := func() { // 定义一个匿名函数,并且赋值给 a
println("Hello")
} // 这里没有 ()
a() // 调用函数
}
|
如果使用 fmt.Printf("%T\n", a) 打印 a 的类型,输出结果是 func()
返回值
函数可以返回任意数量返回值
Go 函数的返回值或者结果参数可以指定一个名字,并且像原始的变量那样使用,就像 输入参数那样。如果对其命名,在函数开始时,它们会用其类型的零值初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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)
}
/*
函数可以返回任意数量返回值
swap 函数返回了两个字符串
*/
|
Go 的返回值可以被命名，并且就像在函数体开头声明的变量那样使用。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
package main
import "fmt"
func split(sum int) (x, y int) { // 初始化返回值为 x,y
x = sum * 4 / 9 // x,y 已经初始化，可以直接赋值使用
y = sum - x
return // 隐式返回x,y(裸返回)
}
func main() {
fmt.Println(split(17))
}
/*
在长的函数中这样的裸返回会影响代码的可读性。
*/
|
有返回值的函数,必须有明确的return 语句,否则会引发编译错误
名词解释
函数原型
函数声明由函数返回类型、函数名和形参列表组成。形参列表必须包括形参类型,但是不必对形参命名。这三个元素被称为函数原型,函数原型描述了函数的接口
函数原型类似函数定义时的函数头，又称函数声明。为了能使函数在定义之前就能被调用，C++规定可以先说明函数原型，然后就可以调用函数。函数定义可放在程序后面。 由于函数原型是一条语句，因此函数原型必须以分号结束。函数原型由函数返回类型、函数名和参数表组成，它与函数定义的返回类型、函数名和参数表必须一致。函数原型必须包含参数的标识符（对函数声明而言是可选的）注意：函数原型与函数定义必须一致，否则会引起连接错误
参考链接
Go 指南
The way to go – 变量
Effective Go
变量和函数部分暂时这些，有更新还会补充。下一篇将会是控制流
将会用到的代码为:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
package main
import "fmt"
func main() {
result := 0
for i := 0; i <= 10; i++ {
result = fibonacci(i)
fmt.Printf("fibonacci(%d) is: %d\n", i, result)
}
}
func fibonacci(n int) (res int) {
if n <= 1 {
res = 1
} else {
res = fibonacci(n-1) + fibonacci(n-2)
}
return
}
|
最后，感谢女朋友支持和包容，比❤️
也可以在公号输入以下关键字获取历史文章：公号&小程序 | 设计模式 | 并发&协程
内推时间
