go语言2 函数, 包, mode模式, if-else语句, 循环, switch语句, 命名返回值, 给类型重命名, 类型零值

1 函数

/*
函数
*/
package main
import "fmt"

func main() {

    //1 函数调用
    //test()

    //2 函数调用
    //a:=10
    //test(a)
    //test(10)

    //3 函数调用
    //test(10,11)
    //test(b=10,a=11) //没有关键字参数

    //4 函数调用
    //var a int
    //a=test(10,11)
    //a:=test(100,11)
    //fmt.Println(a)

    //5 函数调用(有几个返回值，必须用几个值来接收)
    //a,b:=test(10,11)
    //第二个参数不接收了（跟python中_不一样，python中_就是一个变量）
    //a,_:=test(10,11)
    ////fmt.Println(a,b)
    //fmt.Println(a)
    ////fmt.Println(_)

    //6 可变长参数
    //fmt.Println(1,"ddd",3.14,4,4,5,6,7,8)
    //test(1,2,3,4,4,56,7,7,8,9,9,0)

    //7 匿名函数（定义在函数内部，没有名字）
    //放在函数内部，有两种处理方案
        //1 让它执行
        //2 当参数返回
        //否则报错
    //func (){
    //    fmt.Println("我是匿名函数")
    //}()

    //8 函数是一等公民
    //test()()  没问题

    //var a func()
    //a=test()
    //a()

    //a:=test()
    //a()

    // 9 闭包函数调用
    //a:=test(10)
    //fmt.Println(a)
    //a()

    //10 闭包函数高级
    //test(99)(88,77)
    //a:=test(99)
    //a(88,77)
}

//func关键字 函数名(参数1 类型，参数2 类型){函数体的内容}
//1 定义一个无参数，无返回值的普通函数
//func test()  {
//    fmt.Println("我是test")
//}

//2 带参数，无返回值
// go中全是位置参数， 没有所谓的关键字参数，默认参数
//func test(b int)  {
//    fmt.Println(b)
//
//}

//3 带多个参数，无返回值(没有默认参数和关键字参数)
//func test(a int,b int)  {
//如果两个参数都是同一个类型，就可以简略写
//func test(a ,b int,c string)  {
//    fmt.Println(a+b)
//}

//4 带多个参数，有一个返回值(指明返回参数类型是什么)
//返回值类型是int类型
//func test(a, b int) int {
//    c := a + b
//    return c
//}

//5 带多个参数，多返回值（返回值类型，返回值类型。。。）
//func test(a,b int)(int,int) {
//    c:=a+b
//    d:=a*b
//    return c,d
//}
//补充
//func test(a,b int)(){}
//func test(a,b int)(int){}
//func test(a,b int)(int,string,int){}
//func test(a,b int)int{}

//6 可变长参数
//可以传任意长度的int类型
//func test(a ...int) {
//    //a是切片
//    fmt.Println(a[1])
//}

//7 匿名函数（定义在函数内部，没有名字）

//8 函数是一等公民（头等函数）,函数也是一个类型
//在一门语言中，如果函数可以赋值个变量(被当做变量来使用)，那函数就叫一等公民，或者叫头等函数
//返回值是函数类型
//func test() func() {
//    var a func()=func (){
//        fmt.Println("我是内层函数")
//    }
//    return a
//}
//func test() func() {
//    return func (){
//        fmt.Println("我是内层函数")
//    }
//}

//9 闭包函数（1 定义再函数内部 2 对外部作用域有引用）
// 闭包函数：多了一种函数传参的方式

//func test(b int) func() {
//    a:= func() {
//        fmt.Println(b)
//    }
//    return a
//}

//go语言中没有装饰器语法糖，但是可以自己实现装饰器
//@ttt
//func test()  {
//}

//10 闭包函数高级
func test(b int) func(x,y int) {
    var a func(x,y int)
    a= func(x,y int) {
        fmt.Println(b+x+y)
    }
    return a
}

//func test(b func(z int)) (func(x,y int),func()) {
//    var a func(x,y int)
//    a= func(x,y int) {
//        b(12)
//        fmt.Println(x+y)
//    }
//    return a, func() {
//    }
//}

//规范
/*
    1 变量：go语言中变量区分大小写，建议用驼峰
        var Name="lqz"
        var name="lqz"
        fmt.Println(Name)
        fmt.Println(name)
    2 文件名：建议用下划线
    3 大写字母开头，表示导出字段（外部包可以使用）

    4 先导入第三方包，内置包，自己写的包
    5 不像python中缩进代表同一段代码块
            var a =10
        fmt.Println(a)
               fmt.Println("xxx")
*/

2包

