# Swift Operators Precedence and Associativity

> Learn how operator precedence and associativity decide the order Swift evaluates an expression, so you know why 1 + 2 * 3 returns 7 and not 9.

Author: Flavio Copes | Published: 2021-06-13 | Canonical: https://flaviocopes.com/swift-operators-precedence/

> This tutorial belongs to the [Swift](https://flaviocopes.com/swift-introduction/) series

Think about this expression:

```swift
let amount = 1 + 2 * 3
```

The value of `amount` could drastically change depending if `1 + 2` is calculated before `2 * 3`.

The order of calculation is determined by the operator **precedence**. From higher precedence to lower precedence, as for the most popular operators we have:

- Multiplication (`*`), division (`/`), remainder (`%`)
- Add (`+`), subtract (`-`)
- Comparisons (`==`, `!=`, `<`, `>`, `<=`, `>=`)
- Logical AND (`&&`) and OR (`||`)
- Ternary conditional (`?:`)
- Assignment and compound assignment operators (`=`, `+=` and so on)

This means that the above expression is resolved first calculating the multiplication, and then the sum:

```swift
let amount = 1 + 2 * 3 // = 7
```

The full table of precedence, more complicated, is available at <https://developer.apple.com/documentation/swift/swift_standard_library/operator_declarations>.

When inside an expression you have multiple operators with the same precedence, we make use of  the operator **associativity**. Associativity is a property we use to determine which operation has priority when the precedence is the same.

For example, consider this:

```swift
let amount = 4 / 2 * 5
```

Depending if we first execute `4 / 2` or `2 * 5`, the result could be `10` or `0,4`.

Associativity solves this. Multiplication is left associative, so we must first execute the expression on the left. Parentheses help us figure this out:

```swift
let amount = (4 / 2) * 5
```

Multiplication (`*`), division (`/`), remainder (`%`), add (`+`), subtract (`-`), logical AND (`&&`), logical OR (`||`) are **left associative**

Assignment and compound assignment operators (`=`, `+=` and so on) and the ternary conditional (`?:`) are **right associative**

Comparisons (`==`, `!=`, `<`, `>`, `<=`, `>=`) don't have associativity.