// 第一种声明变量方式： 指定变量类型，进行初始化或使用默认值
var boolean1 bool　　     // 声明单个变量
var num1, num2 int 　　  // 声明多个相同类型的变量

​
// 第二种声明变量方式： 
var num3 int = 5
var num3 = 5   　　　　// 系统根据 值 自行判定变量类型


// 第三种声明变量方式： 省略 var，若 := 左侧未声明新的变量，则产生编译错误
str1 := "u_u"
str1, str2, str3 := "-_-", "^_^", "8_8"

// 定义语法：  const name [type] = value

const pi = 3.14159　　　　　　// const 定义常量时，必须要有初始值

const Pi float32 = 3.1415926

const (
    e  = 2.7182818
    pi = 3.1415926
)

// 常量使用关键字 const 定义，用于存储不会改变的数据，常量是在编译时被创建的，即使定义在函数内部也是如此，并且只能是布尔型、数字型（整数型、浮点型和复数）和字符串型。
// 常量的值必须是能够在编译时就能够确定的，可以在其赋值表达式中涉及计算过程，但是所有用于计算的值必须在编译期间就能获得。

// iota关键字通常用来声明enum的时候用，它默认开始值是0，每调用一次+1.

const (
    first = iota
    second
    third
    fourth = "power"
    fifth
    sixth = 22
    seventh
    eighth = iota
    ninth
    tenth
)

// [Output]： 0 1 2 power power 22 22 7 8 9

// if 语句
if condition {　　　　　　　　// condition 为 布尔类型
　　// do something　　 
} 



// if-else 语句
if condition {　　　　　　// if 为真即成立，执行 if代码块；否则执行 else代码块
　　// do something 
} else { 
　　// do something 
} 


// if-else if-else 语句
if condition1 {
    // do something
} else if condition2 {
    // do something else
} else {
    // catch-all or default
}


// if 的特殊姿势
if err := Connect(); err != nil {　　　　　　// Connect() 为带有返回的函数，此条件先获取函数的返回值，再根据这个返回值进行判断
　　fmt.Println(err) 
　　return 
} 


// switch 语句
var a = "hello"
switch a {
case "hello":
    fmt.Println(1)
case "world":
    fmt.Println(2)
default:
    fmt.Println(0)
} 

　// 一分支多值

var a = "mum"
switch a {
case "mum", "daddy":
    fmt.Println("family")
}

// 分支表达式
var r int = 11
switch {
case r > 10 && r < 20:
    fmt.Println(r)
}
注意：
每个 switch 只能有一个 default 分支
  switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。

  switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。

switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough 。


// select 语句
select {
    case communication clause  :
       statement(s);      
    case communication clause  :
       statement(s); 
    // 可以定义任意数量的 case
    default : // 可选 
       statement(s);
}

//  select 随机执行一个可运行的 case。如果没有 case 可运行，它将阻塞，直到有 case 可运行。
每个 case 都必须是一个通信
所有 channel 表达式都会被求值
所有被发送的表达式都会被求值
如果任意某个通信可以进行，它就执行，其他被忽略。
如果有多个 case 都可以运行，Select 会随机公平地选出一个执行。其他不会执行。 
否则：
如果有 default 子句，则执行该语句。
如果没有 default 子句，select 将阻塞，直到某个通信可以运行；Go 不会重新对 channel 或值进行求值。

// for 循环
for index, elem := range nums {
　　// do something
}
 
for {　　　　　　// 死循环
　　// do something 
}


// break & continue 语句 
for _, elem := range nums {
　　switch elem{
　　case "":
　　　　contiue
　　case "bye", "quit":
　　　　break
　　default:
　　　　fmt.Println("Hello World")
　　}　
}

 
// goto 语句： 无条件地转移到代码中 goto语句 指定的标签中 执行标签内代码
func main() {

    for x := 0; x < 10; x++ {

        for y := 0; y < 10; y++ {

            if y == 2 {
                // 跳转到标签
                goto breakHere
            }

        }
    }

    // 手动返回, 避免执行进入标签
    return

    // 标签
breakHere:
    fmt.Println("done")
}

// 声明数组
var ary[2] int

// 数组赋值
ary[0] = 11

// 初始化数组
var balanceSize = [5] float32{100, 2.0, 3.1, 5.5, 6.2}
var balanceSize = [...]float32{100, 2.0, 3.1, 5.5, 6.2}　　// 可省略长度，`...`的方式，会自动根据元素个数来计算长度

// 声明多维数组并赋值
var secondly [2][3] int
for k:=0; k<len(secondly); k++ {
    for m:=0; m<len(secondly[k]); m++ {
        secondly[k][m] = k + m + 100
    }
}

// 初始化多维数组
var secondlyArray = [2][3] int{
    {1, 2, 3},
    {4, 5, 6},
}

// 索引访问数组元素
fmt.Println(balanceSize[0])

