牛骨文教育服务平台(让学习变的简单)

分组声明

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
y=%d
z=%d
w=%d
v=%d", x, y, z, w, v)
}

大写字母开头的变量是可导出的,即其他包可以读取,是公用变量

小写字母开头的不可导出,是私有变量

大写字母开头的函数也一样,相当于class中带public关键字词的公有函数

小写字母开头的函数,就是有private关键词的私有函数

array数组

在[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
", arr[0])
	fmt.Printf("This last is %d
", 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

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,new操作

make

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

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

new

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

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

总结:

new 负责分配内存,new(T) 返回*T 指向一个零值 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 ""