วิธีการลบองค์ประกอบจาก Slice ใน Golang

fmt.Println("Enter position to delete::")
fmt.Scanln(&pos)

new_arr := make([]int, (len(arr) - 1))
k := 0
for i := 0; i < (len(arr) - 1); {
    if i != pos {
        new_arr[i] = arr[k]
        k++
        i++
    } else {
        k++
    }
}

for i := 0; i < (len(arr) - 1); i++ {
    fmt.Println(new_arr[i])
}

ฉันใช้คำสั่งนี้เพื่อลบองค์ประกอบออกจาก Slice แต่ใช้งานไม่ได้โปรดแนะนำ

เรื่องการสั่งซื้อ

หากคุณต้องการจัดลำดับอาร์เรย์ของคุณคุณต้องเลื่อนองค์ประกอบทั้งหมดทางด้านขวาของดัชนีการลบไปทางซ้ายทีละรายการ หวังว่าสิ่งนี้สามารถทำได้อย่างง่ายดายใน Golang:

func remove(slice []int, s int) []int {
    return append(slice[:s], slice[s+1:]...)
}

อย่างไรก็ตามสิ่งนี้ไม่มีประสิทธิภาพเนื่องจากคุณอาจต้องย้ายองค์ประกอบทั้งหมดซึ่งมีค่าใช้จ่ายสูง

คำสั่งไม่สำคัญ

หากคุณไม่สนใจเกี่ยวกับการสั่งซื้อคุณมีความเป็นไปได้ที่เร็วกว่ามากในการสลับองค์ประกอบเพื่อลบกับองค์ประกอบที่ท้ายชิ้นแล้วส่งคืนองค์ประกอบแรก n-1:

func remove(s []int, i int) []int {
    s[len(s)-1], s[i] = s[i], s[len(s)-1]
    return s[:len(s)-1]
}

ด้วยวิธีการ reslicing การล้างอาร์เรย์ 1,000,000 องค์ประกอบใช้เวลา 224 วินาทีโดยใช้เวลาเพียง 0.06ns ฉันสงสัยว่าภายในเปลี่ยนความยาวของชิ้นส่วนเท่านั้นโดยไม่ต้องแก้ไข

แก้ไข 1

บันทึกย่อตามความคิดเห็นด้านล่าง (ขอบคุณพวกเขา!)

เนื่องจากจุดประสงค์คือเพื่อลบองค์ประกอบเมื่อคำสั่งซื้อไม่สำคัญว่าจำเป็นต้องมีการแลกเปลี่ยนครั้งเดียวสิ่งที่สองจะเสียไป:

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    // We do not need to put s[i] at the end, as it will be discarded anyway
    return s[:len(s)-1]
}

นอกจากนี้คำตอบนี้ไม่ได้ดำเนินการขอบเขตการตรวจสอบ คาดว่าจะมีดัชนีที่ถูกต้องเป็นอินพุต ซึ่งหมายความว่าค่าลบหรือดัชนีที่มากกว่าหรือเท่ากับ len (s) จะทำให้ Go to panic ชิ้นและอาร์เรย์เป็น 0 การจัดทำดัชนีลบ n-TH องค์ประกอบของอาร์เรย์หมายถึงการที่จะให้ข้อมูลn-1 ในการลบองค์ประกอบแรกให้เรียกremove (s, 0)เพื่อลบวินาทีเรียกremove (s, 1)และอื่น ๆ ไปเรื่อย ๆ

ลบองค์ประกอบหนึ่งออกจาก Slice (เรียกว่า 're-slicing'):

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println(all) //[0 1 2 3 4 5 6 7 8 9]
    all = RemoveIndex(all, 5)
    fmt.Println(all) //[0 1 2 3 4 6 7 8 9]
}

จุดรอง (โค้ดกอล์ฟ) แต่ในกรณีที่คำสั่งไม่สำคัญคุณไม่จำเป็นต้องสลับค่า เพียงเขียนทับตำแหน่งอาร์เรย์ที่ถูกลบออกด้วยตำแหน่งสุดท้ายที่ซ้ำกันแล้วส่งคืนอาร์เรย์ที่ถูกตัดทอน