// 索引设置数组元素值
balanceSize[0] = 22.2

// 返回数组长度
fmt.Println(len(balanceSize))

// 声明切片： var sliceName []sliceType
var sliceTest [] int        // 第一种方式
sliceTest := make([]string, 3)    // 创建一个长度为3，存储字符串的切片


// 追加元素
sliceTest = append(sliceTest, "power")        
sliceTest = append(sliceTest, "top", "one")


// 取切片
newSlice := sliceTest[:2]    // 取前两个元素
newSlice := sliceTest[:]      // 取所有元素
newSlice := sliceTest[1:5]  // 取索引为1的元素到索引为4的元素


// 同时声明和初始化一个切片
t := []string{"g", "h", "i"}


// 创建二维切片
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
    innerLen := i + 1
    twoD[i] = make([]int, innerLen)
    for j := 0; j < innerLen; j++ {
        twoD[i][j] = i + j
    }
}
fmt.Println("2d: ", twoD)
}


// copy
var nilSlice []int
nilSlice = append(nilSlice, 3, 5, 21, 31, 18)   
copySlice := make([]int, len(nilSlice), (cap(nilSlice))*2)
copy(copySlice, nilSlice)

// 声明 map ：var variable map[keyType]valueType       
var mapVariable map[string]string        // 默认为 map[] nil


// make函数 定义map
mapVariable := make(map[string]string)    


// make 定义并初始化
test := map[string]float32{"a": 1, "b": 2, "c": 3}

// map 是一种引用，两个map指向同一底层，一个修改，另一个也变化
otherTest := test
otherTest["c"] = 6
fmt.Println("modify otherTest: ", otherTest)
fmt.Println("modify test: ", test)

// [Output]：modify otherTest:  map[a:1 b:2 c:6]
// [Output]：modify test:  map[a:1 b:2 c:6]


// 添加键值
mapVariable["s"] = "\u5bb6\u8431"
mapVariable["h"] = "\u99a5\u7504"
mapVariable["e"] = "\u5609\u6866"


// 遍历取出键值
for key, value := range mapVariable{
    fmt.Println(key, value)
}


// 判断是否存在某键
name, ok := mapVariable["s"]        // name：若key存在返回所对应的value，ok：此key是否存在(bool型)


// 删除键值
delete(map_variable1, "she")　　　　// 若key不存在，则忽略


// key 对应 多个 value：切片

　mp1 := make(map[int][]int)

　mp2 := make(map[int]*[]int)

// make & new 的区别

// make
slices := make([]int, 2)
fmt.Println("slices: ", slices)

maps := make(map[int]int)
fmt.Println("maps: ", maps)
// 【Output】：slices:  [0 0]
// 【Output】：maps:  map[]



// 声明结构体
type Info struct {
}


// new
num := new(int)
fmt.Println("num: ", num)

structVariable := new(Info)
fmt.Println("structVariable", structVariable)

//【Output】：num:  0xc00000a120
//【Output】：structVariable &{}




// make & new 区别的实例
type Foo struct {　　　　　　　　// 声明结构体
   weight float64
   age int
}

// 声明
var foo1 Foo
fmt.Println("foo1: ", foo1)
foo1.age = 18
fmt.Println("foo1: ", foo1)

fmt.Println()

// 定义
foo2 := Foo{}
fmt.Println("foo2: ", foo2)
foo2.age = 19
fmt.Println("foo2: ", foo2)

fmt.Println()

// make 只能创建 channel、slice、map

// & 取址
foo3 := &Foo{}
fmt.Println("foo3: ", foo3)
fmt.Println("foo3: ", *foo3)
foo3.age = 20
fmt.Println("foo3: ", foo3)

fmt.Println()

// new
foo4 := new(Foo)
fmt.Println("foo4: ", foo4)
fmt.Println("foo4: ", *foo4)
foo4.age = 21
fmt.Println("foo4: ", foo4)

fmt.Println()

var foo5 *Foo = &Foo{}
fmt.Println("foo5: ", foo5)
fmt.Println("foo5: ", *foo5)
foo5.age = 22
fmt.Println("foo5: ", foo5)


// 以下是输出结果
foo1: {0 0}
foo1: {0 18}

foo2: {0 0}
foo2: {0 19}

foo3: &{0 0}
foo3: {0 0}
foo3: &{0 20}

foo4: &{0 0}
foo4: &{0 21}

foo5: &{0 0}
foo5: &{0 22}




注：foo1 & foo2 为相同的类型，输出的都是 结构体Foo类型的值 ==> {0 0} 由于没有给字段赋值，输出的都是初始值
   foo3 & foo4 & foo5 为相同的类型，输出的都是 结构体Foo类型的内存地址(指针) ==> &{0 0}  只有在前面加了 * 之后才是取到了他的值：*foo3、*foo4、*foo5