zoukankan      html  css  js  c++  java
  • 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:Usersldcgosrcgithub.comastaxieeego
    然后还是报错,显示没有github.comshienaansicolor文件   缺少ansicolor依赖包
    于是从   github.com/shiena/ansicolor  下载包,解压到    C:Usersldcgosrcgithub.comshienaansicolor
    终于可以成功启动。。。
    但是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:
          逻辑代码
    }
  • 相关阅读:
    三大主流负载均衡软件对比(LVS+Nginx+HAproxy)
    nginx 提示the "ssl" directive is deprecated, use the "listen ... ssl" directive instead
    centos安装nginx并配置SSL证书
    hadoop创建目录文件失败
    The server time zone value 'EDT' is unrecognized or represents more than one time zone.
    脚本启动SpringBoot(jar)
    centos做免密登录
    数据库远程连接配置
    Bash 快捷键
    TCP三次握手四次断开
  • 原文地址:https://www.cnblogs.com/ludingchao/p/12757268.html
Copyright © 2011-2022 走看看