第三章 Go语言流程控制

一：switch语句   switch的条件可以传也可以不传，如下：

func liachengtest() {

switch i {

case 0:

fmt.Println("0")

case 1:

fmt.Println("1")

default:

fmt.Println("2")

}

num :=6

switch {

case 0<=num && num<=3:

fmt.Println("3")

case 3<=num && num<=8:

fmt.Println("8")

default:

fmt.Println("mm")

}

}

 二： for语句    在Go中，Go优化了无限循环的场景，然开发者不用再写无聊的for（;;）和do{} while（）；可以直接这些写 如下：

 

func fortest() {

sum :=0

for{

sum++

if(sum>100){

fmt.Println("计数到100，跳出循环")

break

}

}

}

 

并且在Go中条件表达式也支持多重赋值  如：

a :=[]int {1,2,3,4,6,7,8}

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

fmt.Println("for循环多重赋值输出：",a[i],a[j])

}

 

for循环多重赋值输出： 1 8

for循环多重赋值输出： 2 7

for循环多重赋值输出： 3 6

   三：函数  函数定义的方法是   注意第一个”{”必须和func同一行

                                  func add(参数 类型，参数 类型) (返回值 类型，返回值 类型){

 

                                   }

                   如果若干个参数类型相同 可以写成这样 如：

                                  func add(参数1，参数2 类型) (返回值 类型，返回值 类型){

 

                                   }

                       这样参数1和参数2的类型，是一样的，都是参数2的类型，返回值如果类型相                        同也可以这样写

                      如果返回值只有一个类型可以这样写  如

                          func add(参数1，参数2 类型)  类型{

 

                           }

                       不定参数函数的定义方法是，不定参数只能放到函数参数的最后  如下：

                          func add(参数1 ...类型)  类型{

                                 不定参数其实就是一个数组切，也就是[]type所以，不定参数可以用for

                           }

                         这样add就是一个不定参数的函数了，并且所有的参数类型一直  ，实例如：

                          

func myfunc(args ...int) {

fmt.Println("不定参数")

fmt.Println(args)

}

调用

myfunc(1,2,3,45,5)

输出

不定参数

[1 2 3 45 5]

不定参数可以传递数组，但是数组要打散如：

myap :=[]int {9,8,7,6,5,4,3}

myfunc(myap ...)

 

任意类型不定参数的函数  定义方式如下：

func myfunc(fromt string,args ...interface{}){

 

}

使用interface{}传递任意类型是Go惯例用法，而且interface仍然是类型安全的，演示实例如下：

 

func myfunctype(formt string,args ...interface{}) {

for _,arg:=range args {

switch arg.(type) {

case int:

fmt.Println("这个是一个int类型",arg)

case string:

fmt.Println("这个是一个string类型",arg)

default:

fmt.Println("未知类型：",arg)

}

}

}

 

myfunctype("zzl","zzl","tty","赵占龙","瀚海")

myfunctype("zzl",1,24,5,6,76,)

这个是一个string类型 zzl

这个是一个string类型 tty

这个是一个string类型 赵占龙

这个是一个string类型 瀚海

这个是一个int类型 1

这个是一个int类型 24

这个是一个int类型 5

这个是一个int类型 6

这个是一个int类型 76

 

匿名函数和闭包  就是不需要定义函数名的函数（匿名函数可以向普通变量一样传递和使用）

func mybibao() {

var j int =5

a := func() (func()){

var i int =5

return func() {

fmt.Println("闭包内变量 %d 比包外代码块变量 %d：",i,j)

}

}()

a()

j *=2

a()

}

闭包内变量 %d 比包外代码块变量 %d： 5 5

闭包内变量 %d 比包外代码块变量 %d： 5 10

闭包的实现确保了只要闭包还被调用，那么闭包引用的变量会一直存在

 四：读写文件   Go中读写文件还是比较简单的 代码如下：

         

 

//读取文件

file,err :=os.Open("")

if err==nil{

br :=bufio.NewReader(file)

for{

line,isprefix,err1 :=br.ReadLine()

 

if err1==nil{

str :=string(line)

value,err :=strconv.Atoi(str)

fmt.Println("读取文本输出数据")

}

}

}

defer file.Close()

 

//写文件

file2,err2 :=os.Create("")

if err2 ==nil{

file2.WriteString("zzl")

 

}

defer file2.Close()