Xóa phần tử trong một lát

func main() {
    a := []string{"Hello1", "Hello2", "Hello3"}
    fmt.Println(a)
    // [Hello1 Hello2 Hello3]
    a = append(a[:0], a[1:]...)
    fmt.Println(a)
    // [Hello2 Hello3]
}

Làm thế nào để xóa thủ thuật với chức năng chắp thêm hoạt động?

Có vẻ như nó lấy tất cả mọi thứ trước phần tử đầu tiên (mảng trống)

Sau đó nối thêm mọi thứ sau phần tử đầu tiên (vị trí 0)

... (chấm chấm chấm) làm gì?

Đâu alà lát cắt và ilà chỉ mục của phần tử bạn muốn xóa:

a = append(a[:i], a[i+1:]...)

... là cú pháp cho các đối số biến đổi trong Go.

Về cơ bản, khi xác định hàm, nó đặt tất cả các đối số mà bạn chuyển vào một lát của kiểu đó. Bằng cách đó, bạn có thể truyền nhiều đối số như bạn muốn (ví dụ: fmt.Printlncó thể lấy bao nhiêu đối số bạn muốn).

Bây giờ, khi gọi một hàm, ...thực hiện ngược lại: nó giải nén một lát và chuyển chúng dưới dạng các đối số riêng biệt cho một hàm matrixdic.

Vì vậy, dòng này làm gì:

a = append(a[:0], a[1:]...)

về cơ bản là:

a = append(a[:0], a[1], a[2])

Bây giờ, bạn có thể tự hỏi, tại sao không làm

a = append(a[1:]...)

Vâng, định nghĩa hàm appendlà

func append(slice []Type, elems ...Type) []Type

Vì vậy, đối số đầu tiên phải là một lát cắt đúng loại, đối số thứ hai là biến thể, vì vậy chúng ta chuyển vào một lát trống và sau đó giải nén phần còn lại của lát cắt để điền vào các đối số.

Có hai lựa chọn:

A: Bạn quan tâm đến việc giữ lại thứ tự mảng:

a = append(a[:i], a[i+1:]...)
// or
a = a[:i+copy(a[i:], a[i+1:])]

B: Bạn không quan tâm đến việc giữ lại trật tự (điều này có thể nhanh hơn):

a[i] = a[len(a)-1] // Replace it with the last one. CAREFUL only works if you have enough elements.
a = a[:len(a)-1]   // Chop off the last one.

Xem liên kết để xem hàm ý rò rỉ bộ nhớ nếu mảng của bạn là con trỏ.

https://github.com/golang/go/wiki/SliceTricks

Thay vì nghĩ các chỉ số trong [a:]-, [:b]- và [a:b]chú thích là chỉ số phần tử, hãy nghĩ về chúng như các chỉ số của khoảng trống xung quanh và giữa các phần tử, bắt đầu bằng khoảng cách được lập chỉ mục 0trước khi phần tử được lập chỉ mục là 0.

Chỉ nhìn vào những con số màu xanh, sẽ dễ dàng hơn nhiều để thấy những gì đang diễn ra: [0:3]bao quanh mọi thứ, [3:3]trống rỗng và [1:2]sẽ mang lại {"B"}. Sau đó, [a:]chỉ là phiên bản ngắn của [a:len(arrayOrSlice)], [:b]phiên bản ngắn [0:b]và [:]phiên bản ngắn của [0:len(arrayOrSlice)]. Cái sau thường được sử dụng để biến một mảng thành một lát khi cần thiết.

... là cú pháp cho các đối số kiểu chữ.

Tôi nghĩ rằng nó được trình biên dịch triển khai bằng cách sử dụng lát cắt ( []Type), giống như chức năng nối thêm:

func append(slice []Type, elems ...Type) []Type

khi bạn sử dụng "elems" trong "append", thực tế nó là một lát (loại []). Vậy " a = append(a[:0], a[1:]...)" có nghĩa là " a = append(a[0:0], a[1:])"

a[0:0] là một lát không có gì

a[1:] là "Hello2 Hello3"

Đây là cách nó hoạt động

Tôi nhận được một chỉ mục nằm ngoài phạm vi lỗi với giải pháp trả lời được chấp nhận. Lý do: Khi phạm vi bắt đầu, nó không lặp lại giá trị từng cái một, nó được lặp theo chỉ số. Nếu bạn sửa đổi một lát trong khi nó nằm trong phạm vi, nó sẽ gây ra một số vấn đề.

Câu trả lời cũ:

chars := []string{"a", "a", "b"}

for i, v := range chars {
    fmt.Printf("%+v, %d, %s\n", chars, i, v)
    if v == "a" {
        chars = append(chars[:i], chars[i+1:]...)
    }
}
fmt.Printf("%+v", chars)

Hy vọng :

[a a b], 0, a
[a b], 0, a
[b], 0, b
Result: [b]

Thực tế:

// Autual
[a a b], 0, a
[a b], 1, b
[a b], 2, b
Result: [a b]

Cách chính xác (Giải pháp):

chars := []string{"a", "a", "b"}

for i := 0; i < len(chars); i++ {
    if chars[i] == "a" {
        chars = append(chars[:i], chars[i+1:]...)
        i-- // form the remove item index to start iterate next item
    }
}

fmt.Printf("%+v", chars)

Nguồn: https://dinolai.com/notes/golang/golang-delete-slice-item-in-range-probols.html

Trong wiki của golang, nó hiển thị một số thủ thuật cho lát, bao gồm xóa một phần tử khỏi lát.

Liên kết: nhập mô tả liên kết tại đây

Ví dụ a là lát mà bạn muốn xóa phần tử số i.

a = append(a[:i], a[i+1:]...)

HOẶC LÀ

a = a[:i+copy(a[i:], a[i+1:])]