golang数组和切片作为参数和返回值的实现

目录

• 1. 数组作为参数和返回值时
• 1.1数组的定义
• 1.2数组作为参数和返回值的时候
• 2.切片作为参数和返回值
• 2.1 切片的定义初始化
• 2.2 切片的存储大致分为3部分
• 2.3 切片作为参数和返回值
• 2.4 append 切片动态增长的原理
• 2.5 copy 函数 通过赋值切片可以使得两个切片的数据不共享
• 3. 总结:

1. 数组作为参数和返回值时

1.1数组的定义

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型

var arr [10]int  //定义长度为10的类型是int的数组arr
arr[0] = 1   // 数组的下标从0开始 数组的赋值
var arr1 = [5]int{1,2,3,4,5}  //数组的初始化的定义方式
arr2 := [5]int{1,2,3,4,5} //同上
arr3 := [...]int{1,2,3,4,5} //编译器通过元素个数自动推断数组的长度

1.2数组作为参数和返回值的时候

func GetArray(arr [5]int)(v [5]int){
    fmt.Printf("GetArray arr===%v, %p\n", arr,&arr) // 查看传进来的参数和地址
    arr[1] = 3 //修改其中的一个值
    return arr
}

func main(){
    arr :=[...]int{1,2,3,4,5}  // 定义一个长度为5 类型是int的数组
    fmt.Printf("main arr=%v, %p\n", arr, &arr)
    value := GetArray(arr)
    fmt.Printf("main GetArray value=%v, %p, arr=%v,%p\n", value, &value,arr, &arr)
}

输出结果:
main arr=[1 2 3 4 5], 0xc000012390
GetArray arr===[1 2 3 4 5], 0xc000012420
main GetArray value=[1 3 3 4 5], 0xc0000123f0, arr=[1 2 3 4 5],0xc000012390

从上面的输出结果来看 当使用数组作为参数和返回值的时候，传进去的是值，在函数内部对数组进行修改并不会影响原数据

2.切片作为参数和返回值

2.1 切片的定义初始化

Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

var myslice []int  //定义一个切片 所有的数据类型都是int 切片与数组的定义差别是可以不带长度
var myslice []int = make([]int ,5) //定义一个长度为5的切片 
myslice1 := make([]int,5) //同上 
make([]T, length, capacity) //定义的参数分别是类型，长度，容量(可选)
myslice2 :=[] int {1,2,3 }   //切片初始化
myarr := [...]int{1,2,3,4,5} 
myslice3 := myarr[1:3] //也可以先定义一个数组 然后截取这里是从下标1开始到下标为3(不包含)

ps:当我们通过从数组截取获得切片的时候，我们可以发现截取后的切片和原来的数组是共用数据源的，如果修改原来的数组数据源 那么通过截取数组得到的切片的值也会被修改反之亦然

func main(){
    arr :=[...]int{1,2,3,4,5}  // 定义一个长度为5 类型是int的数组
    myslice1 := arr[0:3] //切片获取下标[0,3)的值
    myslice2 := arr[0:4] //切片获取下标[1,4)的值
    fmt.Printf("myslice1=%v, ppp=%p\n", myslice1, &myslice1)
    fmt.Printf("myslice2=%v, ppp=%p\n", myslice2, &myslice2)
    arr[1] = 666 //修改数组的值
    fmt.Printf("After myslice1=%v, ppp=%p\n", myslice1, &myslice1)
    fmt.Printf("After myslice2=%v, ppp=%p\n", myslice2, &myslice2)
    myslice2[2] =777 //修改切片的值
    fmt.Printf("arr=%v", arr)
}

输出的结果:
myslice1=[1 2 3], ppp=0xc000004078
myslice2=[1 2 3 4], ppp=0xc000004090
After myslice1=[1 666 3], ppp=0xc000004078
After myslice2=[1 666 3 4], ppp=0xc000004090
arr=[1 666 777 4 5]

2.2 切片的存储大致分为3部分

一部分是存的指向匿名数组的指针，一个是长度，一个是容量，我们在定义切片的时候 会在底层保存一个匿名的数组，通过上面的数组得到切片的方式得出的结论 当我们通过一个切片得到另一个切片的时候我们的数据源也是共享的

2.3 切片作为参数和返回值

func GetSlice(myslice []int)(value []int){
    fmt.Printf("GetSlice myslice===%v, ppppp=%p\n", myslice,&myslice) // 查看传进来的参数和地址
    myslice[2] = 10
    return myslice
}

