Elimina un elemento da una fetta nel Golang

1. Crea sottosezioni da una determinata fetta
2. Elimina elementi da Slice in Go

In Go, slice è un array di dimensioni variabili che ha l’indicizzazione a partire dall’array ma la sua dimensione non è fissa in quanto può essere ridimensionata. Qualsiasi elemento di uno slice può essere cancellato dallo slice a causa della loro natura dinamica. L’eliminazione di un elemento da una slice è abbastanza diversa dalle altre lingue a causa dell’assenza di funzioni incorporate in Vai per eliminare un elemento da una slice.

Crea sottosezioni da una determinata fetta

Prima di immergerci in profondità nell’eliminazione di un elemento da una slice, daremo un’occhiata alla creazione di una subslice da una data slice poiché è uno dei componenti principali per l’eliminazione di un elemento da slice.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("slice1: %v\n", Slice1)

    Slice2 := Slice1[:2]
    fmt.Printf("slice2: %v\n", Slice2)
}

Produzione:

slice1: [1 2 3 4]
slice2: [1 2]

Qui, slice2 è una sottosezione formata da slice1 che contiene tutti gli elementi dall’inizio cioè dall’indice 0 all’indice 2-1 cioè 1. Nota qui che l’indicizzazione di slice in Go inizia da 0.

package main

import "fmt"

func main() {
    var Slice1 = []int{1, 2, 3, 4}
    fmt.Printf("slice1: %v\n", Slice1)

    Slice2 := Slice1[2:]
    fmt.Printf("slice2: %v\n", Slice2)
}

Produzione:

slice1: [1 2 3 4]
slice2: [3 4]

Qui, slice2 è una sottosezione formata da slice1 che contiene tutti gli elementi dall’indice 2 alla fine della slice.

Elimina elementi da Slice in Go

Il compito di eliminare elementi da slice può essere realizzato in diversi approcci in base alle nostre esigenze. I vari modi per eliminare un elemento da slice sono discussi di seguito:

Quando l’ordine è importante

Se desideriamo mantenere l’ordine delle sezioni dopo aver rimosso l’elemento, spostiamo la posizione di tutti gli elementi a destra degli elementi eliminati verso sinistra di uno.

package main

import "fmt"

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

func main() {
    var Slice1 = []int{1, 2, 3, 4, 5}
    fmt.Printf("slice1: %v\n", Slice1)

    Slice2 := remove(Slice1, 2)
    fmt.Printf("slice2: %v\n", Slice2)
}

Produzione:

slice1: [1 2 3 4 5]
slice2: [1 2 4 5]

Qui slice2 si forma dopo aver rimosso l’elemento all’indice 2 da slice1.

Quando l’ordine non è importante

package main

import "fmt"

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

func main() {
    var Slice1 = []int{1, 2, 3, 4, 5}
    fmt.Printf("slice1: %v\n", Slice1)

    Slice2 := remove(Slice1, 2)
    fmt.Printf("slice2: %v\n", Slice2)
}

Produzione:

slice1: [1 2 3 4 5]
slice2: [1 2 5 4]

Qui slice2 si forma dopo aver rimosso l’elemento all’indice 2 da slice1 ma l’ordine degli elementi non è conservato qui. È più veloce del metodo precedente.

Quindi, quando l’ordine ha una priorità più alta della velocità, usiamo il primo metodo e se la velocità ha una priorità più alta dell’ordine usiamo il secondo metodo per eliminare un elemento da una fetta.