检查对象值是否存在于Javascript对象数组中，如果不存在，则添加一个新对象到数组中

小开

检查现有的用户名相当简单:

var arr = [{ id: 1, username: 'fred' },
{ id: 2, username: 'bill'},
{ id: 3, username: 'ted' }];


function userExists(username) {
return arr.some(function(el) {
return el.username === username;
});
}


console.log(userExists('fred')); // true
console.log(userExists('bred')); // false

但是当你必须向这个数组中添加一个新用户时，要做什么就不那么明显了。最简单的方法-只是推入一个新元素，其id等于array.length + 1:

function addUser(username) {
if (userExists(username)) {
return false;
}
arr.push({ id: arr.length + 1, username: username });
return true;
}


addUser('fred'); // false
addUser('bred'); // true, user `bred` added

它将保证id的唯一性，但如果将一些元素从数组末尾删除，则会使该数组看起来有点奇怪。

小开

最佳答案

我假设__abc0在这里是唯一的。some是一个很棒的函数，用于检查数组中是否存在对象:

const arr = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];


function add(arr, name) {
const { length } = arr;
const id = length + 1;
const found = arr.some(el => el.username === name);
if (!found) arr.push({ id, username: name });
return arr;
}


console.log(add(arr, 'ted'));

小开

我喜欢Andy的回答，但是id不一定是唯一的，所以这里是我想出的创建唯一id的方法。也可以在jsfiddle检查。请注意，如果之前已经删除了任何内容，arr.length + 1很可能不能保证唯一的ID。

var array = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' } ];
var usedname = 'bill';
var newname = 'sam';


// don't add used name
console.log('before usedname: ' + JSON.stringify(array));
tryAdd(usedname, array);
console.log('before newname: ' + JSON.stringify(array));
tryAdd(newname, array);
console.log('after newname: ' + JSON.stringify(array));


function tryAdd(name, array) {
var found = false;
var i = 0;
var maxId = 1;
for (i in array) {
// Check max id
if (maxId <= array[i].id)
maxId = array[i].id + 1;


// Don't need to add if we find it
if (array[i].username === name)
found = true;
}


if (!found)
array[++i] = { id: maxId, username: name };
}

小开

你可以建立你的数组原型，使它更模块化，尝试这样的东西

    Array.prototype.hasElement = function(element) {
var i;
for (i = 0; i < this.length; i++) {
if (this[i] === element) {
return i; //Returns element position, so it exists
}
}


return -1; //The element isn't in your array
};

你可以这样使用它:

 yourArray.hasElement(yourArrayElement)

小开

我认为，这是解决这个问题的最短方法。这里我使用ES6的箭头函数和.filter来检查新添加的用户名是否存在。

var arr = [{
id: 1,
username: 'fred'
}, {
id: 2,
username: 'bill'
}, {
id: 3,
username: 'ted'
}];


function add(name) {
var id = arr.length + 1;
if (arr.filter(item=> item.username == name).length == 0){
arr.push({ id: id, username: name });
}
}


add('ted');
console.log(arr);

Link to Fiddle . Link to Fiddle

小开

数组的本地函数有时比普通循环慢3 - 5倍。另外，本地函数在所有浏览器中都不能工作，所以存在兼容性问题。

我的代码:

<script>
var obj = [];


function checkName(name) {
// declarations
var flag = 0;
var len = obj.length;
var i = 0;
var id = 1;


// looping array
for (i; i < len; i++) {
// if name matches
if (name == obj[i]['username']) {
flag = 1;
break;
} else {
// increment the id by 1
id = id + 1;
}
}


// if flag = 1 then name exits else push in array
if (flag == 0) {
// new entry push in array
obj.push({'id':id, 'username': name});
}
}
// function end


checkName('abc');
</script>

这样你可以更快地达到目的。

注意:我没有检查传递的参数是否为空，如果你想，你可以对它进行检查或写一个正则表达式进行特定的验证。

小开

这个小片段对我有用。

const arrayOfObject = [{ id: 1, name: 'john' }, {id: 2, name: 'max'}];


const checkUsername = obj => obj.name === 'max';


console.log(arrayOfObject.some(checkUsername))

如果你有一个像['john','marsh']这样的元素数组，那么我们可以做这样的事情

const checkUsername = element => element == 'john';
    

