Scala - Operators Precedence

---

Scala operators precedence determine the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

Hierarchy of Operators precedence

There is a clear hierarchy of operator precedence in Scala. Operators with higher precedence are evaluated before those with lower precedence. This prevents ambiguity and provides consistent evaluation for expressions.

Example

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Operators Precedence Table

Take a look at the following table. Operators with the highest precedence appear at the top of the table and those with the lowest precedence appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Syntax

val x = 7 + 3 * 2 

Here, the multiplication 3 * 2 is evaluated first due to its higher precedence. So resulting in 6. This value is then added to 7. Hence assigning x the final value 13.

Example of Operators Precedence

Try the following example program to understand operator precedence in Scala programming language −

object Demo {
  def main(args: Array[String]): Unit = {
    // Operator precedence and associativity
    val x = 7 + 3 * 2
    val y = (7 + 3) * 2
    val z = 10 / 2 * 3
    val w = 10 / (2 * 3)
    
    // Printing the results
    println(s"x = $x") // Output: x = 13
    println(s"y = $y") // Output: y = 20
    println(s"z = $z") // Output: z = 15
    println(s"w = $w") // Output: w = 1
  }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

x = 13
y = 20
z = 15
w = 1