go 函数和流程控制

if/else分支判断

 基本结构如下：

if condition1 {
}

if condition1 {
    
} else {

}

if condition1 {
    
} else if condition2 {

} else if condition3 {
} else {
}

// main
package main

import (
    "fmt"
    "strconv"
)

func main() {
    var input string
    fmt.Scanf("%s", &input)
    conv_input, err := strconv.Atoi(input)
    if err != nil {
        fmt.Println("cannot convert to int")
    } else {
        fmt.Println(conv_input)
    }
}

swich case语句

switch var {
case var1:
case var2:
case var3:
default:
}

var i = 0
switch i {
case 0:
        fallthrough
case 1:
      fmt.Println(“1”)
case 2:
fmt.Println(“2”)
default:
     fmt.Println(“def”)
}

go里面switch默认相当于每个case最后带有break，匹配成功后不会自动向下执行其他case，而是跳出整个switch, 但是可以使用fallthrough强制执行后面的case代码，fallthrough不会判断下一条case的expr结果是否为true。

格式2

var i = 0
switch {
condition1:
      fmt.Println(“i > 0 and i < 10”)
condition2:
fmt.Println(“i > 10 and i < 20”)
default:
     fmt.Println(“def”)
}

var i = 0
switch {
case i > 0 && i < 10:
      fmt.Println(“i > 0 and i < 10”)
case i > 10 && i < 20:
fmt.Println(“i > 10 and i < 20”)
default:
     fmt.Println(“def”)
}

格式3

switch i := 0 {
case i > 0 && i < 10:
      fmt.Println(“i > 0 and i < 10”)
case i > 10 && i < 20:
fmt.Println(“i > 10 and i < 20”)
default:
     fmt.Println(“def”)
}

// main
package main

import (
    "fmt"
    "math/rand"
)

func main() {
    randum_num := rand.Intn(100)

    for {
        var input int
        fmt.Scanf("%d
", &input)
        input_num := input

        if input_num == randum_num {
            fmt.Println("good guess")
            break
        } else if input_num > randum_num {
            fmt.Println("bigger")
        } else {
            fmt.Println("smaller")
        }
    }

}

for 语句

写法1

for 初始化语句; 条件判断; 变量修改 {
}

for i := 0 ; i < 100; i++ {
fmt.Printf(“i=%d
”, i)
}

写法2

for  条件 {
}

for true {
      fmt.Println(“i > 0”)
}

写法3

str := “hello world,中国”
for i, v := range str {
     fmt.Printf(“index[%d] val[%c] len[%d]
”, i, v, len([]byte(v)))
}

break/continue语句

str := “hello world,中国”
for i, v := range str {
       if i > 2 {
             continue
       }
  if (i > 3) {
         break  }
     fmt.Printf(“index[%d] val[%c] len[%d]
”, i, v, len([]byte(v)))
}

goto/lable语句

package main
import "fmt"
func main() {
LABEL1:
    for i := 0; i <= 5; i++ {
        for j := 0; j <= 5; j++ {
            if j == 4 {
                continue LABEL1
            }
            fmt.Printf("i is: %d, and j is: %d
", i, j)
        }
    }
}

package main

func main() {
    i := 0
HERE:
    print(i)
    i++
    if i == 5 {
        return
    }
    goto HERE
}

函数

1. 声明语法：func 函数名 (参数列表) [(返回值列表)] {}

func add() {
}

func add(a int, b int) {
}

func add(a int, b int) int {
}

func add(a int, b int) (int, int)  {
}

func add(a, b int) (int, int)  {
}

2. golang函数特点：
a. 不支持重载，一个包不能有两个名字一样的函数
b. 函数是一等公民，函数也是一种类型，一个函数可以赋值给变量
c. 匿名函数
d. 多返回值

package main

import "fmt"

func add(a, b int) int {
    return a + b
}

func main() {

    c := add
    fmt.Println(c)

    sum := c(10, 20)
    fmt.Println(sum)
       if ( c == add ) {
               fmt.Println(“c equal add”)
       }
}

package main

import "fmt"

type add_func func(int, int) int

func add(a, b int) int {
    return a + b
}

func operator(op add_func, a int, b int) int {
    return op(a, b)
}

func main() {
    c := add
    fmt.Println(c)
    sum := operator(c, 100, 200)
    fmt.Println(sum)
}

3. 函数参数传递方式：
1). 值传递
2). 引用传递

注意1：无论是值传递，还是引用传递，传递给函数的都是变量的副本，不过，值传递是值的拷贝。引用传递是地址的拷贝，一般来说，拷贝更为高效。而值拷贝取决于拷贝的对象大小，对象越大，则性能越低

注意2：map、slice、chan、指针、interface默认以引用的方式传递

4. 命名返回值的名字

func add(a, b int) (c int) {
        c = a + b
        return
}

func calc(a, b int) (sum int, avg int) {
        sum = a + b
        avg = (a +b)/2
        return
}

5. _标识符，用来忽略返回值：

6. 可变参数

func add(arg…int) int {   //0个或多个参数
}

func add(a int, arg…int) int {  //1个或多个参数
}

func add(a int, b int, arg…int) int {  //2个或多个参数

}

注意：其中arg是一个slice，我们可以通过arg[index]依次访问所有参数

func add(a int, arg ...int) int {
    sum := a
    for _, v := range arg {
        sum += v
    }
    return sum
}

7. defer用途：
1. 当函数返回时，执行defer语句。因此，可以用来做资源清理
2. 多个defer语句，按先进后出的方式执行
3. defer语句中的变量，在defer声明时就决定了。

func a() {
          i := 0
          defer fmt.Println(i)
          i++
          return
} 

 func f() {
            for i := 0; i < 5; i++ {
                    defer fmt.Printf(“%d “, i)
            } 
} 

func read() {
file := open(filename)
defer file.Close()

//文件操作
}

func read() {
mc.Lock()
defer mc.Unlock()
//其他操作
}

func read() {
conn := openDatabase()
defer conn.Close()
//其他操作
}