Go: 2-2 条件语句和循环语句

语句 描述
if 语句 if 语句 由一个布尔表达式后紧跟一个或多个语句组成
if…else if 语句 后可以使用可选的 else 语句, else 语句中的表达式在布尔表达式为 false 时执行。
if 嵌套语句 你可以在 if 或 else if 语句中嵌入一个或多个 if 或 else if 语句。
switch 语句 switch 语句用于基于不同条件执行不同动作
select 语句 select 语句类似于 switch 语句,但是select会随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行
    package main
    
    import (
    	"fmt"
    	"io/ioutil"
    )
    
    func grade(score int) string {
    	g := ""
    	switch {
    	case score < 0 || score > 100:
    		panic(fmt.Sprintf(
    			"Wrong score: %d", score))
    	case score < 60:
    		g = "F"
    	case score < 80:
    		g = "C"
    	case score < 90:
    		g = "B"
    	case score <= 100:
    		g = "A"
    	}
    	return g
    }
    
    func main() {
    	// If "abc.txt" is not found,
    	// please check what current directory is,
    	// and change filename accordingly.
    	const filename = "abc.txt"
    	if contents, err := ioutil.ReadFile(filename); err != nil {
    		fmt.Println(err)
    	} else {
    		fmt.Printf("%s\n", contents)
    	}
    
    	fmt.Println(
    		grade(0),
    		grade(59),
    		grade(60),
    		grade(82),
    		grade(99),
    		grade(100),
    		// Uncomment to see it panics.
    		// grade(-3),
    	)
    }

select是Go中的一个控制结构,类似于用于通信的switch语句。每个case必须是一个通信操作,要么是发送要么是接收。
select随机执行一个可运行的case。如果没有case可运行,它将阻塞,直到有case可运行。一个默认的子句应该总是可运行的。

select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    /* 你可以定义任意数量的 case */
    default : /* 可选 */
       statement(s);
}
以下描述了 select 语句的语法:
   package main
   import "fmt"
   import "time"
   func f1(ch chan int) {
       time.Sleep(time.Second * 5)
       ch <- 1
   }
   func f2(ch chan int) {
       time.Sleep(time.Second * 10)
       ch <- 1
   }
   func main() {
       var ch1 = make(chan int)
       var ch2 = make(chan int)
       go f1(ch1)
       go f2(ch2)
       select {
       case <-ch1:
           fmt.Println("The first case is selected.")
       case <-ch2:
           fmt.Println("The second case is selected.")
       }
   }
循环语句
package main

import (
	"strconv"
	"fmt"
	"os"
	"io"
	"bufio"
	"strings"
)

func convertToBin(n int) string  {
	result := ""
	for ; n >0; n /=2{
		lsb := n%2
		result = strconv.Itoa(lsb)+result
	}
	return result
}

func printFile(filename string)  {
	file,err :=os.Open(filename)
	if err != nil {
		panic(err)
	}
	printFileContents(file)
}

func printFileContents(reader io.Reader) {
	scanner := bufio.NewScanner(reader)
	for scanner.Scan() {
		fmt.Println(scanner.Text())
	}
}
func forever()  {
	for{
		fmt.Println("abc")
	}

}

func main()  {
	fmt.Println("convertToBin results:")
	fmt.Println(
		convertToBin(15),
		convertToBin(2),
		convertToBin(5),
	)
	fmt.Println("abc.txt contents:")
	printFile("abc.txt")


	s := `abc "ad"
	kddd
	123
	p
	22333'`
	printFileContents(strings.NewReader(s))
}