坐忘峰

告别昨日梦，今朝艳阳天。

大道通四方，车影舞翩翩。

不做旁观者，去向应了然。

白云绕远树，飞燕春汛传。

天下万千景，彩绘壮河山。

我辈当努力，敢把宏图展。

迈步似虎跃，挥臂龙盘旋。

天地更广阔，豪气入云端。

送给刚度过周末，又要开始上班的程序员们。按照惯例，每周的周一都应该是复盘上周进度，制定本周计划的时间点。每每到了这一天，都是几家欢喜几家愁，有的庆幸进度正常，有的发愁扯皮何时休。欢喜也罢，发愁也罢，在这个天干物燥的冬季，还是要保持乐观平和的心态。气大伤身，提防感冒🤧。老人说得好，酒是穿肠毒药，色是刮骨钢刀, 财是惹祸根苗，气是无烟火炮。这世上吧，没有无缘无故的夸奖，也没有无缘无故的批评。轮到自己挨批评了，别真真计较，心怀宽广，莞尔一笑，世界就变得美好了许多。

话说太多就是烦， 本文也不是心理访谈，所以就此打住不再延伸。总之一句话，工作就是一个工作，又不是你的全部，干嘛那么较真。真要较真，咱们就应该较真一下Golang 🙄。 毕竟，我是写技术文章的，技术才是老本行。 开导人生，那是鞠萍姐姐的工作，下面才是我的工作。

Golang的判断

golang的判断也就是If..else.. , switch和select。 通俗点就是如果满足条件去干嘛，如果不满足条件去干嘛。每种编程语言都有这么一套判断机制，而且判断的标准也大同小异。而唯一不同的地方，就是语法细节千奇百怪。 大胆猜测一下，可能目前流行的编程语言都或多或少受到了C语言的影响，而且绝大多数的程序员开山之课都是C语言，也就造成先入为主的影响。因此C语言是什么风格，新的语言就要仿造的八九不离十，要不学习曲线太陡，光吓就要吓走一大波人。

所以，如果你有其它语言的学习基础，本节基本可以一扫而过。 如果你没有其它语言基础，或者对自己没有足够的自信，就看一看吧。 技多不压身，多学点没坏处。

先来看If。

If是典型的判断语句。 语法是:

  1. If <条件> {}
  3. 例如:
  4. If a >= 0 {
  5.     xxxxx
  6. }

在条件中括号不是必须存在的，可加可不加。 如果你从JS转过来学Golang，那么恭喜你了，加上也没事。 如果Golang转过去学Js，每次都要记得添加括号，这个习惯不是一会半会能扳过来的。

然后再看If … else …

上面是如果满足怎么办，属于单元判断。 而If … else… 是双元判断，如果满足怎么办，否则怎么办.

  1. If <条件>{
  2.     满足的情况
  3. } else{
  4.     不满足的情况
  5. }

双元+单元=多元。将If .. else ..级联起来，就是多元判断。例如:

  1. if <条件1> {
  3. } else if <条件2> {
  5. } else if <条件3> {
  7. }

同样是多元判断，switch的语法看起来就会比If .. else if 要简洁。

  1. switch <表达式>{
  2.     case <值1>:
  3.     case <值2>:
  4.     defalut:
  5. }

上面说过，每个语言在细节上面都有不同。 在Golang中：

  • switch判断不需要添加break。别问为什么，编译器就是这么规定的，匹配一个后，就会退出这个语义块，所以不需要break
  • default是可选项，同样不需要问为什么，如果都匹配不成功，那就是匹配不成功。没有异常，没有报错。所以有可能程序出现非预期结果。
  • 表达式部分必须是一个完整的布尔表达式，或者是一个推算出唯一结果的函数。 如果表达式为空，或者计算失败，则默认为True。
  • 所有的case必须是同一种数据类型，如果类型不一致，就有可能出现非预期的计算结果
  • 通过fallthrough可以跳过case判断。例如:
  1. a := 1
  2. switch {
  3.     case a >= 1:
  4.         fmt.Println("a>=1")
  5.         fallthrough
  6.     case a >= 2:
  7.         fmt.Println("a>=2")
  8.         fallthrough
  9.     case a >= 3:
  10.         fmt.Println("a>=3")
  11.         fallthrough
  12.     case a >= 4:
  13.         fmt.Println("a>=4")
  14.         fallthrough
  15.     default:
  16.     }

执行后的结果是：

  1. a>=1
  2. a>=2
  3. a>=3
  4. a>=4

因为满足条件一后，执行fallthrough，则跳过case2的判断直接执行case2的语句，后面依次类推，因为在case4时也存在fallthrough，所以必须存在defalut，要不然语义解析失败。如果case4没有fallthrough，那么default就可以删除。

switch除了这种用法之外，在生产环境中，还经常用来判断值类型，例如:

  1. switch x.(type){
  2.    case type:
  3.       statement(s);      
  4.    case type:
  5.       statement(s); 
  6.    default: 
  7.       statement(s);
  8. }

将表达式替换为x类型断言，如果是int型则怎么办？ 如果是string类型则怎么办？ 这种用法经常出现在接口中，当可能返回多种类型时，通过这种方式来逐一判断处理。下面举一个例子来说明问题:

  1. var x interface{}
  3.    switch i := x.(type) {
  4.       case nil:      
  5.          fmt.Printf("type of x :%T",i)                
  6.       case int:      
  7.          fmt.Printf("x is int")                       
  8.       case float64:
  9.          fmt.Printf("x is float64")           
  10.       case func(int) float64:
  11.          fmt.Printf("x is func(int)")                      
  12.       case bool, string:
  13.          fmt.Printf("x is bool or string")       
  14.       default:
  15.          fmt.Printf("don't know the type")     
  16.    }
