zoukankan      html  css  js  c++  java

  • go 函数和流程控制

    if/else分支判断

     基本结构如下：

     1 if condition1 {
 2 }
 3 
 4 if condition1 {
 5     
 6 } else {
 7 
 8 }
 9 
10 if condition1 {
11     
12 } else if condition2 {
13 
14 } else if condition3 {
15 } else {
16 }
     1 // main
 2 package main
 3 
 4 import (
 5     "fmt"
 6     "strconv"
 7 )
 8 
 9 func main() {
10     var input string
11     fmt.Scanf("%s", &input)
12     conv_input, err := strconv.Atoi(input)
13     if err != nil {
14         fmt.Println("cannot convert to int")
15     } else {
16         fmt.Println(conv_input)
17     }
18 }
    sample

    swich case语句

    1 switch var {
2 case var1:
3 case var2:
4 case var3:
5 default:
6 }
     1 var i = 0
 2 switch i {
 3 case 0:
 4         fallthrough
 5 case 1:
 6       fmt.Println(“1”)
 7 case 2:
 8 fmt.Println(“2”)
 9 default:
10      fmt.Println(“def”)
11 }
    fallthrough

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

    格式2

    1 var i = 0
2 switch {
3 condition1:
4       fmt.Println(“i > 0 and i < 10”)
5 condition2:
6 fmt.Println(“i > 10 and i < 20”)
7 default:
8      fmt.Println(“def”)
9 }
    1 var i = 0
2 switch {
3 case i > 0 && i < 10:
4       fmt.Println(“i > 0 and i < 10”)
5 case i > 10 && i < 20:
6 fmt.Println(“i > 10 and i < 20”)
7 default:
8      fmt.Println(“def”)
9 }
    sample

    格式3

    1 switch i := 0 {
2 case i > 0 && i < 10:
3       fmt.Println(“i > 0 and i < 10”)
4 case i > 10 && i < 20:
5 fmt.Println(“i > 10 and i < 20”)
6 default:
7      fmt.Println(“def”)
8 }
     1 // main
 2 package main
 3 
 4 import (
 5     "fmt"
 6     "math/rand"
 7 )
 8 
 9 func main() {
10     randum_num := rand.Intn(100)
11 
12     for {
13         var input int
14         fmt.Scanf("%d
", &input)
15         input_num := input
16 
17         if input_num == randum_num {
18             fmt.Println("good guess")
19             break
20         } else if input_num > randum_num {
21             fmt.Println("bigger")
22         } else {
23             fmt.Println("smaller")
24         }
25     }
26 
27 }
    sample

    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. 多返回值

     1 package main
 2 
 3 import "fmt"
 4 
 5 func add(a, b int) int {
 6     return a + b
 7 }
 8 
 9 func main() {
10 
11     c := add
12     fmt.Println(c)
13 
14     sum := c(10, 20)
15     fmt.Println(sum)
16        if ( c == add ) {
17                fmt.Println(“c equal add”)
18        }
19 }
    sample
     1 package main
 2 
 3 import "fmt"
 4 
 5 type add_func func(int, int) int
 6 
 7 func add(a, b int) int {
 8     return a + b
 9 }
10 
11 func operator(op add_func, a int, b int) int {
12     return op(a, b)
13 }
14 
15 func main() {
16     c := add
17     fmt.Println(c)
18     sum := operator(c, 100, 200)
19     fmt.Println(sum)
20 }
    sample2

    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]依次访问所有参数
    1 func add(a int, arg ...int) int {
2     sum := a
3     for _, v := range arg {
4         sum += v
5     }
6     return sum
7 }
    一个或多个数相加

    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)
            } 
} 
    1 func read() {
2 file := open(filename)
3 defer file.Close()
4 
5 //文件操作
6 }
    关闭文件句柄
    1 func read() {
2 mc.Lock()
3 defer mc.Unlock()
4 //其他操作
5 }
    锁资源释放
    1 func read() {
2 conn := openDatabase()
3 defer conn.Close()
4 //其他操作
5 }
    数据库连接释放
  • 相关阅读:
    Go 打印出结构化结构体
    GOPROXY设置
    python判断链表是否有环
    单链表python和go的代码
    mongo索引
    python修改srt字幕的时间轴
    python各个版本的排序
    mac使用python识别图形验证码
    selenium运行js代码笔记
    布隆过滤器
  • 原文地址：https://www.cnblogs.com/cedrelaliu/p/7076871.html
Copyright © 2011-2022 走看看