var a int
var b string
var c float64
var d [5] int  //数组
var e [] int   //数组切片
var f * int    //正确
var v1 int = 5 //正确
var v2 = 5     //正确，编译器自动推导出V2类型
v3 := 5        //正确，编译器自动推导出V3的类型
// 多重赋值
i := 2
j := 3
i, j = j, i  //交换i和j的值，此时i == 3，j == 2

const limit = 512
const top uint16 = 1421
const Pi float64 = 3.1415926
const x,y int = 1,3 //多重赋值

const (
    Cyan = 0
    Black = 1
    White = 2
)

// iota是一个可以被编译器修改的常量，在const关键字出现时被重置为 0，在下一个 const 出现之前，每出现一次 iota,其所代表的数字自动加 1
const (
    a = iota  //a == 0
    b = iota  //b ==1
    c = iota  //c == 2
)

const d = iota //d==0,因为const的出现，iota被重置为0

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    a := 12
    fmt.Println("length of a: ", unsafe.Sizeof(a))
    var b int = 12
    fmt.Println("length of b(int): ", unsafe.Sizeof(b))
    var c int8 = 12
    fmt.Println("length of c(int8): ", unsafe.Sizeof(c))
    var d int16 = 12
    fmt.Println("length of d(int16): ", unsafe.Sizeof(d))
    var e int32 = 12
    fmt.Println("length of e(int32): ", unsafe.Sizeof(e))
    var f int64 = 12
    fmt.Println("length of f(int64): ", unsafe.Sizeof(f))
}

var a bool
a = true
b := (2 == 3) //b也会被推导为bool类型

//错误示范  布尔类型不能接受其他类型的赋值，不支持自动或强制的类型转换
var b bool
b = 1 //编译错误
b = bool(1) //编译错误

//[length]Type
arr1 := [3]int
//[N]Type{value1, value2, ..., valueN}
arr2 := [5]string{"a","b","c","d","e"}
// 如果使用了...（省略符）操作符，Go 语言会为我们自动计算数组的长度
//[...]Type{value1, value2, ..., valueN}
arr2 := [...]float64{2.23,2.24,2.25}

// make([ ]Type, length, capacity)
// length 指的是为这个类型分配多少个元素，capacity 为预分配的元素数量，这个值设定后不影响 length，只是能提前分配空间，降低多次分配空间造成的性能问题。
s1 := make([]int,5,3)
// make([ ]Type, length)
s2 := make([]string,2)
// [ ]Type{}
s3 := []float32{}
// [ ]Type{value1, value2, ..., valueN}
s4 := []float32{2.1,2.2}

t1 := "\"hello\""             //内容： "hello"
t2 := `"hello"`               //内容：和t1一致
t3 := "\u6B22\u8FCE"          //内容：欢迎

// 大段文字
t4 := `
这事一个段落
这事一个段落
这事一个段落
`

package main
import "fmt"
func main() {

    var mapLit map[string]int
    var mapAssigned map[string]int
    mapLit = map[string]int{"one": 1, "two": 2}

    mapCreated := make(map[string]float32)
    mapAssigned = mapLit
    mapCreated["key1"] = 4.5
    mapCreated["key2"] = 3.14159
    mapAssigned["two"] = 3
    fmt.Printf("Map literal at \"one\" is: %d\n", mapLit["one"])
    fmt.Printf("Map created at \"key2\" is: %f\n", mapCreated["key2"])
    fmt.Printf("Map assigned at \"two\" is: %d\n", mapLit["two"])
    fmt.Printf("Map literal at \"ten\" is: %d\n", mapLit["ten"])
}