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
typeof
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
void
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
delete
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.