1.编译型(类似于谷歌翻译)  
     例如：
　　　　 go：谷歌出品必属精品
    　　c，c+，
    　　c#:微软（当初收钱作死，然后就凉了）
    　　java：sun公司，后来被甲骨文收购了（竟然开始收费了，市场份额开始下降，怕是下一个c#）


       一次翻译之后，就可以拿着翻译之后的结果可以去多次运行
       编译的过程需要用到编译器
                
                优点:执行效率高
                缺点:开发效率低
            
2.解释型(类似于同声传译) 
     例如：python，php，js

         一行一行的翻译(读一行翻译一行)
         解释的过程需要用到解释器
                
                优点:开发效率高
                缺点:执行效率低

1.闭:定义在函数内部，对外部函数作用域有引用（内部函数将自己函数名返回给外部函数，外部函数加括号就可以调用内部函数）
2.闭包函数典型应用：装饰器

//go语言中，函数是一等公民，像int、string等一样可以把函数赋值给一个变量
// 不是所有的函数都是一等公民，go和python是，java就不是，所以go和python实现闭包直接接收函数返回出来就好了，java实现闭包时很麻烦
package main
import "fmt"

func test(a int) (int,int) {
    return 1,2
}

func main() {
    var a func(a int)(int,int)  //上面有几个参数，返回值什么类型等必须一毛一样
    a=test  //函数赋值给变量
    a(1)  // 就是 test(1)
    fmt.Println(a(1))  // 1,2
}

动态类型语言：写程序时不用声明任何变量的数据类型，在运行期间才去做数据类型检查的，如python
静态类型语言：在写程序时要声明所有变量的数据类型，编译期间就要做数据类型进行检查，如java

强类型定义语言：一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了，如java，python
弱类型定义语言：数据类型可以被忽略的语言，一个变量可以赋不同数据类型的值，如VBScript

Python   是动态 强类型定义语言（类型安全的语言）
JAVA go  是静态 强类型定义语言（类型安全的语言）
VBScript 是动态  弱类型定义语言（类型不安全的语言）

-c开发：
        不支持跨平台，在windows上开发，编译好的只能在windows上用，到linux上需要再编译一下
    
    -java横空出世：凭借‘跨平台，一处编码到处运行’迅速走红
        -运行在java虚拟机之上，只需要开发出不同系统的虚拟机就好了，类似于python解释器但是又不同，所以一直争议java到底是什么语言
        -编译成字节码文件（中间态）：1.先编译成中间态，拿中间态去执行，所以可以跨平台，并且速度提高 但还是没有原生二进制快，
                              2.字节码是加密的，直接看不懂，但是有反解软件可以还原代码，
                              3.python写的代码，别人登陆服务器就可以看到源码，python崇尚开源，js也是
    -go：跨平台编译
        -在windows平台可以编译出linux下的可执行文件
        
    -java概念普及：
        -jvm:java虚拟机，这个是必须的都要装
        -jdk：开发人员需要装jdk，又能编译又能执行
        -jre：运行java程序，需要装，不能编译
        

        -javase：java基础（学完这个就可以分方向学习，如学习安卓就不用学习其他方向了）
        -javaee：javaweb方向
            -ssh框架：spring  structs  Hibernate
            -ssm框架：spring  springmvc  mybatis（支持sql）
            -spring全家桶 ：新的项目都用这个
                -springboot：一站式搞定，现在都用这个，类似于django，将orm等都封装了
                -springclode：微服务开发
        -javame：手机端开发，很早的手机中有这个，不用了现在
        -大数据：
    
         PS：

Spring进行业务流转Struts进行流程控制有bug改用springmvc了，Hibernate进行数据库操作的封装（大家都不用了，完全不用写sql，跨框架跨平台不行,改用mybatis）
 
django 对当次整个请求放到一个事务中怎么做：1）调模块 代码块来做局部事务，有目的 2）装饰器实现大事务，浪费资源

1.python函数不写return则返回none，go中什么都接收不到
2.python中_可以当作变量名接受返回值，go中就是不要这个值了，不接收
3.在go中没有位置参数和关键字参数，都是位置参数,定义函数时也没有默认参数一说

4.go中的模块、函数、变量等一旦定义，必须使用，不然报错
5.go中类型一旦定义不支持修改类型，如a:=5,可以改变a的值a:=10,但是不能改变类型a:=\'报错了\'


