D 的个人博客

全职做开源,自由职业者

  menu

Go 边看边练 -《Go 学习笔记》系列(一)

相信大家在看编程语言学习教程的时候都会难免觉得有点枯燥:

  • 自己看书,遇到问题不方便求助
  • 书上的代码片段、示例是静态的
  • 虽然有时书上会给出运行输出,但是不够直观
  • 自己拷贝代码到 IDE 里运行是也比较麻烦
  • 即使运行了也要来回在 IDE 和书之间切换,还是麻烦
  • 总之,程序员都是懒人

如果能边看边练就会舒服很多,书上的示例代码经过自己实际验证/微调后也更容易理解并消化。

基于这个出发点,Sym 社区决定给大家上干货中的干货:

  • 从内容上:选择了雨痕的《Go 学习笔记》作为教程,该书言简意赅,讲解的都是 Go 关键点
  • 从技术上:社区整合了 Go 黑科技——Wide,在技术上实现了边看边练

即使你以前看过该书,我们也强烈建议你在这里再看一遍,因为这将会带来完全不一样的体验~

光说不练假把式,上货!


ToC


1.1 变量

Go 是静态类型语言,不能在运行期改变变量类型。

使用关键字 var 定义变量,自动初始化为零值。如果提供初始化值,可省略变量类型,由编译器自动推断。

1var x int
2var f float32 = 1.6
3var s = "abc"	

在函数内部,可用更简略的 ":=" 方式定义变量。

1func main() {
2    x := 123        // 注意检查,是定义新局部变量,还是修改全局变量。该方式容易造成错误。
3}

可一次定义多个变量。

多变量赋值时,先计算所有相关值,然后再从左到右依次赋值。

1data, i := [3]int{0, 1, 2}, 0 
2i, data[i] = 2, 100                // (i = 0) -> (i = 2), (data[0] = 100) 

特殊只写变量 "_",用于忽略值占位。

编译器会将未使用的局部变量当做错误。

1var s string      // 全局变量没问题。
2
3func main() {
4	i := 0        // Error: i declared and not used。(可使用 "_ = i" 规避)
5}

注意重新赋值与定义新同名变量的区别。

1.2 常量

常量值必须是编译期可确定的数字、字符串、布尔值。

 1const x, y int = 1, 2 // 多常量初始化
 2const s = "Hello, World!" // 类型推断
 3
 4const ( // 常量组
 5	a, b = 10, 100
 6	c bool = false
 7)
 8
 9func main() {
10	const x = "xxx" // 未使⽤用局部常量不会引发编译错误。
11}

不支持 1UL、2LL 这样的类型后缀。

在常量组中,如不提供类型和初始化值,那么视作与上一常量相同。

1const (
2	s = "abc"
3	x // x = "abc"
4)

常量值还可以是 lencapunsafe.Sizeof 等编译期可确定结果的函数返回值。

1const (
2	a = "abc"
3	b = len(a)
4	c = unsafe.Sizeof(b)
5)

如果常量类型足以存储初始化值,那么不会引发溢出错误。

1const (
2	a byte = 100 // int to byte
3	b int = 1e20 // float64 to int, overflows
4)

枚举

关键字 iota 定义常量组中从 0 开始按行计数的自增枚举值。

 1const (
 2    Sunday = iota     // 0
 3    Monday            // 1,通常省略后续⾏行表达式。
 4    Tuesday           // 2
 5    Wednesday         // 3
 6    Thursday          // 4
 7    Friday            // 5
 8    Saturday          // 6
 9)
10
11const (
12    _         = iota                  // iota = 0
13    KB  int64 = 1 << (10 * iota)      // iota = 1
14    MB                                // 与 KB 表达式相同,但 iota = 2
15    GB
16    TB
17)

在同一常量组中,可以提供多个 iota,它们各自增长。

1const (
2    A, B = iota, iota << 10   // 0, 0 << 10
3    C, D                      // 1, 1 << 10
4)

如果 iota 自增被打断,须显式恢复。

1const (
2    A   = iota      // 0
3    B               // 1
4    C   = "c"       // c 
5    D               // c,与上⼀一⾏行相同。
6    E   = iota      // 4,显式恢复。注意计数包含了 C、D 两⾏行。
7    F               // 5
8)

可通过自定义类型来实现枚举类型限制。

下一篇: [1437558810339]



社区小贴士

  • 关注标签 [golang] 可以方便查看 Go 相关帖子
  • 关注标签 [Go 学习笔记] 可以方便查看本系列
  • 关注作者后如有新帖将会收到通知

该文章同步自 黑客派