package main
import "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, 12
fmt.Println(a, b, c)
// 再 : 左侧有未定义过的变量就可以
//var c =90
//var c int =99
//w,c:="xxx",90 // 重复定义
//fmt.Println(c)
//fmt.Println(w)
// 6 变量不能重复定义，但是 := 特殊，只要左侧有没定义过的变量，它算赋值（修改值）
}
// 基础数据类型
整形 正负整数 表示的数字范围不一样 不同类型不允许直接运算
int
int8 8占8个比特位，一个btye，表示范围是？ -2的7次方 到 +2的7次方-1 128---127之间
int16 -2的15方 到 2的15次方-1
int32
int64
int 类型 再32位机器上是 int32 再64位机器上是int64
正整数
uint
uint8 0--255
uint16
uint32
uint64
uint 类型 再32位机器上是 uint32 再64位机器上是 uint64
浮点型--表示小数点后位数不一样
float32 ： 大约小数点后7位
float64 ： 大约小数点后15位
复数类型
complex64
布尔类型
bool
true
false
字符串类型
string
rune 和 byte 用来表示 字节和 字符
byte 是 uint8 的别名
rune 是 int32 的别名
// java 整数类型 byte short int long
// go 整数类型 int8 int16 int32 int64
// java float double
// go float32 float64
// 常量--》后期值不能改变
// 方式一，完整定义
const name string = "lin"
// 类型推导
const hobby = "篮球"
package main
import "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 + b
res = "计算成功"
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