go 语言（二）相关基础学习

1、go语言main函数的了解

把程序比作商场 -- 需要入口函数
1）go语言以包作为管理单位
2）每个文件必须先声明包
3）程序必须有一个main包（重要） 一个文件夹只能有一个main函数
fmt.Println("23") // go语言语句结尾没有分号
命令行编译
go build xxx.go 编译go代码，生成一个可执行程序.exe
go run xxx.go 不生成程序，直接运行，不过一般都是直接go run 

2、变量相关

（1）声明格式 var 变量名 类型 变量声明也必须要用

（2）只是声明，没有初始化的变量，默认值是0

（3）同一个() 里，声明的变量是唯一的

变量的初始化，声明变量时，同时赋值
var d int = 10 // 初始化，声明变量时，同时赋值（一步到位）
d = 20 // 赋值，先声明，后赋值
fmt.Println("d = ", d)

自动推导类型，必须初始化，通过初始化的值确定类型（常用）
e := 30
// %T打印变量所属的类型
fmt.Printf("e type is %T\n", e) // e type is int 

格式化输出，printf和println
p := 10
q := 20
fmt.Println("p = ", p, ",q = ", q) // p = 10, q = 20
fmt.Printf("p = %d, q = %d\n", p, q) // p = 10, q = 20  

多重赋值，变量交换
i, j := 10, 20
i, j = j, i
fmt.Printf("i = %d, j = %d\n", i, j) // i = 20, j = 10 

3、匿名变量的使用

package main

import "fmt" // 导入包，必须要使用

// go函数的定义： 函数可以返回多个值
func test() (a, b, c int) {
	return 1, 2, 3
}

func main() {
	var tmp int
	i, j := 10, 20
	// _匿名变量，丢弃数据不处理，_匿名变量配合函数返回值使用，才有优势
	tmp, _ = i, j
	fmt.Println("tmp = ", tmp)

	var c, d, e int
	c, d, e = test() // return 1,2,3
	fmt.Printf("c = %d, d = %d, e = %d\n", c, d, e)

	_, d, e = test() //return 1,2,3
	fmt.Printf("d = %d, e = %d\n", d, e)
}

其中主要注意的是函数的定义，函数的调用，匿名变量_ 的使用

4、常量的使用

常量，程序运行期间，不可以改变的量，常量声明需要const
    // 变量，程序运行期间，可以改变值，变量声明需要var
    // 常量，程序运行期间，不可以改变的量，常量声明需要const

    const a int = 10
    fmt.Println("a = ", a)

    const b = 11.2 // 没有使用：=
    fmt.Printf("b type is %T\n", b)
    fmt.Println("b = ", b)

5、多个变量或者常量定义

多个变量定义，初始时不进行声明

var (
a int
b float64
)
a, b = 10, 3.14
fmt.Println("a = ", a)
fmt.Println("b = ", b)

多个常量定义，初始时进行赋值声明(需要注意浮点型的精度问题)

const (
i int = 10
j float64 = 3.14
)
fmt.Println("i = ", i) // i = 10
fmt.Println("j = ", j) // j = 3.14
fmt.Printf("i = %d, j = %f\n", i, j) // i = 10, j = 3.140000

6、iota 枚举

	// 1、iota常量自动生成器，每个一行，自动累加1
	// 2、iota给常量赋值使用
	const (
		a = iota // 0
		b = iota // 1
		c = iota // 2
	)

	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c) // 0,1,2

	// 3、iota 遇到const，重置为0
	const d = iota
	fmt.Printf("d = %d\n", d) // 0

	// 4、可以只写一个iota
	const (
		a1 = iota // 0
		a2
		a3
	)
	fmt.Printf("a1 = %d, a2 = %d, a3 = %d\n", a1, a2, a3) // 0,1,2

	// 5、如果是同一行，值都一样
	const (
		i1     = iota       // 0
		i2, j1 = iota, iota // 同一行的值相同
		i3     = iota
	)
	fmt.Printf("i1 = %d,i2 = %d, i3 = %d, j1 = %d\n", i1, i2, i3, j1) // 0,1,2,1

7、格式化输出