console.log(arrayOfObject.some(checkUsername))

小开

接受的答案也可以这样写，在。some上使用箭头函数

 function checkAndAdd(name) {
var id = arr.length + 1;
var found = arr.some((el) => {
return el.username === name;
});
if (!found) { arr.push({ id: id, username: name }); }
}

小开

Lodash中的xorWith可以用来实现这一点

let objects = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]
let existingObject = { id: 1, username: 'fred' };
let newObject = { id: 1729, username: 'Ramanujan' }


_.xorWith(objects, [existingObject], _.isEqual)
// returns [ { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]


_.xorWith(objects, [newObject], _.isEqual)
// returns [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ,{ id: 1729, username: 'Ramanujan' } ]

小开

点击这里查看:

https://stackoverflow.com/a/53644664/1084987 < a href = " https://stackoverflow.com/a/53644664/1084987 " > < / >

你可以在后面创建if条件，比如

if(!contains(array, obj)) add();

小开

function number_present_or_not() {
var arr = [2, 5, 9, 67, 78, 8, 454, 4, 6, 79, 64, 688];
var found = 6;
var found_two;
for (i = 0; i < arr.length; i++) {
if (found == arr[i]) {
found_two = arr[i];
break;
}
}
if (found_two == found) {
console.log('number present in the array');
} else {
console.log('number not present in the array');
}
}

小开

这是我在@sagar-gavhane的答案之外所做的

const newUser = {_id: 4, name: 'Adam'}
const users = [{_id: 1, name: 'Fred'}, {_id: 2, name: 'Ted'}, {_id: 3, name:'Bill'}]


const userExists = users.some(user => user.name === newUser.name);
if(userExists) {
return new Error({error:'User exists'})
}
users.push(newUser)

小开

出于某种原因，我确实尝试了上述步骤，但对我来说似乎并不管用，但这是我对自己问题的最终解决方案，可能对阅读本文的任何人都有帮助:

let pst = post.likes.some( (like) => {  //console.log(like.user, req.user.id);
if(like.user.toString() === req.user.id.toString()){
return true
} } )

这帖子。点赞是喜欢某篇文章的用户的数组。

小开

试试这个

第一种方法使用一些

  let arr = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
let found = arr.some(ele => ele.username === 'bill');
console.log(found)

第二种方法使用包括、映射

   let arr = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
let mapped = arr.map(ele => ele.username);
let found = mapped.includes('bill');
console.log(found)

小开

假设我们有一个对象数组，你想检查value of name是否像这样定义，

let persons = [ {"name" : "test1"},{"name": "test2"}];


if(persons.some(person => person.name == 'test1')) {
... here your code in case person.name is defined and available
}

小开

下面是一个ES6方法链，使用.map()和.includes():

const arr = [ { id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' } ]


const checkForUser = (newUsername) => {
arr.map(user => {
return user.username
}).includes(newUsername)
}


if (!checkForUser('fred')){
// add fred
}

映射现有用户以创建用户名字符串数组。
检查该用户名数组是否包含新用户名
如果不存在，则添加新用户

小开

你也可以试试这个

 const addUser = (name) => {
if (arr.filter(a => a.name == name).length <= 0)
arr.push({
id: arr.length + 1,
name: name
})
}
addUser('Fred')

小开

可以有多种可能的方法来检查元素是否在你的case它的Object)是否存在于数组中

const arr = [
{ id: 1, username: 'fred' },
{ id: 2, username: 'bill' },
{ id: 3, username: 'ted' },
];

假设你想找一个id = 3的对象。

<强> 1。发现: 它在数组中搜索一个元素，如果找到了，就返回该元素，否则返回undefined。它返回所提供数组中满足所提供测试函数的第一个元素的值。参考 < / p >

const ObjIdToFind = 5;
const isObjectPresent = arr.find((o) => o.id === ObjIdToFind);
if (!isObjectPresent) {            // As find return object else undefined
arr.push({ id: arr.length + 1, username: 'Lorem ipsum' });
}

<强> 2。过滤器: 它搜索数组中的元素，并过滤掉所有符合条件的元素。它返回一个包含所有元素的新数组，如果没有符合条件，则返回空数组。参考 < / p >

const ObjIdToFind = 5;
const arrayWithFilterObjects= arr.filter((o) => o.id === ObjIdToFind);
if (!arrayWithFilterObjects.length) {       // As filter return new array
arr.push({ id: arr.length + 1, username: 'Lorem ipsum' });
}

<强> 3。一些: some()方法测试数组中是否至少有一个元素通过了所提供函数实现的测试。它返回一个布尔值。参考 < / p >

const ObjIdToFind = 5;
const isElementPresent = arr.some((o) => o.id === ObjIdToFind);
if (!isElementPresent) {                  // As some return Boolean value
arr.push({ id: arr.length + 1, username: 'Lorem ipsum' });
}

小开

const __checkIfElementExists__ = __itemFromArray__ => __itemFromArray__.*sameKey* === __outsideObject__.*samekey*;


if (cartArray.some(checkIfElementExists)) {
console.log('already exists');
} else {
alert('does not exists here')

小开

请看下面的例子

$(document).ready(function(){
const arr = document.querySelector(".list");
var abcde = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 2, username: 'ted' }];
$("#btnCheckUser").click(function() {
var tbUsername = $("#tbUsername").val();
if (abcde.some(obj => obj.username === tbUsername)) {
alert('existing user ' + tbUsername);
return;
}
else {
abcde.push({ id: abcde.length + 1, username: tbUsername });
alert('added new user ' + tbUsername);
arr.appendChild(createArray(tbUsername));
return;
}
});
  

function createArray(name) {
let li = document.createElement("li");
li.textContent = name;
return li;
}
abcde.forEach((x) => arr.appendChild(createArray(x.username)));


});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>


