Is there a “not in” operator in JavaScript for checking object properties?

Broadening the Search

!("key" in object) maybe a straight way to check non-existence, but modern methods and essential nuances enhance the stew of knowledge.

Object.hasOwn: A New Soldier in Town

ECMAScript 2021 ushered in Object.hasOwn(), providing a lucid and dependable comb for absent property search:

Example:

const object = { a: 1, b: 2 };
console.log(!Object.hasOwn(object, 'c')); // true - 'c' gone AWOL


Dodging the Prototype Landmines

in ransacks the whole prototype chain. For a search limited to own properties, apply Object.prototype.hasOwnProperty.call():

Example:

const object = { a: 1, b: 2 };
console.log(!Object.prototype.hasOwnProperty.call(object, 'c')); // true - 'c' left no footprints


Clear-cut Property Checks

Another strategy for validating non-existence is flagging undefined:

Example:

const object = { a: 1, b: 2 };
console.log(object['c'] === undefined); // true - 'c' playing hide & seek


It's a blunt approach; however, it can't draw the line between non-existent properties and properties painted undefined.

Scoping In: Property Non-Existence In Real Action

In the throes of real-world applications, these checks can be the armor against code maladies.

Wrestling With Dynamic Properties

With runtime-determined properties, devise a check that lock-steps with your case:

Example:

const userPermissions = getUserPermissions(); // A wild object appears!
const checkPermission = (permission) => !('permission' in userPermissions);

if (checkPermission('adminAccess')) {
  // Sorry, no admin access. Better luck next time!
}


Walking the Tightrope of State Management

In the world of state management, a property's vanishing act can dictate your code's storyline. It can switch features on or off or oversee configuration checks:

Example:

const featureFlags = getFeatureFlags();

if (!('newFeature' in featureFlags)) {
  // New feature? Nope, back you go!
}


Navigating the Ocean of Optional Values

JSON parsing often elicits fields with a knack for playing truant. For such rebels, property absence checks assure data fortitude:

Example:

const userData = JSON.parse(responseData);

if (!('age' in userData)) {
  // Age is just a number...that we don't have
}


Deciphering in operator: No 'Not in' Edition

In the in operator game, ensure your line of attack is clad in legibility and agility.

Prototype Chain: Know Thy Friend & Foe

By keeping a tab on the prototype chain, you can sidestep unwanted surprises. Safely parachute using methods targeting own properties.

Boolean Algebra: A Magic Trick or Two

With a few tricks up your boolean algebra sleeve, you can simplify conditions. For instance, use:

if (!('key' in object)) { /* ... */ }


instead of:

if (!('key' in object) === false) { /* ... */ }


Streamline Your Code: A 'Less is More' Tale

Disconnect needless if-else by hitching on direct property checks that return a boolean:

const accessGranted = !('restricted' in userRoles); // Red carpet access?


This boolean can be directly cooked into conditional expressions sans further detours.