Go基础之流程[if, for,switch]和函数[func]

流程控制
　　流程控制有三大类：条件判断， 循环控制， 无条件跳转

　　if：所有语言 都有的一种判断：如果满足就做 不满足就做另一件

　　if x > 5 {
　　fmt.println("比5大")
　　} else {
　　fmt.println("比5小")
　　}

　　

 

　　不同点：GO在条件判断语句里允许声明一个变量，作用范围在该条件逻辑块内

　　if a := computedValue(); a>5 {
　　　　fmt.println("比5大")
　　} else {
　　　　fmt.println("比5小")
　　}

　　a出了if语句块那么也就超范围 失效了
　　fmt.println(a)

　　

 

　　多条件： if xxx{} else if xxx{} else{}

　　　　

 

　　goto goto跳转必须在当前函数内定义好的标签。(标签大小写敏感)

　　func myFunc() {
　　　　i := 0
　　　　Here:
　　　　println(i)
　　　　i++
　　　　goto Here
　　}

　　

 

for:
　　Go里控制逻辑，它可以用来循环读取数据 又能控制逻辑 还能迭代操作
　　for xx1, xx2, xx3 { xxx } 其中xx1，xx2, xx3都是表达式

　　//例子
　　package main
　　import "fmt"

　　func main(){
　　sum :=0；
　　for index :=0; index < 10; index ++ {
　　　　sum += index
　　　　}
　　　　fmt.Println("sum is" , sum)
　　}

 

　　有时候需要进行多个赋值操作，go没有 所以使用平行赋值i， j= i + 1 ,j-1

　　有时候可以忽略条件1和条件3
　　sum := 1
　　for ; sum <1000; {
　　　　sum += sum
　　}

　　

 

　　; 也可以省略

　　在循环体中有两个关键操作 break和continue。break跳出循环 continue 跳出本次循环

　　break 和 continue 可以跟着标号 用来调到多重循环中的外层循环

　　for配合 range 可以用于读取slice和maip的数据

　　for k, v:=range map {
　　　　fmt.println("map",k)
　　　　fmt.println("map",v)
　　}

　　！！！由于GO支持"多值返回"，并且对"多声明变量不用会报错"在这种情况下 可以使用_来丢弃不需要使用的返回值

　　for _, v := range map{
　　　　fmt.Println("maps val:",v)
　　}

switch
　　有时候你需要写很多的if-else来实现逻辑处理那么可以用switch来代替

　　　　switch sexpr {
　　　　case expr1:
　　　　　　some instructions
　　　　case expr2:
　　　　　　some instructions
　　　　case expr3:
　　　　　　some instructions
　　　　default:
　　　　　　other code
　　　　}

　　其中 sexpr 和exprx 的类型要保持一致。Go的switch非常灵活，表达式不必是常量或证书，执行过程从上到下，直到找到匹配项：
　　如果switch没有表达式，它会匹配true

　　go里面switch中 默认每个case后面带有break，配对成功后不会向下执行而是跳出switch 但是可以用fallthrough 强制执行后面的case代码

函数：
　　函数是Go里面的核心设计，通过关键字func来声明

　　func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {

　　//这里处理逻辑代码
　　//返回多个值
　　　　return value1, value2
　　}

　　func 是声明一个函数 funcName
　　函数可以有一个或者多个参数，每个参数后面带有类型，通过，分割
　　函数可以返回多个值

　　//例子
　　func max(a,b int) int {//a,b int 都是int 缩略一个int
　　　　if a > b {
　　　　　　return a
　　　　}
　　　　return b

　　}

　　func main() {
　　　　x := 3
　　　　y := 4
　　　　z := 5

　　　　max_xy := max(x, y) //调用函数max
　　　　max_xz := max(x, z)
　　　　fmt.Printf("max(%d,%d)=%d\n", x, y, max_xy)
　　}

　　多返回值

　　　　Go函数支持变参，接受变参的函数是有着不定数量的参数的 但是类型保持一致
　　func myfunc(arg ...int) {}
　　　　arg ... int 告诉GO这个函数接受不定数量的参数 在函数体中arg是个slice

　　for _, ｎ := range arg {
　　　　fmt.Pringtf("and the number is : %d\n", n)
　　}

 

传值和传指针

　　　　当我们传一个参数值到被调用函数里面时，世纪穿了这个值得一份copy 当在被调用函数中修改参数值的时候，
　　调用函数中相应实参不会发生任何变化，因为数值变化只作用在copy上。

　　例子：
　　package main
　　import "fmt"

　　// 函数实现+1操作
　　func add1(a int) int {
　　　　a = a + 1
　　　　retrun a //返回一个新值
　　}

　　func main() {
　　　　x := 3
　　　　fmt.Println("x =", x) //应该输出 "x = 3"
　　　　x1 := add1(x) //调用add1()
　　　　fmt.Println("x + 1 =", x1) //应该输出"x+1 =4"
　　　　fmt.Println("x = ", x) //应该输出 "x = 3"
}

