go语言 二

GO语言

　　1，函数高级，类型命名，别名

　　2，if-else的使用

　　3，包的使用

　　4，for循环

　　5，switch的使用

　　6，数组的基础

　　7，数组的使用

补充知识点：
    1，go version 查看go的版本号
    2，go    是否安装
    3，go env 查看go的环境
    4，goroot  go的安装路径，如果没有配置，内置包就使用不了  GOROOT=D:DownloadGOyuyang
    5，GOPATH  go的代码存放的路径       GOPATH=D:Gosrc
                go中所有的代码都必须放在gopath路径下的src路径下
                下载的第三方包是放在gopath路径下，只能存在一个版本，也无虚拟环境
    6，导包的时候，查找路径：先去goroot中查找，然后再去gopath中寻找，在找不到，就报错，
                    所以自己写的包就放在gopath中
    7，go语言编译命令：go build 文件名   先编译再执行，编译后会形成一个与当前系统对应的编译文件，然后执行该文件，s1.exe
                    go run 文件名     编译并执行，不会产生一个编译文件， 例如 go run s1.go

    8，回顾：
        1，变量：
            定义的三种方式：
                var 变量名 变量类型 = 值    全写
                var 变量名 = 值           类型推导
                变量名 := 值              简写
        2，变量类型 ：int类型默认值为0
                    string类型默认值为空字符串""
                    bool类型默认值为false  （小写）
                bool类型：false，true
                数字类型：int 整数
                        uint 正整数
                        float32，float64  小数   （32或者64表示范围）
                        复数
                        byte：uint8的别名，表示一个字节
                        rune：int32的别名，表示四个字节，一个字符，可以表示任意的一个中文，(韩文，日文)等字符
                字符类型：双引号（单行），反引号（多行）
        3，常量：const 关键字，定义以后不能再进行改变
        4，函数：
                func 关键字 函数名(参数1 参数类型，参数2 参数类型)(返回值类型1，返回值类型2){}
                type 标明类型
                可变长 ：func test(a...int)                (int 可以是类型，可以是函数，也可以接口...)

函数高级：
    1,内层函数：定义在函数内部的函数
    2，闭包函数：定义在函数内部，对外部作用有引用(即直接或者间接引用了外部作用域的变量）
    3，go中函数内部定义的函数是不能有名的，需要定义匿名函数：没有名字
    4,go中的函数定义了必须使用，

闭包函数：

func test(a int) (func()){
    var c = 100
    b:=func(){
        fmt.Println(a)
        fmt.Println("我是内层函数")
        fmt.Println(c)
    }   // 函数定义了要么赋值给一个变量，要么加括号执行
    return b
}
func main() {
    a :=test(3)
    a()

}

类似于装饰器

func test1(a func()) func(){    //
    b :=func(){
        fmt.Println("我先执行")
        a()
        fmt.Println("我执行完了")
    }
    return b
}
func test2() {
    fmt.Println("xxx")
}
func main() {
    a :=test2
    a = test(a)
    a()
}

//重命名,给类型命别名
//type MyInt int
//var a int = 20   //重命名了应用了 才起作用
//var a MyInt =10   //应用重命名

type MyFunc func(a int,b int)func()

//func test()func(a int,b int)func() {
func test()MyFunc {
    c:= func(a int,b int)func(){
        return func() {
            fmt.Println("我是")
        }
    }
    return c
}



func main() {
    //a :=test2
    //a = test1(a)
    //a()
    a:=test()
    fmt.Println(a)
}

if-else 条件判断

func main() {
    a:=90
    // if 条件{满足条件后执行的结果}
    if a==90{   //大括号和条件之间不能换行
        fmt.Println("等于90后满足的条件")
    }else if a>90{
        fmt.Println("大于90执行的结果")
    }else {
        fmt.Println("小于90的结果")
    }
    fmt.Println("wo")
}

注意：


func main() {
    //在条件中可以定义变量，但是它的作用范围是在if判断内部使用
    if a :=90;a>90{
        fmt.Println("大于")
    }else if a==90{   //在这里也属于if条件判断的内部
        fmt.Println(a)
    }
}

包

/*
包
在gopath的src路径下新建一个文件夹，通常情况下，包名就是文件夹名。在同一文件夹下包名必须一致
在同一个文件夹下，所有的包名必须一致，一般默认为文件夹名字
在该文件夹下，你定义的函数或者创建的.go文件都属于同一个包，在该包内函数名不可以重复
即s1.go,s2.go,s.go都属于同一个包，在这些文件中定义的函数，变量不能有重复定义
也就是在一个包下定义了两个不同的函数，只是把这两个函数放在了不同的文件中
在包内定义的函数如果是小写字母开头，只能在包内使用
在外部包相使用，必须首字母大写

*/
func test1() {
    test(a:1,b:2)
    fmt.Println("xxx")
}

例如：

　　import “mypackage”

　　mypackage

for循环

//for循环，是go语言中的唯一循环

func main() {
　　//语法结构
    for i:=0;i<10;i++{   //定义变量（变量的初始化）;条件;自增；for后面的三部分都可以省略，但是不能sl封号
        fmt.Println(i)  //结果为0到9
    }

    //第一部分省略
    i :=0      作用域范围i可以定义在外部，也可以定义在内部，或者if内部，if内部只能在if内部内使用
    for ;i<10;i++{
        fmt.Println(i)
    }

    //省略第三部分
    i :=0
    for ;i<10;{
        i++
        fmt.Println(i)  //结果为1到10
    }

    //省略第二部分
    for ;;{
        fmt.Println("死循环") //没有条件，都为真，死循环
    }
    for {  //相当于while True
        fmt.Println("死循环的简写方式")
    }
    //只写条件 for 条件{}  等同于while循环
    i:=0
    for i<10{
        i++
        fmt.Println(i)
    }
　　
　　//break和contiue
　　

    for i :=0; i<11;{
      i++
      if i==5{
         fmt.Println("没有5")
         continue
      }else if i==9 {
         fmt.Println("9结束循环")
         break
      }
      fmt.Println(i)
   }
}

}

