JavaScript Unary Operators

In JavaScript, operators are used to manipulate or perform actions on operands (values or variables). Unary operators, specifically, are those that operate on a single operand and can either precede or follow the operand, depending on the operation being performed.

Unary Plus (+)

The unary plus operator is used to convert its operand into a number. If the operand is already a number, it has no effect. However, if the operand is a non-numeric value, it attempts to convert it into a number.

let x = "42";
let y = +a;
console.log(typeof y);  // prints: number
console.log(y);         // prints: 42

Unary Negation (-)

The unary negation operator negates the value of its numeric operand. Similar to the unary plus, it converts non-numeric values into numbers before negating them.

let x = "42";
let y = -x;
console.log(typeof y);  // prints: number
console.log(y);         // prints: -42

Logical NOT (!)

The logical NOT operator is used to negate the boolean value of its operand. It returns true if the operand is falsy (e.g., null, undefined, false, 0, NaN, or an empty string) and false otherwise.

let x = "42";
console.log(!x);  // prints: false
let y;
console.log(!y);  // prints: true

Bitwise NOT (~)

The Bitwise NOT operator that inverts the bits of its operand. This will also flip the sign bit (the leftmost) so the result is negative.
NB: Bitwise operators treat their operands as a sequence of 32 bits.

10          // binary: 00000000 00000000 00000000 00001010
~10 = -11   // binary: 11111111 11111111 11111111 11110101

Increment (++) and Decrement (--)

These unary operators are used to increase or decrease the value of a numeric operand by 1. They come in two forms: prefix (e.g., ++a) and postfix (e.g., a++). The difference between the two forms lies in the order of evaluation when used in an expression.

let x = 42;
let y = x++;
console.log(x);  // prints: 43
console.log(y);  // prints: 42
y = ++x;
console.log(y);  // prints: 44
console.log(y);  // prints: 44


The typeof operator returns a string representing the data type of its operand. It is helpful in determining the type of a variable or value.

let x = 42;
let y = "Hello, World!";
console.log(typeof x);  // prints: number
console.log(typeof y);  // prints: string


The void operator evaluates an expression and returns undefined. It is often used in cases where a function should not return any value, such as with hyperlink onclick event handlers.

function doSomething() {
  console.log("Action performed");
  return "result";

let result = void doSomething();
console.log(result); // undefined


The delete operator is used to remove a property from an object. It returns true if the deletion is successful or if the property doesn't exist, and false if the property is non-configurable.

const person = {
    name: 'Charlie',
    age: 30
console.log(delete person.age);  // prints:  true

Take Away

JavaScript unary operators are powerful tools that can help you write more efficient and clean code. Mastering these operators will enhance your problem-solving skills and provide you with a deeper understanding of JavaScript's inner workings. From basic arithmetic and logical operations to manipulating object properties and handling edge cases, unary operators play a critical role in JavaScript programming.