package main

import "fmt"

func main()  {
	var a  = 3
	var b = 4
	_, b = b,a // _表示丢弃的值，最终结果为3, 3
	fmt.Println("a =", a, "", "b = ", b)


}

package main

import (
	"fmt"
	"math/rand"
)

/*
 * go语言只有for循环，没有while循环
 *
 * 条件语句的格式
 *
 * // 注意 else if 和 else 语句的位置，如果位置错了会显示语法错误
 * if 条件变量{
 *   // 执行的代码块
 * }else if 条件变量{
 *   // 执行的代码块
 * }else{
 *   // 执行的代码块
 * }
 */

func main(){

	a := rand.Intn(100) // 返回[0, 100]之间的一个整数
	var b int

	for ;; {
		fmt.Printf("请输入猜数字:")
		fmt.Scanf("%d", &b)
		if a == b {
			fmt.Println("恭喜你猜对了")
			break
		} else if a > b {
			fmt.Println("数字有点小了")
		} else {
			fmt.Println("数字有点大了")
		}
	}

	// 死循环
	for true{
		fmt.Println("hello world")
		break // 中断循环
	}
	fmt.Println("结束掉了")
}

package main

import (
	"fmt"
	"unsafe"
)

// iota 是一个可以被编译器修改的常量，常量计数器
/*
 * iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，
 * const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为
 * const 语句块中的行索引)。
*/

// const 修饰的变量表示在程序运行的过程中不会被修改
func main(){
	const(
		a = iota
		b = iota
		c
		d = iota
	)
	fmt.Println(a , b , c , d)
	const(
		e = iota
		f
		g
	)
	fmt.Println(e, f, g)

	const(
		h = iota
		i = "hello"
		j
		k = iota
	)
	fmt.Println(h , i, j ,k)

	const(
		l = 1 << iota // 1 左移 0 位
		m = 2 << iota // 2 左移 1 位
		n             // 结果为  8, 解释应为 2 左移 3 位
		o             // 结果为 16, 解释应为 2 左移 4 位

	)
	fmt.Println(l, m, n, o)

	const(
		p = "hello world"
		q = len(p)
		r = unsafe.Sizeof(p)
		/*
			Golang中的string内部实现由两部分组成，一部分是指向字符串起始地址的指针，
			另一部分是字符串的长度，两部分各是8字节，所以一共16字节
		*/
	)
	fmt.Println(p, q, r)
}

package main

import "fmt"

/*
 *  算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符、其他运算符
 *
 *  算术运算符：+ - * / % ++ --
 *  关系运算符：== != > < >= <=
 *  逻辑运算符：&& || !
 *  位运算符：& | ^ << >>
 *  赋值运算符：= += -= *= /= %= <<= >>= &= ^= |=
 *  其他运算符：&(返回变量存储地址) *(指针变量)
 */
func main(){
	var a = "hello" // 可以自动判断变量类型，所以string类型名可以省略掉
	var b = "world"
	c := a + b
	fmt.Printf("c = %s, len(c) = %d", c, len(c))
}

package main

import "fmt"

/*
 * 函数内定义的变量称为局部变量
 * 函数外定义的变量称为全局变量
 * 函数定义中的变量称为形式参数
 *
 **/

var a = 3 // 全局变量

func main(){
	var a, b = 1, 4 // 局部变量,局部变量必须使用，否则会报错
	fmt.Println("sum is", add(a, b))
}

// n int 是形式参数
func add(n, m int)int{
 	return n + m
}

package main

import "fmt"

/*
结构体:
	type struct_variable_type struct{
		member definition;
		member definition;
		...
		member definition;
	}
*/

type student struct{
	name string
	id	 int
	sex  bool; school string
}

func main() {
	var st1= student{"张三", 12, true, "西安邮电大学"}
	st2 := student{"张三", 12, true, "西安邮电大学"}
	fmt.Println(st1)
	fmt.Println(st2)

	var st3 student
	st3.name = "李四"
	st3.id = 13
	st3.sex = false
	st3.school = "西安邮电大学"
	fmt.Println(st3)


	var st4 = [3]student{
		{"张三", 12, true, "西安邮电大学"},
		{"张三", 12, true, "西安邮电大学"},
		{"张三", 12, true, "西安邮电大学"},
	}

	fmt.Println(st4)
}

