一、变量命名规范 
1 变量命名，推荐用驼峰  AgeOfXX==  （变量，函数，大写字母开头表示导出，外部包可以使用）
2 go文件命名，推荐用下滑线
3 个名字必须以一个字母（Unicode字母）或下划线开头，后面可以跟任意数量的字母、数字或下划线
4 不要用关键字和保留关键字作为变量名
5 大写字母和小写字母是不同的：Name和name是两个不同的变量

　　注意：文件名建议用下划线，变量建议用驼峰，是因为在go中有公有私有之分

　　　　　　go语言是编译型语言编译最快的

6 Go语言中关键字有25个
    break      default       func     interface   select
    case       defer         go       map         struct
    chan       else          goto     package     switch
    const      fallthrough   if       range       type
    continue   for           import   return      var

7 有37个保留字，主要对应内建的常量、类型和函数
    内建常量: true false iota nil
    内建类型:  int int8 int16 int32 int64
                 uint uint8 uint16 uint32 uint64 uintptr
               float32 float64 complex128 complex64
               bool byte rune string error
    内建函数: make len cap new append copy close delete
              complex real imag
              panic recover
二、定义变量 
# 三种定义方式
    -var a int =10
    -var a =10
    -a:=10
# 定义多个变量
    -var a,b int=10,11
    -var a,b =10,11
    -a,b:=10,11
# 了解其它方式
    var (
        name="lili"
        age int
    )
# 注意点：
    1 变量要先定义再使用
    2 完整定义可以先定义再赋初值，后面两种方式，定义阶段必须赋初值
    3 变量的类型一旦确定，后期不能修改(跟py最大的差距)
三、数据类型 
# 数字类型
1 int类型（长度不一样）
    - int8（正负，2的7次方-1），int16（正负，2的15次方-1），int32（正负，2的31次方-1），int64
    -int：在32位机器上是int32，在64位机器上是int64
2 uint类型（无符号）
    -uint8（2的8次方，256），uint16，uint32，uint64
    -uint：在32位机器上是uint32，在64位机器上是uint64
3 float类型(表示精度不一样)
    -float32，float64
    
4 complex 复数类型（不知道）：实部和虚部，并返回一个复数类型
    -complex64, complex128
    
5 byte
    -是 uint8 的别名
6 rune（go语言中的编码方式使用unicode编码）
    -是 int32的别名

# 字符串类型
1 string
# 布尔类型
1 bool


# 注意：
强类型语言：不同类型之间不允许直接运算
显示类型转换：手动转换
四、常量 
# 恒定不变的量，定义并赋值后，再也不能改了
const name string="lili"
五、函数基础 
package main

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


func main(){
    //var a int=add(7,8)
    //a:=add(7,8)

    //有多个返回值，必须用多个值来接收
    //a,b:=add(7,8)
    //有多个返回值，只要第一个
    //a,_:=add(7,8)
    //var a,b=add(7,8)
    //var a int
    //var b string
    //a,b=add(7,8)
    //fmt.Println(a)
    //fmt.Println(b)



}

//1 最简单的函数
//func add(a int,b int)  {
//    fmt.Println(a+b)
//}


//2 有1个返回值
//func add(a int,b int) int {
//func add(a int,b int) (int) {
//    return a+b
//}

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


//3 多个参数，类型一致,可以省略前面的类型
//func add(a int ,b int){
//func add(a ,b int)int{
////func add(a int,b string){
//    return a+b
//}


//4 命名返回值（了解）
//func add(a,b int) (int) {
//    c:=a+b
//    return c
//}

//func add(a,b int) (c int) {
//    //c:=a+b //重复定义
//    c=a+b    //内部不需要定义
//    //return c  //返回的时候，c可以省略
//    return   //返回的时候，c可以省略
//}

//5 空白符  _  忽略掉某个返回值
六、函数高级 
package main

import "fmt"

//函数高级(都是按位置传，没有关键字一说)

func main() {
    //test(1,2,5,6,7,8,8)

    //res:=find(10,1,2,43,54,6,7,8,9,10)
    //fmt.Println(res)


    //3 匿名函数 ，定义在函数内部
    //定义一个匿名函数,加括号使用匿名函数
    //func (){
    //    fmt.Println("我是匿名函数")
    //}()
    //把函数赋值给一个变量,并且执行
    //var a func()  //函数类型
    //a = func() {
    //    fmt.Println("aaaaa")
    //}
    //a()
    ////a是什么类型？定义出a来



    //var a func()=test(10)
    //a()
    //fmt.Println(a)
    var f func(c int)int
    f=test(10,20)
    res:=f(30)
    fmt.Println(res)

}


//1 可变长参数(可以传任意长度的int类型)
//func test(a... int)  {
//    fmt.Println(a)  //切片类型
//    fmt.Println(a[0])
//}

//2 案例：输入一个数字，和一堆数字，判断第一个数字在不在后面一堆中

//func find(a int,b ...int) string {
//    for i:=0;i<len(b);i++ {
//        if a==b[i]{
//            return "在"
//        }
//    }
//    return "不在"
//}


// 3 匿名函数（没有名字的函数）


// 4 闭包函数（定义在函数内部，对外部作用域有引用）
// 函数可以赋值给一个变量：函数是一等公民，头等函数
//func test(c int) func() {
//    a:=func (){
//        fmt.Println(c)
//    }
//    return a
//}


//5 更高级的使用
//func test(a func(func()),b func())(func(a,b int),func())  {
//    return func(a, b int) {
//
//    }, func() {
//
//        }
//}


//函数的参数和返回值都是类型的一部分
//func()
//func(a int)
//func(a int)int
func test(a,b int)func(c int)int{
    f:= func(c int) int{
        return a+b
    }
    return f
}