Golang入门第一天

1. 变量的使用
2. 自动推导类型
3. 多重赋值和匿名变量
4. 常量的使用
5. 多重变量或常量的定义
6. iota枚举
7. bool布尔类型
8. 浮点型
9. 字符类型
10. 字符串类型
11. 字符类型和字符串类型的区别
12. 复数类型

---

// 1. go语言以包为管理单位
// 2. 每个文件必须先声明包
// 3. 程序必须有一个main包
package main

// 导入包
// 导入的包必须被使用
import (
	"fmt"
)

// 入口函数
func main() { // 左括号必须与函数命同行

	// 变量，手动初始化，定义的变量必须被使用
	var b int = 20
	// 定义变量，自推导数据类型
	a := 10
	fmt.Println("aa = ", a)
	fmt.Printf("b = %T", b)

	// 定义多个变量并推断初始化
	i, j := 10, 20
	fmt.Printf("i = %d, j= %d\n", i, j)

	// go语言可直接交换两个变量的值，无需使用中间变量
	i, j = j, i
	fmt.Printf("i = %d, j = %d\n", i, j)

	//定义常量，且必须马上初始化
	const k int = 30
	const k2 int = 40
	fmt.Printf("k = %d, k2 = %d\n", k, k2)

	// _ 匿名变量，丢弃数据不做处理
	tmp, _ := k, k2
	fmt.Printf("tmp = %d\n", tmp)

	// _匿名变量，一般配合函数返回值使用
	_, tmp, _ = demo()
	fmt.Printf("tmp = %d\n", tmp)

	// 多个变量的定义
	var (
		k3 int = 0
		k4 int = 1
		k5 int = 2
	)
	fmt.Printf("k3 = %d, k4 = %d, k5 =%d\n", k3, k4, k5)

	// 多个常量的定义
	const (
		k6 int = 0
		k7 int = 1
		k8 int = 2
	)
	fmt.Printf("k6 = %d, k7 = %d, k8 =%d\n", k6, k7, k8)

	// iota常量自动生成器，每隔一行，就自动累加一
	// 通常配合常量使用。当作一个枚举使用
	const (
		c1 int = iota
		c2 int = iota
		c3 int = iota
	)
	fmt.Printf("c1 = %d, c2 = %d, c3 =%d\n", c1, c2, c3)

	// iota遇到const自动重置为0，且在同一行的iota的值是相同的
	const (
		c4     int = iota
		c5, c6 int = iota, iota
	)
	fmt.Printf("c4 = %d, c5 = %d, c6 =%d\n", c4, c5, c6)

	// bool 布尔值，零值(初始值) = false
	var b1 = true
	fmt.Printf("b1 = %T\n", b1)
	fmt.Println("b1 = ", b1)

	// 浮点型float32
	var f32 float32
	f32 = 3.14
	fmt.Println("f32 = ", f32)

	// 默认推导小数类型为float64，精度高于float32
	var f64 = 3.14
	fmt.Printf("f64 = %T\n", f64)

	// 字符类型
	var byte1 byte
	byte1 = 97
	fmt.Printf("byte1 = %c, %d\n", byte1, byte1)
	byte1 = 'A'
	fmt.Printf("byte1 = %c, %d\n", byte1, byte1)
	// A = 65, a = 97, 大小写相差32，小写大
	fmt.Printf("大写转化为小写 = %c, %d\n", byte1+32, byte1+32)

	// 字符串类型
	var string1 string
	string1 = "字符串"
	fmt.Printf("string1 = %s\n", string1)
	// 自动推导类型
	var string2 = "字符串2"
	fmt.Printf("String2.type = %T\n", string2)
	// 内建函数len()可以计算字符串长度
	fmt.Printf("string2.length = %d\n", len(string2))

	// 字符和字符串的区别
	var (
		// 字符1-单引号，2-字符，往往都是一个字符，'\n'除外
		char2 byte = 'a'
		// 字符串1-双引号，2-字符串由一个或多个字符组成，3-字符串都是隐藏了一个结束符'\0'
		string3 string = "a"
	)
	fmt.Printf("char2 = %c, string3 = %s\n", char2, string3)

	// 取目标字符串中特定位的字符
	var string4 string = "abc"
	fmt.Printf("string4[0] = %c, string4[1] = %c\n", string4[0], string4[1])

	// 复数类型，分实部和虚部
	var complex1 complex128
	complex1 = 1.2 + 2.1i
	fmt.Println("complex1 = ", complex1)
	// 自动推导类型
	complex2 := 2.1 + 3.1i
	fmt.Printf("complex2.type = %T\n", complex2)
	// 通过内建函数，可以取到实部real()和虚部imag()
	fmt.Println("实部real(complex2) = ", real(complex2), "虚部imag(complex2) = ", imag(complex2))
}

func demo() (a, b, c int) {
	return 1, 2, 3
}

运行结果

PS E:\go> go run .\hello.go
aa =  10
b = inti = 10, j= 20 
i = 20, j = 10       
k = 30, k2 = 40      
tmp = 30
tmp = 2
k3 = 0, k4 = 1, k5 =2
k6 = 0, k7 = 1, k8 =2
c1 = 0, c2 = 1, c3 =2
c4 = 0, c5 = 1, c6 =1
b1 = bool
b1 =  true
f32 =  3.14
f64 = float64        
byte1 = a, 97
byte1 = A, 65
大写转化为小写 = a, 97
string1 = 字符串
String2.type = string
string2.length = 10
char2 = a, string3 = a
string4[0] = a, string4[1] = b
complex1 =  (1.2+2.1i)
complex2.type = complex128
实部real(complex2) =  2.1 虚部imag(complex2) =  3.1
PS E:\go>