package main

// 导包
import (
    "fmt"
    "math"
)

// 定义包内部全局变量
// 因为我现在在main这个包下面，相当于就是 我这个变量是这个包内部的全局变量
// 两种方式定义变量
var aa = 3
var ss = "kkk"
var bb = true

var (
    dd = 3
    ff = "kkk"
    tt = true
)


// 定义方法, 空值
func variableZeroValue()  {
    var a int
    var s string

    // go语言不输出 string 空值
    fmt.Println(a,s)
    // 如果希望输出 go 语言的 string 空值
    fmt.Printf("%d %q\n",a,s)

}

// 定义方法，赋初始值
func variableInitialValue(){
    var a, b int = 3, 4
    var s string = "abc"

    fmt.Println(a,b,s)
}

// 定义方法， 省略基本类型
func variableTypeDeduction(){
    // 可以推测自动类型， 就是可以不用写变量的属性
    var a, b =3, 4
    var s = "abc"
    fmt.Println(a, b, s)
}

// 定义方法， 常量
func consts(){
    // 定义常量
    const filename  = "abc.txt"
    const a, b = 3, 4
    var c int
    c = int(math.Sqrt(a*a + b*b))
    fmt.Println(filename, c)
}

func constss(){
    // 定义常量
    const (
        filename  = "abc.txt"
        a, b = 3, 4
    )
    var c int
    c = int(math.Sqrt(a*a + b*b))
    fmt.Println(filename, c)
}

// 定义枚举， go语言中没有枚举关键字， 一般都是用 const 定义的一组变量当做枚举
func enums(){
    //const (
    //  cpp = 0
    //  java = 1
    //  python = 2
    //  golang = 3
    //)

    // iota 表示自增值, 从0开始
    const (
        cpp = iota
        java
        python
        golang
    )

    // iota 可以参与运算，用的好的话，可以当做种子来进行自增值
    const (
        b = 1 << (10 * iota)
        kb
        mb
        gb
        tb
    )
    fmt.Println(cpp, java, python, golang)
    fmt.Println(b, kb, mb, gb, tb)
}


func main() {
    fmt.Println("Hello world")
    variableZeroValue()
    variableInitialValue()
    variableTypeDeduction()
    consts()
    enums()
}