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小说网

巴特西

go之切片

一、概念

二、切片的声明方式

三、切片的增删改查

四、切片之函数使用

五、切片之拷贝

六、切片之copy

七、注意

最新文章

热门文章