相关:
    1G = 1024M   1M =1024KB   1KB = 1024B   1B = 8bit
    
    -c开发：在windows上开发，编译好的只能在windows上用
    -java开发：跨平台，一处编码到处运行
        -运行在java虚拟机之上
        -编译成字节码文件：中间态
    -go：跨平台编译
        -在windows平台可以编译出linux下的可执行文件
        
    -java概念普及：
        -jdk：开发人员需要装jdk
        -jre：运行java程序，需要装
        -jvm:java虚拟机
        -javase：java基础，安卓方向
        -javaee：javaweb方向
            -ssh框架：spring  structs  Hibernate
            -ssm框架：spring  springmvc  mybatis
            -spring全家桶
                -springboot：一站式搞定
                -springclode：微服务开发
        -javame：手机端开发
        -大数据：

    -编译语言:-不依赖语言环境运行
        c,c+,c#,java,go
    -解释型语言:-需要解释器，缺点是执行速度慢
        python,js
    
-Go是静态强类型语言：强类型：类型固定
    -跨平台的编译型语言:一处编码到处运行
      eg:在windows平台可以编译出linux下的可执行文件
    
-go为什么这么火？
    -docker容器化   devops 比较火
    -k8s go写的：容器编排
    -区块链 ：第一个开源的区块链项目是用go写的
    -性能高，特别适合服务端开发
    -部署容易

-环境搭建
    -go开发环境：go1.13.5.windows-amd64
        -go version  查看go版本
        -环境变量自动配置
        -go env
            -GOPATH=C:\Users\oldboy\go    go的代码必须放在这个路径下
            -GOROOT=c:\go                 go的安装路径
    -go ide：
        -goland-2019.3.exe
        -vs code
        
-第一个helloworld   
    -先编译再执行
        -go build 文件名         编译
        -文件名执行
    -编译并执行
        -go run 文件名    

-变量 用来存储特定类型的值        
    方式一：全名称  
        var关键字 变量名  变量类型 = 值
        var a int=10   //定义了一个int类型的a ，把10赋值给他
    
    方式二:类型推导
        var a =10
        fmt.Println(a)    
        
    方式三:简略声明
        a:=10
        fmt.Println(a)
                        
    注: 1.go语言中变量定义了必须使用，否则报错
        2.变量不能重复定义
        3.强类型语言,类型是固定的
        4.定义不赋初值  :int 类型默认值是0  string 类型默认值是空字符串
        5.可以同时定义多个变量
            -var a,b int=10,20
            -var a,b=10,"666"
            -a,b:=10,"lqz"
            
            
-变量类型
    -bool类型:表示一个布尔值，值为 true 或者 false    
        a := true
        b := false
        fmt.Println("a:", a, "b:", b)
        a: true b: false  
        
    -数字类型:
         -有符号
            int8   8 位   -128～127(2**7-1)
            int16  16 位  -32768～32767(2**15-1)
            int32  32 位  .....
            int64  64 位  
            int  在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
         -无符号
            uint8   8 位   2**8
            uint16  16 位  2**16
            uint32  32 位  2**32
            uint64  64 位  2**64
            uint  在 32 位系统下是 32 位，而在 64 位系统下是 64 位。
            
        -浮点型
            float32：32 位浮点数
            float64：64 位浮点数
        -complex64类型：复数
        -byte: uint8的别名
        -rune:int32的别名
                
    -string 类型:是字节的集合
        var a string="lqz"
        
        var c string=`阿斯蒂芬a
            手动阀afd阿斯蒂芬
            安抚
            asfd阿萨德f`
            
        var a string="阿发" +
            "按时发大水f" +
            "agessdfas" +
            "按时发大水发d"
        注:字符串(必须用双引号),反引号是python中的三引号
        
    -常量:恒定不变的量  用const定义
        const b ="192.168.1.1"
        fmt.Println(b)
        
        
    -函数
        语法:
            func关键字 函数名(参数1 类型，参数2 类型) (返回值类型){}
        
        1.无参数，无返回值
            func test()  {
                fmt.Println("xxx")

            }
            
        2.有多个参数
            func test(a ,b int,c string)  {
                fmt.Println(a+b)
            }

        3.返回多个值
            func test(a,b int) (int,string)  {
                return a+b,"成功"
            }
            
        4.有一个返回值,一定要指定返回值类型
            func test(a,b int) int {
                return a+b
            }
            
            func test(a,b int) string {
                return "lqz"
            }
            
        5.命名返回值
            func test(a,b int) (c int, d string)  {
                c=10
                d="成功"
                return
            }
            
        6.不定长参数
            func test(a ...interface{})  {
                fmt.Println(a)

            }
            
            
        7.闭包函数
            定义:在函数内部，对外部作用域有引用
            函数是一等公民:可以把函数赋值给一个变量，函数就是一等公民


            注:在go中没有关键字参数与默认参数，都是位置参数
            
            
        package main

        import "fmt"

        func main() {
            test()
            test(1,2)
            var a int=test(1,2)
            var a =test(1,2)
            var a string
            a =test(1,2)
            fmt.Println(a)
            var a int
            var b string
            a,b:=test(1,2)
            不要第二个返回值
            a,_:=test(1,2)
            fmt.Println(a)
            fmt.Printf(_)
            a:=test()
            fmt.Printf(a)
            test(a=10,b=21)
            fmt.Println(1,"lqz")
            test(1,"lqz")

        }