bytes

tutorials

javascript

precedence of operators

Module - 3 JavaScript Operators

Lesson - 4 Understanding Operator Precedence in JavaScript

Imagine you are a chef trying to prepare a complex recipe with many ingredients. You know that if you add the ingredients in the wrong order, the recipe won't turn out as expected. Similarly, in JavaScript, if you use operators in the wrong order, your code may not perform as expected. This is where operator precedence and associativity rules come into play.

Just as certain ingredients are added to a recipe before others, certain operators have higher precedence than others. For example, multiplication * and division / have higher precedence than addition + and subtraction -. If an expression contains multiple operators with different precedence levels, JavaScript evaluates the operators with higher precedence first.

In JavaScript, operators are symbols that are used to perform operations on values. They can be used for simple arithmetic operations like addition and subtraction, or for more complex operations like assignment and comparison. However, when multiple operators are used in the same expression, their order of evaluation can become important. This is where operator precedence comes in.

Operator precedence refers to the order in which JavaScript evaluates operators in an expression. For example, in the expression 5 + 2 * 3, JavaScript will first evaluate the multiplication operator * before the addition operator +, resulting in the value 11. However, if we want the addition to be evaluated first, we can use parentheses to change the order of evaluation, like this: (5 + 2) * 3, which will result in the value 21.

JavaScript has a set of rules for operator precedence that determine the order in which operators are evaluated. These rules are based on the type of operator and are generally the same as in other programming languages.

Here are the most commonly used operators in JavaScript, ordered by precedence from highest to lowest:

- Grouping: ()
- Unary: +, -, !
- Multiplicative: *,/, %
- Additive: +, -
- Relational: <, >, <=, >=
- Equality: ==, !=, ===, !==
- Logical AND: &&
- Logical OR: ||
- Conditional: ?:
- Assignment: =, +=, -=, *=, /=, %=

Let's take a look at some examples to better understand how these rules work:

Example 1:

```
let x = 5;
let y = 10;
let z = 15;
let result = x + y * z;
console.log(result); // Output: 155
```

In this example, y * z is evaluated first, resulting in the value 150. Then, x is added to 150 to give a final result of 155.

Example 2:

```
let x = 5;
let y = 10;
let z = 15;
let result = (x + y) * z;
console.log(result); // Output: 225
```

In this example, the parentheses force the addition of x and y to be evaluated first, resulting in the value 15. Then, 15 is multiplied by z to give a final result of 225.

Example 3:

```
let x = 5;
let y = 10;
let z = 15;
let result = x > y && y < z;
console.log(result); // Output: false
```

In this example, the relational operator > is evaluated first, resulting in false. Then, the logical AND operator && is evaluated, but since one of its operands is false, the final result is also false.

Example 4:

```
let x = 5;
let y = 10;
let z = 15;
let result = x < y || y < z;
console.log(result); // Output: true
```

In this example, the less-than operator < is evaluated first, resulting in true. Then, the logical OR operator || is also evaluated, and since one of its operands is true, the final outcome is true.

It's important to keep in mind that while operator precedence is significant to understand, it can also be confusing and lead to mistakes if not used carefully. It's always a good idea to use parentheses to clarify the order of evaluation when there is any ambiguity.

Keep in mind that the rules of operator precedence in JavaScript are not always intuitive or easy to remember.

Here are some additional examples of expressions with different operators and their resulting values:

Example 5:

```
let a = 10;
let b = 5;
let c = 2;
let result = a / b * c;
console.log(result); // Output: 4
```

In this example, the division operator / is evaluated first, resulting in the value 2. Then, 2 is multiplied by c, resulting in the final value of 4.

Example 6:

```
let a = 5;
let b = 3;
let result = a++ + b--;
console.log(result); // Output: 8
```

In this example, the post increment operator ++ and post decrement operator -- have higher precedence than the addition + operator. The values of a and b are first used in the addition, resulting in the sum of 8. Then, the values of a and b are incremented and decremented, respectively.

Example 7:

```
let a = 5;
let b = 3;
let result = !(a > b);
console.log(result); // Output: false
```

In this case, the greater-than relational operator (>) has higher precedence than the logical negation operator (!). The expression a > b evaluates to true, after which the logical NOT operator (!) is applied, resulting in a final value of false.

Associativity rules specify the order in which operators with the same precedence are evaluated. There are two types of associativity: left-to-right and right-to-left.

**Left-to-right associativity** means that operators with the same precedence are evaluated from left to right. For example, the addition operator + has left-to-right associativity, so expressions like 3 + 4 + 5 are evaluated as (3 + 4) + 5 and result in 12.

**Right-to-left associativity** means that operators with the same precedence are evaluated from right to left. For example, the assignment operator = has right-to-left associativity, so expressions like a = b = c are evaluated as a = (b = c) and result in c being assigned to both b and a.

Here are some examples that illustrate the associativity rules in JavaScript:

Example 8:

```
let result = 3 - 2 - 1;
console.log(result); // Output: 0
```

In this example, the subtraction operator - has left-to-right associativity. The expression is evaluated as (3 - 2) - 1, which results in 0.

Example 9:

```
let a = 1;
let b = 2;
let c = 3;
a += b += c;
console.log(a); // Output: 6
console.log(b); // Output: 5
console.log(c); // Output: 3
```

In this example, the compound assignment operator += has right-to-left associativity. The expression is evaluated as a += (b += c), which results in a being assigned the value of 6, b being assigned the value of 5, and c retaining its original value of 3.

- Use parentheses to clarify expressions: Even if you understand the order of operations, using parentheses can make your code more readable and prevent mistakes.
- Be aware of operator precedence and associativity: It's important to know the precedence and associativity of operators you're using, especially when dealing with complex expressions.
- Use brackets and dot notation carefully: In JavaScript, brackets [] and dot notation . have higher precedence than many other operators. Be mindful of this when working with arrays and objects.
- Use logical operators for branching: Logical operators like && and || can be used for branching in place of if statements. Be sure to understand their precedence and associativity when using them.

In conclusion, understanding operator precedence and associativity rules is essential for writing correct and efficient code in JavaScript. These rules determine the order in which operators are evaluated in expressions, and they can greatly impact the result of complex expressions. By using parentheses and following the rules of operator precedence and associativity, you can write code that is easy to read and maintain.

As the mathematician and philosopher Blaise Pascal once said, "*Clarity of thought means clarity of expression.*" By understanding the rules of operator precedence and associativity, you can express your ideas clearly and effectively in code.

Made with

in Bengaluru, India - Join AlmaBetter
- Sign Up
- Become A Coach
- Coach Login

- Contact Us
- admissions@almabetter.com
- 08046008400

- Location
- 4th floor, 133/2, Janardhan Towers, Residency Road, Bengaluru, Karnataka, 560025

- Follow Us

© 2022 AlmaBetter