Operator precedence in Go

Introduction

Operator precedence tells the computer which math or logic steps to do first when there are many in one line.

When you write math calculations with many operators like +, -, *, / in one line.

When you combine different logic checks like && and || in one condition.

When you want to make sure your code does things in the right order without extra parentheses.

When you read code and want to understand how the computer will solve the expression.

Syntax

Go

Go uses a fixed order of precedence for operators. For example:

* and / have higher precedence than + and -
== and != have lower precedence than arithmetic operators
&& has higher precedence than ||

Parentheses () can be used to change the order.

Operators with higher precedence are done before operators with lower precedence.

Use parentheses to make your code clearer and control the order explicitly.

Examples

Multiplication (*) happens before addition (+), so 4 * 2 = 8, then 3 + 8 = 11.

Go

result := 3 + 4 * 2

Parentheses change the order: 3 + 4 = 7 first, then 7 * 2 = 14.

Go

result := (3 + 4) * 2

&& has higher precedence than ||, so false && false = false first, then true || false = true.

Go

flag := true || false && false

Sample Program

This program shows how Go uses operator precedence to calculate expressions. It prints the results of each expression.

Go

package main

import "fmt"

func main() {
    a := 3 + 4 * 2
    b := (3 + 4) * 2
    c := true || false && false

    fmt.Println("a:", a)
    fmt.Println("b:", b)
    fmt.Println("c:", c)
}

Important Notes

Remember that multiplication and division happen before addition and subtraction.

Logical AND (&&) is done before logical OR (||).

Use parentheses to avoid confusion and make your code easier to read.

Summary

Operator precedence decides which parts of an expression are calculated first.

Multiplication and division have higher precedence than addition and subtraction.

Use parentheses to control or clarify the order of operations.

Practice

1. In Go, which operator has the highest precedence among these: +, -, *, /?

easy

A. Subtraction (-)

B. Addition (+)

C. All have the same precedence

D. Multiplication (*) and division (/)

Solution

1. Step 1: Recall operator precedence rules in Go

   Multiplication (*) and division (/) have higher precedence than addition (+) and subtraction (-).

2. Step 2: Compare given operators

   Among the given operators, * and / are evaluated before + and -.

3. Final Answer:

   Multiplication (*) and division (/) -> Option D

4. Quick Check:

   *, / > +, - [OK]

Hint: Remember: multiply/divide before add/subtract [OK]

Common Mistakes:

• Thinking all operators have equal precedence
• Confusing addition with multiplication precedence
• Ignoring division operator precedence

2. Which of the following Go expressions is syntactically correct and respects operator precedence?

easy

A. result := 5 + (3 * 2

B. result := 5 + * 3 2

C. result := 5 + 3 * 2

D. result := 5 + 3 * * 2

Solution

1. Step 1: Check each expression for syntax correctness

   result := 5 + 3 * 2 uses valid operators and correct syntax. Options B, C, and D have syntax errors like misplaced operators or missing parentheses.

2. Step 2: Confirm operator precedence in result := 5 + 3 * 2

   Multiplication (*) happens before addition (+), so expression is valid and respects precedence.

3. Final Answer:

   result := 5 + 3 * 2 -> Option C

4. Quick Check:

   Valid syntax and precedence in result := 5 + 3 * 2 [OK]

Hint: Check for misplaced or missing operators and parentheses [OK]

Common Mistakes:

• Using two operators in a row without operand
• Missing closing parentheses
• Confusing operator placement

3. What is the output of this Go code?

package main
import "fmt"
func main() {
    x := 2 + 3 * 4 - 6 / 2
    fmt.Println(x)
}

medium

A. 11

B. 10

C. 12

D. 14

Solution

1. Step 1: Apply operator precedence to expression

   Multiplication and division first: 3 * 4 = 12, 6 / 2 = 3.

2. Step 2: Calculate addition and subtraction left to right

   Expression becomes 2 + 12 - 3 = 14 - 3 = 11.

3. Final Answer:

   11 -> Option A

4. Quick Check:

   2 + (3*4) - (6/2) = 11 [OK]

Hint: Do * and / before + and -, then left to right [OK]

Common Mistakes:

• Adding before multiplying
• Subtracting before division
• Ignoring left-to-right evaluation for + and -

4. Identify the error in this Go code snippet related to operator precedence:

package main
import "fmt"
func main() {
    result := 10 / 2 * 3
    + 4 - 1
    fmt.Println(result)
}

medium

A. Line break splits expression incorrectly without continuation

B. Division operator has lower precedence than multiplication

C. Missing parentheses around addition and subtraction

D. Using + and - operators together causes syntax error

Solution

1. Step 1: Check expression syntax across lines

   The expression is split across two lines without proper continuation, causing a syntax error.

2. Step 2: Understand Go line continuation rules

   Go requires expressions split across lines to be clearly continued, usually by operators at line end or parentheses.

3. Final Answer:

   Line break splits expression incorrectly without continuation -> Option A

4. Quick Check:

   Line breaks need proper continuation [OK]

Hint: Avoid breaking expressions without operators or parentheses [OK]

Common Mistakes:

• Assuming operator precedence causes error
• Thinking + and - together cause syntax error
• Ignoring Go's line continuation rules

5. Given the Go expression:

result := 8 + 2 * (5 - 3) / 2 - 1

What is the correct value of result after evaluation?

hard

A. 8

B. 9

C. 10

D. 11

Solution

1. Step 1: Evaluate parentheses first

   (5 - 3) = 2.

2. Step 2: Apply multiplication and division left to right

   2 * 2 = 4, then 4 / 2 = 2.

3. Step 3: Perform addition and subtraction left to right

   8 + 2 = 10, then 10 - 1 = 9.

4. Final Answer:

   9 -> Option B

5. Quick Check:

   8 + 2*(2)/2 - 1 = 9 [OK]

Hint: Calculate parentheses first, then * /, then + - left to right [OK]

Common Mistakes:

• Ignoring parentheses priority
• Doing addition before multiplication
• Dividing before multiplying inside parentheses