函数、包、

一、函数

基本语法：func关键字 函数名(参数1  类型，参数2   类型)  （返回值类型，返回值类型，）{函数体的内容}

package main

import "fmt"

func main() {

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

    //1 定义一个无参数，无返回值的普通函数
    //func test()  {
    // fmt.Println("我是test")
    //}


    //2 函数调用
    //a:=10
    //test(a)
    //test(10)
    
   //2 定义一个 带参数，无返回值 go中全是位置参数， 没有所谓的关键字参数，默认参数
   //func test(b int)  {
   //    fmt.Println(b)
   //}


    //3 函数调用
    //test(10,11)
    //test(b=10,a=11) //没有关键字参数，这样写是错的
    
    //3 定义一个带多个参数，无返回值(没有默认参数和关键字参数)
    //func test(a int,b int)  {
   //    fmt.Println(a+b)
    //}

    //注意：//如果两个参数都是同一个类型，就可以简略写
        //func test(a ,b int,c string)  {
         // }
    
    
    //4 函数调用
    //var a int
    //a=test(10,11)
    //或者
    //a:=test(100,11)
    //fmt.Println(a)
    
    //4 定义一个带多个参数，有一个返回值(要指明返回参数类型是什么)
    //func test(a, b int) int { 返回值类型是int类型
    //    c := a + b
    //    return c
    //}


    //5 函数调用(有几个返回值，必须用几个值来接收)
    //a,b:=test(10,11)  //有几个返回值，必须用几个值来接收）
    //fmt.Println(a,b)
    //a,_:=test(10,11)  //第二个参数不接收了（跟python中_不一样，python中_就是一个变量）
    //fmt.Println(a)
    //fmt.Println(_)  //打印不出来，但是在python中可以打印出来
    
    //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 函数调用（可变长参数）
    //test(1,2,3,4,4,56,7,7,8,9,9,0)
    
   //6 定义一个 带可变长参数的函数
   //func test(a ...int) { //可以传任意长度的int类型
   //    fmt.Println(a[1])   //    //a是切片
   //}


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

    //func (){    // 这里的（）前没有函数名  所以这叫匿名函数
    //    fmt.Println("我是匿名函数")
    //}()           //这里的（）表示调用匿名函数
    
    //注意：//匿名函数定义在函数内部，有两种处理方案
        //1 让它执行
        //2 当参数返回
        //否则报错
    

    //8 调用 函数是一等公民
    //调用方式一 
    //test()()  没问题

    // 调用方式二
    //var a func()
    //a=test()
    //a()

    //调用方式三（常用）
    //a:=test()
    //a()
    
    //8 定义一个 函数是一等公民（头等函数）,函数也是一个类型
    //在一门语言中，如果函数可以赋值个变量，那函数就叫一等公民（叫头等函数）
    //func test() func() {//这里的func()表示 返回值是函数类型
    //    var a func()=func (){//这里的a后面是func() 表示变量a的类型。
    //        fmt.Println("我是内层函数")
    //    }
    //    return a
    //}

    //或者
    //func test() func() {
    //    return func (){
    //        fmt.Println("我是内层函数")
    //    }
    //}


    // 9 闭包函数调用
    //a:=test(10)   
    //fmt.Println(a) // 结果：是变量a的地址
    //a()  // 结果：10
    
    //9 定义一个闭包函数（1 定义再函数内部 2 对外部作用域有引用）
    // 闭包函数：多了一种函数传参的方式

     //func test(b int) func() {
     //    a:= func() {       //这才是闭包，定义在函数内部的函数
     //        fmt.Println(b)//这才是闭包，定义在函数内部的函数
     //    }//这才是闭包，定义在函数内部的函数
     //    return a
     //}
    


    //10 闭包函数高级的调用

      test(99)(88,77)
    // 或者
    //a:=test(99)
    //a(88,77)
    //}
    //10 定义一个 闭包函数高级

    //func test(b int) func() { //func()是返回类型
    //   a := func(x,y int) {  //这行代码 表示 变量a的类型是 func(x,y int)
    //   fmt.Println(b+x+y)  //a 是闭包  引用了外部函数test的参数 b 。x,y 是闭包a 的参数
   //  }
   // return a
   // }

   //上面几行代码报错  是因为 返回值a 的类型 不匹配
   //修改如下：

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
}

 

// 11 函数的更高级
//func test(b func(z int)) (func(x,y int),func()) { // func(z int) 表示test的参数可以是函数类型
//    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")

*/

 二、包

1、建一个文件夹（包）

 

 

 

 

 2、在同一个包下（文件夹下）的所有文件中，包名必须一致，一般是文件夹名（包名）。要改包名，需要包下的所有文件中的包名统一改成一样的包名。

    注：不要改包名。

 

 

 

 

 

3、包名就是文件夹的名字，同一个包下，同名函数只能有一个（init除外）

 

 

 注意：

 

 

 

4 一个 包（文件夹），同一包（文件夹）下的函数，直接调用即可

 

 

 注意：导包的位置，从src路径开始。包只要在src路径下就可以导入。

 

 

 

5、大写表示导出，在外部的包下 可以使用，小写只能在包 内部 使用

 

 

6、使用第三方包：

在终端下

命令：go get github.com/astaxie/beego （放到gopath的src路径下）

 

 

 

 

 

package main
import "github.com/astaxie/beego"  //是从src开始导的

func main() {
beego.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

//4 解析  python中__init__.py
//  在代码中导入模块 （ import app）：   实质上触发app下的 __init__.py 的执行 。

   一般情况下，在__init__.py中 写from app import views  ：将要使用到的函数导过来。以后再用 views.函数
    (在__init__.py中也可以执行其他代码，对应到go中就是init函数)

//5 go mode模式 出来之前，可以设置多个gopath，开发某个项目，切到不同的gopath，类似于虚拟环境

//6 go env
-GO111MODULE="off"                                                          表示go mod模式是关闭的，用gopath
                                                                                               一旦开启了go mod模式，代码不需要放在src路径下（任意位置都可以）
-在项目路径下要有 go.mod 文件（文件里记录了，go版本，项目依赖的包，包的版本）
-写代码，建自己的包即可
-一般情况下，项目有一个main.go 内部是main包，main函数，整个程序的入口

四、流程控制

1、判断语句

//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{
    //    fmt.Println("xxx")
    //}else {
    //    fmt.Println("yyyy")
    //}
    //fmt.Println(a)

    //fmt.Println(a)
}

 

2、循环语句

//循环（只有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
    //}
}

3、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("不知道")
    //}
}