func main(){
    var myslice []int //定义一个空的切片
    myslice = append(myslice, 1)
    myslice = append(myslice, 2)
    myslice = append(myslice, 3)
    myslice = append(myslice, 4)
    myslice = append(myslice, 5) //向切片里面追加元素
    fmt.Printf("myslice ==%v ppp=%p\n", myslice, &myslice)
    rslice := GetSlice(myslice)
    fmt.Printf("rslice==%v ppp=%p, myslice==%v,ppp=%p\n", rslice,&rslice,myslice,&myslice)
}

输出结果:
myslice ==[1 2 3 4 5] ppp=0xc000004078
GetSlice myslice===[1 2 3 4 5], ppppp=0xc0000040c0
rslice==[1 2 10 4 5] ppp=0xc0000040a8, myslice==[1 2 10 4 5],ppp=0xc000004078

结论:从上面的输出的结果和地址来看，当切片作为参数的时候穿进去的是值，也就是值传递，但是当我在函数里面修改切片的时候，我们发现源数据也会被修改，这是因为我们在切片的底层维护这一个匿名的数组，当我们把切片当成参数的时候，会重现创建一个切片，但是创建的这个切片和我们原来的数据是共享数据源的，所以在函数内被修改，源数据也会被修改

2.4 append 切片动态增长的原理

golang提供了append 函数向切片中增加元素，但是切片和数组一样也是有长度的，如果添加的元素个数刚好在长度范围内，就直接在末尾添加元素，但是如果添加的元素的个数超过了长度之后，就需要对底层的数组进行扩容了，这个新的数组的长度是原来的两倍 ，而创建这个新的数组之后我们将新的数组的指针保存到切片数据中，就这样我们实现了切片的动态增长，而当切片作为参数的时候，如果我们在函数里使用append函数增加元素，且元素的个数超过长度的话 在函数中我们就会创建除一个新的切片这个时候我们在函数内对新的切片进行修改 就不会影响到原来的切片了

func GetSlice(myslice []int)(value []int){
    fmt.Printf("GetSlice myslice===%v, ppppp=%p\n", myslice,&myslice) // 查看传进来的参数和地址
    myslice = append(myslice, 6)
    return myslice
}

func main(){
    myslice := make([]int,5)  //定义长度为5 类型是int的切片
    for i:=0; i< len(myslice);i++{
        myslice[i] = i+1
    }
    fmt.Printf("myslice ==%v ppp=%p\n", myslice, &myslice)
    rslice := GetSlice(myslice)
    fmt.Printf("rslice==%v ppp=%p, myslice==%v,ppp=%p\n", rslice,&rslice,myslice,&myslice)
}

输出结果:
myslice ==[1 2 3 4 5] ppp=0xc000004078
GetSlice myslice===[1 2 3 4 5], ppppp=0xc0000040c0
rslice==[1 2 3 4 5 6] ppp=0xc0000040a8, myslice==[1 2 3 4 5],ppp=0xc000004078

2.5 copy 函数 通过赋值切片可以使得两个切片的数据不共享

func main(){
    myslice := make([]int,5)  //定义长度为5 类型是int的切片
    for i:=0; i< len(myslice);i++{
        myslice[i] = i+1
    }
    fmt.Printf("myslice ==%v ppp=%p\n", myslice, &myslice)
    copymyslice := make([]int,5)
    copy(copymyslice, myslice)
    myslice[4] = 10
    fmt.Printf("copymyslice ==%v myslice=%v\n", copymyslice, myslice)
}

输出结果:
myslice ==[1 2 3 4 5] ppp=0xc000004078
copymyslice ==[1 2 3 4 5] myslice=[1 2 3 4 10]

结论:使用copy函数对切片进行赋值的时候可以避免源数据与目标数据共享底层数组

3. 总结:

数组还是切片，在函数中传递的时候如果没有指定为指针传递的话，都是值传递，但是切片在传递的过程中，有着共享底层数组的风险，所以如果在函数内部进行了更改的时候，会修改到源数据，所以我们需要根据不同的需求来处理，如果我们不希望源数据被修改话的我们可以使用copy函数复制切片后再传入，如果希望源数据被修改的话我们应该使用指针传递的方式

到此这篇关于golang数组和切片作为参数和返回值的实现的文章就介绍到这了,更多相关golang数组和切片作为参数和返回值内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！