Golang nối một vật phẩm vào một lát cắt

Tại sao lát cắt avẫn giữ nguyên? Có append()tạo ra một lát mới không?

package main

import (
    "fmt"
)

var a = make([]int, 7, 8)

func Test(slice []int) {
    slice = append(slice, 100)
    fmt.Println(slice)
}

func main() {
    for i := 0; i < 7; i++ {
        a[i] = i
    }

    Test(a)
    fmt.Println(a)
}

Đầu ra:

[0 1 2 3 4 5 6 100]
[0 1 2 3 4 5 6]

Trong ví dụ của bạn, sliceđối số của Testhàm nhận một bản sao của biến atrong phạm vi của người gọi.

Vì một biến lát cắt chứa một "bộ mô tả lát cắt" chỉ tham chiếu đến một mảng bên dưới, trong Testhàm của bạn, bạn sửa đổi bộ mô tả lát cắt được giữ trong slicebiến vài lần liên tiếp, nhưng điều này không ảnh hưởng đến trình gọi và abiến của nó .

Bên trong Testhàm, hàm đầu tiên appendphân bổ lại mảng hỗ trợ bên dưới slicebiến, sao chép nội dung ban đầu của nó lên, gắn 100vào nó và đó là những gì bạn đang quan sát. Khi thoát khỏi Test, slicebiến sẽ vượt ra khỏi phạm vi và mảng cơ bản (mới) cắt các tham chiếu đó cũng vậy. ( Jeff Lee đã đúng về việc đó không phải là những gì thực sự xảy ra, vì vậy phiên bản cập nhật sẽ theo sau; như anh ấy nói một cách chính xác, câu trả lời này là đúng, nếu có thể hơi ngắn gọn.)

Bên ngoài Testhàm, một lát có độ dài 7 và dung lượng 8 được phân bổ, và 7 phần tử của nó được lấp đầy.
Bên trong Testhàm, đầu tiên appendthấy rằng dung lượng của lát cắt vẫn lớn hơn một phần tử so với chiều dài của nó - nói cách khác, có chỗ cho một phần tử nữa để thêm vào mà không cần phân bổ lại. Vì vậy, nó "ăn" phần tử còn lại đó và đặt 100vào đó, sau đó nó điều chỉnh độ dài trong bản sao của bộ mô tả lát cắt để trở nên bằng với giới hạn của lát cắt. Điều này không ảnh hưởng đến bộ mô tả lát cắt trong phạm vi của trình gọi.

Và đó là những gì bạn đang quan sát. Khi thoát khỏi Test, slicebiến sẽ vượt ra khỏi phạm vi và mảng cơ bản (mới) cắt các tham chiếu đó cũng vậy.

Nếu bạn muốn thực hiện Testhành vi như thế nào append, bạn phải trả lại lát mới từ nó - giống như appendhiện tại - và yêu cầu người gọi Testsử dụng nó theo cách họ sẽ sử dụng append:

func Test(slice []int) []int {
    slice = append(slice, 100)

    fmt.Println(slice)

    return slice
}

a = Test(a)

Vui lòng đọc kỹ bài viết này vì về cơ bản nó chỉ cho bạn cách triển khai appendbằng tay, sau khi giải thích cách các lát cắt hoạt động nội bộ. Sau đó, đọc này .

appendCách sử dụng điển hình là

a = append(a, x)

bởi vì appendcó thể sửa đổi đối số của nó tại chỗ hoặc trả về một bản sao của đối số của nó với một mục nhập bổ sung, tùy thuộc vào kích thước và dung lượng của đầu vào. Sử dụng một phần trước đó đã được thêm vào có thể cho kết quả không mong muốn, ví dụ:

a := []int{1,2,3}
a = append(a, 4)
fmt.Println(a)
append(a[:3], 5)
fmt.Println(a)

có thể in

[1 2 3 4]
[1 2 3 5]

Để làm cho mã của bạn hoạt động mà không cần phải trả lại lát từ Kiểm tra, bạn có thể chuyển một con trỏ như sau:

package main

import (
    "fmt"
)

var a = make([]int, 7, 8)

func Test(slice *[]int) {
    *slice = append(*slice, 100)

    fmt.Println(*slice)
}

func main() {

    for i := 0; i < 7; i++ {
        a[i] = i
    }

    Test(&a)

    fmt.Println(a)
}

LƯU Ý rằng append tạo ra một lát mới nếu không đủ giới hạn . Câu trả lời của @ kostix là đúng, hoặc bạn có thể chuyển đối số lát cắt bằng con trỏ!

