Go 开发基础入门——4

YMLiang 的个人博客 / 350 / 0 / 创建于 4年前 / 更新于 4年前 / 1 个改进

请关注我的个人博客

流程控制

if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
}

*不支持三元操作符(三目运算符) "a > b ? a : b"。

if else：

if 布尔表达式 {
/* 在布尔表达式为 true 时执行 */
} else {
/* 在布尔表达式为 false 时执行 */
}

for

Go语言的For循环有3中形式，只有其中的一种使用分号。

for init; condition; post { }
for condition { }
for { }
init： 一般为赋值表达式，给控制变量赋初值；
condition： 关系表达式或逻辑表达式，循环控制条件；
post： 一般为赋值表达式，给控制变量增量或减量。
for语句执行过程如下：
①先对表达式 init 赋初值；
②判别赋值表达式 init 是否满足给定 condition 条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。

公式：
for [condition |  ( init; condition; increment ) | Range]
{
    statement(s)
}

替代 while(true)的方法：

for {

}

因为比较简单，我这里说一个稍微复杂一点的就是 range ，那么请先看range的知识点

下面是一个栗子：
func changeBigSmallWord(str string) string{
    result := ""
    for i,value := range str{
        if i%2==0 {
            result += strings.ToUpper(string(value))
        }else {
            result += strings.ToLower(string(value))
        }
    }
    return result
}
循环时用到range 即迭代传入的 str 相当于遍历了

range

range = 迭代器的效果
简单理解成遍历没有问题

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

str := "abcdefgHiGKLmn"

result := ""
for _, value := range str {
    result += string(value)
}

举个栗子
```
//字母大小写变化
```

func changeBigSmallWord(str string) string{
result := ""
for i,value := range str{
if i%2==0 {
result += strings.ToUpper(string(value))
}else {
result += strings.ToLower(string(value))
}
}
return result
}
func main{
str2 := "abcdefGHIGKLMN"
result2 := changeBigSmallWord(str2)
fmt.Println(result2)
}

AbCdEfGhIgKlMn

for 和 for range有什么区别?

主要是使用场景不同

for可以

遍历array和slice
遍历key为整型递增的map
遍历string

for range可以完成所有for可以做的事情，却能做到for不能做的，包括

遍历key为string类型的map并同时获取key和value
遍历channel

switch
```
switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

变量 var1 可以是任何类型，而 val1 和 val2 则可以是同类型的任意值。类型不被局限于常量或整数，但必须是相同的类型；或者最终结果为相同类型的表达式。    
```
- 举个栗子
```
package main
```
import "fmt"

func main() {
/ 定义局部变量 /
var grade string = "B"
var marks int = 90

switch marks {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}

switch {
case grade == "A" :
fmt.Printf("优秀!\n" )
case grade == "B", grade == "C" :
fmt.Printf("良好\n" )
case grade == "D" :
fmt.Printf("及格\n" )
case grade == "F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" )
}
fmt.Printf("你的等级是 %s\n", grade )
}

优秀!
你的等级是 A

比较好理解，和java中的类似，下面来看一些不太一样的，比如case中包含 && || 等，或者是判断某个 interface 变量中实际存储的变量类型

定义语句： Type switch
Type Switch 语法格式如下：
switch x.(type){
case type:
statement(s)
case type:
statement(s)
/ 你可以定义任意个数的case /
default: / 可选 /
statement(s)
}

实例：
package main

import "fmt"

func main() {
var x interface{}
//写法一：
switch i := x.(type) { // 带初始化语句
case nil:
fmt.Printf(" x 的类型 :%T\r\n", i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool, string:
fmt.Printf("x 是 bool 或 string 型")
default:
fmt.Printf("未知型")
}
//写法二
var j = 0
switch j {
case 0:
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
default:
fmt.Println("def")
}
//写法三
var k = 0
switch k {
case 0:
println("fallthrough")
fallthrough
/
Go的switch非常灵活，表达式不必是常量或整数，执行的过程从上至下，直到找到匹配项；
而如果switch没有表达式，它会匹配true。
Go里面switch默认相当于每个case最后带有break，
匹配成功后不会自动向下执行其他case，而是跳出整个switch,
但是可以使用fallthrough强制执行后面的case代码。
/
case 1:
fmt.Println("1")
case 2:
fmt.Println("2")
default:
fmt.Println("def")
}
//写法三
var m = 0
switch m {
case 0, 1:
fmt.Println("1")
case 2:
fmt.Println("2")
default:
fmt.Println("def")
}
//写法四
var n = 0
switch { //省略条件表达式，可当 if...else if...else
case n > 0 && n < 10:
fmt.Println("i > 0 and i < 10")
case n > 10 && n < 20:
fmt.Println("i > 10 and i < 20")
default:
fmt.Println("def")
}
}

结果为：
x 的类型 :
fallthrough
1
1
def
循环控制Goto、Break、Continue