package main

import (
	"fmt"
)

/*
指针类型：
	var var_name * var-type
  例：
	var ip * int      // 指向整形的指针变量
	var fp * float32  // 指向浮点型的指针变量

空指针：nil，指针的默认值为nil
*/


/*
指针数组：这是一个数组，变量类型是指针类型的
	var p [3] *int
*/


/*
二级指针：指向指针的指针
	var a int
	var p * int
	var pp ** int
*/
func main(){
	var a = [] int {1,2 ,3,}
	var p [3] *int

	for i := 0; i < len(a); i++{
		p[i] = &a[i]
	}
	fmt.Println(a)
	fmt.Println(p)
	for i := 0; i < len(a); i++{
		fmt.Print(*p[i], "=>", p[i], " ")
	}

	fmt.Println("\n%")
	fmt.Printf("%%\n")
	fmt.Print("%\n") //(MISSING)%,发现没有后续动词,格式化输出会出现此问题


	// 多级指针
	var b int
	var bp * int
	var bpp ** int

	b = 4
	bp = &b
	bpp = & bp
	fmt.Println(b, bp, bpp)
	fmt.Println(*bp, *bpp)
	fmt.Println(**bpp)
}

package main

import "fmt"

/*
一维数组的定义：
	var variable_name [SIZE] variable_type

一维数组的初始化:
	var balance = [5]float32{100.0, 2.0, 3.4, 7.0, 50.0}
	var balance = []float32{100.0, 2.0, 3.4, 7.0, 50.0}
多维数组：
	var variable_name [SIZE1][SIZE2]...[SIZEN] variable_type
*/
func main() {
	var a = [] int{1, 2, 3, 4, 5}
	var b = [5] int{1, 2, 3, 4, 5}
	var c = [3][4] int{ {1, 2, 3}, {4, 5, 6} } // 未初始化的默认设置为 0
	var d = [4][] int{ {1, 2, 3}, {4, 5, 6} }  // 没有的值设置为空

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)

	myFunction01(a) // 方式一:只能接收没有长度限制的数组
	myFunction02(b) // 方式二:只能接收相同长度和类型的数组
}

// 函数传参
// 方式一:只能接收没有长度限制的数组
func myFunction01(a []int) {

}

// 方式二:只能接收相同长度和类型的数组
func myFunction02(a [5]int) {

}

package main

import "fmt"

/*
定义切片:声明一个未指定大小的数组来定义切片
	var identifier []type // 切片不需要说明长度

或者使用make()函数来创建切片:
	var slicel []type = make([]type, len)
	slicel := make([]type, len)

指定容量:(可以省略不写),要求length <= capacity,符合逻辑
	make([]T, length, capacity)


len()
cap()

append()
copy()
*/

func main(){
	var arr = [] int{1, 3, 4, 5, 3, 2, 7}
	a := arr[1:5]
	b := arr[:5]
	c := arr[1:]
	d := arr[len(arr) - 1:len(arr) - 0]

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)


	var array = make([]int, 5, 7)
	fmt.Println(array)
	fmt.Println("len =", len(array), "\ncap =", cap(array))


	arrayAppend := append(array, 1)
	fmt.Println(arrayAppend)


	arrayCopy := make([]int, 3)
	// 如果len(array_copy) < len(array_append)那么只会复制len(array_copy)个元素
	copy(arrayCopy, arrayAppend)
	fmt.Println(arrayCopy)
}

package main

import	"fmt"

/*
	range关键字用于for循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)
的元素。
	返回值：
		第一个表示下标
		第二个表示值
	如果是map：
		第一个表示key
		第二个表示value

	用 '_'去接收一个变量表示不关心这个变量的值，起到占位的作用，该位置的值会被抛弃掉
*/
func main() {
	a := [] int{1, 2, 4, 5}
	m := map[int]string{1:"hello", 2:"world", 3:"hi"}
	fmt.Println(a)

	for index, num := range a { // 如果不关心下标，可以设置为 '_'
		fmt.Println("index =", index, "num =", num)
	}



	for key, value := range m{
		fmt.Println("key =", key, " value =", value)
	}
}