Hãy thử điều này, mà tôi nghĩ làm cho nó rõ ràng. mảng bên dưới được thay đổi nhưng lát cắt của chúng tôi thì không, printchỉ in các len()ký tự, bằng một lát cắt khác vào cap(), bạn có thể thấy mảng đã thay đổi:

func main() {

  for i := 0; i < 7; i++ {
      a[i] = i
  }

  Test(a)

  fmt.Println(a) // prints [0..6]
  fmt.Println(a[:cap(a)] // prints [0..6,100]
}

Giải thích (đọc bình luận nội tuyến):

package main

import (
    "fmt"
)

var a = make([]int, 7, 8)
// A slice is a descriptor of an array segment. 
// It consists of a pointer to the array, the length of the segment, and its capacity (the maximum length of the segment).
// The length is the number of elements referred to by the slice.
// The capacity is the number of elements in the underlying array (beginning at the element referred to by the slice pointer).
// |-> Refer to: https://blog.golang.org/go-slices-usage-and-internals -> "Slice internals" section

func Test(slice []int) {
    // slice receives a copy of slice `a` which point to the same array as slice `a`
    slice[6] = 10
    slice = append(slice, 100)
    // since `slice` capacity is 8 & length is 7, it can add 100 and make the length 8
    fmt.Println(slice, len(slice), cap(slice), " << Test 1")
    slice = append(slice, 200)
    // since `slice` capacity is 8 & length also 8, slice has to make a new slice 
    // - with double of size with point to new array (see Reference 1 below).
    // (I'm also confused, why not (n+1)*2=20). But make a new slice of 16 capacity).
    slice[6] = 13 // make sure, it's a new slice :)
    fmt.Println(slice, len(slice), cap(slice), " << Test 2")
}

func main() {
    for i := 0; i < 7; i++ {
        a[i] = i
    }

    fmt.Println(a, len(a), cap(a))
    Test(a)
    fmt.Println(a, len(a), cap(a))
    fmt.Println(a[:cap(a)], len(a), cap(a))
    // fmt.Println(a[:cap(a)+1], len(a), cap(a)) -> this'll not work
}

Đầu ra:

[0 1 2 3 4 5 6] 7 8
[0 1 2 3 4 5 10 100] 8 8  << Test 1
[0 1 2 3 4 5 13 100 200] 9 16  << Test 2
[0 1 2 3 4 5 10] 7 8
[0 1 2 3 4 5 10 100] 7 8

Tham khảo 1: https://blog.golang.org/go-slices-usage-and-internals

func AppendByte(slice []byte, data ...byte) []byte {
    m := len(slice)
    n := m + len(data)
    if n > cap(slice) { // if necessary, reallocate
        // allocate double what's needed, for future growth.
        newSlice := make([]byte, (n+1)*2)
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0:n]
    copy(slice[m:n], data)
    return slice
}

Go có cách tiếp cận nhẹ nhàng và lười biếng hơn trong việc này. Nó tiếp tục sửa đổi cùng một mảng cơ bản cho đến khi đạt đến dung lượng của một lát cắt.

Tham khảo: http://criticalindirection.com/2016/02/17/slice-with-a-pinch-of-salt/

Đầu ra của ví dụ từ liên kết giải thích hành vi của các lát trong Go.

Tạo lát cắt a.

Slice a len=7 cap=7 [0 0 0 0 0 0 0]

Lát b đề cập đến các chỉ số 2, 3, 4 trong lát a. Do đó, công suất là 5 (= 7-2).

b := a[2:5]
Slice b len=3 cap=5 [0 0 0]

Sửa đổi lát b, cũng sửa đổi a, vì chúng đang trỏ đến cùng một mảng cơ bản.

b[0] = 9
Slice a len=7 cap=7 [0 0 9 0 0 0 0]
Slice b len=3 cap=5 [9 0 0]

Thêm 1 vào lát cắt b. Ghi đè a.

Slice a len=7 cap=7 [0 0 9 0 0 1 0]
Slice b len=4 cap=5 [9 0 0 1]

Nối 2 thành lát b. Ghi đè a.

Slice a len=7 cap=7 [0 0 9 0 0 1 2]
Slice b len=5 cap=5 [9 0 0 1 2]

Nối 3 thành lát b. Tại đây, một bản sao mới được tạo ra khi dung lượng bị quá tải.

Slice a len=7 cap=7 [0 0 9 0 0 1 2]
Slice b len=6 cap=12 [9 0 0 1 2 3]

Việc xác minh các lát a và b trỏ đến các mảng bên dưới khác nhau sau khi quá tải dung lượng ở bước trước.

b[1] = 8
Slice a len=7 cap=7 [0 0 9 0 0 1 2]
Slice b len=6 cap=12 [9 8 0 1 2 3]

package main

import (
    "fmt"
)

func a() {
    x := []int{}
    x = append(x, 0)
    x = append(x, 1)  // commonTags := labelsToTags(app.Labels)
    y := append(x, 2) // Tags: append(commonTags, labelsToTags(d.Labels)...)
    z := append(x, 3) // Tags: append(commonTags, labelsToTags(d.Labels)...)
    fmt.Println(y, z)
}

func b() {
    x := []int{}
    x = append(x, 0)
    x = append(x, 1)
    x = append(x, 2)  // commonTags := labelsToTags(app.Labels)
    y := append(x, 3) // Tags: append(commonTags, labelsToTags(d.Labels)...)
    z := append(x, 4) // Tags: append(commonTags, labelsToTags(d.Labels)...)
    fmt.Println(y, z)
}

func main() {
    a()
    b()
}

First guess could be

[0, 1, 2] [0, 1, 3]
[0, 1, 2, 3] [0, 1, 2, 4]

but in fact it results in

[0, 1, 2] [0, 1, 3]
[0, 1, 2, 4] [0, 1, 2, 4]

Thông tin chi tiết xem tại https://allegro.tech/2017/07/golang-slices-gotcha.html

Tôi nghĩ câu trả lời ban đầu là không chính xác. append()đã thay đổi cả lát và mảng bên dưới mặc dù mảng bên dưới bị thay đổi nhưng vẫn được chia sẻ bởi cả hai lát.

Theo quy định của Go Doc:

Một lát cắt không lưu trữ bất kỳ dữ liệu nào, nó chỉ mô tả một phần của một mảng bên dưới. (Liên kết)

Slices chỉ là các giá trị bao bọc xung quanh mảng, có nghĩa là chúng chứa thông tin về cách chúng cắt một mảng bên dưới mà chúng sử dụng để lưu trữ một tập dữ liệu. Do đó, theo mặc định, một lát cắt, khi được truyền cho một phương thức khác, thực sự được truyền theo giá trị, thay vì tham chiếu / con trỏ mặc dù chúng vẫn sẽ sử dụng cùng một mảng cơ bản. Thông thường, các mảng cũng được truyền theo giá trị, vì vậy tôi giả sử một lát cắt trỏ đến một mảng bên dưới thay vì lưu trữ nó dưới dạng giá trị. Về câu hỏi của bạn, khi bạn chạy đã chuyển lát cắt của mình cho hàm sau:

func Test(slice []int) {
    slice = append(slice, 100)
    fmt.Println(slice)
}

bạn thực sự đã chuyển một bản sao của lát cắt của mình cùng với một con trỏ đến cùng một mảng bên dưới. Điều đó có nghĩa là những thay đổi bạn đã thực hiện đối với slicenó không ảnh hưởng đến một trong các mainhàm. Bản thân lát cắt lưu trữ thông tin về số lượng mảng mà nó cắt lát và hiển thị cho công chúng. Do đó, khi bạn chạy append(slice, 1000), trong khi mở rộng mảng bên dưới, bạn cũng thay đổi thông tin cắt lát, thông tin slicenày được giữ kín trongTest() hàm .

Tuy nhiên, nếu bạn đã thay đổi mã của mình như sau, nó có thể đã hoạt động:

func main() {
    for i := 0; i < 7; i++ {
        a[i] = i
    }

    Test(a)
    fmt.Println(a[:cap(a)])
}

Lý do là bạn đã mở rộng abằng cách nói a[:cap(a)]trên mảng cơ bản đã thay đổi của nó, thay đổi theo Test()chức năng. Như được chỉ định ở đây:

Bạn có thể kéo dài chiều dài của lát bằng cách cắt lại, miễn là nó có đủ dung lượng. (Liên kết)

Đây là một triển khai tốt của append cho các lát. Tôi đoán nó tương tự như những gì đang diễn ra dưới mui xe:

package main

import "fmt"

func main() {
    slice1 := []int{0, 1, 2, 3, 4}
    slice2 := []int{55, 66, 77}
    fmt.Println(slice1)
    slice1 = Append(slice1, slice2...) // The '...' is essential!
    fmt.Println(slice1)
}

// Append ...
func Append(slice []int, items ...int) []int {
    for _, item := range items {
        slice = Extend(slice, item)
    }
    return slice
}

// Extend ...
func Extend(slice []int, element int) []int {
    n := len(slice)
    if n == cap(slice) {
        // Slice is full; must grow.
        // We double its size and add 1, so if the size is zero we still grow.
        newSlice := make([]int, len(slice), 2*len(slice)+1)
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0 : n+1]
    slice[n] = element
    return slice
}