!!!上面x 调用了 add1(x) 并且在add1中执行 a = a + 1 操作，但是x变量的值没有发生变化
解析原因： 当我们调用add1的时候 add1接收的参数其实是x的copy 而不是x本身

　　如果传本身呢？ 那就是要传指针了啊

　　　　package main
　　　　import "fmt"
　　　　//简单的一个函数，实现了参数+1的操作
　　　　func add1(a *int) int {
　　　　*a = *a + 1 //修改了a的值
　　　　retrun *a //返回新值
　　　　}

　　　　func main() {
　　　　　　x := 3
　　　　　　fmt.Println("x=", x) //应该输出"x=3"

　　　　　　x1 := addr1(x)
　　　　　　fmt.Println("x+1", x) //应该输出 4
　　　　　　fmt.Println("x", x) //应该输出4

　　　　}

　　// 传指针的好处
　　1.传指针使得多个函数能操作同一个对象
　　2.传指针比较轻量级(8bytes),只是传内存地址，我们尅用指针传递体积大的结构体。
　　如果用参数值传需要copy会花额外多的系统开销。所以传递大的结构体的时候，用指
　　针是一个明确的选择

　　3.Go语言中string, slice, map这三种类型的实现机制类似于指针 可以直接传递 不用取地址后传递指针

defer:
GO语言中有种不错的设计 延迟语句 defer。可以在函数中添加多个defer.并且defer按照逆序进行执行

　　func ReadWrite() bool{
　　file.Open("file")
　　//做一些工作
　　if filurex {
　　　　file.Close()
　　　　retrun false
　　}
　　if filurey {
　　　　file.Close()
　　　　retrun false
　　}
　　file.Close()
　　retrun false
　　}

上面代码太重复 defer解决了这个问题

　　func ReadWriter() bool{
　　file.Open("file")
　　defer file.Close()
　　if failurex {
　　　　return false
　　}
　　if failureY {
　　　　renturn false
　　}
　　return ture
　　}

!!!如果很多defer引用，那么defer是采用后进先出的模式

函数作为值，类型

　　在Go中函数也是变量之一 可以用type来定义。它的类型就是所拥有相同的参数，相同的返回值的一种类型

type typeName func() type

package main
import "fmt"

type testInt func(int) bool //声明了一个函数类型

func isOdd(integer int) bool {
if integer % 2 == 0 {
return false
}
retrun true
}

func isEven(integer int) bool {
if integer % 2 == 0 {
return true
}
retrun false
}

// 声明的函数类型在这个地方做了一个参数

func filter(slice []int, f testInt) []int {
var result [] int
for _, value := range slice {
if f(value) {
result = append(result, value)
}
}
return result
}

func main() {
slice := [] int {1, 2, 3, 4, 5, 7}
fmt.Println("slice = ", slice)
odd := filter(slice, isOdd) // isOdd这个函数当做值 传递到了 filter这个函数里边
fmt.Println("Odd elements of slice are: ", odd)
even := filter(slice, isEven)
fmt.Println("Even elements of slice are: ", even)
}

　　用途： 函数当做值 和类型在我们写一些通用接口时候非常有用 上面例子中testInt类型是个函数类型。 我们可以实现很多种逻辑使得我们程序变得非常灵活

panic和Recover

main 函数 和Init 函数
　　GO里面有两个保留函数： init函数 (应用于所有package) 和main函数 (只能应用于package main)
　　这2个函数定义时候不能有任何参数和返回值
　　两个函数一个包只限制有一个
　　GO会自动调用init() 和main() 不需要任何地方调用
　　init() 是可选的 但是main 是必须的
　　先执行main包 --- 然后导入其他包 重复只导入一次 ----init包

import 包
　　GO代码经常用到import这个命令来导入包文件
　　import( "fmt")
　　fmt是Go语言的标准库 , 去goroot 下加载该模块，
　　go也支持其他2种方式来加载自己模块
　　1.相对路径 ：import "./model" //当前文件同一目录的model目录，不推荐这种方式导入
　　2.绝对路径 : import "shorturl/model" //架子啊gopath/src/shorturl/model模块

　　特殊导入import
　　1.点操作：
　　import(
　　.　　"fmt"
　　)
　　这个.的意思是 这个包导入 有点 后在引用这个包的函数时候不需要前缀 ---> print()
　　2.别名操作
　　import(
　　　　f "fmt"
　　)
　　别名操作调用包函数时候 前缀变成我们的前缀 ---> f.print()

　　3._操作
　　import (
　　　　"database/sql"
　　　　_"github.com...."
　　)
　　_操作就是引入该包，不引入包里面函数，而是调用该包里面的init函数

2017年12月23日13:49:48 [小路写·过去篇]