6.python中的包下载后会放到安装目录的文件夹，go必须放到GOPATH下，（代码也是必须放到GOPATH下src中，不然不能执行），
7.自定义的模块python中可以直接在项目中写，然后import导入即可，go则必须单独写，放在GOPATH中，然后导入
8.go的包管理混乱，很多第三方包无处安放就放在了github上，下载时从github上下载

9.go中有参函数和无参函数不是同类型，数组长度不同类型也不同，就这么严格。。

10.go中指明了参数和返回值类型，python中不强制，但是也可以实现，这在多人协同开发中很关键，防止瞎吉儿传

11.go轻量级，只需要很小几兆内存即可运行，比如java虚拟机竟然要几百兆内存，啥都不干先占内存，再扩容开辟线程
12.go编译速度很快，用c的话，编译超慢，可能要几分钟
13.python的一个列表可以放任何类型，支持步长，go同一数组以及切片只能放指定一种类型，且定长，以为切片是数组的地址引用所以肯定不能支持步长

传值还是传址要分具体情况：
不可变参数是值类型，用值传递，通过拷贝进行传递的，如：数字，字符串，元组
可变参数，引用传递，修改内存，如：列表，字典

        -go语言发展:Google
        -Go是静态强类型语言：强类型：类型固定
        -跨平台的编译型语言
        -2009年11月出的；python：1989年；  java ：1990
        -go为什么这么火？
            -docker容器化   devops 比较火
            -k8s go写的：容器编排
            -区块链 ：第一个开源的区块链项目是用go写的
            -性能高，特别适合服务端开发
            -部署容易

        -go开发环境：
            -下载安装对应版本，傻瓜安装即可
            -go version  查看go版本
            -环境变量会自动配置到环境变量，里面会生成项目保存路径GOPATH,以及path里面也会生成启动路径，可自定义
            -go env 查看环境，关注下面两个
                -GOPATH=C:\Users\oldboy\go    go的代码必须放在这个路径下，可以修改，见连接，修改后再次查看是否修改成功
                -GOROOT=c:\go                 go的安装路径
        -go IDE选择：
            -goland-2019.3.exe   任何ide都推荐JTBR家的，好用齐全，操作和pycharm基本一样
            -vs code   不推荐

//单行注释
/*
多行注释
多行注释
*/
package main //表示当前go文件属于main包，所有文件开头都这样写，上面不能出现代码
import "fmt" //导入fmt包，go中导入的包必须使用，定义的变量也必须引用，不然就报错

// 编译型语言需要有一个入口文件  main包下的main函数
func main() { //定义了一个main函数

    fmt.Println("hello world") //打印helloworld,go中都用双引号
    //a 是编辑器给你提示的，参数名是a，后面会解释

}

    执行方式：
        方式一：IDE中，绿三角编译并执行

        方式二：编译并执行 （和右键绿三角本质一样，不生成exe文件）
            -go run 文件名     

        方式三：先编译再执行
            -go build 文件名.go         编译生成‘ 文件名.exe’ 这个就可以拿到各个平台执行
            -文件名执行

//变量
package main //表示是main包的
import "fmt"

func main() {
    //定义变量三种方式
    　　// 完整版 定义了一个int类型的a ，把10赋值给他
    　　　　//var a int=10
    　　　　//fmt.Println(a)
   　　//省略类型 类型推导 会自动推导识别出类型
   　　　　 //var a =10
    　　　　//fmt.Println(a)
    　　//简略声明  不写var不写类型
    　　　　//a:=10
    　　　　//fmt.Println(a)

    //变量可以重新赋值，但不能重复定义
    　　//var a int=10
   　　 //a=1000
   　　 //var a =10  报错
    　　////a:=10  报错
    　　//fmt.Println(a)

    //强类型语言,类型是固定的，一旦定义不能修改
    　　//var a =10
   　　 //a=100
   　　 //b:="lqz"
   　　 //a=b  报错
    　　//fmt.Println(a)
    　　//fmt.Println(b)

    //定义不赋初值  :int 类型默认值是0   string 类型默认值是空字符串  bool默认值为false
    　　//var a int
   　　//var b string
    　　//fmt.Println(a,b)

    //同时定义多个变量
   　　 //var a,b int
    　　//var a,b int=10,20

    　　//var a,b=10,20
    　　//var a,b=10,"lqz"

   　　 //a,b:=10,20
    　　//a,b:=10,"lqz"
 
    //fmt.Println(a)
    //fmt.Println(b)
    var (
        name   = "naveen"
        age    = 29
        height int
    )
    fmt.Println(name)
    fmt.Println(age)
    fmt.Println(height)

}

