数组
arrays.go
go run arrays.go
package main
import "fmt"
func main() {
/*
go的`数组`,是固定长度
[]创建,[5] 指定数组长度
[5]int -> 创建一个长度为5的数组,元素类型是int型
没有指定数组,使用初始类型值,数组是[0,0,0,0,0]
*/
var a [5]int
fmt.Println("emp:", a)
// 更改index为4的值为100,index从0开始
a[4] = 100
fmt.Println("set:", a)
fmt.Println("get:", a[4])
// len 返回数组长度
fmt.Println("len:", len(a))
/*
创建数组并直接给定初始值
*/
b := [5]int{1, 2, 3, 4, 5}
fmt.Println("dcl:", b)
// 二维数组[2] 创建[a,b]
// [2]type -> type是[3]int
// 创建的数组为 [[0,0,0] [0,0,0]]
var twoD [2][3]int
// 更改数组值
fmt.Println(twoD)
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
切片
Slice 切片是 Go 中一个关键的数据类型
slices.ho
// _Slice_ 是 Go 中一个关键的数据类型,是一个比数组更
// 加强大的序列接口
package main
import "fmt"
func main() {
// 不想数组,slice 的类型仅有它所包含的元素决定(不像
// 数组中还需要元素的个数)。要创建一个长度非零的空
// slice,需要使用内建的方法 `make`。这里我们创建了一
// 个长度为3的 `string` 类型 slice(初始化为零值)。
// 使用make([]string,3)
// 创建长度为3,元素为字符串的切片
// [ ]
s := make([]string, 3)
fmt.Println("emp:", s)
s[0] = "a"
s[1] = "b"
s[2] = "c"
fmt.Println("set:", s)
fmt.Println("get:", s[2])
fmt.Println("len:", len(s))
// 使用内建的append,向切片末端添加值,可以添加多个
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println("apd:", s)
// 创建一个空切片,长度和s相同,然后复制
c := make([]string, len(s))
copy(c, s)
fmt.Println("cpy:", c)
// 还可以进行 `切片`操作
l := s[2:5]
fmt.Println("sl1:", l)
// 0-5 不含s[5]
l = s[:5]
fmt.Println("sl2:", l)
// s[2] 到最后一个
l = s[2:]
fmt.Println("sl3:", l)
// 声明并初始化切边
// 可以不适用make创建,未指定大小的
t := []string{"g", "h", "i"}
fmt.Println("dcl:", t)
// Slice 可以组成多维数据结构。内部的 slice 长度可以不
// 同,这和多位数组不同。
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoD[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}
总结
# 1.使用make,len是初始长度,cap是容量
s :=make([]int,len,cap)
# 2.直接初始化切片
s :=[] int {1,2,3}
# 3.通过对`切片`操作,生产切片
s := arr[:]
s := arr[startIndex:endIndex]
s := arr[startIndex:]
s := arr[:endIndex]
# 4. 通过对切片进行`切片`操作
s1 := s[startIndex:endIndex]
关联数组 map
map 是 Go 内置关联数据类型(在一些其他的语言中称为哈希 或者字典 )。
// map 字典
package main
import "fmt"
func main() {
// make(map[key-type]value-type)
m := make(map[string]int)
// 使用典型的 `make[key] = val` 语法来设置键值对。
m["k1"] = 7
m["k2"] = 13
// 使用例如 `Println` 来打印一个 map 将会输出所有的
// 键值对。
fmt.Println("map:", m)
// 通过key,获取value
v1 := m["k1"]
fmt.Println("v1: ", v1)
// 长度
fmt.Println("len:", len(m))
// 删除key-value
delete(m, "k2")
fmt.Println("map:", m)
// 如果不存在,它也会返回,不过是0,""等初始值,但其实这个key不在map中
val := m["k999"]
fmt.Println("prs:", val)
// 这种情况下,我们可以在增加一个接收值,表示是否在map中,true/false
// 使用_ ,是因为如果定义变量不使用会报错,_就没问题
_,prs := m["k888"]
fmt.Println("prs:", prs)
// 你也可以通过这个语法在同一行申明和初始化一个新的
// map。
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", n)
}
range 遍历
range.go
for index,value := range obj {
}
// _range_ 迭代各种各样的数据结构。让我们来看看如何在我们
// 已经学过的数据结构上使用 `range` 吧。
package main
import "fmt"
func main() {
// 遍历切片
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
fmt.Println("sum:", sum)
// 遍历切片,接收index
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
// 遍历map字典
kvs := map[string]string{"a": "apple", "b": "banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
// 遍历字符串
for i, c := range "go" {
fmt.Println(i, c)
}
}
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111