1 变量定义
2 类型
3 常量
4 函数

1 变量定义

package mainimport "fmt"//注释  单行注释/*
多行注释
*/
func main() {// 变量定义// 1 完整定义 var关键字  变量名  变量类型  = 变量值//var age int = 19 // 变量定义了必须使用，不使用就报错//fmt.Println(age)// 2 类型推导    // 不写类型，推导出类型，类型是固定的，后期不能改变//var age1 = 19 // 推导出是int类型//fmt.Println(age1)age1="xxx"    // 类型是固定的，后期不能改变// 3 简略声明     变量要先定义再使用   这种用的多//age1 := 19//fmt.Println(age1)//fmt.Println(age1 + 1)//fmt.Println(age1 + 2)// 4 变量要先定义再使用  使用上面三种方式定义都可以,类型固定，不能改变//name := "lin"//var name string   // 定义，不赋初值  必须用方式一定义//name = "彭于晏"//name="9"//fmt.Println(name)// 5 同时定义多个变量// 完整定义//var a, b, c int//var a, b, c int = 10, 11, 12//var (//	a int    = 10//	b string = "lin"//	c int    = 12//)// 类型推导//var a, b, c = 10, 11, 12//var a, b, c = 10, "lin", 12//var (//	a int = 10//	b     = "lin"//	c     = 12//)// 简略声明a, b, c := 10, 11, 12fmt.Println(a, b, c)// 再 : 左侧有未定义过的变量就可以//var c =90//var c int =99//w,c:="xxx",90  // 重复定义//fmt.Println(c)//fmt.Println(w)// 6 变量不能重复定义，但是 := 特殊，只要左侧有没定义过的变量，它算赋值（修改值）}

2 类型

// 基础数据类型整形   正负整数  表示的数字范围不一样   不同类型不允许直接运算intint8    8占8个比特位，一个btye，表示范围是？ -2的7次方 到  +2的7次方-1  128---127之间int16   -2的15方  到 2的15次方-1int32   int64   int 类型 再32位机器上是 int32   再64位机器上是int64正整数uint   uint8     0--255uint16uint32uint64uint 类型 再32位机器上是 uint32   再64位机器上是 uint64浮点型--表示小数点后位数不一样float32 ： 大约小数点后7位float64 ： 大约小数点后15位复数类型complex64布尔类型booltruefalse字符串类型stringrune  和  byte  用来表示   字节和  字符byte 是 uint8 的别名rune  是 int32 的别名// java 整数类型  byte   short   int      long
// go 整数类型    int8   int16   int32    int64 // java  float     double
//  go   float32   float64

3 常量

// 常量--》后期值不能改变
// 方式一，完整定义
const name string = "lin"// 类型推导
const hobby = "篮球"

4 函数

package mainimport "fmt"// 函数的使用
func main() {// 1 调用 无参无返回值函数  无需先定义再调用//test01()// 2 调用有参函数//var name = "lin"//test02(name)//test02("彭于晏")// test02(99)// 3 调用多个参数函数   都是按位置传//test03(99, "lin")// 4 调用多个参数函数   都是按位置传//test04(99, 180, "lin")// 5 调用有返回值的函数//var res int//res = test05(3, 4)//var res = test05(3, 4)//res := test05(3, 4)//fmt.Println(res)// 6 调用多返回值函数,有几个返回值，就要用几个变量来接受//res, res1 := test06(4, 5)//fmt.Println(res)//fmt.Println(res1)//res, _ := test06(4, 5) // 多个返回值，就只想要第一个//fmt.Println(res)//_, res2, _ := test07(6, 7)//fmt.Println(res2)// 调用匿名函数//test10()// 调用test12//f := test12()//f()// 调用闭包函数//var f = test13("lin")//f()//f := test14("lin")//f(99)ff:=func(i int) string {fmt.Println(i)return "返回值"}var fff myFunc=test16("lin",ff )fff(1, func() {})}// 1 无参数无返回值
func test01() {fmt.Println("test01")
}// 2 有一个参数，无返回值
func test02(name string) {fmt.Println(name)
}// 3 多个参数无返回值  不同类型
func test03(age int, name string) {fmt.Println(age, name)
}// 4 多个参数无返回值  相同类型
// func test04(age int, height int) {
func test04(age, height int, name string) {fmt.Println(age, height, name)
}// 4 两个参数，一个返回值  如果要返回值，必须指定返回值类型
// def test05(a:int,b:int)->int:
func test05(a, b int) int {return a + b
}// 5  两个参数，两个返回值
func test06(a, b int) (int, string) {return a + b, "计算成功"
}// 6
func test07(a, b int) (int, string, bool) {return a + b, "计算成功", true
}// 8 命名返回值
func test09(a, b int) (c int, res string) {c = a + bres = "计算成功"return
}// 9 匿名函数 ---》没有名字的函数---》必须定义再函数内部-->要么返回，要么加 （）执行
func test10() {func() {fmt.Println("我是匿名函数")}()
}func test11() {f := func() {fmt.Println("我是匿名函数")}f()
}func test12() func() {// 类型是func类型var f func() = func() {fmt.Println("我是匿名函数")}return f
}// 10 闭包函数：定义再函数内部，对外部作用域有引用
func test13(name string) func() {return func() {fmt.Println(name)}
}// 11 函数参数和返回值都是类型一部分
func test14(name string) func(int) {return func(age int) {fmt.Println(name, age)}
}// 12 更恶心操作
func test15(name string) func(int)string {return func(age int) string{fmt.Println(name, age)return "执行完成"}
}func test16(name string,f func(int)string) myFunc {return func(age int,f1 func()) string{fmt.Println(name, age)return "执行完成"}
}// 对类型重命名
type myFunc func(int,func())string