2-go-变量定义、类型、常量、函数

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

1 变量定义

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 变量不能重复定义，但是 := 特殊，只要左侧有没定义过的变量，它算赋值（修改值）

}

2 类型

// 基础数据类型
	整形   正负整数  表示的数字范围不一样   不同类型不允许直接运算
		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

3 常量

// 常量--》后期值不能改变
// 方式一，完整定义
const name string = "lin"

// 类型推导
const hobby = "篮球"

4 函数

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