go语言

go语言：

    补充：
        1，什么是闭包函数？
            1,定义在函数内部，对外部作用域有引用
        2，编译型语言：不依赖语言环境运行，速度快一些，先编译再执行，编程复杂 c java go
        3，解释型语言：依赖解释器执行，执行速度慢一些，开发速度快  python js
        4，计算机最小单位比特位，8bit = 1bytes
        5，go语言09年11月出生，由Google开发的开源语言，是夸平台的编译型语言
                是静态的强类型语言：强类型：数据类型固定

        6，java补充：
                c开发：在windows上开发，编译好只能在windows上运行
                java横空出世：跨平台，一处编码到处运行
                java编译成字节码文件:中间态    需要反解，go不能反解

            go：跨平台编译
                在windows平台可以编译出linux下的可执行文件

            java概念：
                jdk：java集成开发环境，开发人员需要装jdk
                jre： 运行java程序，需要装 类似于解释器
                jvm：java虚拟机

                javase：java基础，变量，对象，函数，安卓开发，
                javaee：javaweb方向
                    ssh框架：spring struts Hibernate
                    ssm框架：spring springmvc mybatis
                    spring全家桶：
                        springboot
                        springclode
                javame：手机端开发，很老，已过时，例如山寨机的java

//go语言 注释：单行注释//
/*
    go语言 注释：单行注释// ,
                多行注释
*/
package main //表示当前go文件属于main包，此行为第一行
import "fmt"
/*
1,    所有的编译型语言需要一个入口文件，main包下的main函数
2,    所有main包下的main函数都要写在main函数内部，或在main函数内部调用
3,    正常情况下必须再vscode上先编译再执行，在golang这个软件上只是提供了这种右击run运行的测试方法
    按照正常的程序：先编译在执行，前提是必须在当前目录下执行编译命令
        命令：go build 文件名   例如：go build s1.go  ，生成一个编译的s1.exe文件
            执行此命令后，会在当前目录下生成一个编译后的可执行文件（默认情况是生成该平台下的可执行文件），这个是windows系统，就生成的是windows可执行的文件
        执行命令：生成的该文件名直接执行 ,例如s1.exe
    编译并执行：
            go run 文件名
4, 导包：go中叫包，import "fmt" ，包导入必须使用，不然报错
5，定义函数：关键字func  函数main  {函数体内容}，更缩进没关系
6，变量的定义：
*/


func main() {
    fmt.Println("hello world")   //打印hello world   Println表示打印后换行
    //a是编辑器给你提示的，参数名是a，提示就是可以传多个，
    //定义变量
    //方式一：全名称。在go语言中，变量定义了必须使用，不然报错
    //var a int=10
    //fmt.Println(a)
    // 方式二：类型推导，一个变量不能重复定义，只能定义一次
    //var a =10
    //fmt.Println(a)
    //第三种，简洁式
    //a := 10    //:=必须连在一起
    //fmt.Println(a)
    // 变量不能重复定义
    //var a int=10
    //var a =20   //报错
    //a:=2      //报错
    //a = 2
    //fmt.Println(a)  //a为2

    //强类型语言，即类型一旦给定，就不能改变,
    //var a= 10
    //a="lqzdsb"       //报错
    //fmt.Println(a)

    //定义不赋初值  int不赋初值时为0  string类型默认值是空字符串，变量定义不赋初值，必须指定类型
    //var a int
    //fmt.Println(a)
    //var a string
    //fmt.Println(a)

    //同时定义多个变量
    //var a,b = 10,20
    //var a,b = 10,20
    //a,b:=10,29
    //fmt.Println(a)
    //fmt.Println(b)

    //var a,b = 10,"lqz"
    //fmt.Println(a)
    //fmt.Println(b)

    var (
        name1 = "hdfhjgf"
        age = 10
        height int
        )
    fmt.Println(name1)
    fmt.Println(age)
    fmt.Println(height)
}

package main

import "fmt"

func main() {
    // bool类型 0值是false
    //var b bool = true
    //b:=true
    var b bool            //
    fmt.Println(b)
    //int类型：表示整数，int8   int16  int32  int64
    // 计算机最小计量单位： bit位
    // uint类型：表示正整数uint8 uint16
    //float类型：表示小数只有float32 和 float64
    //complex64类型：复数
    //byte:uint8 的别名
    //rune:int32 的别名

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

    //var a float32 =2.33
    //fmt.Println(a)
    //字符串(必须用双引号),反引号是python中的三引号

    var a string=`
jdfslhg;fd
kgf;hlfg''
    jfdshgdf
jkfdjhfd
`
    fmt.Println(a)

}

go中的常量

package main
import "fmt"
//常量：恒定不变的量const
func main() {
    var a int = 10
    // 定义一个常量a
    const b int = 20
    const c = 30
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}

函数
package main

import (
    "fmt"
)

func main() {
    fmt.Println()
    //test()
    //a:=test(1,2)
    //fmt.Println(a)
    //var a  string
    //a= test(1,2)
    //fmt.Println(a)

    //在go中，有几个返回值就必须用几个值接受
    a,b:=test(3,1)
    fmt.Println(a)
    fmt.Println(b)


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

//无参数，无返回值
//func test() {
//    fmt.Println("xxx")
//}
//func test(a int,b int ,c string) {
//    fmt.Println(a+b)
//}
// 有一个数字类型返回值,一定要指定返回值类型
//func test(a,b int) string {
//    fmt.Println()
//    return "sads"
//}

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