The rest of the operators

The last operator map

You already know the everyday operators: arithmetic, assignment, comparisons, logical operators, ??, and optional chaining. This lesson finishes the operator map. Some of these operators are common, like the ternary. Some are rare, like void. A few are powerful but easy to misuse, like bitwise operators.

The goal is not to make your code clever. In the Coding style lesson you learned to avoid tricks that make readers pause. Here you will learn what these operators mean so you can read them in real code, choose the clear ones, and know when to reach for a named helper or an if statement instead.

We will move from the friendly, expression-sized ternary to type checks, property checks, bitwise operators, shifts, comma, void, and a practical precedence table you can use while reading code.

The conditional operator is the only JavaScript operator with three operands. Its shape is:

condition ? valueIfTrue : valueIfFalse

Read it like a quick fork in the road: if the condition is truthy, JavaScript takes the left path after ?; otherwise it takes the right path after :. Because the whole thing is an expression, it produces a value. That means you can store it, return it, or put it inside a template literal.

1const age = 18;Run2const label = age >= 18 ? "adult" : "minor";3const sentence = `This visitor is an ${label}.`;4console.log(sentence);

A good ternary reads in one breath:

const shipping = cartTotal >= 500 ? "free" : "₹50";
console.log(`Shipping is ${shipping}.`);

A nested ternary asks the reader to hold several forks in their head:

const label = score >= 90 ? "A" : score >= 80 ? "B" : "keep practicing";

let readableLabel;
if (score >= 90) {
  readableLabel = "A";
} else if (score >= 80) {
  readableLabel = "B";
} else {
  readableLabel = "keep practicing";
}

The next lesson is if, else & conditions. For now, use this rule: ternary for a small value choice; if / else when the logic needs room.

typeof asks, “what kind of value is this?” It is most useful for primitives: "string", "number", "boolean", "bigint", "symbol", "undefined", and "function". For most objects, it simply says "object".

instanceof asks a different question: “does this object come from this constructor’s family tree?” That is a simple way to use it today. The prototype chain lesson later explains the exact chain it walks.

1const values = [null, [], new Date(0), "text"];Run2console.log(typeof values[0]);3console.log(Array.isArray(values[1]));4console.log(values[1] instanceof Array);5console.log(values[1] instanceof Object);6console.log(values[3] instanceof String);

"key" in object checks whether a property is available on an object. It includes inherited properties, so it answers “can this key be found?” not “did this object define the key itself?” For own properties, use Object.hasOwn(object, "key").

delete object.key removes a configurable property. It is useful for object dictionaries, but not for normal array removal: deleting an array element leaves a hole and keeps the same length.

1const user = { name: "Ada", age: 36 };Run2console.log("name" in user);3console.log("toString" in user);4console.log(Object.hasOwn(user, "toString"));5delete user.age;6console.log("age" in user);7const letters = ["a", "b", "c"];8delete letters[1];9console.log(letters.length);10console.log(1 in letters);

JavaScript numbers are 64-bit floating-point values, as you learned in Numbers & math. Bitwise operators are different: before they work, JavaScript converts the number to a 32-bit integer. Then it treats the integer as a row of 32 tiny switches: each switch is 0 or 1.

1const a = 12; // 000011002const b = 10; // 000010103console.log(a & b);  // both bits are 14console.log(a | b);  // either bit is 15console.log(a ^ b);  // bits are different6console.log(~a);     // flip 32 bits7console.log(a << 1); // shift left8console.log(a >> 1); // shift right9console.log(a >>> 1); // unsigned shift right

console.log(2 ** 32 | 0); // 0: wraps to a 32-bit signed integer
console.log(~5);        // -6: flip all 32 bits
console.log(-1 >>> 0);  // 4294967295: read all bits as unsigned

A realistic beginner-friendly use is permission flags. Give each permission one bit, combine flags with |, test one flag with &, and toggle a flag with ^.

const READ = 1;    // 001
const WRITE = 2;   // 010
const EXECUTE = 4; // 100
let permissions = READ | WRITE;
console.log((permissions & WRITE) !== 0);
permissions = permissions ^ WRITE;
console.log((permissions & WRITE) !== 0);

Shift operators slide the 32-bit switches left or right. << shifts left and fills with zeros on the right. >> shifts right while keeping the sign bit, so negative numbers stay negative. >>> shifts right and fills with zeros, producing an unsigned 32-bit result.

console.log(5 << 1);  // 10
console.log(5 >> 1);  // 2
console.log(-1 >>> 0); // 4294967295

Two final operators mostly appear in older or specialized code. The comma operator evaluates expressions from left to right and keeps the last value. The void operator evaluates an expression, throws away its value, and produces undefined.

1let i = 0, j = 10;Run2i++, j--;3const kept = (1, 2, 3);4const swallowed = void kept;5console.log(i, j, kept, swallowed);

Precedence answers: “which operator groups with its operands first?” It does not mean “which part is evaluated first” in every detail; many expressions still evaluate their operands left to right. For beginners, the practical rule is: when mixing unfamiliar operators, add parentheses.

Sort the cards by whether they bind higher or lower than addition. If you are unsure, the feedback tells you where the operator sits.

Where you’ll use this

In everyday front-end code, these operators show up in predictable places:

• Use a ternary to choose a CSS class, label, or short message: const tone = error ? "danger" : "success";
• Use typeof at API boundaries when a value might be a string, number, or function.
• Use Array.isArray before calling array methods on data you did not create.
• Use Object.hasOwn when reading plain object data where inherited keys should not count.
• Read bitwise flags in libraries, file permissions, graphics, and low-level browser APIs, even if you do not write them often.

function describeUpload(file) {
  const kind = Array.isArray(file.tags) ? "tagged" : "untagged";
  const owner = Object.hasOwn(file, "owner") ? file.owner : "unknown";
  return `A ${kind} file owned by ${owner}.`;
}

Common misconceptions

Take your time. Every answer explains why it is right or wrong, and code questions are based on real JavaScript output.

Key takeaways

• A ternary is an expression-sized two-way choice: condition ? left : right.
• typeof is best for primitives; use Array.isArray for arrays and instanceof for constructor family checks.
• in includes inherited properties; Object.hasOwn checks only direct keys.
• delete removes object properties, but on arrays it leaves holes and keeps length.
• Bitwise operators convert to 32-bit integers; flags are a clear use, clever number tricks are not.
• Comma and void are rare; recognize them, but do not reach for them first.
• Precedence explains grouping, but parentheses explain your intent to humans.

Up next: if, else & conditions, where choices get full statements, blocks, and room to breathe.