//变量类型
package main

func main() {
    //bool类型 0值是false
            //var b bool =true
            //var b =true
            //b:=true
            //var b bool
            //fmt.Println(b

    //数字类型
            /*
            int类型：表示整数,int8   int16  int32  int64  (直接用int就行了，别人用什么要认识)
            uint类型：表示正整数,无符号类型 uint8 uint16...
            　　32位无符号整数 ，其表示范围是2的32次方，最大整数为 2的32次方-1
            　　有符号数则要去除一个符号位，正数最大为2的31次方-1 , 负数最小为负  2的31次方
            　　在32位机器上int 就是int32 ，在64位机器上int就是int64
            float类型：表示小数，只有float32和float64
            
　　　　　　　complex64类型：复数，不用考虑
            byte: uint8的别名
            rune:int32的别名

             */
            //var a int=-10
            //fmt.Println(a)

            //var a int8 =100000
            //fmt.Println(a) 超出范围，报错

            //var a uint8=100
            //fmt.Println(a)

            //var a float32=2.33
            //fmt.Println(a)

    //字符串(必须用双引号)
            //b:=\'a\'
            //fmt.Printf("%T",b)  单引号示范（不要用），会打印出类型，发现变成整形了

            //反引号带换行，等同于python中的三引号
            　　//    var c string=`阿斯蒂芬a
           　　 //手动阀afd阿斯蒂芬
            　　//asfd阿萨德f`  反引号示范，空格也占位，输入什么输出什么

　　　　　　　// 双引号不带换行，输出结果为一整行，不要考虑单引号，就当没有
            　　//var a string="阿发" +
            　　//    "按时发大水f" +
            　　//    "agessdfas" +
            　　//    "按时发大水发d"  //双引号示范，输出一整行

            //fmt.Println(a)

}

//常量：恒定不变的量 用于ip 端口什么的
package main

import "fmt"

func main() {

    //定义了一个常量a
    //const a int=10
    const a =10
    //a=100  报错 ，不能改
    fmt.Println(a)
    const b ="192.168.1.1"

}

//函数
package main

//func main() {

//无参数，无返回值
        //test()

//有两个int类型的参数
    //test(1,2)

    //var a int=test(1,2)  // 接收并打印，这种参数必须为int，下方函数中改变后报错
    //var a =test(1,2)
    //a,b:=test(1,2)  //推荐这一种写法

    //var a string =test(1,2)
    //fmt.Println(a)


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

//}

//函数定义，语法
//func关键字 函数名(参数1 类型，参数2 类型) (返回值类型){}

//无参数，无返回值
        //func test()  {
        //    fmt.Println("xxx")
        //}
                //test()   // main中传值

//有两个int类型的参数
        //func test(a int,b int)  {
        //    fmt.Println(a+b)
            //}

        //func test(a ,b int)  {
        //    fmt.Println(a+b)
        //}

        //func test(a ,b int,c string)  {
        //    fmt.Println(a+b，c)
        //}

                //test(1,2)  // main中传值

//有一个数字类型返回值,一定要指定返回值类型
        //func test(a,b int) int {
        //    return a+b
        //}
        //func test(a,b int) string {
        //    return "lqz"
        //}

//返回多个值
        //func test(a,b int) (int,string)  {
        //    return a+b,"成功"
        //}

//命名返回值
        //func test(a,b int) (c int, d string)  {
        //    c=10
        //    d="成功"
        //    return  //上面指定返回值类型时已经指明返回值了
        //}

//在go中没有位置参数和关键字参数，都是位置参数,也没有默认参数
        //func test(a,b int) int {
        //    return a+b
        //}

//不定长参数
        //空接口类型，可以接受传入的任何类型，也可以放具体类型比如int，则只能传入int
        //func test(a ...interface{})  {
        //    fmt.Println(a)
        //
        //}