澳门皇冠金沙网站-澳门皇冠844网站

热门关键词: 澳门皇冠金沙网站,澳门皇冠844网站

Go基础系列,程序的流程控制

3.1 选取结构

3.2.1 for语句

for语句的语法如下:

// 普通循环

for 初始化表达式; 条件表达式; 步进表达式 {

    循环体语句

}

 

澳门皇冠844网站,率施夷光行早先化表明式,然后实行准则表达式,即便基准表明式的结果为真,实践循环体语句和步进表达式。然后再再次来到条件表明式进行判别,生生不息的再一次推行。假诺条件表达式的结果为假,直接跳出for循环,意味这一体for循环截至。

 

 澳门皇冠844网站 1

 普通for循环的流程图:

我们看一个for循环的事例,求1~100的数值的和。

package main

 

import "fmt"

 

func main() {

 

    //保存结果

    var sum int = 0

    // i表示1~100

    for i := 1; i <= 100; i  {

        sum = sum   i

    }

    fmt.Println("sum:", sum)

}

 

简单的说说明式1:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for ; i <= 100; i  {

        sum = sum   i

    }

    fmt.Println("sum:", sum)

}

简言之表明式2:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for ; ; i  {

        if i > 100 {

            break

        }

 

        sum = sum   i

    }

    fmt.Println("sum:", sum)

}

简短表达式3:

package main

 

import "fmt"

 

func main() {

    var sum int = 0

    i := 1

    for {

        if i > 100 {

            break

        }

        sum = sum   i

        i

    }

    fmt.Println("sum:", sum)

}

 

 

数组循环:

// 数组循环

for i, v := range array {

    ...

}

 

注意事项:

1) 只支持for结构,不支持while和do-while结构。

2) 左花括号{必得与for处于同一行。

3) 不帮忙以逗号为距离的多赋值语句,帮忙选用多元赋值的主意来发轫化三个变量。这些很好判定,在一个表明式中不容许有多少个赋值语句,即:=或=。

package main

 

import "fmt"

 

func main() {

    array := []int{1, 2, 3, 4, 5, 6}

    for i, j := 0, len(array)-1; i < j; i, j = i 1, j-1 {

        array[i], array[j] = array[j], array[i]

    }

    fmt.Println(array)

}

 

switch语句

switch语句用于提供分支测量检验。有二种swithc结构:expression switch和type switch,本文前段时间只介绍expression switch,它用来推断表明式是或不是为true。

对于expression switch,也可能有二种情势:等值相比、表明式相比较、发轫化表明式。

等值比较结构:当var1的值为val1时,施行statement1,当var1的值为val2时,试行statement2,都不知足时,试行暗中同意的言语statement。

switch var1 {    case val1:        statement1    case val2:        statement2    default:        statement}

等值相比较局限性非常大,只可以将var1和case中的值相比较是或不是等于。如若想比较不等,大概别的表明式类型,能够选用上边包车型客车表明式相比较结构。

表明式相比结构:评估每一种case结构中的condition,只要评估为真就实践,然后退出。

switch {    case condition1:        statement1    case condition2:        statement2    default:        statement}

早先化表达式:能够和if一样为switch加上发轫化表达式,相同成效域只在switch可知。但只顾,initialization前边记得加上分号";"结尾。见下文示例。

