Question

如果两个值都不存在，我怎样才能进入数组？这是我的阵列：

[
    { name: "tom", text: "tasty" },
    { name: "tom", text: "tasty" },
    { name: "tom", text: "tasty" },
    { name: "tom", text: "tasty" },
    { name: "tom", text: "tasty" }
]

如果我尝试使用name: "tom"或text: "tasty"再次推入数组，我不希望发生任何事情......但如果这些都不存在，那么我希望它{ {1}}

我该怎么做？

Answer 1

对于一个字符串数组（但不是一个对象数组），您可以通过调用var newItem = "NEW_ITEM_TO_ARRAY"; var array = ["OLD_ITEM_1", "OLD_ITEM_2"]; array.indexOf(newItem) === -1 ? array.push(newItem) : console.log("This item already exists"); console.log(array)检查某个项是否存在，如果它不是推送项目进入数组：

＆＃13;

{% extends 'form_div_layout.html.twig' %}

{% block form_label %}
    <label class="control-label" for="">
        {{ label }}
    </label>

{% endblock %}


{% block form_widget_simple %}
    <div class="form-group">
        {{ form_label(form) }}

        {{ parent() }}
    </div>
{% endblock %}

＆＃13;

Answer 2

您可以使用自定义方法扩展Array原型：

// check if an element exists in array using a comparer function
// comparer : function(currentElement)
Array.prototype.inArray = function(comparer) { 
    for(var i=0; i < this.length; i++) { 
        if(comparer(this[i])) return true; 
    }
    return false; 
}; 

// adds an element to the array if it does not already exist using a comparer 
// function
Array.prototype.pushIfNotExist = function(element, comparer) { 
    if (!this.inArray(comparer)) {
        this.push(element);
    }
}; 

var array = [{ name: "tom", text: "tasty" }];
var element = { name: "tom", text: "tasty" };
array.pushIfNotExist(element, function(e) { 
    return e.name === element.name && e.text === element.text; 
});

Answer 3

使用List函数很容易，它将函数作为参数：

Array.findIndex

Answer 4

http://api.jquery.com/jQuery.unique/

var cleanArray = $.unique(clutteredArray);

你可能也对makeArray感兴趣

前面的例子最好说在推送之前检查它是否存在。事后我看到它也声明你可以将它声明为原型的一部分（我猜这也就是类扩展），所以下面没有大的增强。

除了我不确定indexOf是否是更快的路线然后inArray？可能。

Array.prototype.pushUnique = function (item){
    if(this.indexOf(item) == -1) {
    //if(jQuery.inArray(item, this) == -1) {
        this.push(item);
        return true;
    }
    return false;
}

Answer 5

准确地使用像underscore.js这样的js库。使用：union：计算传入数组的并集：按顺序存在于一个或多个数组中的唯一项列表。

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]

Answer 6

喜欢这个吗？

var item = "Hello World";
var array = [];
if (array.indexOf(item) === -1) array.push(item);

使用对象

var item = {name: "tom", text: "tasty"}
var array = [{}]
if (!array.find(o => o.name === 'tom' && o.text === 'tasty'))
    array.push(item)

Answer 7

简单的代码，如果'indexOf'返回'-1'，则表示元素不在数组内，则条件'=== -1'检索true / false。

'&&'运算符的意思是'and'，因此，如果第一个条件为true，则将其推入数组。

array.indexOf(newItem) === -1 && array.push(newItem);

Answer 8

我知道这是一个非常古老的问题，但如果您使用的是ES6，则可以使用非常小的版本：

[1,2,3].filter(f => f !== 3).concat([3])

非常简单，首先添加一个删除项目的过滤器 - 如果它已经存在，然后通过concat添加它。

这是一个更现实的例子：

const myArray = ['hello', 'world']
const newArrayItem

myArray.filter(f => f !== newArrayItem).concat([newArrayItem])

如果您的数组包含对象，您可以像这样调整过滤器函数：

someArray.filter(f => f.some(s => s.id === myId)).concat([{ id: myId }])

Answer 9

动态推送

var a = [
  {name:"bull", text: "sour"},
  {name: "tom", text: "tasty" },
  {name: "Jerry", text: "tasty" }
]

