go语言定义byte数组变量 go语言变量类型

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。在数学概念中，变量表示没有固定值且可改变的数。但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

声明变量的一般形式是使用 var 关键字：

var name type

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。
需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b; 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。而在 Go 中，则可以和轻松地将它们都声明为指针类型：

var a, b *int

声明变量有几种形式：
正常格式：

var 变量名 变量类型

批量格式

var (
    a int
    b string
    c []float32
    d float64
    ...
)

简短格式：

名字 := 表达式

package main

import "fmt"

func main() {
	//变量测试
	//小块内存 可以改变，不可以改变的是常量
	// var 变量名 类型
	var num1 int
	num1 = 30
	fmt.Printf("num1 = %d\n", num1)

	var num2 int = 15
	fmt.Printf("num2 = %d\n", num2)
	// 虽然go语言是静态余语言但是支持类型的自动判断
	var num3 = 30
	fmt.Printf("num3 = %d\n", num3)
	fmt.Print("var test")
	// 使用类型腿短 := ,这种方式只能用于函数体内，不能用于全局变量的盛行声明
	num4 := 45
	fmt.Printf("type = [%T]num4 = [%d]\n", num4, num4)

	// 变量集合声明
	var (
		studentName = "xiaoming"
		teacherName = "jianguo"
		studentAge  = 18
		teacherAge  = 28
	)
	fmt.Printf("student name = [%s] age = [%d], Teacher name = [%s] age = [%d]\n",
		studentName, studentAge, teacherName, teacherAge)

}

package main

import "fmt"

func main() {
	var num int
	num = 100
	fmt.Printf("num = %d &"+
		" = %p\n", num, &num)

	//	常量的定义
	//	常量尽量都使用大写的定义，定义之后不允许修改
	const PI = 3.14
	const PATH string = "http:www.baidu.com"
	fmt.Println(PATH)
	//	定义一组常量
	//	变量的集合
	const C1, C2, C3 = 100, 3, "haha"
	const (
		NAME     = "xiaoming"
		LINKMODE = 1
	)
	// 一组常量，如果某个常量没有给初始值，就会默认和上一个常量保持一致的值
	const (
		a int = 100
		b
		c string = "ruby"
		d
		e
	)
	fmt.Printf("type = %T, b = [%d]\n", a, a)
	fmt.Printf("type = %T, b = %d\n", b, b)
	fmt.Printf("type = %T, b = %s\n", d, d)
	fmt.Printf("type = %T, b = %s\n", e, e)
}

特殊的常量 iota

package main

import "fmt"

func main() {
	// iota 特殊常量，可以被编译器自动修改的常量，每当定义一个const， iota会自动清零
	// 在同一个变量集合中，iota随着变量的定义一直递增，直到遇到下一个const在清零
	const (
		a = iota
		b = iota
		c = iota
	)
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)

	const (
		e = iota
		f // 默认和上一行一致
		g = iota
	)
	fmt.Println(e)
	fmt.Println(f)
	fmt.Println(g)
	//	枚举实现
	const (
		MALE = iota
		FEMALE
		UNKNOWM
	)
	fmt.Println(MALE, FEMALE, UNKNOWM)

}

package main

import "fmt"

func f1(f func()) {
	fmt.Println("this is f1")
	f()
}

func f2(x, y int) {
	fmt.Println("this is f2")
	fmt.Print(x + y)
}

func f3(f func(int, int), x, y int) func() {
	tmp := func() {
		fmt.Println("hello")
		f(x, y)
	}

	return tmp
}

func main() {
	//基本的数据类型
	//	1.布尔类型
	//	2.数值类型

	//	3.字符串
	//	4.复合数据类型
	//	 array slice mao function pointer struct interface channel...
	//	bool
	var a bool = true
	fmt.Printf("%t\n", a)

	//	byte == uint8
	//	rune == int32
	var b rune = 100
	fmt.Println(b)
	// 匿名函数，立即执行函数
	func(x, y int) {
		fmt.Println(x + y)
	}(1, 2)

	//	闭包
	f1(f3(f2, 2, 3))

}