在Golang判断环节，还有经常使用的一种判断: Select

select语法和switch语法非常相像，有些初学者很容易将两者弄混。但除了样子相近之外，二者作用完全不同。先看外表:

  1. select {
  2.    case communication clause  :
  3.       statement(s);      
  4.    case communication clause  :
  5.       statement(s); 
  6.    default :
  7.       statement(s);
  8. }

如果把select换成switch，活脱脱一个条件判断表达式。 所以外表极其相似。但你要注意：

  • select后面没有表达式
  • case后面的类型必须是chan。(chan我们还没有提到，提前剧透一下，chan是一种数据通信管道，golang封装成了数据类型)
  • default是可选的。如果有default，必须放到select最后。

因为我们没有讲到chan，所以目前来说记住上面的部分就可以了。

Golang的判断相对于其它语言来说，只有If， switch和select三种。 其中select还属于特殊的判断。所以只剩下if和switch两种。相当好记，相当好用。

如果本节就这么结束了，不用你说，我都感觉内容不详实(不详实也不是一次两次了，这次是由衷的感觉不详实)。所以再写一下Golang里面的循环。放心内容不会多的，我就想写成口袋书，一次就看一部分，不用长篇累牍的写那么多。 你们看着累，我写的也累。

Golang的循环只有For循环

好了，写完了。 板砖尽情的扔过来吧，让我来感受一下遭人抨击的感觉吧。 虽说你们扔了板砖，但我仍然要说Golang只有For循环一种循环语法。 没有什么while循环，do..for循环，foreach循环，….map()循环之类的东西。在Golang当中需要使用循环，记住只有For循环。

  1. for [condition |  ( init; condition; increment ) | Range] {
  2.    statement(s);
  3. }

上面就是For循环的三种写法。

  • condition。 条件判断。 也就是传说中的 for true{} 循环，某种意义上等于与while循环
  • init; condition; increment。初始化循环，预定俗称的写法就是初始化i:=0，然后当i<=N时循环，每次i++。
  • Range，迭代循环。基本用来迭代数组.例如；
  1. numbers := [6]int{1, 2, 3, 5} 
  2. for i,x:= range numbers {
  3.       fmt.Printf("value of x = %d at %d\n", x,i)
  4. }

下面用一个例子，来演示三种情况:

  1.    var b int = 15
  2.    var a int
  3.    numbers := [6]int{1, 2, 3, 5} 
  5.    /* for loop execution */
  6.    for a := 0; a < 10; a++ {
  7.       fmt.Printf("value of a: %d\n", a)
  8.    }
  9.    for a < b {
  10.       a++
  11.       fmt.Printf("value of a: %d\n", a)
  12.    }
  13.    for i,x:= range numbers {
  14.       fmt.Printf("value of x = %d at %d\n", x,i)
  15.    }

如果一个For循环使用的不过瘾，可以嵌套多个For循环。直接看语法:

  1. for [condition |  ( init; condition; increment ) | Range] {
  2.    for [condition |  ( init; condition; increment ) | Range] {
  3.       statement(s);
  4.    }
  5.    statement(s);
  6. }

语法看不懂，那就给你一个实例，比对着看吧:

  1.    var i, j int
  3.    for i = 2; i < 100; i++ {
  4.       for j = 2; j <= (i/j); j++ {
  5.          if(i%j==0) {
  6.             break; // if factor found, not prime
  7.          }
  8.       }
  9.       if(j > (i/j)) {
  10.          fmt.Printf("%d is prime\n", i);
  11.       }
  12.    }

上面实例中，出现了一个break。这是标准的退出循环的方式。 那么Golang中有几种退出循环的方式呢？

  • Break。 使用率最高的方式，当满足退出条件时，直接break退出
  • Continue。有人说不算出退出循环，因为它只是跳出了本次循环，继续下次循环。但如果不放这里，我又把continue放哪里呢？所以暂且就把continue当做跳出循环吧。只不过是跳出本次循环而已。
  • Goto。 武林界失传已久的Goto大法，在Golang中重出江湖。 与其它语言，强制半强制的屏蔽Goto不同，golang很大方的推出goto。没有什么其它限制条件，只要你认为goto使用的正确就可以大胆的使用。(小心陷入死循环)。使用Goto时，需要提前定义标签，然后goto 标签即可。 下面是一个实例:
  1.    var a int = 10
  3.    LOOP: for a < 20 {
  4.       if a == 15 {
  5.          a = a + 1
  6.          goto LOOP
  7.       }
  8.       fmt.Printf("value of a: %d\n", a)
  9.       a++     
  10.    }

如果你认真的分析一下代码，或者自己执行一下代码就会发现：你死循环了！所以不限制用，不等于滥用。 不是老司机，就别调试小寡妇。 寡妇不是病，真闹起来，要你命。所以用之前，慎重考虑一下是否真的要用。 记住:no zuo no die!

侯门一入深如海, 从此萧郎是路人。 代码之路漫漫而长，如果从头开始一直在跟着本文的更新，那么你现在已经算是踏入了Golang的大门，至少我还没有开始摧残你那颗幼小的心灵。 由易而难，慢慢来。 跟着练，悄然之间你就会发现Golang原来就是这么一回事。