JavaScript Operator Precedence

In JavaScript, operator precedence determines the order in which operators are evaluated when multiple operators are present in an expression. Just like in mathematics, where multiplication and division take precedence over addition and subtraction, JavaScript has rules governing the order in which different operators are executed.

Let’s delve into some common examples to better understand how operator precedence works:

1. Arithmetic Operators:

   let result = 5 + 3 * 2;
   console.log(result); // Output: 11

Here, multiplication takes precedence over addition. So, 3 * 2 is evaluated first, and then the result is added to 5.

2. Assignment Operators:

   let a = 5;
   let b = 3;
   let c = a * b;
   console.log(c); // Output: 15

The assignment operator (=) has lower precedence than the multiplication operator (*). The expression a * b is evaluated first, and then the result is assigned to c.

3. Logical Operators:

   let x = 10;
   let y = 5;
   let z = x > 5 && y < 8;
   console.log(z); // Output: true

Here, the logical AND (&&) operator has higher precedence than the comparison operators (> and <). So, x > 5 and y < 8 are evaluated first, and then the AND operation is applied.

4. Grouping with Parentheses:

   let result = (10 + 2) * 3;
   console.log(result); // Output: 36

Parentheses can be used to explicitly control the order of operations. In this example, the expression inside the parentheses is evaluated first.

Understanding operator precedence is crucial for writing code that behaves as expected. It helps prevent unintended bugs and ensures that expressions are evaluated in the correct order.

In summary, JavaScript operator precedence dictates the order in which operations are performed in an expression. By grasping these rules, you can write more efficient and predictable code.