import "fmt"
import "os"

const i = 100
const ii = 3.1415
const iii = "test"

var i int
var ii float64
var iii string

//分组代码如下
import(
    "fmt"
    "os"
)
const(
   i = 1
   ii = 3.1415
   iii = "test"
)
var (
  i int
  ii float64
  iii string
)

iota枚举

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

package main

import "fmt"

const (
	x = iota
	y = iota
	z = iota
	w
)
const v = iota //每遇到const关键字，iota就会重置

func main() {
	fmt.Printf("x=%d\ny=%d\nz=%d\nw=%d\nv=%d", x, y, z, w, v)
}

在[n]array中，

n表示数组的长度

type表示存储元素的类型

var arr [n]array

package main

import "fmt"

func main() {
	var arr [5]int //声明了一个int类型的数值
	arr[0] = 10
	arr[4] = 20

	fmt.Printf("This first is %d\n", arr[0])
	fmt.Printf("This last is %d\n", arr[4])
}

说明：长度也是数组类型的一部分，因此[5]int与[10]int是不同的类型，数组也就不能改变长度。

如果使用指针，就需要用到slice类型

package main

import "fmt"

func main() {
	a := [5]int{1,2,3,4,5} //声明了一个长度为5的int数组
	b := [...]int{7,8,9} //可以省略长度，`...`的方式，会自动根据元素个数来计算长度
        c := [2][4]int{1,2,3,4},{5,6,7,9} //声明了一个二维数组，两个数组作为元素，每个数组中又有4个int类型的元素
}

slice

在初始定义数组时，我们并不知道需要多大的数组，因此我们就需要“动态数组”，这种数据结构叫slice。

slice并不是真正意义上的动态数组，而是一个引用类型。

slice总是指向一个底层array

//声明和array一样，只是少了长度
var a []int

slice通过 array[i:j]来获取，其中i是数组的开始位置,j是结束为止，但不包含array[j]，

//声明一个含有5个元素类型为byte的数组
	test := [5]byte{'a', 'b', 'c', 'd', 'e'}
	//声明两个含有byte的slice
	var a, b []byte
	a = test[1:3] //test[1],test[2]
	b = test[3:5] //test[3],test[4]

1、slice的默认开始位置0，test[:n]等价于test[0:n]

2、slice的第二个序列默认是数组的长度，test[n:] 等价于 test[n:len[test]]

3、如果直接获取slice,可以使用test[:]

map读取和设置也类似slice一样，通过key来操作，只是slice的index只能是int类型，而map多了很多类型，可以是int,string及所有完全定义了 == 与 != 操作的类型。

package main

import "fmt"

func main() {
	//声明一个key是字符串，值为int的字典，这种声明需要在使用之前使用make初始化
	//var numbers map[string]int
	//另一种map的声明方式
	numbers := make(map[string]int)
	numbers["test"] = 1
	numbers["test1"] = 2
	numbers["test2"] = 3
	fmt.Println("test2:", numbers["test2"])
}

map的初始化

可以通过key:val的方式初始化值，同时map内置有判断是否存在key的方式

package main

import "fmt"

func main() {
	//初始化一个字典
	test := map[string]float32{"a": 1, "b": 2, "c": 3}
	//map有两个返回值，第二个返回值,如果不存在key返回flase,如果存在key返回true
	testArr, result := test["a"]
	if result {
		fmt.Println("value:", testArr)
	} else {
		fmt.Println("key不存在")
	}
}

通过delete删除map元素

delete(testArr,"a") //删除key为a的元素

map是一种引用类型

如果两个map同时指向一个底层，那么一个改变，另一个也相应改变

package main

import "fmt"

func main() {
	m := make(map[string]string)
	m["test"] = "test"
	m1 := m
	m1["test"] = "change test" //现在,m["test"]的值也已经是chage test了
	fmt.Printf("改变后的test:%s", m["test"])
}

make用于内建类型(map、slice、channel)的内存分配

make(T,args)与new(T)有着不同的功能，make只能创建slice,map,channel，并且返回一个有初始值(非零)的T类型，而不是*T

new用于各种类型的内存分配【new返回指针】

new(T)分配了零值填充的T类型的内存空间，并且返回其地址，即一个*T类型的值(GO语言的术语：返回了一个指针，指向新分配的类型T的零值)

make 负责初始化值，make(T) 返回初始化后的 T ，而非指针
最重要的一点：make 仅适用于slice，map 和channel

关于“零值”，并非是空值，而是一种“变量未填充前”的默认值，通常为0，如下

int  0
int8 0
int32 0
int64 0
uint 0x0
rune 0 //rune的实际类型是 int32
byte 0x0 //byte的实际类型是uint8
float32 0 //长度为4 byte
float64 0 //长度为8 byte
bool false
string ""

有疑问加站长微信联系（非本文作者）