此处需要注意浮点型的判断，%f 小数位和 %v 小数位的不同

	a := 10
	b := "abc"
	c := 'a'
	d := 3.14

	fmt.Printf("%T, %T, %T, %T\n", a, b, c, d) //int, string, int32, float64

	// %d整形格式 %s字符串格式 %c字符格式 %f浮点型格式
	fmt.Printf("a=%d, b=%s, c=%c, d=%f\n", a, b, c, d) //a=10, b=abc, c=a, d=3.140000

	// %v自动匹配格式输出
	fmt.Printf("a=%v, b=%v, c=%v, d=%v\n", a, b, c, d) //a=10, b=abc, c=97, d=3.14

	fmt.Println("Hello, World!")

8、输入的使用

	var a int // 声明变量
	fmt.Printf("请输入变量a：")

	// 阻塞等待用户的输入
	fmt.Scanf("%d", &a)
	//fmt.Scan(&a)

	fmt.Println("a = ", a)

9、类型别名

由于一些语言使用习惯的问题，如果java或者c语言使用者过渡到go语言，可以在此处进行字段类型的别名替换

	// 给int64 起一个别名叫bigint
	type bigint int64
	
	var a bigint // 等价于var a int64
	
	type {
		longint int64
		char byte
	}
	
	var b longint = 11
	var c char = 'a'
	
	fmt.Println("b = %d, c = %c\n",b,c)

10、条件判断的使用 if-else

	s := "success"

	if s == "error" {
		fmt.Println("继续努力！")
	} else {
		fmt.Println("恭喜您答对了！")
	}

	// if 支持1个初始化语句，初始化语句和判断条件以分号分隔
	if a := 10; a == 10 {
		fmt.Println("a == 10")
	}

11、switch和case的使用

第一种使用：

	var num int
	fmt.Printf("请按下楼层：")
	fmt.Scan(&num)

	//	switch a:=10,a {}

	switch num { // switch 后面写的是变量本身

	case 1:
		fmt.Println("按下的是1层")
		// break // go语言保留了break关键字，跳出switch语言，不写，默认包含
		fallthrough // 不跳出switch语句，后面的无条件执行
	case 2:
		fmt.Println("按下的是2层")
	case 3:
		fmt.Println("按下的是3层")
	case 4:
		fmt.Println("按下的是4层")
	case 5, 6, 7, 8, 9, 10:
		fmt.Println("这些楼层不停")
	default:
		fmt.Println("按下的是xxx楼")
	}

第二种使用：

switch 可以没有条件，将条件放到case后面

	score := 85
	switch { // 可以没有条件
	case score > 90: // case后面可以放条件
		fmt.Println("优秀")
	case score > 80:
		fmt.Println("一般")
	case score > 70:
		fmt.Println("不及格")
	default:
		fmt.Println("其他 ")
	}

12、for循环的使用

	// for 初始化条件 ; 判断条件; 条件变化  {

	// 计算 1 + 2 + 3 + ... + 100
	sum := 0
	for num := 1; num <= 100; num++ {
		sum += num
	}
	fmt.Println("sum = ", sum)

13、range 迭代的使用

迭代比较重要，切片、通道都能用的上

	str := "abc"

	// 通过for打印每个字符
	for i := 0; i < len(str); i++ {
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}

	// 迭代打印每个元素，默认返回2个值： 一个是元素的位置，一个是元素本身
	for i, data := range str {
		fmt.Printf("str[%d]=%c\n", i, data)
	}

	for i := range str {
		// 第二个返回值，默认丢弃，返回元素的位置（下标）
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}

	for i, _ := range str {
		// 第二个返回值，默认丢弃，返回元素的位置（下标）
		fmt.Printf("str[%d]=%c\n", i, str[i])
	}
	//str[0]=a
	//str[1]=b
	//str[2]=c

14、goto 和 time的使用

import "fmt"
import "time"
func main() {

  fmt.Println("1111111")
  
  time.Sleep(time.Second)  // 延时1s

  fmt.Println("1111111")
  goto End // goto是关键字，End是用户起的名字，叫做标签
  fmt.Println("2222222")

End:
  fmt.Println("3333333")
}