在学习计算机编程的时候我们知道（没系统学过的）也知道关于计算机的指令系统是0和1构成，同时计算机只识别0和1的串，最后计算机可以执行的就是0和1串组成的机器代码。我们称之为计算机的逻辑判断，也可以称之为true或者false（加入1代表true，0代表false），和有趣的非对即错的现象非常类似。当然世界一定不是只有2个状态，非true就是false，还会有第三种状态，当然这个时候咱们谈论的就是不是条件判断了。
所以一定是条件判断就是非true即false的，不同情况下代表不同的执行路径和不同的处理方式，计算机需要明确的指令。同时也同时存在一种情况或者场景是这样的，就是”计算机需要连续的执行某一系列的指令，当存在某些条件的时候需要退出执行或者继续执行等等“，就如同走路一般，左右的路，也有需要一直转圈的路。
那么对于Go语言的条件和循环逻辑的都包含有什么内容呢，让我们一起看一下，首先对于条件语句和循环逻辑的定义如下：

• 条件语句，是用来判断给定的条件是否满足（表达式值是否为0或者false），并根据判断的结果（true或者false）决定执行的语句，选择的结构和流程就是使用条件语句来实现的。
• 循环语句，则是指具有规律性的重复操作，因此在程序中就需要重复执行某些语句。一组被重复执行的语句称之为循环体，其中能否继续重复，决定循环的终止条件。
  那么接下来我们就看下条件和循环的细节。

1 Go 条件判断语句

1.1 判断的形式和说明

• if语句 if语句 由一个布尔（bool）表达式后紧跟一个或者多个语句组成
• if … else 语句 if语句后面可以跟else语句，else语句中的表达式是在布尔（bool）表达式为false时候进行执行
• switch语句 switch语句主要用于基于不同条件的路径动作和执行
• select语句 select语句类似于switch语句，但是select会随机执行一个可运行的case，如果没有case可以执行，则会阻塞，知道有case执行位置。
• switch不会有阻塞的特性。

1.2 条件判断的例子代码

package main  
import "fmt"
func main() {
        // run ifelse
        ifelse_func()
        // run switch 
        switch_func()
        // run select 
        select_func()
}
func ifelse_func() {
        flag := false 
        if !flag { // 条件值为true 
                fmt.Println("this is ", flag, "loop")
        } else { // 条件值为false 
                fmt.Println("this is ", !flag, "loop")
        }
}
func switch_func() {
        tag := 3
        switch tag {
                case 1:
                        fmt.Println("current tag is : ", tag)
                case 2:
                        fmt.Println("current tag is : ", tag)
                case 3:
                        fmt.Println("current tag is : ", tag)
                case 4:
                        fmt.Println("current tag is : ", tag)
        }
}
func select_func() {
        var sigchan1, sigchan2 chan int
        var s1, s2 int
        select {
                case s1 = <- sigchan1:
                        fmt.Println("receive ", s1, " from sigchan 1")
                case sigchan2 <- s2:
                        fmt.Println("send ", s2, " to sigchan2")
                default:
                         fmt.Println("no signal")
        } 
}

2 Go 循环语句

2.1 循环类型

循环语句主要在计算机中让计算机重复的执行一系列的指令，在业务层级来说就是循环的做一件事情。循环类型分为普通的循环和嵌套循环，即常见的for循环，以及for循环里面嵌套for循环。即：

• for循环：重复执行语句块
• 嵌套循环：在for循环内部还有for循环

2.2 循环语句

循环语句控制可以对内部的执行过程进行控制，让执行的loop按照自己希望的方式进行执行。Go 语言支持的循环控制语句有：break语句，用于终端当前for循环或者跳出switch语句；
continue语句，用于调过当前循环的剩余语句，然后从头开始继续往下执行循环；goto语句，将控制转移跳转到被标记的语句，任意跳转。
循环中其中有一种叫做无限循环，就是循环不会退出，这种类型的循环多用于一个routine中，或者main主函数中用于主程序的daemon运行。用于做到业务要求的24小时不停止服务请求的业务逻辑。

2.3 循环例子代码

普通循环和控制

package main

import (
        "fmt"
)

func main() {
        num := 5
        for num < 20 {
                fmt.Println("num is ", num);
                if num <= 10 {
                        num++
                        fmt.Println("num is less than 10")
                        continue
                }
                if num > 10 {
                        fmt.Println("num is larger than 10")
                        break;
                }
        }
}

无限循环例子

package main

import ( 
    "fmt" 
    "os" 
    "os/signal" 
    "time" 
)

func main() { 
    go sig_listen() 
    time.Sleep(time.Hour) 
}

func sig_listen() { 
    sig_chan := make(chan os.Signal) 
    signal.Notify(sig_chan) 
    // get a signal then exit 
    for { 
        signal := <- sig_chan 
        fmt.Println("Get a Sig:", signal) 
                os.Exit(0)
    } 
}

3 经验总结和分享

作为程序的逻辑和业务流程，循环是一个程序的控制器，有了循环才让这个程序有了更多的想象空间，比如做一个互联网产品服务，24小时提供不间断服务，那么就需要无限循环。而对于Go语言，无限循环多用于main主线程的loop逻辑确保程序的24小时不间断运行。同时也会结合Go 的routine的方式进行job的执行调度，在routine的循环中不退出，可以做到不停的处理任务的作用，在进行类型worker的设计模式实践过程中，循环也是一个常见的编码方式和设计模式。

关于本专栏——Go 语言教程，专栏致力于为希望可以系统地，一条一条地，一步一步的学习Go语言的朋友提供一个可以持续阅读的地方，当然也希望可以通过我的实践经验以及相应的基础，可以给你一些学习之外的想法和总结，以及提高。如果真的有帮助，哪怕一点点，可以把这个一点点的提高分享给我，欢迎跟我勾搭联系。