GO——变量定义规范，，类型，，常量，，函数，，包

# 1 变量定义规范
# 25关键字
    for if 。。。。
# 37个保留字
    int int8 panic 。。。
    
    
# 2 变量定义
    1 完整定义
    var 变量名  变量类型 = 变量值
    var 变量名 变量类型
    
    2 类型推导（变量类型在定义阶段固定了，后期不能改变）
    var 变量名 = 值
    
    3 简略声明 （左侧必须有未定义过的变量）
    变量名  :=  变量值
    
    4 变量不能重复定义，先定义在使用
    
    5 同时定义多个变量
        var a,b,c int =11,22,33
        var a,b,c  = 11,22,"33"
        a,b,c:=11,22,"33"
        
        var (
         name string
         age =99
        )
        
        
   6 变量定义后必须使用，否则报错

类型

# 每个变量都是有类型的，并且要求严格，一旦确定，后期不能改变

# go 基础数据类型
    -数字
        -整数：  int     int8     int16   int32    int64
            -表示整数范围不一样
                int8 占 1 个byte，一个字节，8个比特位--》表示范围 -2的7次方： -128 到  +127
                int16 占 2 个byte--》表示范围 负 2的15次方   到  正2的15次方-1 -32768～32767
                int32：-2147483648～2147483647
               int64：-9223372036854775808～9223372036854775807
            -int 跟平台有关系
                32位系统上是int32
                64位系统上是int64
                
        -正整数: uint   uint8     uint16   uint32    uint64
            uint8 ：0到 255之间
            uint16：0～65535
            uint32 0～4294967295
            uint64：0～18446744073709551615
            
        
        -小数:   float32  float64
            float32：32 位浮点数
            float64：64 位浮点数
        -复数:  complex
            实部和虚部
         
        -byte : uint8   一个字节
        -rune : int32   一个字符
    
    -字符串    
        string：必须用 双引号 或 反引号
    
    -布尔类型
        bool ：只有 true或false

------------------------------------
package main

import "fmt"

// ########## 变量类型##############
func main() {

    //1 整数类型
    var a int = 33333
    var a1 int8 = 127
    fmt.Println(a)
    fmt.Println(a1)

    // 2 正整数
    var a2 uint8 = 255
    fmt.Println(a2)

    // 3 浮点型（小数）
    var a3 float32 = 1.1234567890
    var a4 float64 = 1.1234567890123456789
    fmt.Println(a3)
    fmt.Println(a4)

    // 4 字符串
    var s string = "lqz is hadsome"
    var s1 string = `lqz xxfas 撒打发
asfsad
阿斯顿发
暗室逢灯
asdf阿瑟发d`
    fmt.Println(s)
    fmt.Println(s1)

    // 5 布尔
    var b bool = true
    b = false
    fmt.Println(b)

    // 6 byte类型===>uint8 --->256种变化---》ascii值--》一个字节
    //var bb byte = 255
    var bb byte = 'a'
    //var bb byte = 97
    fmt.Println(bb)
    fmt.Println(string(bb))
    // 李清照  [230, 157, 142, 230, 184, 133, 231, 133, 167]
    var abc []byte = []byte{230, 157, 142, 230, 184, 133, 231, 133, 167}
    var ssss = string(abc)
    fmt.Println(ssss)

    // 7 rune 类型---》int32---》4个字节---》unicode编码表示一个字符
    var rr rune = '照'
    var rr1 rune = 20013
    fmt.Println(rr)          // 20013
    fmt.Println(string(rr1)) //中   26446  28165  29031

    var abcd []rune = []rune{26446, 28165, 29031}
    fmt.Println(string(abcd))

    // 8 go是强类型语言--》不同类型不允许运算
    var aaa1 int8 = 99
    var aaa2 int32 = 99
    fmt.Println(aaa2 + int32(aaa1))
    
}

---------------------------------------
s='李清照'

b=s.encode('utf-8')
print(b) # '\xe6\x9d\x8e    \xe6\xb8\x85    \xe7\x85\xa7'   16 进制显示   字节数组16进制展示

# 十进制进制展示
aa=[ item for item in b]
print(aa)  # [230, 157, 142, 230, 184, 133, 231, 133, 167]

# 二进制展示
bb=[ bin(item)[2:] for item in b]
print(bb)  # ['11100110', '10011101', '10001110', '11100110', '10111000', '10000101', '11100111', '10000101', '10100111']

# 16进制展示
bb=[ hex(item) for item in b]
print(bb)

常量

# 恒定不变的量，一旦赋值，后期不能变化
    -python 是有---》强制--》约定俗称的--》全大写的是常量
    -Django，flask配置信息---》其实就是常量

package main

import "fmt"

const school = "清华大学"

// ########## 常量 ##############
func main() {

    // 1 定义常量
    //const hobby string="篮球"
    const hobby = "篮球"
    fmt.Println(hobby)
    // 2 作用域范围
    var school string = "xxx"
    school = "上海交大"
    fmt.Println(school)

}

func demo01() {
    fmt.Println(school)
}

函数

// 1 函数定义规范
func 函数名(形参 形参类型,形参 形参类型)返回值类型{
    函数体
    return 返回值
}

package main

import "fmt"

// ########## 函数 ##############