//1 在同一个包下（文件夹下），包名必须一致
//2 以后，包名就是文件夹的名字    (规定只有main包下的main函数才可以执行，其他包下的main函数，只是重名，一般不这么写)
//3 同一个包下，同名函数只能有一个（init除外）
//4 一个包（当成一个文件），同一包下的函数，直接调用即可
//5 导包的位置，从src路径开始
package main
import "s13_day02_go/s13package"

func main() {
    s13package.Test()
}

// 另一种导包方式 括号中导包
package main
import (
    "fmt"
    "s13_day02_go/s13package"
)

func main() {
    fmt.Println("xxx")
    s13package.Test()
}
//6 包只要在src路径下就可以导入
//7 大写表示导出，在外部包可以使用，小写只能再包内部使用
package main
import (
    "s13_day02_go/s13package"
)
func main() {
    s13package.Test()
    // 大写表示导出，在外部包可以试用，小写只能在包内使用
    //s13package.test()   // 找不到该方法
}
//8 使用第三方包：go get github.com/astaxie/beego  （放到gopath的src路径下）
-python：pip3 install requests (不像python有统一管理包地方，go约定管理在github上) 
    package main
    import "github.com/astaxie/beego"

    func main() {
      beego.Run()
    }

注：此处我安装一直失败，无奈转为离线安装
从  github.com/astaxie/beego  下载包，解压到    C:\Users\ldc\go\src\github.com\astaxie\beego
然后还是报错，显示没有github.com\shiena\ansicolor文件   缺少ansicolor依赖包
于是从   github.com/shiena/ansicolor  下载包，解压到    C:\Users\ldc\go\src\github.com\shiena\ansicolor
终于可以成功启动。。。
但是ide没有识别，无法通过按住ctrl+点击进入源码，beego.Run()中的Run也报红，未找到。不过能运行了

补充mode模式

//1 包导入 import . "github.com/astaxie/beego"  类似于python中form xx import *
//2 包导入 import _ "github.com/go-sql-driver/mysql"  触发init的执行(从上往下)，但是不试用包内的函数
//3 包导入 import f "fmt"   重命名，以后直接用f
package s13package
import f "fmt"

func Test() {
    f.Println("我是包内的大写TEST")
    test()
}

//4 对比python中__init__.py  
//在代码中导入模块
import xx   实质上触发__init__.py  的执行(在__init__.py中也可以执行其他代码，对应到go中就是init函数)
一般情况下，在__init__.py写from xx import 会使用到的函数，导过来
以后再用 xx.函数()

//5 go mod没有之前，可以设置多个gopath，开发某个项目，切到不同的gopath，类似于虚拟环境

//6 go env
    -GO111MODULE="off"  表示go mod模式是关闭的，用gopath
    set GO111MODULE=on  // windows             go 会忽略 GOPATH 和 vendor 文件夹
    export GO111MODULE=on // linux

    -一旦开启了go mod模式，代码不需要放在src路径下（任意位置都可以）
    -在项目路径下要有 go.mod 文件（文件里记录了，go版本，项目依赖的包，包的版本）
go.mod可以手动创建；
也可以通过在根目录下执行命令go mod init test-demo(名字随便，最好是项目名),然后会生成一个go.mod
    -写代码，建自己的包即可(建起mvc架构项目)
    -一般情况下，项目有一个main.go  内部是main包，main函数，整个程序的入口，为启动文件
    
通过运行main函数     go run main.go (主函数坐在文件)   会自动在在go.mod中require()里写入需要的组件和版本，
并且下载组件到pkg(src和bin同级路径)/mod/.github.com/astaxie/beego@v1.12.1文件夹下(以beego为例)
# 如果关闭GO111MODULE模式，删了go.mod文件，一定要拷贝到src文件路径下，才能执行

3 if-else语句

//if-else
package main

func main() {
    //a:=9
    //1 基本使用
    //if a>10{
    //    fmt.Println("大于10")
    //}else {
    //    fmt.Println("小于等于10")
    //}

    //2 if -else if -else
    //if a>10{
    //    fmt.Println("大于10")
    //}else if a==10 {
    //    fmt.Println("等于10")
    //}else {
    //    fmt.Println("小于10")
    //}

    //3 不能换行（go语言每一行结尾，需要加一个;  ,每当换行，会自动加;）
    //if a>10{
    //    fmt.Println("大于10")
    //}else if a==10 {
    //    fmt.Println("等于10")
    //}else
    //{
    //    fmt.Println("小于10")
    //}

    //4 条件里可以进行初始化操作(有作用域范围的区别)
    //a:=10; 
    //if a<10{
    //if a:=10;a<10{    // a的作用域在内部，外部不可以应用啊
    //    fmt.Println("xxx")
    //}else {
    //    fmt.Println("yyyy")
    //}
    //fmt.Println(a)

    //fmt.Println(a)
}

4 循环

//循环（只有for循环，没有while ，do while）
package main

