声明

var（声明变量）, const（声明常量）, type（声明类型） ,func（声明函数）。

变量

初始化时各个类型有其默认值，例如：

整型和浮点型变量的默认值为0。
字符串变量的默认值为空字符串。
布尔型变量默认为 *false*。
切片、函数、指针变量的默认为 *nil*

语法：var 变量名 (类型) = 值 变量名：=值

变量的类型省略，编译器会根据等号右边的值来推导变量的类型完成初始化。

可批量定义。

var a = float32(e)
var b float = true
c :="hello"
var e, f =  c + "world", 7
var (
        g string
        h int
        m bool
        q float32
    )
var r float64   
 

（字符串是内置类型，可直接通过加号拼接，也能直接用等号比较两个字符串）

常量

常量与变量很相似，但常量在定义的时候必须赋值。没有确定类型，会根据上下文自动确定类型。

 const (
        pi = 3.1415
        e = 2.7182
    )

 const (
        n1 = 100
        n2
        n3
    )

此时n1=n2=n3=100

常量计数器iota（没太搞明白，大概好像就是不太明白）

数组 array

长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型。 感觉go的数组定义和java的有点像

var arr0 [5]int = [5]int{1, 2, 3}

var arr0 [5][3]int//输出[[0 0 0] [0 0 0] [0 0 0] [0 0 0] [0 0 0]] 

c := [5]int{2: 100, 4: 200} //这个通过引号初始化元素输出[0 0 100 0 200]还挺有意思的

切片 slice

由于数组的长度是固定的，所以我们更常用切片。其与数组的不同点是其可以任意修改长度。slice 并不是数组或数组指针。它通过内部指针和相关属性引用数组片段，以实现变长方案。 切片是数组的一个引用（本质了可以说是 ），因此切片是引用类型。但自身是结构体，值拷贝传递。

if  s1 == nil {fmt.Println("是空")
else { fmt.Println("不是空")}//顺便学习一下 go 语言中的 if else 格式跟 c 还是有出入的。

package main
import "fmt"

func main() {
  s := make([]string,2)
  s[0] = "a"
  s[1] = "b"
  s = append(s,"c","e","f")
  fmt.Println("get:",s)  //[a,b,c,d,e]
  fmt.Println(len(s)) //5
  
  c := make([]string,len(s))
  copy(c,s)  //将s中数据拷贝到c中
  fmt.Println(c) //[a,b,c,d,e]

  fmt.Println(s[1:4])  //可理解为前闭后开[b,c,d]

}

map

map是一种无序的基于key-value的数据结构，Go语言中的map是引用类型，必须初始化才能使用。遍历map时的元素顺序与添加键值对的顺序无关。

 map[KeyType]ValueType
 KeyType:表示键的类型。
 ValueType:表示键对应的值的类型。

package main
import "fmt"

func main(){
  m := make(map[key值类型]value值类型)
  m["one"] = 1 // one => 1 
  m["two"] = 1 // two => 1
  m["one"] = 2 // one =>2(代替1)

  fmt.Println(len(m))  //2

  r,ok := m["one"] //判断map中是否含有 key=one的元素
  // 如果key存在ok为true,r为对应的值；不存在ok为false,r为值类型的零值

  fmt.Println(r,ok)  //2 true

  delete(m,"one")//delete(map, key)  
  for k,r := range m{fmt.Println(k, r)}//使用for range遍历map
}