go基础02
变量名的命名规范
// go语言中的函数，变量名，常量名，类型名和包名等所有的命名都会遵循一个命名规则：
1.一个名字必须以字母（Unicode字母）或者下划线开头，后面可以是任意的字母数字下划线组成
2.大写字母与小写字母是不同的：（区分大小写，在Go语言张红的大写是由特殊含义的）
3.关键字和保留字都是不建议做Wie变量名的
4. 不能以数字作为变量名的开头
建议：
函数名的定义建议使用驼峰
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
// 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
变量的定义和使用
在功中有三种定义变量的方式：
1.完整定义
var 关键字 变量名 变量名类型= 变量值
PS：var name string ='小攻'
注意：变量只要定义了就一定要使用，否则就会报错
2.类型推导：（简写类型）自动推导
‘ name = '小红'
注：虽然是类型推导出来的，但是是有类型的，并且后期的类型是不能改变的
类型只要定义了，类型就固定了，后期不能改变
3.简略声明：省略var 省略类型，使用:=符号
name := '小明'
4.声明多个变量（就是上面的三种变量定义方式的变形）
完整定义：var name，age，hobby string ='小红'，'18','看书'
var(
name string ='小明'
age int =19
hobby string ='看书'
)
类型推导：
var name，age，hobby ='小明'，19，'篮球'
简略声明：
name，age，hobby:='小红'，'19','足球'
5.混合使用：
var(
name ='白白'
age int =18
hobby ='音乐'
)
6.变量不能重复定义三种定义方式
// var name ='小欧'
// name:='西西'
// var name string ='小黑'
// name ,age:= 'ppy',19
7.变量可以先定义再赋值，必须使用完整定义
var name string // 默认值 是一个空字符串
var age int // 默认值是0
var age // 不指定类型，不行
name := // 不行
8.查看变量的类型
a := 'Andy'
fmt.Printf("a的值是：%V，类型是：%T"，a,a)
总结：
- 三种方式定义变
- -完整定义 var 变量名 类型 =值
- -类型推导 var 变量名 = 值
- -简略声明 变量名 :=变量值
- 可以同时定义多个变量
- 变量不能被重复定义
- 变量类型是固定的，不能改变
- 变量定义了就必须使用，不使用会报错
GO的变量类型
// 数字
int （正负整数） int8 int16 int32 int64
PS：java 中 byte short int long
-int8 一个字节表示(8个比特位) 范围： -2的7次方 到 +2的7次方-1
-int16 2个字节表 范围： -2的15次方 到 +2的15次方-1
-同理以此类推
-int：32位机器，是int32,64位机器是int64
uint （正整数） uint8 uint16 uint32 uint64
# uint 正整数 uint uint8 uint16 uint32 uint64
-uint8 一个字节表示(8个比特位) 范围： 0 到 +2的8次方-1
-uint16 2个字节表示(8个比特位) 范围： 0 到 +2的16次方-1
-uint：32位机器，是uint32,64位机器是uint64
# 浮点型：表示小数 表示小数后范围不一样
float32：
float6
# 复数类型 实部和虚部
complex64
complex128
ps:分别对应着64位和32位的实数和虚数部分。complex128包含两个64位的浮点数，一个表示实数部分，另一个表示虚数部分。complex64则包含两个32位的浮点数，一个表示实数部分，另一个表示虚数部分。
例子：
package main
import "fmt"
func main() {
// 定义复数
var z1 complex128 = complex(1, 2) // 1 + 2i
var z2 complex128 = complex(3, 4) // 3 + 4i
// 加法
sum := z1 + z2
fmt.Println(sum) // 输出: (4+6i)
// 乘法
product := z1 * z2
fmt.Println(product) // 输出: (-5+10i)
// 实部和虚部
realPart := real(z1)
imaginaryPart := imag(z1)
fmt.Println(realPart, imaginaryPart) // 输出: 1 2
}
# bool类型
true false
# rune byte
byte 是uint8 的别名
rune 是int32 的别名
# string
-双引号包裹： 不能换行
-反引号包裹： 可以换行
# go 也能使用能使用单引号，但是它不是字符串
单引号引的字母是ASCLL码对应的字符数字
常量
常量：就是不能改变的变量，一旦定义值就固定了，就不能改变，在go中是使用 const 关键字来定义变量的
func main(){
// 定义常量 const
const name string ='lqz'
const name='pyy'// 代码执行就会报错
fmt.Println(name)
}
# 变量，常量的作用域范围（变量只要不在同一个范围内，是可以再次定义的），它查找的顺序和python的查找顺序是一致的
// LEGB 各自代表的含义
var name = "lqz"
//name:="lqz"
func main() {
//var name = "pyy"
name="pyy"
fmt.Println(name)
}
iota 的使用 必须用const 关键字
iota是一个特殊的常量，它可以用于生成一系列相关的常量值。当使用iota定义一个常量时，它的值默认从0开始自增1，直到下一个const关键字出现或者显式地将其设置为其他值。以下是iota的使用示例：
package main
import "fmt"
func main() {
const (
A = iota // A=0
B // B=1
C // C=2
D = "hello" // D="hello"
E // E="hello" (与D相同)
F = iota // F=5 (重新开始自增)
G // G=6
)
fmt.Println(A, B, C, D, E, F, G)
}
在上面的示例中，我们定义了一个常量组，并使用iota定义了其中的常量。常量A、B和C的值分别为0、1和2，常量D和E的值都为"hello"，常量F和G的值分别为5和6。注意，在定义D和E时，iota的值并没有自增，因为它们与上一个常量D有相同的值。另外，当我们定义F时，iota的值重新开始自增，所以F的值为5，而不是3。
函数基础
package main
import "fmt"
// 函数的调用与定义
func main() {
//1 调用普通函数
//test()
// 2 调用有参数的函数 (类型必须严格一致，有几个值就传几个值，按位置，没有关键字传参)
//test1(11, "lqz")
// 3 调用简写的有参函数
//test2(11, 12, "lqz")
// 4 调用有返回值的函数
//res := test3(1, 2)
//var res = test3(1, 2)
//var res int= test3(1, 2)
//fmt.Println(res)
//test3(3, 4)
// 5 调用多个参数，多个返回值的函数 必须用多个接收,有几个就要用几个变量接收，不能多不能少
//res1, res2, res3 := test4(5, 6)
//fmt.Println(res1)
//fmt.Println(res2)
////fmt.Println(res3)
// 5.1 就不想要第三个参数，后面不会用第三个参数
//_, _, res1 := test4(5, 6) // 忽略掉第三
//fmt.Println(res1)
////fmt.Println(res2)
////fmt.Println(res3)
//fmt.Println(_) //不能当变量用，就是个空白
}
// 1 定义普通函数，没有参数，没有返回值
func test() {
fmt.Println("我是普通函数")
}
// 2 有参数的函数,必须指定参数类型
func test1(a int, b string) {
fmt.Println(a)
fmt.Println(b)
}
// 3 有参数的函数，多个参数，类型一致可以简写 （go语言想发设法让你少写代码）
//func test2(a, b int, c string) {
// fmt.Println(a)
// fmt.Println(b)
// fmt.Println(c)
//}
// 4 既有参数，又有返回值的 ,只有一个返回值的，需要指明返回值类型
func test3(a, b int) int {
return a + b
}
// 5 多个参数，多个返回值
func test4(a, b int) (int, int, string) {
return a + b, a * b, "成功"
}
函数高级
# 在同一个包下，变量，函数名只能定义一次
# 匿名函数： 函数没有名字，一般定义在其他函数的内部
f:= func(){
}
# 被赋值的函数名返回就是一个闭包
函数名作为参数的话，函数本身就是一种类型，有参数，参数的类型也要加上，
package main
import "fmt"
// 函数高级
func main() {
// 1 匿名函数
//test5()
// 2 匿名函数赋值给变量
//test6()
// 3 调用函数，返回闭包函数
res := test7()
fmt.Println(res) //0x68de00 内存地址
res()
}
// 1 匿名函数加括号直接调用
func test5() {
func() {
fmt.Println("我是内层函数")
}()
}
// 2 匿名函数赋值给一个变量--->函数是一种类型---》在go中，函数又称一等公民（可以赋值给变量的都叫一等公民），又叫头等函数，一等函数
func test6() {
f:=func() {
fmt.Println("我是内层函数")
}
// // f 类型是什么呀？完整定义，写类型
// var f func() = func() {
// fmt.Println("我是内层函数")
// }
// fmt.Printf("%T", f) // func()
//
//}
// 3 函数是一等公民，是一种类型：于是乎函数的参数和返回值都是类型的一部分
func test6() {
var f func() = func() {
fmt.Println("我是内层函数")
}
f ：是func() 类型
// var f1 func(int) int = func(a int) int {
// fmt.Println(a)
// return 10
// }
f1：是func(a,int)类型 a 可以省略掉
func(a int) int： 最后面的int是函数的返回值
里面的int是 a 的数据类型
// var f2 func(int) string = func(c int) string {
// fmt.Println(a)
// return "10"
// }
// fmt.Printf("%T\n", f)
// fmt.Printf("%T", f1)
func(int) string 是f2的类型
func(c int) string ：string是返回的参数的类型
// f2(1)
//}
func test7() func() {
//return func() {
// fmt.Println("我是内存函数")
//}
t := 10
f := func() {
fmt.Println(t)
fmt.Println("我是内存函数")
}
return f // 闭包函数
}
test7就是一个闭包函数