func main() {
    // 1 无参数无返回值
    //test01()

    //2 一个参数，无返回值
    //test02(12)

    //3 多个相同类型参数，无返回值
    //test03(11, 12)

    // 4 多个参数，一个返回值
    //res := test04(11, 22)
    //fmt.Println(res)

    // 5 多个参数，多个返回值
    //var a, ok = test05(3, 4)
    //if ok {
    //    fmt.Println(a)
    //}

    // 6 匿名函数
    //test06()

    // 7 把函数赋值给变量，通过变量调用函数
    //res:=f(3,4)
    //var xx = f
    //res := xx(3, 4)
    //fmt.Println(res)

    //  9 空白符-->函数有多个返回值，只想要某一个或几个
    //_, ok := test05(4, 5) // python 中也可以用  _  接收返回值，但是python 中  _ 是一个变量
    ////a := test05(4, 5) // 有几个返回值必须用几个来接收
    //fmt.Println(ok)
    //
    //// 11 函数是一等公民---》函数当返回值返回--->函数内的内层函数
    //var f func() = test11()
    //fmt.Println(f)
    //f()

    // 12 闭包--》跟语言无关---》定义在函数内部  对外部作用域有引用
    //a := 99 // 值类型--》传到函数中，相当于复制了一份，相互脱离了
    //res := test12(a)
    //fmt.Println(res)
    //a = 199 // 闭包函数是对外部作用域的引用
    //res()

    // 14 函数 变量 当参数传入到函数中--->了解
    //func test14(a int,f func(i int))  {
    //    f(a)
    //}
    //var f= func(a int) {
    //    fmt.Println("数字+99 是",a+99)
    //}
    //test14(99,f)

    test14(99, func(i int) {
        fmt.Println("数字+99 是", i+99)
    })
    // 控制台打印什么？

}

// 1 无参数无返回值
func test01() {
    fmt.Println("我是test")
}

// 2 一个参数无返回值
func test02(a int8) {
    fmt.Println("我是test02", a)
}

// 3 多个同类型参数无返回值
// func test03(i int, i2 int) {
func test03(i, i2 int) { // 简略写法
    fmt.Println(i + i2)
}

// 4 多个参数，一个返回值
func test04(i int, i2 int) int {
    return i + i2
}

// 5 多个参数，多个返回值
func test05(i int, i2 int) (int, bool) {
    return i + i2, false
}

// 6 函数高级 匿名函数---》没有函数名的函数-->一般定义在函数内部-->函数内部定义的函数不能有名字(只能定义成匿名函数)
func test06() {
    fmt.Println("test06--start")
    // 定义匿名函数--->如果不赋值给变量，就必须调用执行
    func() {
        fmt.Println("inner")
    }()
    fmt.Println("test06--end")
}

// 7 go 中函数是一等公民(头等函数)---》函数可以赋值给变量---》python中函数是一等公民---》go中函数是一种类型
// 可以存储在变量中。 可以作为参数传递给函数。 可以作为函数的返回值
// 类型推导
//var f =func (a,b int)int  {
//    return a+b
//}

// 完整定义
var f = func(a, b int) int {
    return a + b
}

// 8 函数也是一种类型，函数的参数和返回值都是类型的一部分

// 9 空白符-->函数有多个返回值，只想要某一个或几个

// 10 命名返回值
func test10(a, b int) (s int, ok bool) {
    //return a+b,true
    // s 和ok 不需要定义了
    s = a + b
    ok = true
    //return s,ok
    return
}

// 11 函数是一等公民---》函数当返回值返回
func test11() func() {
    a := func() {
        fmt.Println("我是匿名内部函数")
    }
    return a
}

// 12 闭包--》跟语言无关---》定义在函数内部  对外部作用域有引用
func test12(x int) func() {
    x = 666
    // f是个闭包函数
    f := func() {
        fmt.Println("我是匿名内部函数", x)
    }
    return f
}

// 13 装饰器--》设计模式--》23 种--》单例，工厂---》
// go 中 也有装饰器的用法---》但是没有装饰器的语法糖--》go实现装饰器
// go实现装饰器--》统计函数运行时间

// 14 函数 变量 当参数传入到函数中--->了解
func test14(a int, f func(i int)) {
    f(a)
}

// 15 奇葩写法
func test15(f1 func(int) int, f2 MyFunc) (func(), func(int) int) {
    // f1 参数：func(int)int  类型
    // f2参数：func(string)(int,int)类型

    // 返回值 func()
    //返回值 func(int)int
    return func() {

    }, func(i int) int { return 0 }
}

// 16 给类型重命名
type MyFunc func(string) (int, int)

包

包用于组织 Go 源代码，提供了更好的可重用性与可读性

# 包规范
// 1 包内部的函数，变量。。大写字母开头表示导出---》别的包才可以用
// 2 在同一个文件夹下，包名必须一致，建议包名就是文件夹名
// 3 在同一个包下，所有变量和函数，方法。。。 都认为是在同一个go文件中
// 4 使用包，导入使用 ---》导入到包名这一层--》包名.导出字段用即可
// 5 导入包：import "go_day02/common"
    包名.方法名使用
    
// 6 导入包并重命名： import lqz "go_day02/common/v1"
    lqz.方法使用
// 7 一次导入多个包
import (
    fm "fmt"
    "go_day02/global"
)