JavaScript Unary Operators Example

Unary operators in javaScript; In this tutorial, you will learn what are unary operators in javascript and how to use javascript unary operators.

JavaScript Unary Operators

What are unary operators?
Types of unary operators in js
- Unary plus / minus
- Increment / Decrements operators

What are unary operators?

A unary operator works on one operand.

Types of unary operators in js

There are two types of unary operators in javascript, the following operators are:

Unary plus / minus
Increment / Decrements operators

See the following unary operators in JavaScript are:

Unary plus (+) – convert an operand into a number
Unary minus (-) – convert an operand into a number and negate the value after that.
prefix / postfix increments (++) – add one to its operand
prefix / postfix decrements (--) – subtract one from its operand.

Unary plus / minus

The unary plus operator is a simple plus sign + and the unary minus is the minus sign -. You can use a javascript unary plus or minus with js variables.

Consider the following examples:

let a = 15;
a = +a; // 15
a = -a; // -15

In the above example, The unary plus operator will not take any effect, whereas the unary minus negates the value.

If you can use unary plus or minus with non-numeric value, it will works the same conversion as the Number() function.

let str = '15';
console.log(+str); // 15

Here, str is a string. However, when we used the unary plus operator with it, it will convert string to a number.

The following example shows how the unary operator converts boolean values into numbers, false to 0 and true to 1.

let f = false,
    t = true;
console.log(+f); // 0
console.log(+t); // 1

Increment / Decrements operators

JavaScript borrows increment and decrement operators from the C language. Both of increment and decrement operators have two versions: prefix and postfix.

You put he prefix version of the increment or decrement operators before a variable and the postfix versions after the variable.

Consider the following example:

Add 1 to a variable by using the prefix increment operator:

let a = 20;
++a;
console.log(a); // 21

In this example, the prefix increment operator adds 1 to the value of a. As a result, the value of a is 9.

The work is the same as the following:

let a = 20;
dan = a + 1;
console.log(a); // 21

The prefix decrement operator subtracts 1 from a given value:

let a = 20;
--a;
console.log(a); // 19

In this example, the prefix decrement subtracts 1 from 9.

It’s necessary to note that, the variable value changed before the statement is executed by using prefix decrement.

See the following example:

let x = 10,
    y = 20;
let z = --x + y;
console.log(z); // 29

T prefix decrement operator is evaluated first, the value of x is update to 9, and then 20 is added, resulting in 29.

The postfix versions of increment and decrement have the same forms: ++ and -- but are placed after a variable.

The only difference between the postfix and prefix is that JavaScript doesn’t evaluate them until the containing statement has been evaluated.

Here is an example:

let i = 10;
i--;

After the second statement, the value of i is 9.

It has the same work as:

let i = 10;
--i;

Now, we clear some difference, when you mix the postfix version with other operations:

let i = 10, j = 20;
let m = i-- + j;
console.log(m); // 30
console.log(i); // 9

i = 10;
let n = --i + j;
console.log(n); // 29
console.log(i); // 9

In this example, m uses the original value of i, which is 10 whereas n uses the decremented value of i which is 9.

Conclusion

In this tutorial, you have learned what is unary operators in js and how to use JavaScript unary operators.

Subscribe to Blog via Email