# 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"
)
标签：常量,int,fmt,var,Println,函数,func,GO,变量 From： https://www.cnblogs.com/wzh366/p/18112848