if else
基础语法
//condition 称之为条件表达式或者布尔表达式,执行结果需返回true或false。{ 必须在条件表达式的尾部
if condition {
// 条件为真执行
}
if condition {
// 条件为真 执行
} else {
// 条件不满足 执行
}
if condition1 {
// condition1 满足 执行
} else if condition2 {
// condition1 不满足 condition2满足 执行
}else {
// condition1和condition2都不满足 执行
}
else if 分支的数量是没有限制的,但是为了代码的可读性,还是不要在 if 后面加入太多的 else if 结构
使用例子
x := 0
if x <= 0 {
fmt.Println("为真进入这里")
}
x := 5
if x <= 0 {
fmt.Println("为真进入这里")
//go语言格式要求很严,else必须写在}后面
}else{
fmt.Println("为假进入这里")
}
//if语句可以嵌套:
/* 定义局部变量 */
var a int = 100
var b int = 200
/* 判断条件 */
if a == 100 {
/* if 条件语句为 true 执行 */
if b == 200 {
/* if 条件语句为 true 执行 */
fmt.Printf("a 的值为 100 , b 的值为 200\n" )
}
}
//特殊写法,可以在 if 表达式之前添加一个执行语句,再根据变量值进行判断,代码如下:
if a := 10; a >5 {
fmt.Println(a)
return
}
//这种写法可以将返回值与判断放在一行进行处理,而且返回值的作用范围被限制在 if、else 语句组合中。
在编程中,变量的作用范围越小,所造成的问题可能性越小,每一个变量代表一个状态,有状态的地方,状态就会被修改,函数的局部变量只会影响一个函数的执行,但全局变量可能会影响所有代码的执行状态,因此限制变量的作用范围对代码的稳定性有很大的帮助。
for
go语言中的循环语句只支持 for 关键字,这个其他语言是不同的。
//第一种写法
sum := 0
//i := 0; 赋初值,i<10 循环条件 如果为真就继续执行 ;i++ 后置执行 执行后继续循环
for i := 0; i < 10; i++ {
sum += i
}
//第二种写法 下面的代码,如果没有break跳出循环,那么其将无限循环
sum := 0
for {
sum++
if sum > 100 {
//break是跳出循环
break
}
}
//第三种写法
n := 10
for n>0 {
n--
fmt.Println(n)
}
step := 2
//初值可以省略,但是;必须有,但是这样写step的作用域就比较大了,脱离了for循环
for ; step > 0; step-- {
fmt.Println(step)
}
//进一步简化代码,将 if 判断整合到 for 中,变为下面的代码:
step := 2
for step > 0 {
step--
fmt.Println(step)
}
结束循环的方式
- return
step := 2
for step > 0 {
step--
fmt.Println(step)
//执行一次就结束了
return
}
//不会执行
fmt.Println("结束之后的语句....")
- break
step := 2
for step > 0 {
step--
fmt.Println(step)
//跳出循环,还会继续执行循环外的语句
break
}
//会执行
fmt.Println("结束之后的语句....")
- painc
step := 2
for step > 0 {
step--
fmt.Println(step)
//报错了,直接结束
panic("出错了")
}
//不会执行
fmt.Println("结束之后的语句....")
- goto
func main() {
for x := 0; x < 10; x++ {
for y := 0; y < 10; y++ {
if y == 2 {
// 跳转到标签
goto breakHere
}
}
}
// 手动返回, 避免执行进入标签
return
// 标签
breakHere:
fmt.Println("done")
}
案例
输出九九乘法表
package main
import "fmt"
func main() {
// 遍历, 决定处理第几行
for y := 1; y <= 9; y++ {
// 遍历, 决定这一行有多少列
for x := 1; x <= y; x++ {
fmt.Printf("%d*%d=%d ", x, y, x*y)
}
// 手动生成回车
fmt.Println()
}
}
for range
for range 结构是Go语言特有的一种的迭代结构,for range 可以遍历数组、切片、字符串、map 及管道(channel)
for key, val := range coll {
...
}
val
始终为集合中对应索引的值拷贝
,因此它一般只具有只读性质,对它所做的任何修改都不会影响到集合中原有的值
demo
//遍历map:
m := map[string]int{
"hello": 100,
"world": 200,
}
for key, value := range m {
fmt.Println(key, value)
}
//字符串也可以使用for range:
str := "我是一个字符串"
//因为一个字符串是 Unicode 编码的字符(或称之为 rune )集合
//char 实际类型是 rune 类型
for pos, char := range str {
fmt.Println(pos,char)
}
//每个 rune 字符和索引在 for range 循环中是一一对应的,它能够自动根据 UTF-8 规则识别 Unicode 编码的字符。
- 通过 for range 遍历的返回值有一定的规律:
- 数组、切片、字符串返回索引和值。
- map 返回键和值。
- channel只返回管道内的值。
switch
switch 语句用于基于不同条件执行不同动作,每一个 case 分支都是唯一的,从上至下逐一测试,直到匹配为止。
switch 分支表达式可以是任意类型,不限于常量。可省略 break,默认自动终止。
语法
switch var1 {
case val1:
...
case val2:
...
default:
...
}
变量 var1 可以是任何类型,而 val1 和 val2 则可以是同类型的任意值。
类型不被局限于常量或整数,但必须是相同的类型;或者最终结果为相同类型的表达式。
您可以同时测试多个可能符合条件的值,使用逗号分割它们,例如:case val1, val2, val3。
/* 定义局部变量 */
var grade string = "B"
var score int = 90
switch score {
case 90: grade = "A"
case 80: grade = "B"
case 50,60,70 : grade = "C"
default: grade = "D"
}
//swtich后面如果没有条件表达式,则会对true进行匹配
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 )
Go里面switch默认相当于每个case最后带有break,匹配成功后不会自动向下执行其他case,而是跳出整个switch, 那么如何做到执行完一个case之后,进入下一个case而不是跳出swtich呢?
答案是:fallthrough
var s = "hello"
switch {
case s == "hello":
fmt.Println("hello")
fallthrough
case s != "world":
fmt.Println("world")
}
加了fallthrough后,会直接运行【紧跟的后一个】case或default语句,不论条件是否满足都会执
goto
goto 语句通过标签进行代码间的无条件跳转,同时 goto 语句在快速跳出循环、避免重复退出上也有一定的帮助,使用 goto 语句能简化一些代码的实现过程。
demo
使用 goto 退出多层循环
func main() {
for x := 0; x < 10; x++ {
for y := 0; y < 10; y++ {
if y == 2 {
// 跳转到标签
goto breakHere
}
}
}
// 手动返回, 避免执行进入标签
return
// 标签
breakHere:
fmt.Println("done")
}
使用 goto 语句后,无须额外的变量就可以快速退出所有的循环
break
break 语句可以结束 for、switch 和 select 的代码块,另外 break 语句还可以在语句后面添加标签
,表示退出某个标签
对应的代码块,标签要求必须定义在对应的 for
、switch
和 select
的代码块上。
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 2:
fmt.Println(i, j)
break OuterLoop
case 3:
fmt.Println(i, j)
break OuterLoop
}
}
}
}
continue
continue 语句可以结束当前循环,开始下一次的循环迭代过程,仅限在 for 循环内使用,在 continue 语句后添加标签
时,表示继续执行标签对应的循环
func main() {
OuterLoop:
for i := 0; i < 2; i++ {
for j := 0; j < 5; j++ {
switch j {
case 2:
fmt.Println(i, j)
continue OuterLoop
}
}
}
}
//我们有一个外部循环(outerLoop)和一个内部循环。当 j 都等于 2 时,我们使用continue outerLoop语句,这会导致程序继续执行外部循环。如果没有标签,continue语句将只继续执行内部循环。