Go结构化编程-流程控制

一. 结构化编程

1. 什么是结构化编程

• 结构化编程是以函数为单元，自上而下，按功能划分，强调某个功能的算法。
• 结构化编程的流程控制包括：顺序结构、条件结构和循环结构。

2. 与面向对象的区别

• 面向对象的基本思想是使用类, 对象, 继承, 封装, 消息等基本概念进行程序设计。
• 类是对象的抽象, 对象是类的实例化，类的封装使得程序具有了高内聚, 低耦合特性。
• 封装性：将对象的实现细节隐藏起来, 通过一些公共的接口方法来供外部调用对象的功能。
• 继承性：子类继承父类, 子类直接获得父类的非private属性和方法（共性）。
• 多态性：子类对象在执行同一个方法时, 可能表现出不同的特征（个性）。

二. 顺序结构

• go提供了两个保留函数：init和main，且只能由GO程序自动调用。
• init是初始化函数，可以在一个包或文件中出现多次(0次或n次)。
• 只有main包中的main函数可以作为入口函数，且只能包含一个main函数。
• 一个包被多处导入时，实际只会被导入一次，如：fmt包。
• 包导入顺序是：内向外递归，执行顺序：常量>变量>init()，如下图：
  

package main

func init() {
    println("init1")
}
func init() {
    println("init2")
}
func main() {
    println("main")
}

三 .条件结构

条件结构有if语句、switch语句和select语句，遵循自上而下，先配先得原则。

1. if 语句

func Foo(n int) {
   if n < 60 {
      fmt.Println("flunk")
   } else if n < 80 {
      fmt.Println("pass")
   } else {
      fmt.Println("excellent")
   }
}

2. Switch 语句

• Switch的表达更为丰富，有范围匹配(布尔匹配)和精准匹配(常量匹配、类型匹配)，且精准匹配不可重叠。
• Switch可省略break，增加了fallthrough(鸡肋)，且fallthrough只对常量匹配有效，default位置任意。

// 布尔匹配
func Foo(x int) string {
   switch {
   case x < 60:
      return "flunk"
   case x < 80:
      return "pass"
   default:
      return "excellent"
   }
}

// 常量匹配
func Bar(x int) {
   switch x {
   case 1, 2, 3:
      fmt.Println("差评")
   case 4:
      fmt.Println("Next Case")
      fallthrough
   case 5:
      fmt.Println("警告")
   case 6, 7:
      fmt.Println("一般")
   default:
      fmt.Println("好评")
   }
}

// 类型匹配
func Baz(o interface{}) {
   switch o.(type) {
   default:
      fmt.Println("Other")
   case bool:
      fmt.Println("Boolean")
   case int, int64, float32, float64:
      fmt.Println("Number")
   case string, []byte:
      fmt.Println("String")
   }
}

四. 循环结构

1. For循环

• 循环结构有基础循环、条件循环和无限循环，其中条件循环和无限循环都是基础循环的衍生结构。
• 基础循环: for 初始化;条件;步进；条件结构: 即for;exp; ；无限循环: 即 for;; 或 for;true; 。
• 还可以通过goto语句或递归函数模拟循环结构。

// 基础循环
func Foo() {
   for i := 0; i < 5; i++ {
      fmt.Println(i)
   }
}

// 条件循环
func Bar() {
   var n = 0
   for n < 5 {
      fmt.Println(n)
      n++
   }
}

// 无限循环
func Baz() {
   for {
      time.Sleep(time.Second * 1)
      println(time.Now().Format("2006-01-02 15:04:05"))
   }
}

2. 循环控制

• 循环控制包括：中断(break/return)、继续(continue)、跳转(goto)。
• goto语句中，标签不能跳过变量的声明，且跳转只能在同一作用域进行。

//中断：循环输入
func Foo() {
   for {
      var input string
      fmt.Scanln(&input)
      if input == "q" {
         fmt.Println("quit")
         break //return
      }
      fmt.Println(input)
   }
}

//继续：打印奇数
func Bar() {
   for i := 0; i < 10; i++ {
      if i%2 == 0 {
         continue
      }
      fmt.Println(i)
   }
}

//跳转
func Baz() {
   goto FLAG
   fmt.Println("a")
FLAG:
   if true {
      //子作用域
   }
   fmt.Println("b")
}

参考：
https://blog.csdn.net/benben_2015/article/details/79486077
http://blog.chinaase.com/2019/02/12/golang%E9%9D%A2%E5%90%91%E6%8E%A5%E5%8F%A3%E3%80%81%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1%E5%AF%B9%E8%B1%A1%E6%80%9D%E6%83%B3%E5%8F%8A%E7%BC%96%E7%A8%8B%E4%BB%A5%E5%8F%8A%E7%BB%93%E6%9E%84%E5%8C%96/