func main() {
    //1 基本语法
    //for 初始化;条件判断;自增/自减{ 循环体内容  }    三部分都可以省略
    // 打印0--9
    //for i:=0;i<10 ;i++  {
    //    fmt.Println(i)
    //}

    //2 省略第一部分（初始化）,作用域范围不一样
    //i:=0
    //for ;i<10 ; i++ {
    //    fmt.Println(i)
    //}

    //3 省略第三部分
    //for i:=0;i<10 ;  {
    //    i++
    //    fmt.Println(i)
    //}

    //4 省略第一和第三部分
    //i := 0
    //for ; i < 10; {
    //    i++
    //    fmt.Println(i)
    //}
    //5 这不就是while循环吗？
    //for 条件 {}
    //i := 0
    //for i < 10 {
    //    i++
    //    fmt.Println(i)
    //}
    //for true{  // 死循环
    //    fmt.Println(1)
    //}

    //6 死循环（三部分都省略）
    //for {
    //    fmt.Println(1)
    //}

    //7 break和continue（不讲了）
    //for {
    //    fmt.Println(1)
    //    //break
    //    continue
    //}
}

5 switch语句

//switch
package main

func main() {
    // 1 switch 基本使用
    //a:=10
    //switch a {
    //case 1:
    //    fmt.Println("1")
    //case 2:
    //    fmt.Println(2)
    //case 9:
    //    fmt.Println(9)
    //case 10:
    //    fmt.Println("10")
    //}

    //2 default    都不满足情况下走它
    //a:=15
    //switch a {
    //case 1:
    //    fmt.Println("1")
    //case 2:
    //    fmt.Println(2)
    //case 9:
    //    fmt.Println(9)
    //case 10:
    //    fmt.Println("10")
    //default:
    //    fmt.Println("不知道")
    //}

    //3 多条件
    //a:=3
    //switch a {
    //case 1,2,3:
    //    fmt.Println("1")
    //case 4,5,6:
    //    fmt.Println(2)
    //case 7,9:
    //    fmt.Println(9)
    //case 10,16:
    //    fmt.Println("10")
    //default:
    //    fmt.Println("不知道")
    //}

    //4 无表达式
    //a:=3
    //switch  {
    //case a==1 || a==3:
    //    fmt.Println("1")
    //case a==4||a==5:
    //    fmt.Println(2)
    //default:
    //    fmt.Println("不知道")
    //}

    //5 fallthrough,无条件执行下一个case
    //a:=1
    //switch  {
    //case a==1 || a==3:
    //    fmt.Println("1")
    //    //fallthrough  //fallthrough 会无条件执行下一个case
    //case a==4||a==5:
    //    fmt.Println(2)
    //    fallthrough
    //default:
    //    fmt.Println("不知道")
    //}
}

命名返回值, 给类型重命名

package main
import "fmt"

func main() {
    //x:=test(1,2)
    //fmt.Println(x)
    var a MyFunc
    a(1,2)
}

//命名返回值
//func test(x,y int)(a int)  {
////    a:=x+y     //返回值已经定义，此处不能再次定义，会报错
//    a=x+y
//    return  // 可以省略a
//}

//给类型重命名
//func(x,y int) 类型命名为MyFunc
type MyFunc func(x,y int)

func test() MyFunc {
    return func(x,y int) {
        fmt.Println(x+y)
        fmt.Println("xxx")
    }
}

补充类型零值

// 补充：类型的默认值
    var a int
    var b float32
    var c string
    var d bool
    fmt.Println(a)     // 0 
    fmt.Println(b)     // 0
    fmt.Println(c)     //
    fmt.Println(d)     // false

总结：

//函数，包，if-else ，循环， switch
//python中的参数传递是值传递还是引用传递    引用传递(但有可变类型，不可变类型之分，后面指针会分析)
// go语言类型部分，只要不一样，就不是一个类型

//1 函数基本语法 func 函数名区分大小写（参数1，参数2 类型）(类型,类型 ){}
//2 同一个包下函数名不能重复
//3 可变长参数func 函数名（参数1 ... 类型）{}
//4 匿名函数：定义在函数内部，没有名字
//5 闭包：定义在函数内部，对外部作用域有引用

//6 函数部分补充两个东西（命名返回值）

//7 包
    -新建一个文件夹，在文件夹中建go文件，保证当前文件夹下所有的包名必须一致（建议就用文件夹名）
    -把包内的所有go文件当成一个（定义多个同名函数，不允许；使用当前包下的函数，不用导入直接使用）
    -go项目目录开发规范

//8 if-else
//9 循环 for 初始化;条件;自增/自减{}

// 10 switch   
switch 变量 {
  case 1,4:
      逻辑代码
  case 2,5: 
      逻辑代码
  default：
      逻辑代码
}