go之切片

一、概念

• 关于切片

1、切片是对数组一个连续片段的引用，所以切片是一个引用类型
2、切片是数组一样可以索引，可以通过len函数获取切片的数据长度。（数组也可以通过len获取）
3、切片是一个长度可变的数组
4、切片有容量的概念，这是数组所没有的，go 提供了计算容量的函数cap(),可以计算切片容量。0 <=len(s) <=cap(s)

优点：
    因为切片是引用，所以它不需要额外的内存并且比使用数组更有效率，所以在go代码中切片比数组更常用

• 定义

# 方式一
var slice []type
slice = make([]type,slice_len)
// 如:
//     var s []int
//     s = make([]int,0)

# 方式二
slice := make([]type,slice_len)
// 如:
//     s := make([]int,0) 

# 方式三
slice := []type{}
// 如
//   s := []int{1,2,3}

二、切片的声明方式

• 切片的声明与内存创建

package main

import "fmt"

func main(){
	var slice []string
	// make(类型，长度，容量。。。)
	slice = make([]string,3)  // make 内存创建，只用于 切片，map,chan类型

	slice[0] = "j"
	slice[1] = "m"
	slice[2] = "z"
	fmt.Println(slice)

}

• 关于make

1、引用类型 可以理解为指针，声明引用类型并不会并不会分配内存。
2、与值类型不同，值类型的变量在声明时会分配内存并存储初始值
3、make 就是用于对引用类型分配内存使用的，并返回类型本身
4、目前make函数只用于 切片，map和chan

三、切片的增删改查

package main

import "fmt"

func main(){
	var slice []string
	// make(类型，长度，容量。。。)
	slice = make([]string,0)  // make 内存创建，只用于 切片，map,chan类型

	// 增
	slice = append(slice,"j")
	slice = append(slice,"m","z")
	arr := []string{"j","l","y"}  // 简短声明切片
	slice = append(slice, arr...) // 将切片打撒
	fmt.Println(slice) // [j m z j l y]

	// 改
	// 重新赋值即为改
	slice[0] = "j1"
	slice[1] = "m2"
	slice[2] = "z3"
	fmt.Println(slice) // [j1 m2 z3 j l y]

	// 查
	fmt.Println(slice[3])  // j
	fmt.Println(slice[2:4])  // 输入下标2～4直接的数据，包头不包尾，不包含下标4   // [z3 j]
	fmt.Println(slice[3:])  // 输出下标3之后的所有数据，包含下标3				// [j l y]
	fmt.Println(slice[:3]) // 输出 下标3之前的所有数据，不包含下标3              // [j1 m2 z3]
	for index,v := range slice{
		fmt.Printf("slice[%d]=%v\n",index,v)
	}
	/*
	slice[0]=j1
	slice[1]=m2
	slice[2]=z3
	slice[3]=j
	slice[4]=l
	slice[5]=y
	 */

	// 删
	// go 的切片删除是通过append 来实现的
	slice1 := []string{}
	// 删除slice[3]的数据
	slice1 = append(slice1,slice[:3]...)   // 包头不包尾，不包含下标3的
	slice1 = append(slice1,slice[4:]...)

	fmt.Println(slice1) //[j1 m2 z3 l y]
	}

四、切片之函数使用

• 引用类型之切片函数使用

package main

import "fmt"

func main() {
	var slice []int
	// make(类型，长度，容量。。。)
	slice = make([]int, 3) // make 内存创建，只用于 切片，map,chan类型

	fmt.Println(slice) // [0,0,0]

	slice = append(slice, 4)
	fmt.Println(slice) // [0,0,0,4]

	saveSlice(slice)
	fmt.Println(slice)
}

func saveSlice(s []int){
	s[0] = 111
}

[0 0 0]
[0 0 0 4]
[111 0 0 4]

• 为什么函数没有返回值，却改变类切片的值

切片是引用类型，你可以理解为指针
切片在传参的过程不是值拷贝的过程
切片传参实际传的是引用

五、切片之拷贝

• 引用的复制

package main

import "fmt"

func main() {
	s := []int{1,2,3,4}

	var s1 []int
	s1 = make([]int,len(s))
	s1 = s  // 将 s 复制给 s1

	/*
	s1 := s  // 与上面是一样的效果
	 */

	s[0] = 111
	fmt.Println(s1)
}

• 为什么切片s的修改，s1 也发生类变化

1、切片其实本质还是对数组的引用
2、赋值操作其实还是对引用的拷贝

简单点：s1 只是对s引用的拷贝，不是值的拷贝

• 值的拷贝一

package main

import "fmt"

func main() {
	s := []int{1,2,3,4}

	var s1 []int
	s1 = make([]int,len(s))
	for index := range s{
		s1[index] = s[index]
	}
	s[0] = 1111
	fmt.Println(s1)
}

• 值的拷贝二

package main

import "fmt"

func main() {
	s := []int{1,2,3,4}

	var s1 []int
	s1 = make([]int,0)
	s1 = append(s1,s...)

	s[0] = 111
	fmt.Println(s1)
}

六、切片之copy

• go 内部函数copy

package main

import "fmt"

func main() {
	s := []int{1,2,3,4}

	s1 := make([]int,len(s))

	copy(s1,s)
	s[0] = 111
	fmt.Println(s1)

}

输出结果
[1 2 3 4]

七、注意

切片的简短声明方式
s := []int{}  // var s []int;s = make([]int,0)   一样的

如果喜欢看小说，请到183小说网