<p>Add text and click on Check.</p>


<input type="text" id="tbUsername" />
<button type="button" id="btnCheckUser">Check</button>


<div class="list">
<ul></ul>
</div>

小开

极大地简化了我之前的解决方案，并通过在检查指定ID是否存在之前无需遍历整个数组来提供更好的性能。

这应该是最简单的解决方案(我认为):

const users = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
const addUser = (username) => {
const user = users.find((user) => user.username === username);
if (user) return { ...user, new: false };
const newUser = {
id: users.length + 1,
username,
};
users.push(newUser);
return { ...newUser, new: true };
};

下面是一个活生生的例子:

const users = [{ id: 1, username: 'fred' }, { id: 2, username: 'bill' }, { id: 3, username: 'ted' }];
const addUser = (username) => {
const user = users.find((user) => user.username === username);
if (user) return { ...user, new: false };
const newUser = {
id: users.length + 1,
username,
};
users.push(newUser);
return { ...newUser, new: true };
};


// a little extra scripting here to support the input and button in the example


const form = document.querySelector('form');
const input = document.querySelector('input');
const span = document.querySelector('span');
const pre = document.querySelector('pre');


const syncDataWithPre = () => {
pre.innerHTML = JSON.stringify(users, null, 2);
};


form.onsubmit = (e) => {
e.preventDefault();
span.textContent = '';
if (input.value) {
const user = addUser(input.value);
const { new: isNew, ...userDetails } = user;
span.classList[isNew ? 'add' : 'remove']('new');
span.textContent = `User ${isNew ? 'added' : 'already exists'}`;
}
input.value = '';
syncDataWithPre();
};


syncDataWithPre();

body {
font-family: arial, sans-serif;
}
span {
display: block;
padding-top: 8px;
font-weight: 700;
color: #777;
}
span:empty {
display: none;
}
.new {
color: #0a0;
}
.existing: {
color: #777;
}

<form>
<input placeholder="New username" />
<button>Add user</button>
</form>
<span></span>
<pre></pre>

小开

我被赋予了一个条件来检查mysql数据库表中的数据，我的表的对象数组由id，纬度和经度作为列名组成，我必须检查位置是否在数据库中，否则将此插入到表中，这样: 我创建了一个函数处理提交调用的按钮，

handle Submit = (event) => {
const latitude = document.getElementById("latitude").innerHTML;
const longitude = document.getElementById("longitude").innerHTML;
const found = this.state.data.some((el) => el.latitude === latitude);
if (!found) {
Axios.post("http://localhost:3001/api/insert", {
latitude: latitude,
longitude: longitude,
}).then(() => {
alert("successful insert");
});
console.log(latitude, longitude);
}
};

在这里您可以看到用于插入的条件语句，如果数据库中不存在。