GOLANG Delete a slice from Slice of Slice

Question

I want to create function to delete a slice from slice of slice. It should take two inputs: 1. slice of slice (list var) and 2. slice to be deleted (eachsvc) as input. And return updated slice of slice (list var).

I am having issues with this code as it is not working with slice of slice. Any help is appreciated. Thanks.

func truncate_slice(list [][]string, eachsvc []string) [][]string {
    //find index of eachsvc in list
    i := indexOf(eachsvc, list)
    copy(list[i:], list[i+1:]) // Shift a[i+1:] left one index.
    list[len(list)-1] = ""     // Erase last element (write zero value).
    list = list[:len(list)-1]  // Truncate slice.
    return list
}

Func to get index of slice to be deleted from slice of slice

func indexOf(element []string, data [][]string) int {
    for k, v := range data {
        if element == v {
            return k
        }
    }
    return -1 //not found.
}

How do you want to compare slices in indexOf? Do you want to find the slice with the same elements or do you want to find a slice that shares a backing array and length with some other slice? — Charlie Tumahai, Jul 30 '22 at 14:42
Replace `element == v` with code that compares the elements of `element` with the elements of `v`. — Charlie Tumahai, Jul 30 '22 at 14:50
https://stackoverflow.com/a/15312097/5728991 describes how to compare the elements of two slices. — Charlie Tumahai, Jul 30 '22 at 15:01
As for deleting the slice itself, Go has some well-documented "slice tricks" on their GitHub wiki, and here's the same but with nice visualizations, https://ueokande.github.io/go-slice-tricks/. — Zach Young, Jul 31 '22 at 06:08

AminMal · Answer 1 · 2022-07-30T15:11:05.257

Since you want to compare slices based on their elements (as you commented), you will first need to define a function to check equality of 2 given slices. Something like this:

func eq(s1, s2 []string) bool {
    if len(s1) != len(s2) {
        return false
    }
    s2Map := make(map[string]int)
    s1Map := make(map[string]int)
    for _, str := range s2 {
        s2Map[str] += 1
    }
    for _, str := range s1 {
        s1Map[str] += 1
    }
    for key, count := range s1Map {
        if count != s2Map[key] {
            return false
        }
    }
    return true
}

So in this case, ["John", "Doe"] is equal to ["Doe", "John"]. If you also want to check order, I would suggest you to use reflect.DeepEqual(slice1, slice2) instead of implementing one. By the way, using == to compare slices, means if they have the same reference, since slices are views over arrays basically.

Slices cannot be compared with `==` unless comparing to `nil`. — Hymns For Disco, Jul 30 '22 at 16:14

score 0 · Answer 2 · answered Jul 31 '22 at 05:17

As AminMal has said, you can use "reflect.DeepEqual(slice1, slice2)" to compare the slices.

As per documentation:

Slice values are deeply equal when all of the following are true: they are both nil or both non-nil, they have the same length, and either they point to the same initial entry of the same underlying array (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal. Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil)) are not deeply equal.

package main

import (
    "errors"
    "fmt"
    "reflect"
)

func main() {
    sl := [][]string{[]string{"test1"}, []string{"test1", "test2"}, []string{"test3"}}

    truncSlic, err := truncate_slice(sl, []string{"test3"})
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(truncSlic)
}

func indexOf(element []string, data [][]string) int {
    for i, v := range data {
        if reflect.DeepEqual(element, v) { //compare two silces
            return i
        }

    }
    return -1
}

func truncate_slice(list [][]string, eachsvc []string) ([][]string, error) {
    //find index of eachsvc in list
    i := indexOf(eachsvc, list)
    if i == -1 {
        return nil, errors.New("Not Found")
    }
    copy(list[i:], list[i+1:]) // Shift a[i+1:] left one index.
    list[len(list)-1] = nil    // Erase last element (write zero value).
    list = list[:len(list)-1]  // Truncate slice.
    return list, nil
}

Output: [[test1] [test1 test2]]

score 0 · Answer 3 · answered Aug 01 '22 at 09:44

element == v is invalid, because the operator == is not defined on []string, so you should define it:

    func truncate_slice(list [][]string, eachsvc []string) [][]string {
        //find index of eachsvc in list
        i := indexOf(eachsvc, list)
        copy(list[i:], list[i+1:]) // Shift a[i+1:] left one index.
        list[len(list)-1] = nil    // Erase last element (write zero value).
        list = list[:len(list)-1]  // Truncate slice.
        return list
    }        

    func indexOf(element []string, data [][]string) int {
        for k, v := range data {
            if equals(element, v) {
                return k
            }
        }
        return -1 //not found.
    }        

    func equals(l1, l2 []string) bool {
        if len(l1) != len(l2) {
            return false
        }
        for i := 0; i < len(l1); i++ {
            if l1[i] != l2[i] {
                return false
            }
        }
        return true
    }

GOLANG Delete a slice from Slice of Slice

3 Answers3