func remove(s []int, i int) []int {
    s[i] = s[len(s)-1]
    return s[:len(s)-1]
}

ผลลัพธ์เดียวกัน

นี่เป็นเรื่องแปลกที่เห็น แต่คำตอบส่วนใหญ่ในที่นี้อันตรายและเป็นการปัดสวะสิ่งที่พวกเขากำลังทำอยู่ เมื่อดูคำถามเดิมที่ถามเกี่ยวกับการลบรายการออกจากสไลซ์จะมีการสร้างสำเนาของชิ้นส่วนและจากนั้นจึงถูกเติมเต็ม สิ่งนี้ช่วยให้มั่นใจได้ว่าเมื่อชิ้นส่วนถูกส่งไปรอบ ๆ โปรแกรมของคุณคุณจะไม่แนะนำจุดบกพร่องที่ละเอียดอ่อน

นี่คือโค้ดบางส่วนที่เปรียบเทียบคำตอบของผู้ใช้ในชุดข้อความนี้และโพสต์ต้นฉบับ ที่นี่คือสนามเด็กเล่นต้องยุ่งกับรหัสนี้

ผนวกการลบตาม

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    return append(s[:index], s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[999 1 2 3 4 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

ในตัวอย่างข้างต้นคุณจะเห็นฉันสร้างชิ้นและเติมด้วยตนเองด้วยตัวเลข 0 ถึง 9 จากนั้นเราจะลบดัชนี 5 ออกจากทั้งหมดและกำหนดให้ลบดัชนี อย่างไรก็ตามเมื่อเราไปพิมพ์ทั้งหมดตอนนี้เราพบว่ามีการแก้ไขเช่นกัน เนื่องจากชิ้นส่วนเป็นตัวชี้ไปยังอาร์เรย์พื้นฐาน เขียนมันออกไปremoveIndexสาเหตุallที่จะแก้ไขเป็นอย่างดีด้วยความแตกต่างที่เป็นอยู่มีความยาวโดยองค์ประกอบหนึ่งที่ไม่สามารถเข้าถึงได้จากall removeIndexต่อไปเราจะเปลี่ยนค่าremoveIndexและเราจะเห็นว่าallได้รับการแก้ไขเช่นกัน มีผลบังคับใช้ในรายละเอียดเพิ่มเติมเกี่ยวกับเรื่องนี้

ตัวอย่างต่อไปนี้ฉันจะไม่เข้าไป แต่มันก็ทำในสิ่งเดียวกันสำหรับวัตถุประสงค์ของเรา และเพียงแค่แสดงให้เห็นว่าการใช้สำเนาไม่แตกต่างกัน

package main

import (
    "fmt"
)

func RemoveCopy(slice []int, i int) []int {
    copy(slice[i:], slice[i+1:])
    return slice[:len(slice)-1]
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeCopy := RemoveCopy(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 6 7 8 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[0 1 2 3 4 6 7 8 9]

    removeCopy[0] = 999
    fmt.Println("all: ", all) //[99 1 2 3 4 6 7 9 9]
    fmt.Println("removeCopy: ", removeCopy) //[999 1 2 3 4 6 7 8 9]
}

คำถามคำตอบเดิม

การดูคำถามเดิมจะไม่แก้ไขชิ้นส่วนที่กำลังลบรายการออก ทำให้คำตอบเดิมในชุดข้อความนี้ดีที่สุดสำหรับคนส่วนใหญ่ที่เข้ามาในหน้านี้

package main

import (
    "fmt"
)

func OriginalRemoveIndex(arr []int, pos int) []int {
    new_arr := make([]int, (len(arr) - 1))
    k := 0
    for i := 0; i < (len(arr) - 1); {
        if i != pos {
            new_arr[i] = arr[k]
            k++
        } else {
            k++
        }
        i++
    }

    return new_arr
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    originalRemove := OriginalRemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[0 1 2 3 4 6 7 8 9]

    originalRemove[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("originalRemove: ", originalRemove) //[999 1 2 3 4 6 7 8 9]
}

ดังที่คุณเห็นผลลัพธ์นี้ทำหน้าที่ตามที่คนส่วนใหญ่คาดหวังและน่าจะเป็นสิ่งที่คนส่วนใหญ่ต้องการ การแก้ไขoriginalRemoveไม่ทำให้เกิดการเปลี่ยนแปลงallและการดำเนินการลบดัชนีและกำหนดก็ไม่ทำให้เกิดการเปลี่ยนแปลงเช่นกัน! สุดยอด!

รหัสนี้มีความยาวเล็กน้อยแม้ว่าข้างต้นจะสามารถเปลี่ยนเป็นรหัสนี้ได้

คำตอบที่ถูกต้อง

package main

import (
    "fmt"
)

func RemoveIndex(s []int, index int) []int {
    ret := make([]int, 0)
    ret = append(ret, s[:index]...)
    return append(ret, s[index+1:]...)
}

func main() {
    all := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    removeIndex := RemoveIndex(all, 5)

    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 8 9]
    fmt.Println("removeIndex: ", removeIndex) //[0 1 2 3 4 6 7 8 9]

    removeIndex[0] = 999
    fmt.Println("all: ", all) //[0 1 2 3 4 5 6 7 9 9]
    fmt.Println("removeIndex: ", removeIndex) //[999 1 2 3 4 6 7 8 9]
}

เกือบจะเหมือนกับโซลูชันลบดัชนีเดิม แต่เราสร้างชิ้นส่วนใหม่เพื่อต่อท้ายก่อนส่งคืน

จากหนังสือThe Go Programming Language

หากต้องการลบองค์ประกอบออกจากตรงกลางของชิ้นโดยรักษาลำดับขององค์ประกอบที่เหลือให้ใช้การคัดลอกเพื่อเลื่อนองค์ประกอบที่มีตัวเลขสูงกว่าลงมาทีละรายการเพื่อเติมช่องว่าง:

func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

นี่คือวิธีการที่คุณลบจากชิ้นวิธีสำนวน คุณไม่จำเป็นต้องสร้างฟังก์ชันที่มีอยู่ในภาคผนวก ลองดูที่นี่https://play.golang.org/p/QMXn9-6gU5P

z := []int{9, 8, 7, 6, 5, 3, 2, 1, 0}
fmt.Println(z)  //will print Answer [9 8 7 6 5 3 2 1 0]

z = append(z[:2], z[4:]...)
fmt.Println(z)   //will print Answer [9 8 5 3 2 1 0]

ฉันใช้วิธีการด้านล่างเพื่อลบรายการออกเป็นชิ้น ๆ สิ่งนี้ช่วยในการอ่านสำหรับผู้อื่น และยังไม่เปลี่ยนรูป

func remove(items []string, item string) []string {
    newitems := []string{}

    for _, i := range items {
        if i != item {
            newitems = append(newitems, i)
        }
    }

    return newitems
}

ค้นหาวิธีที่นี่โดยไม่ต้องย้ายที่อยู่

• เปลี่ยนลำดับ

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
a[i] = a[len(a)-1] // Copy last element to index i.
a[len(a)-1] = ""   // Erase last element (write zero value).
a = a[:len(a)-1]   // Truncate slice.

fmt.Println(a) // [A B E D]

• รักษาระเบียบ

a := []string{"A", "B", "C", "D", "E"}
i := 2

// Remove the element at index i from a.
copy(a[i:], a[i+1:]) // Shift a[i+1:] left one index.
a[len(a)-1] = ""     // Erase last element (write zero value).
a = a[:len(a)-1]     // Truncate slice.

fmt.Println(a) // [A B D E]

วิธีที่ดีที่สุดคือใช้ฟังก์ชันผนวก:

package main

import (
    "fmt"
)

func main() {
    x := []int{4, 5, 6, 7, 88}
    fmt.Println(x)
    x = append(x[:2], x[4:]...)//deletes 6 and 7
    fmt.Println(x)
}

https://play.golang.org/p/-EEFCsqse4u

บางทีคุณอาจลองใช้วิธีนี้:

// DelEleInSlice delete an element from slice by index
//  - arr: the reference of slice
//  - index: the index of element will be deleted
func DelEleInSlice(arr interface{}, index int) {
    vField := reflect.ValueOf(arr)
    value := vField.Elem()
    if value.Kind() == reflect.Slice || value.Kind() == reflect.Array {
        result := reflect.AppendSlice(value.Slice(0, index), value.Slice(index+1, value.Len()))
        value.Set(result)
    }
}

การใช้งาน:

arrInt := []int{0, 1, 2, 3, 4, 5}
arrStr := []string{"0", "1", "2", "3", "4", "5"}
DelEleInSlice(&arrInt, 3)
DelEleInSlice(&arrStr, 4)
fmt.Println(arrInt)
fmt.Println(arrStr)

ผลลัพธ์:

0, 1, 2, 4, 5
"0", "1", "2", "3", "5"

บางทีรหัสนี้อาจช่วยได้

จะลบรายการด้วยดัชนีที่กำหนด

ใช้อาร์เรย์และดัชนีเพื่อลบและส่งคืนอาร์เรย์ใหม่ค่อนข้างเหมือนกับฟังก์ชันผนวก

func deleteItem(arr []int, index int) []int{
  if index < 0 || index >= len(arr){
    return []int{-1}
  }

    for i := index; i < len(arr) -1; i++{
      arr[i] = arr[i + 1]

    }

    return arr[:len(arr)-1]
}

ที่นี่คุณสามารถเล่นด้วยรหัส: https://play.golang.org/p/aX1Qj40uTVs

ไม่จำเป็นต้องตรวจสอบทุกองค์ประกอบเว้นแต่คุณจะใส่ใจเนื้อหาและคุณสามารถใช้การผนวกชิ้นส่วนได้ ลองดู

pos := 0
arr := []int{1, 2, 3, 4, 5, 6, 7, 9}
fmt.Println("input your position")
fmt.Scanln(&pos)
/* you need to check if negative input as well */
if (pos < len(arr)){
    arr = append(arr[:pos], arr[pos+1:]...)
} else {
    fmt.Println("position invalid")
}

หากต้องการลบองค์ประกอบออกจากตรงกลางของชิ้นโดยรักษาลำดับขององค์ประกอบที่เหลือให้ใช้การคัดลอกเพื่อเลื่อนองค์ประกอบที่มีตัวเลขสูงกว่าลงมาทีละรายการเพื่อเติมช่องว่าง:

func remove(slice []int, i int) []int {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

หากไม่จำเป็นต้องรักษาคำสั่งเราก็สามารถย้ายองค์ประกอบสุดท้ายไปที่ช่องว่างได้

func remove(slice []int, i int) []int {
  slice[i] = slice[len(slice)-1]
  return slice[:len(slice)-1]
}

นี่คือตัวอย่างสนามเด็กเล่นที่มีพอยน์เตอร์อยู่ในนั้น https://play.golang.org/p/uNpTKeCt0sH

package main

import (
    "fmt"
)

type t struct {
    a int
    b string
}

func (tt *t) String() string{
    return fmt.Sprintf("[%d %s]", tt.a, tt.b)
}

func remove(slice []*t, i int) []*t {
  copy(slice[i:], slice[i+1:])
  return slice[:len(slice)-1]
}

func main() {
    a := []*t{&t{1, "a"}, &t{2, "b"}, &t{3, "c"}, &t{4, "d"}, &t{5, "e"}, &t{6, "f"}}
    k := a[3]
    a = remove(a, 3)
    fmt.Printf("%v  ||  %v", a, k)
}