switch用法

//switch 语句
func main() {
    //基本用法
    a := 10
    switch a {
    case 1:
        {
            fmt.Println("1")
        }
    case 2:
        {
            fmt.Println("2")
        }
    case 3:{
        fmt.Println("3")
    }
    case 10:{
        fmt.Println("我是10")
    }
    }
}


第二中多值用法
func main() {
    //多值匹配用法
    a := 10
    switch a {
    case 1,2,4:
        {
            fmt.Println("1.455566")
        }
    case 5,6,7:
        {
            fmt.Println("2，333")
        }
    case 8,9:{
        fmt.Println("3")
    }
    case 10:{
        fmt.Println("我是buzd")
    }
    }
}

三种：

func main() {
   //条件用法
   a := 10
   switch {
   case a>10:
      {
         fmt.Println("1.455566")
      }
   case a ==10:
      {
         fmt.Println("2，333")
      }
   default:
      fmt.Println("小于10")
   }
}
还有一种Fallthrough
　　//穿透，表示无条件执行下一个case的内容

数组

//go语言无集合
//数组：同一类元素的集合，即要是字符串就都为字符串，要是int就都为int，数据类型必须一致
//数组的存储结构是连续存储的内存块，长度必须一致，列表的存储是存储的地址
//数组插入值是重新开辟个内存空间复制一份原来的进行增值，把原来的丢弃，
//列表插入值是把新的值的地址与原来的进行关联，
//go中的数组在定义阶段长度和类型就已经固定了，无法更改

func main() {
        
    //var a [5] int   //定义了一个长度为5的int类型数组
    //fmt.Println(a)  //[0 0 0 0 0]
    //a[1]=100      //把第二个位置放上100
    //fmt.Println(a)   //[0 100 0 0 0]
    //定义并赋初值
    //var a [6] int =[6]int{1,2,3,4,5,6} //不能超出长度
    //fmt.Println(a)

    //var a = [6]int{1,2,3}  //也可以这样定义
    //fmt.Println(a)  //[1 2 3 0 0 0]

    //a:=[6]int{1,2,3}   //也可以这样定义
    //fmt.Println(a)

//    第99个位置设置为99,没有负索引
    a:=[100]int{1,2,98:99,87:88}
    fmt.Println(a)
}    

//数组类型是值传递
//数组的大小也是类型的一部分，即便是同一个类型也不支持比较，支持直接赋值
//数组的长度用len

python是值传递还是引用传递

　　1，要分数据类型：不可变类型就是值传递，值传递就是把值copy一份传递过去，

　　　　　　　　　　　可变类型就是引用传递，（地址）拷贝的是列表的地址，你进行更改时，地址就发生改变了

　　所用的函数传参都是copy传递，如果是a=10，就是把这个值copy一份传递过去了，如果是列表，就是copy列表传多去

-Supervisord:进程管理工具，用python写的，