2基本数据类型（整数，浮点数，复数，布尔值，字符串，常量）

待补充

指针

package main
import "fmt"
/*
改变指针指向的地址
*/
func testPointer(p *int)  {
    *p =2
}
/*
不能改变指针本身
*/
func testPointer1(p *int)  {
    p = nil
}
/*
交换变量值
*/
func swapValue1(a,b *int)  {
    *a,*b = *b,*a
}
func swapValue(a,b int)(int ,int)  {
    return b,a
}
func main() {
    var a = 0
    b := new(int)
    fmt.Println(b)
    testPointer(&a)
    fmt.Println(a)
    fmt.Println(b)
    testPointer1(b)
    fmt.Println(b)
    m,n := 1,2
    swapValue1(&m,&n)
    fmt.Println(m,n)
    fmt.Println(swapValue(m,n))
}

 

数组

package main
/*
数组是具有固定长度，元素数据类型相同的序列。slice的长度是可以改变的，所以更受欢迎

数据元素访问方式与Python的列表一样

len() 计算数组长度

*/
import "fmt"

func main()  {
    var a [3]int  //新的数组中元素初始值为元素类型的零值
    fmt.Println(a[1])
    //打印索引及值
    for i,v:=range a{
        fmt.Printf("%d %d\n",i,v)
    }
    //只打印值
    for _,v:=range a{
        fmt.Printf("%d\n",v)
    }
    //初始化定义一个数组
    var q [3]int = [3]int{1,2,3}
    var r [3]int = [3]int{1,2}    //不够零值补充
    fmt.Println(q)
    fmt.Println(r)

    //数组长度由初始化数组的元素个数决定
    e:=[...]int{4,5,6,7}
    fmt.Println(e)
    //数组长度是数组类型的一部分，下面两种是不容的数组类型，数组的长度必须是常量表达式（也就是这个值在编译时就可以确定）
    fmt.Printf("%T\n",q)  //[3]int
    fmt.Printf("%T\n",e)  //[4]int

    //初始化数组是，可以给通过index:value的形式给对应index的元素一个初始值，不给就是该元素类型的领值
    type Cu int
    const (
        U Cu=iota  // 0
        E     // 1
        G     // 2
        R     // 3
    )
    fmt.Println(U,E,G,R)
    symbol:=[...]string{U:"$",E:"@",G:"#",R:"++"}
    fmt.Println(symbol) //[$ @ # ++]
    fmt.Println(E,symbol[E]) //1 @
    //指定索引对用的值，没有给的是该类型的领值
    s:=[...]int{1:3,2:1,6:6,5:5}
    fmt.Println(s)

    //数组比较： 如果数组里的元素类型是可比较的，数组也可以比较。 == 判断两边数组是否相同（必须两个数组内的元素完全相同）。 ！= 比较两个数组是否不同
    aa:=[2]int{1,2}
    bb:=[...]int{1,2}
    cc:=[2]int{1,3}
    fmt.Println(aa==bb,aa==cc,bb==cc)   //true false false
    dd:=[3]int{1,2}
    fmt.Println(aa == dd)  //类型不同无法比较 invalid operation: aa == dd (mismatched types [2]int and [3]int)

总结：数组是不可变的（无法添加、删除元素）， 且是值引用（可以通过指针引用）
}