2

我正在尝试从我的map[string][]interface{}

我正在使用该strings.Split函数来分隔我希望删除的每个值，然后循环遍历它们。

我已经设法得到它，所以我可以删除索引值 0 和 1，但是，1,2 会删除索引值 1，但索引 2 会出错。

我还设法让它删除一个值

我的想法是，如果我可以让它只删除一个值（我输入的任何索引，包括第一个和最后一个索引），那么我可以使用循环来循环并删除其余的。

一切都存储在下面：

package db

var DataStore map[string][]interface{}

功能

func HandleDelete(w http.ResponseWriter, k, v string) {

它将您希望删除的值作为参数（和键，但功能齐全）

问题所在的代码块

循环从地图切片的末尾开始，因此，例如，当您删除索引值 5 时，4 仍然是 4。而如果我反过来，如果我删除 5，则 6 将变为索引 5。所以 5,6 是删除实际上意味着 5,7 被删除。

for i := len(db.DataStore) - 1; i >= 0; i-- {
        for _, idxvalue := range values {
            val, err := strconv.Atoi(idxvalue)

            if err != nil {
                log.Fatal(err)
                return
            }

            dbval := db.DataStore[k][val]

            if i == val {
                if len(db.DataStore[k])-1 == i { //the length goes 1,2,3,4... the index goes 0,1,2,3 - therefore length -1, would be 3 - deletes the last index value
                    db.DataStore[k] = db.DataStore[k][:i]
                } else { //delete everything else
                    db.DataStore[k] = append(db.DataStore[k][:i], db.DataStore[k][i+1:]...)
                }
                //when you delete the last value in that key, delete the key.
                /*if len(db.DataStore[k]) == 0 {
                    delete(db.DataStore, k)
                }*/
                fmt.Fprintf(w, "Key: %v, Value: %v was deleted successfully", k, dbval)
            }
        }
    }

我已经尝试了两个循环，如下所示：

for i := len(db.DataStore) - 1; i >= 0; i-- {

当然，以下不起作用的原因是因为您在循环之前（在 func 主体中）获得了长度，该长度在每次迭代后都不会改变。

idx := len(db.DataStore) - 1

    for i := idx; i >= 0; i-- {

下面的代码是删除输入的索引（这适用于单个值）

if len(db.DataStore[k])-1 == i { //the length goes 1,2,3,4... the index goes 0,1,2,3 - therefore length -1, would be 3 - deletes the last index value

                    db.DataStore[k] = db.DataStore[k][:i]
                } else { //delete everything else
                    db.DataStore[k] = append(db.DataStore[k][:i], db.DataStore[k][i+1:]...)
                }

我希望'2,1'的输出删除索引1和2，但实际输入是它只是删除索引1。

4

2 回答 2

1

例如，

package main

import "fmt"

// Delete m k v elements indexed by d.
func deleteMKVD(m map[string][]interface{}, k string, d []int) {
    v, ok := m[k]
    if !ok {
        return
    }
    for _, i := range d {
        if 0 <= i && i < len(v) {
            v[i] = nil
        }
    }
    lw := 0
    for i := range v {
        if v[i] != nil {
            lw++
        }
    }
    if lw == 0 {
        delete(m, k)
        return
    }
    w := make([]interface{}, 0, lw)
    for i := range v {
        if v[i] != nil {
            w = append(w, v[i])
        }
    }
    m[k] = w
}

func main() {
    m := map[string][]interface{}{
        "k0": {"v0", "v1", "v2", "v3"},
    }
    fmt.Println(m)
    deleteMKVD(m, "k0", []int{0, 3})
    fmt.Println(m)
    deleteMKVD(m, "k0", []int{1, 0})
    fmt.Println(m)
}

游乐场： https: //play.golang.org/p/biEAxthTaj8

输出：

map[k0:[v0 v1 v2 v3]]
map[k0:[v1 v2]]
map[]
于 2019-03-25T00:39:12.727 回答
-1

我认为您的问题实际上是从具有索引数组的数组中删除元素。
这里的简单解决方法是：
1）找到所有具有特定 k 的索引，使其成为一个数组（vals []int）。
2) 对该数组 int 后代进行排序。并迭代此数组以删除 3）然后迭代此数组以删除元素。

这样，每次你删除一个元素时，它都不会触及其他元素的索引。它可能不是最有效的，但它会是一个快速修复。

顺便说一句，我认为for i := len(db.DataStore) - 1; i >= 0; i--这不是你想要的。
如果我理解正确，这里的代码似乎可以确保 val 是这些索引中最大的索引。因此，您实际上需要 i:=len(db.DataStore[k])-1
而不是 writei:=len(db.DataStore) - 1

于 2019-03-24T21:04:00.280 回答