Javascript 在数组中添加或删除元素

如果数组中不存在对象，我想将其添加到数组中；如果数组中已经存在对象，我想将其删除。 我成功地添加了第一个项，但如果在数组中添加了其他对象，则它不起作用。我可以删除第一项。有一只虫子，我不知道为什么

这是我的密码：

function checkAmi(pseudo, id) {
    var info = ({
        pseudo: pseudo,
        id: id
    });
    if (amisNotifies.length > 0) {
        // iterate over each element in the array
        for (var i = 0; i < amisNotifies.length; i++) {
            console.log(angular.toJson(amisNotifies[i].pseudo));
            // look for the entry with a matching `code` value
            if (amisNotifies[i].pseudo === pseudo) {
                amisNotifies.removeValue('pseudo', pseudo);
                $("#checkAmi" + id).addClass("fa-circle-o");
                $("#checkAmi" + id).removeClass("fa-check-circle-o");
            } else {
                amisNotifies.push(info);
                $("#checkAmi" + id).removeClass("fa-circle-o");
                $("#checkAmi" + id).addClass("fa-check-circle-o");
            }
        }
    } else {
        amisNotifies.push(info);
        $("#checkAmi" + id).removeClass("fa-circle-o");
        $("#checkAmi" + id).addClass("fa-check-circle-o");
    }
}