switch initialization; {  // 不要省略分号    case condition1:        statement1    case condition2:        statement2    defautl:        statement}

default是可选的,且能够写在switch的任何地点。

一旦case中有五个要施行的语句,可以加大括号,也得以不加大括号。当唯有一个口舌的时候,statement可以和case在同一行。

case中得以提供四个用于测量检验的值,使用逗号分隔,只要有多个相符,就满意条件:

switch var1 {    case val1,val2,val3:        statement1    case val4,val5:         statement2    default:        statement}

例如:

val := 20switch val {case 10, 11, 15:    printlncase 16, 20, 22:      // 命中    println(16, 20, 22)default:    println("nothing")}

纵使是表明式相比结构,也一律能够利用逗号分隔两个表明式,那时和接纳逻辑或"||"是等价的:

func main() {    val := 21    switch {    case val % 4 == 0:        println    case val % 4 == 1, val % 4 == 2:  //命中        println    default:        println("3")    }}

暗中认可情形下case命中就得了,所以具备的case中只有三个会被试行。但假若想要推行四个,能够在实行完的有个别case的结尾多少个语句上增多fallthrough,它会白白地一向跳转到下一条case并实践,假如下一条case中还会有fallthrough,则如出一辙的逻辑。其它,fallthrough的末尾总得只好是下多个case或default,不可能是额外的另外语句,不然会报错。

例如:

func main() {    val := 21    switch val % 4 {    case 0:        println    case 1, 2:         // 命中        println  // 输出        fallthrough    // 执行下一条,无需条件评估        // println("sd") //不能加此行语句    case 3:        println     // 输出        fallthrough    // 执行下一条,无需条件评估    default:        println("end")  // 输出    }}

施行结果为:

1 23end

fallthrough相似用于跳过有些case。举个例子:

swtich i {    case 0: fallthrough    case 1: statement1    default: statement}

它意味着等于0或等于1的时候都试行statement1。那和近期case中多个评价值评估的意义是一致的。

以下是一个起首化表明式结构的switch示例:

func main() {    val := 21    switch val := 23; {    case val % 4 == 0:        println    case val % 4 == 1 || val % 4 == 2:        println    default:             // 命中        println   // 输出"3 23"    }    println         // 输出21}
  1. 梯次结构最为简练,程序试行时,遵照语句的逐条自上而下依次施行。
  2. 接纳结构是依据标准表达式的结果采用实施有些语句。
  3. 循环结构是重复试行实行有个别语句。

3.3 goto语句

goto语句是跳转语句,天生要和标签合作使用。能够让程序任务的跳转到标签之处继续执行。一般的语法格式:

goto LABEL

...

...

...

LABEL:

案比如下:

package main

 

import "fmt"

import "time"

 

func main() {

    i := 0

    for {

        i

        if i >= 10 {

            goto FINISH

 

        }

        fmt.Print(i, "  ")

        time.Sleep(1 * time.Second)

    }

FINISH:

    fmt.Println("nFinish")

}

一般来说格式的for

// 完整格式的forfor init; condition; modif { }// 只有条件判断的for,实现while的功能// 要在循环体中加上退出条件,否则无限循环for condition { }

例如:

// 完整格式func main() {    for i := 0; i < 5; i   {        fmt.Println    }}// 只有条件的格式func main() {    var i int = 5    for i >= 0 {        i = i - 1        fmt.Printf    }}

3.3 goto语句

goto语句是跳转语句,天生要和标签合作使用。能够让程序职责的跳转到标签之处继续实行。一般的语法格式:

gotoLABEL

...

...

...

LABEL:

案举个例子下:

packagemain

import"fmt"

import"time"

funcmain(){

i:=0

for{

i

ifi>=10{

gotoFINISH

}

fmt.Print

time.Sleep(1*time.Second)

}

FINISH:

fmt.Println("nFinish")

}

  1.  顺序结构最为简练,程序奉行时,依照语句的一一自上而下依次施行。
  2. 慎选结构是依赖法规表明式的结果选择实施某个语句。
  3. 巡回结构是重复施行实践有些语句。

break和continue

breake用于退出当前漫天循环。要是是嵌套的循环,则脱离它所在的那一层循环。break除了能够用在for循环中,仍是能够用在switch结构或select结构。

continue用于退出当前迭代,步入下一轮迭代。continue只可以用来for循环中。

3.1.2 switch语句

switch语句的语法:

switchcondition{

casev0:

...

casev1:

...

casev2:

...

casev3:

...

casev4,v5,v6:

...

default:

...

}

注意事项:

1.左花括号{必得与switch同处一行。

2.case后方可采纳常量,还足以选用变量。

packagemain

import"fmt"

funcmain(){

condition:=0

caseValue:=0

switchcondition{

casecaseValue:

fmt.Println

case1:

fmt.Println

default:

fmt.Println("Default")

}

}

注意事项:

  1. 单个case后得以出现八个结实选项。
  2. 不必要用break来显明退出贰个case。
  3. 除非在case中确定增加fallthrough关键字,才会继续实践下三个case。

packagemain

import"fmt"

funcmain(){

condition:=1

switchcondition{

case0:

fmt.Println

case1:

fmt.Println

fallthrough

default:

fmt.Println("Default")

}

}

同意设定switch后的基准表明式,在此种情形下全方位switch结构与if...else...的逻辑等同。

packagemain

import"fmt"

funcmain(){

num:=1

switch{

case0<=num&&num<=3:

fmt.Println

case4<=num&&num<=6:

fmt.Println

case7<=num&&num<=9:

fmt.Println

}

}

事例:依据输入的年份月份总括月份的流年?

packagemain

import"fmt"

funcmain(){

fmt.Println("请输入年份月份:")

varmonthint

varyearint

fmt.Scanln(&year,&month)

switchmonth{

case1,3,5,7,8,10,12:

fmt.Println

case4,6,9,11:

fmt.Println

case2:

if(year%4==0&&year0!=0)||(year@0==0){

fmt.Println

}else{

fmt.Println

}

default:

fmt.Println("输入的月份有误!")

}

}

3.2.2 continue和break语句

continue语句在for循环结构中的作用是得了本次巡回,即跳过循环体中下部还并未有执行的话语,接着实行下贰次巡回。break语句在循环结构中的功用是跳出循环体,提前甘休循环。

例如:打印1~10之间能够被3整除的数下:

package main

 

import "fmt"

 

func main() {

    for i := 1; i <= 10; i  {

        if i%3 != 0 {

            continue

        }

        fmt.Println("i=", i)

    }

}

 

 

尽管Go是类C的语言,但Go在这几个流程序调节制语句中的条件表明式部分不使用括号。以致有一些时候使用括号会报错,但有个别复杂的标准化剖断要求选用括号改动优先级。

前后相继的流程序调整制首要包蕴三种区别的布局,分别是各样结构、选用结议和巡回结构。

程序的流程序调控制器重不外乎两种不一样的结构,分别是逐条结构、选择结商谈巡回结构。

最棒循环

有个别种办法实现for的但是循环。只要简单for的基准判别部分就足以兑现Infiniti循环。

for i := 0;;i   for { } for ;; { }for true { }

最为循环时,一般在循环体中增加退出语句,如break、os.Exit、return等。

本文由澳门皇冠金沙网站发布于编辑程序,转载请注明出处:Go基础系列,程序的流程控制