There isn't any need to reinvent the wheel loop, at least not explicitly.

Use some as it allows the browser to stop as soon as one element is found that matches:

if (vendors.some(e => e.Name === 'Magenic')) {
  // We found at least one object that we're looking for!
}

or the equivalent (in this case) with find, which returns the found object instead of a boolean:

if (vendors.find(e => e.Name === 'Magenic')) {
  // Usually the same result as above, but find returns the element itself
}

If you'd like to get the position of that element, use findIndex:

const i = vendors.findIndex(e => e.Name === 'Magenic');
if (i > -1) {
  // We know that at least 1 object that matches has been found at the index i
}

If you need to get all of the objects that match:

if (vendors.filter(e => e.Name === 'Magenic').length > 0) {
  // The same result as above, but filter returns all objects that match
}

If you need compatibility with really old browsers that don't support arrow functions, then your best bet is:

if (vendors.filter(function(e) { return e.Name === 'Magenic'; }).length > 0) {
  // The same result as above, but filter returns all objects that match and we avoid an arrow function for compatibility
}

It's true that object lookup occurs in constant time - O(1) - so using object properties instead of an array is one option, but if you're just trying to check whether a value is included in a collection, it would be more appropriate to use a Set, which is a (generally unordered) collection of values, which can also be looked up in linear time. (Using a plain object instead would require you to have values in addition to your keys, which you don't care about - so, use a Set instead.)

const set = new Set(['foo', 'bar']);
console.log(set.has('foo'));
console.log(set.has('baz'));

This will be useful when you have to look up multiple values for the same Set. But, adding items to the Set (just like adding properties to an object) is O(N), so if you're just going to look up a single value, once, there's no benefit to this nor the object technique, and you may as well just use an array includes test.

includes essentially checks if any element === the element you're searching for. In case of objects, === means literally the same object, as in the same reference (same place in memory), not the same shape.

var a1 = { name: 'a' }
var a2 = { name: 'a' }

console.log(a1 === a2) // false because they are not the same object in memory even if they have the same data

But if you search for an object that is actually in the array it works:

var a1 = { name: 'a' }
var a2 = { name: 'a' }
var array = [a1, a2]

console.log(array.includes(a1)) // true because the object pointed to by a1 is included in this array 

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.

Usesome method to check whether Capulet exists in an array:

let obj = { last: "Capulet" };
const isExist = whatIsInAName.some(f => f.last == obj.last)

const whatIsInAName = [
  { first: "Romeo", last: "Montague" },
  { first: "Mercutio", last: null },
  { first: "Tybalt", last: "Capulet" }
 ];

let obj = { last: "Capulet" };
const isExist = whatIsInAName.some(f => f.last == obj.last)
console.log(`Exists: ${isExist}`)

Or you can use filter to get all objects based on criteria:

const whatIsInAName = [
  { first: "Romeo", last: "Montague" },
  { first: "Mercutio", last: null },
  { first: "Tybalt", last: "Capulet" }
 ];

let obj = { last: "Capulet" };
const result = whatIsInAName.filter(f => f.last == obj.last);

console.log(result)

You can turn the values of an Object into an array and test that a string is present. It assumes that the Object is not nested and the string is an exact match:

var obj = { a: 'test1', b: 'test2' };
if (Object.values(obj).indexOf('test1') > -1) {
   console.log('has test1');
}

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values

Hei, just published chai-subset. Check this out: https://www.npmjs.org/package/chai-subset This should work for you)

 var chai = require('chai');
 var chaiSubset = require('chai-subset');
 chai.use(chaiSubset);

 var obj = {
     a: 'b',
     c: 'd',
     e: {
         foo: 'bar',
         baz: {
             qux: 'quux'
         }
     }
 };

 expect(obj).to.containSubset({
     e: {
         foo: 'bar',
         baz: {
             qux: 'quux'
         }
     }
 });

does include works with array of objects?

Yes — if you use the same object as the argument to includes that's in the array:

const obj = {name: "Dan", id: 2};
const arr = [{name: "T.J.", id: 42}, obj, {name: "Joe", id: 3}];
console.log(arr.includes(obj));                  // true
console.log(arr.includes({name: "Dan", id: 2})); // false

includes uses a === check, and o1 === o2 is only ever true when o1 and o2 refer to the same object. In your example, you're using two different but equivalent objects instead.

For your use case, you probably want some, which lets you execute a callback to determine whether an entry in the array matches a condition:

if (arr.some(e => e.id === 2)) {

Example:

const obj = {name: "Dan", id: 2};
const arr = [{name: "T.J.", id: 42}, obj, {name: "Joe", id: 3}];
console.log(arr.some(obj => obj.id === 2));      // true

There are various ways to spin that, depending on what you want the check to be (which are discussed at length in this question's answers), but that just means adjusting the contents of the function you pass some.