function addItem(item) {
  var index = a.findIndex(x => x.name == item.name)
  if (index === -1) {
    a.push(item);
  }else {
    console.log("object already exists")
  }
}

var item = {name:"bull", text: "sour"};
addItem(item);

Answer 10

我的选择是使用 .includes() 扩展 Array.prototype，正如@Darrin Dimitrov 建议的那样：

Array.prototype.pushIfNotIncluded = function (element) {
    if (!this.includes(element)) {
      this.push(element);
    }
}

只记得 includes 来自 es6 并且在 IE 上不起作用： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes

Answer 11

不确定速度，但stringification + indexOf是一种简单的方法。首先将数组转换为字符串：

let strMyArray = JSON.stringify(myArray);

然后，对于一系列属性 - 值对，您可以使用：

if (strMyArray.indexOf('"name":"tom"') === -1 && strMyArray.indexOf('"text":"tasty"') === -1) {
   myArray.push({ name: "tom", text: "tasty" });
}

查找整个对象更简单：

if (strMyArray.indexOf(JSON.stringify(objAddMe) === -1) { 
   myArray.push(objAddMe);
}

Answer 12

如果您需要简单的东西而不想扩展Array原型：

// Example array
var array = [{id: 1}, {id: 2}, {id: 3}];

function pushIfNew(obj) {
  for (var i = 0; i < array.length; i++) {
    if (array[i].id === obj.id) { // modify whatever property you need
      return;
    }
  }
  array.push(obj);
}

Answer 13

在你希望通过对象的特定属性进行搜索的情况下，我使用map和reduce来执行此操作，因为直接对象相等通常会失败。

var newItem = {'unique_id': 123};
var searchList = [{'unique_id' : 123}, {'unique_id' : 456}];

hasDuplicate = searchList
   .map(function(e){return e.unique_id== newItem.unique_id})
   .reduce(function(pre, cur) {return pre || cur});

if (hasDuplicate) {
   searchList.push(newItem);
} else {
   console.log("Duplicate Item");
}

Answer 14

如果任何人的要求不那么复杂，这里是我对简单字符串数组的答案的改编：

Array.prototype.pushIfNotExist = function(val) {
    if (typeof(val) == 'undefined' || val == '') { return; }
    val = $.trim(val);
    if ($.inArray(val, this) == -1) {
        this.push(val);
    }
};

更新：用IE8兼容性的jQuery替代方法替换indexOf并修剪

Answer 15

简短示例：

if (typeof(arr[key]) === "undefined") {
  arr.push(key);
}

Answer 16

a是您拥有的对象的数组

a.findIndex(x => x.property=="WhateverPropertyYouWantToMatch") <0 ? 
a.push(objectYouWantToPush) : console.log("response if object exists");

Answer 17

您可以将findIndex方法与回调函数及其“this”参数一起使用。

注意：旧浏览器不知道findIndex，但可以使用polyfill。

示例代码（请注意，在原始问题中，只有当新对象的数据都不在先前推送的对象中时才会被推送）：

var a=[{name:"tom", text:"tasty"}], b;
var magic=function(e) {
    return ((e.name == this.name) || (e.text == this.text));
};

b={name:"tom", text:"tasty"};
if (a.findIndex(magic,b) == -1)
    a.push(b); // nothing done
b={name:"tom", text:"ugly"};
if (a.findIndex(magic,b) == -1)
    a.push(b); // nothing done
b={name:"bob", text:"tasty"};
if (a.findIndex(magic,b) == -1)
    a.push(b); // nothing done
b={name:"bob", text:"ugly"};
if (a.findIndex(magic,b) == -1)
    a.push(b); // b is pushed into a

Answer 18

在推送后删除重复项

如果您已经具有包含重复项的数组，请将对象数组转换为字符串数组，然后使用Set()函数消除重复项：

// Declaring an array of objects containing duplicate objects
let arrayOfObjects = [{name: "tom", text: "tasty"}, {name: "tom", text: "tasty"}];

// Transforming array of objects into array of strings
let arrayOfStrings = arrayOfObjects.map(obj => JSON.stringify(obj));

// Creating a new set, Set() returns unique values by definition
let uniqueSet = new Set(arrayOfStrings);

// Transforming set into array and reversing strings to objects
let uniqueArrayOfObjects = [...uniqueSet].map(elem => JSON.parse(elem));

console.log(uniqueArrayOfObjects);
// [{name: "tom", text: "tasty"}]

推送前检查

如果到目前为止还没有重复项，并且您想在推送新元素之前检查重复项：

// Declaring an array of objects without duplicates
let arrayOfObjects = [{name: "tom", text: "tasty"}];

// Transforming array of objects into array of strings
let arrayOfStrings = arrayOfObjects.map(obj => JSON.stringify(obj));

// Declaring new element as an example
let newElem = {name: "tom", text: "tasty"};

// Stringifying new element
let newElemString = JSON.stringify(newElem);

// At this point, check if the string is duplicated and add it to array
!arrayOfStrings.includes(newElemString) && arrayOfObjects.push(newElem);

console.log(arrayOfObjects);
// [{name: "tom", text: "tasty"}]

Answer 19

我建议您使用Set，

设置仅允许唯一的条目，这将自动解决您的问题。

可以这样声明集合：

const baz = new Set(["Foo","Bar"])

Answer 20

someArray = [{a: 'a1 value', b: {c: "c1 value"},
             {a: 'a2 value', b: {c: "c2 value"}]
newObject = {a: 'a2 value', b: {c: "c2 value"}}

//New object which needs check for duplicity

let isExists = checkForExists(newObject) {
    return someArray.some(function(el) {
        return el.a === newObject.a && el.b.c === newObject.b.c;
    });
}
// write your logic here 
// if isExists is true then already object in an array else you can add

Answer 21

这个问题有点老了，但我的选择：

    let finalTab = [{id: 1, name: 'dupont'}, {id: 2, name: 'tintin'}, {id: 3, name:'toto'}]; // Your array of object you want to populate with distinct data
    const tabToCompare = [{id: 1, name: 'dupont'}, {id: 4, name: 'tata'}]; // A array with 1 new data and 1 is contain into finalTab
    
    finalTab.push(
      ...tabToCompare.filter(
        tabToC => !finalTab.find(
          finalT => finalT.id === tabToC.id)
      )
    ); // Just filter the first array, and check if data into tabToCompare is not into finalTab, finally push the result of the filters

    console.log(finalTab); // Output : [{id: 1, name: 'dupont'}, {id: 2, name: 'tintin'}, {id: 3, name: 'toto'}, {id: 4, name: 'tata'}];

Answer 22

在这里，您可以针对两个数组在一行中完成此操作：

const startArray = [1,2,3,4]
const newArray = [4,5,6]

const result = [...startArray, ...newArray.filter(a => !startArray.includes(a))]

console.log(result);
//Result: [1,2,3,4,5,6]

Answer 23

我想我在这里回答还为时已晚，但这是我最终为我编写的邮件管理器想到的。我需要的全部作品。

o2

Answer 24

这是对象比较的工作函数。在某些情况下，您可能需要比较很多字段。只需循环数组并使用现有项和新项调用此函数。

 var objectsEqual = function (object1, object2) {
        if(!object1 || !object2)
            return false;
        var result = true;
        var arrayObj1 = _.keys(object1);
        var currentKey = "";
        for (var i = 0; i < arrayObj1.length; i++) {
            currentKey = arrayObj1[i];
            if (object1[currentKey] !== null && object2[currentKey] !== null)
                if (!_.has(object2, currentKey) ||
                    !_.isEqual(object1[currentKey].toUpperCase(), object2[currentKey].toUpperCase()))
                    return false;
        }
        return result;
    };

Answer 25

如果没有结果，您可以使用jQuery grep和push：http://api.jquery.com/jQuery.grep/

它与“扩展原型”解决方案基本相同，但没有扩展（或污染）原型。

Answer 26

您可以使用foreach检查数组，然后弹出项目（如果存在），否则添加新项目...

示例newItemValue＆amp; submitFields是键值对

> //submitFields existing array
>      angular.forEach(submitFields, function(item) {
>                   index++; //newItemValue new key,value to check
>                     if (newItemValue == item.value) {
>                       submitFields.splice(index-1,1);
>                         
>                     } });

                submitFields.push({"field":field,"value":value});

如果不存在Array.push（）？

26 个答案:

在推送后删除重复项

推送前检查