函数checkAmi（伪，id）{
变量信息=({
伪:伪,，
id:id
});
如果（amisnotifyes.length>0）{
//迭代数组中的每个元素
对于（变量i=0；i

内置的

pop

和

shift

方法从两端移除

如果要删除数组中间的元素，可以使用

---

如何判断元素是否位于数组中取决于“in”的含义

indexOf

相当不错，但有一个极端情况：

[NaN]。indexOf（NaN）

是

-1

，因为

NaN！==NaN

假设您不担心NaN，您可以这样做

function togglePresent(arr, el) {
  var idx = arr.indexOf(el);
  if (idx >= 0) {
    arr.splice(idx, 1);
  } else {
    arr.push(el);
  }
}

如果您愿意，您可以尝试不同的策略，在

isNaN（el）

时重新计算

idx

---

注意：这只删除了

arr

中的

el

的一个实例。您的逻辑似乎不正确-假设您在aminitifes中有两个项，并且您希望添加第三个新值-在for循环第一次运行时（i=0），它将添加项（pseudo），第二次（i=1），它将删除添加的项（pseudo）最终，新项目将不会被添加，您应该根据amiNotifies中的存在，重新修改添加和删除的逻辑

---

您可能还应该使用拼接操作来删除amintifies中的值。

您只是将每个项目与伪进行比较，从而错误地检查了重复项。您需要遍历所有项目，查看是否匹配任何项目，然后根据匹配执行添加/删除。以下代码适用于您

function checkAmi(pseudo, id) {
    var info = ({
        pseudo: pseudo,
        id: id
    });
    var getIndexOf = function (psdu) {
        for (var i = 0; i < amisNotifies.length; i++) {
            if (amisNotifies[i].pseudo === psdu) {
                return i;
            }
        }

        return -1;
    };

    if (amisNotifies.length > 0) {
        var index = getIndexOf(pseudo);
        if (index > -1) {
            //so already exists. now remove it.
            Array.prototype.splice.call(amisNotifies, index, 1);
            $("#checkAmi" + id).addClass("fa-circle-o");
            $("#checkAmi" + id).removeClass("fa-check-circle-o");
        }
        else {
            //does not exist, now add it
            amisNotifies.push(info);
            $("#checkAmi" + id).removeClass("fa-circle-o");
            $("#checkAmi" + id).addClass("fa-check-circle-o");
        }

    } else {
        amisNotifies.push(info);
        $("#checkAmi" + id).removeClass("fa-circle-o");
        $("#checkAmi" + id).addClass("fa-check-circle-o");
    }
}

函数checkAmi（伪，id）{
变量信息=({
伪:伪,，
id:id
});
var getIndexOf=函数（psdu）{
对于（变量i=0；i0）{
var指数=getIndexOf（伪）；
如果（索引>-1）{
//所以已经存在。现在删除它。
Array.prototype.splice.call（amisnotifys，index，1）；
$（“#checkAmi”+id）.addClass（“fa-circle-o”）；
$（“#checkAmi”+id）.removeClass（“fa-check-circle-o”）；
}
否则{
//不存在，现在添加它
amisnotifys.push（信息）；
$（“#checkAmi”+id）；
$（“#checkAmi”+id）.addClass（“fa-check-circle-o”）；
}
}否则{
amisnotifys.push（信息）；
$（“#checkAmi”+id）；
$（“#checkAmi”+id）.addClass（“fa-check-circle-o”）；
}
}

您可以这样做

const addOrRemove = (array, item) => {
  const exists = array.includes(item)

  if (exists) {
    return array.filter((c) => { return c !== item })
  } else {
    const result = array
    result.push(item)
    return result
  }
}

---

这是我用的。Typescript，但在JS中使用的strip类型暗示

export function addOrRemove<T>(source: T[], candidate: T, comparator?: (a: T, b: T) => boolean): T[] {
  const c = comparator || ((a, b) => a == b)
  const e = source.find(i => c(i, candidate))
  return e ? source.filter(i => !c(i, candidate)) : [...source, candidate]
}

导出函数addOrRemove（源：T[]，候选：T，comparator？：（a:T，b:T）=>布尔值）：T[]{ 常数c=比较器| |（（a，b）=>a==b） const e=source.find（i=>c（i，候选者）） 返回e？source.filter（i=>！c（i，候选者））：[…源，候选者] } 它将不可变地切换数组元素（如果存在则删除，如果不存在则添加）。作为最后一个参数的可选比较器函数可用于比较非标量值，例如对象。

TESTED

这是另一个简单的解决方案：

var newItem = "NEW_ITEM_TO_ARRAY";
var array = ["OLD_ITEM_1", "OLD_ITEM_2"];
array.indexOf(newItem) === -1 ? array.push(newItem) : array.splice(array.indexOf(newItem), 1);

console.log(array)

如果找不到indexOf，它将返回-1，这意味着如果它不存在，您将添加。。有关更多信息：

否则，如果找到它，意味着它存在，您将使用splice删除它，第一个参数是索引，第二个参数是要删除的元素数：有关详细信息：

---

在一个vue-3项目中，我做了以下工作：

<script>
import { defineComponent, ref } from 'vue';

export default defineComponent({
  setup() {
    const itemsSelected = ref([]);

    const addOrRemoveItem = (itemId) => {
      const exists = itemsSelected.value.includes(itemId);

      if (exists) {
        itemsSelected.value = itemsSelected.value.filter((id) => id !== itemId);
      } else {
        itemsSelected.value.push(itemId);
      }
    };

    return { addOrRemoveItem };
  },
});
</script>

从“vue”导入{defineComponent，ref}；
导出默认定义组件({
设置（）{
const itemsSelected=ref（[]）；
const addorremovietem=（itemId）=>{
const exists=itemsSelected.value.includes（itemId）；
如果（存在）{
itemsSelected.value=itemsSelected.value.filter（（id）=>id！==itemId）；
}否则{
itemsSelected.value.push（itemId）；
}
};
返回{addorremovietem}；
},
});

什么是

amisnotifys

？什么是

removeValue

？amisnotifys=[]；removeValue是一个删除对象值的函数。在标准JS数组中没有名为

removeValue

的函数。我制作了它，我说它在主题中有效，我成功地添加了第一个并删除了它。如果您请求帮助，但没有显示所有相关代码，那么就不可能帮助您。但是我使用console.log来测试它，它一直持续到推环的时候。它没有推动新的发展info@guillaumekotarba，你是如何记录的？当您将对象传递给

console.log

而不是字符串时，可能会延迟将其转换为字符串，这意味着lo

<script>
import { defineComponent, ref } from 'vue';

export default defineComponent({
  setup() {
    const itemsSelected = ref([]);

    const addOrRemoveItem = (itemId) => {
      const exists = itemsSelected.value.includes(itemId);

      if (exists) {
        itemsSelected.value = itemsSelected.value.filter((id) => id !== itemId);
      } else {
        itemsSelected.value.push(itemId);
      }
    };

    return { addOrRemoveItem };
  },
});
</script>