Go

Go编程基础(控制流程语句)

2018-10-07  本文已影响76人  Michaelhbjian

现在来学习下go语言中控制流程语句,区别下其他语言不同的写法。

1.for循环

Go只有for一个循环语句关键字,但支持3三种形式,条件语句每次循环都会被重新检查,因此不建议在条件语句中使用函数,尽量提前计算好条件并以变量或常量代替。左大括号必须和条件语句在同一行。

package main
import "fmt"
func main() {
    a:=getSum1()
    fmt.Println(a)
    b:=getSum2()
    fmt.Println(b)
}
func getSum2() (sum2 int) {
    sum :=1
    for ; sum <100;  {
        sum +=sum
    }
    return sum
}
func getSum1() (sum1 int) {
    sum :=0
    for i:= 0; i < 10; i++ {
        sum+=i
    }
    return sum
}

2.for是Go中“while”

package main
import "fmt"
func main() {
    sum:= 1
    for sum < 1000 {
        sum +=sum
    }
    fmt.Print(sum)
}

看在goland中显示:

image.png

3.if判断以及简写

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Print(sqrt(2),sqrt(-4))
    fmt.Println(pow(3,3,20))
}
//注意类型的转换
func pow(x float64, n float64, lim float64) float64 {
    //这里可以把表达式写在if上
    if v := math.Pow(x, n); v < lim {
        return v
    }
}
func sqrt(x float64) (string) {
    if x < 0 {
        return sqrt(-x)+"i"
    }
    return fmt.Sprint(math.Sqrt(x))
}

4.if和else

package main
import (
    "fmt"
    "math"
)
func main() {
    fmt.Print(powTest(3,2,10))
}
//如果前面的几个参数的类型相同,则只需要在最后一个参数后面声明类型即可
func powTest(x,n, lim float64) float64 {
    if v:=math.Pow(x,n); v <lim {
        return v
    }else{
        fmt.Println(v,lim)
    }
    return lim
}

5.switch

switch可以使用任何类型或者表达式作为条件语句,不需要写break,一旦条件符合自动终止。如希望继续执行下一个case,需要使用fallthrough语句。支持一个初始化表达式(可以是并行方式),右侧需要跟分号。

package main
import "fmt"
func main() {
    a:=1
    //表达式可以写在switch后面,也可以不写
    switch {
    case a >=0:
        fmt.Println("a=0")
        //继续执行下一个case
        fallthrough
    case a >=1:
        fmt.Println("a=1")
    }
}
image.png

6.指针(重点)

Go虽然保留了指针,但与其它编程语言不同的是,在Go当中不支持指针运算以及->运算符,而直接采用.选择符来操作指针目标对象的成员。

操作符&取变量地址,使用*通过指针间接访问目标对象
默认值为nil而非NULL
package main
import "fmt"
func main() {
    a:=1
    a++
    //&是取变量的地址
    var p *int = &a
    //*是通过指针间接访问目标对象
    fmt.Print(*p)
}

7.defer关键字

Go的defer语句是用来延迟执行函数的,而且延迟发生在调用函数return之后的。而且defer执行顺序为可以理解为栈:先进后出

先解释第一句话:的defer语句是延迟执行函数的

package main
import "fmt"
func main() {
    defer fmt.Print("world!")
    fmt.Print("hello")
}
image.png

然后解释第二句话:而且延迟发生在调用函数return之后的。(可能结果会跟你想的不一样)

package main
import "fmt"
func main() {
    a:=f1()
    b:=f2()
    c:=f3()
    fmt.Print(a,b,c)
}

/**
return会做几件事:
1.给返回值赋值
2.调用defer表达式
3.返回给调用函数
 */
func f1()(result int)  {
    defer func() {
        result++
    }()
    return 0
}

/**
defer是在t赋值给r之后执行的,而defer延迟函数只改变了t的值,r不变
 */
func f2() (r int) {
    t:=5
    defer func() {
        t=t+5
    }()
    return t
}

/**
这里将r作为参数传入defer表达式
 */
func f3()(r int)  {
    defer func(r int) {
        r=r+5
    }(r)
    return 1
}
image.png

解释来自stackoverflow

image.png

参考资料

https://go-tour-zh.appspot.com/welcome/1

上一篇下一篇

猜你喜欢

热点阅读