GO(函数、包、if-else语句、swish语句)

函数

1、定义位置没关系,不像python必须在调用之上定义,因为go是编译型语言

 

/*
函数
*/

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")

*/

闭包函数

 

 

//1 在同一个包下(文件夹下),包名必须一致
//2 以后,包名就是文件夹的名字
//3 同一个包下,同名函数只能有一个(init除外)
//4 一个包(当成一个文件),同一包下的函数,直接调用即可
//5 导包的位置,从src路径开始
//6 包只要在src路径下就可以导入
//7 大写表示导出,在外部包可以使用,小写只能再包内部适应
//8 使用第三方包:go get github.com/astaxie/beego  (放到gopath的src路径下)
    -python:pip3 install requests
    package main
    import "github.com/astaxie/beego"

    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 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
    -一旦开启了go mod模式,代码不需要放在src路径下(任意位置都可以)
    -在项目路径下要有 go.mod 文件(文件里记录了,go版本,项目依赖的包,包的版本)
    -写代码,建自己的包即可
    -一般情况下,项目有一个main.go  内部是main包,main函数,整个程序的入口

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

    //fmt.Println(a)
}

循环

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

swish语句

 

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

回顾

# 1 python中的变量在内存中如何存储的?
    --一切皆对象:都是一个地址,引用
  --变量
  --is 和 ==:如果变量a和b指向同一个地址a is b 就是true   a和b的值相同,a==b是true
  --小整数池,不开辟新的内存空间
  --python中一个int类型,占得空间比较大
  
# 2 go语言介绍
# 3 环境搭建(ide+开发包)
# 4 helloworld :每个go文件第一行必须加package maim/其他,main包下的main函数是整个程序的入口,导包
    -为什么要配置goroot和gopath?
      -导入包:内置包,第三方包,如果不配goroot和gopath,导包时,内置包找不到,第三方包也找不到,就报错了
# 5 变量定义:三种方式,其他都是变形:
        -var a int =10
      -var a =10
        -a :=10
    -变量不能重复定义
    -变量要先定义后使用
    -变量定义了必须使用
    -变量类型是固定(在定义的那一刻)
# 6 常量:const a int =10   const a =10
# 7变量类型:
    -数字类型:
      -int,int8。。。。。。
    -uint8。。。。。
    -float32 float64
    -复数
  -字符串:string
      "",``
  -布尔 bool

1

 

posted @ 2020-04-21 13:19  小猪皮蛋  阅读(32)  评论(0编辑  收藏  举报