Array.includes() to find object in array

Question

I'm attempting to find an object in an array using Array.prototype.includes . Is this possible? I realize there is a difference between shallow and deep comparison. Is that the reason the below code returns false? I could not find a relevant answer for Array.includes() .

Answer 1

Array.includes compares by object identity just like obj === obj2 , so sadly this doesn't work unless the two items are references to the same object. You can often use Array.prototype.some() instead which takes a function:

 const arr = [{a: 'b'}] console.log(arr.some(item => item.a === 'b'))

But of course you then need to write a small function that defines what you mean by equality.

Answer 2

Its' because both of the objects are not the same. Both are stored at different place in memory and the equality operation results false .

But if you search for the same object, then it will return true .

Also, have a look at the below code, where you can understand that two identical objects also results false with the === operator.

For two objects to return true in === , they should be pointing to same memory location.

Answer 3

You are on the right track but, the issue is the difference between reference and value types, you currently are using a reference type (object literal), so when you compare what is in the array with what you have, it will compare the references and not the values. this is what I mean:

 var ar = []; var x = {a: "b", c: "d" }; ar.push(x); // this will log true because its the same reference console.log("should be true: ", ar[0] === x); ar.push({a: "b", c: "d" }); // this will log false because i have created // a different reference for a new object. console.log("should be false: ", ar[1] === x); // Think of it like this var obja = { foo: "bar" }; // new reference to 'obja' var objb = { foo: "bar" }; // new reference to 'objb' var valuea = 23; var valueb = 23; // 'obja' and 'obja' are different references // although they contain same property & value // so a test for equality will return false console.log("should be false: ", obja === objb); // on the other hand 'valuea' and 'valueb' are // both value types, so an equality test will be true console.log("should be true: ", valuea === valueb);

to achieve what you want, you either have to have added the actual reference, as I did above, or loop through the array and compare by unique property of the objects.

Answer 4

This is because the includes checks to see if the object is in the array, which it in fact is not:

> {a: 'b'} === {a: 'b'}
false

This is because the test for equality is not testing if the objects are the same, but whether the point to the same object. Which they don't.

Answer 5

you can use find to returns the value of the this element

const array = [{a: 'b'}];
array.includes(array.find(el=>el.a==='b'));

Answer 6

 const arr = [{a: 'b',b:'c'},{a: 'c'}] console.log(arr.some(item => item.b === 'c'))

Answer 7

Yes, you can, if only so

 const arr = [{a:'a'},{a: 'b'}] const serch = arr[1] console.log(arr.includes(serch))

Answer 8

You cannot use string comparisons on objects unless you first convert them to strings with...

JSON.stringify(TheObject)

So to loop through all objects in an array so as to prevent adding a duplicate object, you can use something like this...

let Bad=false;

ObjectArray.forEach(function(e){if(JSON.stringify(NewObject)===JSON.stringify(e)){Bad=true;}});

if(Bad){alert('This object already exists!');} else {ObjectArray.push(NewObject);}