Relational operators in Go - Step-by-Step Execution

Concept Flow - Relational operators

Start

↓

Evaluate Left Operand

↓

Evaluate Right Operand

↓

Apply Relational Operator

↓

Result: true or false

↓

Use Result in Condition or Output

↓

End

Relational operators compare two values and return true or false, which can be used in conditions or printed.

Execution Sample

Go

package main
import "fmt"
func main() {
  a, b := 5, 3
  fmt.Println(a > b)
}

This code compares if a is greater than b and prints the result.

Execution Table

Step	Expression	Evaluation	Result	Output
1	a = 5	Assign 5 to a	5
2	b = 3	Assign 3 to b	3
3	a > b	5 > 3	true
4	fmt.Println(a > b)	Print true		true

💡 Program ends after printing the relational operator result.

Variable Tracker

Variable	Start	After Step 1	After Step 2	Final
a	undefined	5	5	5
b	undefined	undefined	3	3

Key Moments - 2 Insights

Why does the expression 'a > b' return true or false instead of a number?

Relational operators compare values and always return a boolean (true or false), not a number. See execution_table row 3 where '5 > 3' evaluates to 'true'.

What happens if both operands are equal in a relational operator like 'a == b'?

If both operands are equal, the '==' operator returns true. This is shown by the relational operator always returning a boolean based on the comparison.

Visual Quiz - 3 Questions

Look at the execution table, what is the result of 'a > b' at step 3?

A false

B true

C 5

D 3

💡 Hint

Check the 'Result' column in execution_table row 3.

At which step is the value 3 assigned to variable b?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Expression' and 'Evaluation' columns in execution_table row 2.

If we change 'a' to 2, what would be the result of 'a > b' at step 3?

A 2

B true

C false

D 3

💡 Hint

Compare values in variable_tracker and recall that 2 > 3 is false.

Concept Snapshot

Relational operators compare two values and return true or false.
Common operators: ==, !=, >, <, >=, <=.
Used in conditions and expressions.
Example: a > b returns true if a is greater than b.
Always returns a boolean value.

Full Transcript

This example shows how relational operators work in Go. Variables a and b are assigned values 5 and 3. The expression 'a > b' compares these values and returns true because 5 is greater than 3. The result is printed. Relational operators always return true or false, not numbers. This is useful for making decisions in code.

Practice

1. Which of the following relational operators in Go checks if two values are equal?

easy

A. >

B. !=

C. ==

D. <=

Solution

1. Step 1: Understand the meaning of relational operators

   Relational operators compare two values and return true or false based on the comparison.

2. Step 2: Identify the operator for equality

   The operator '==' checks if two values are equal in Go.

3. Final Answer:

   == -> Option C

4. Quick Check:

   Equality operator = == [OK]

Hint: Remember: double equals (==) means equal in Go [OK]

Common Mistakes:

• Confusing '=' (assignment) with '==' (equality)
• Using '!=' for equality check
• Thinking '>' means equal

2. Which of the following is the correct syntax to check if variable a is not equal to variable b in Go?

easy

A. a !== b

B. a <> b

C. a =! b

D. a != b

Solution

1. Step 1: Recall Go syntax for not equal operator

   In Go, the not equal operator is written as '!='.

2. Step 2: Match the syntax with the options

   a != b uses 'a != b', which is correct syntax for not equal in Go.

3. Final Answer:

   a != b -> Option D

4. Quick Check:

   Not equal operator = != [OK]

Hint: Not equal in Go is always '!=' not '<>' or '!==' [OK]

Common Mistakes:

• Using '<>' which is not valid in Go
• Swapping '=' and '!' to '=!'
• Using JavaScript style '!==' which is invalid in Go

3. What will be the output of the following Go code?

package main
import "fmt"
func main() {
    x := 10
    y := 20
    fmt.Println(x > y)
}

medium

A. false

B. 10

C. true

D. Compilation error

Solution

1. Step 1: Understand the comparison x > y

   Variable x is 10 and y is 20. The expression checks if 10 is greater than 20.

2. Step 2: Evaluate the expression

   Since 10 is not greater than 20, the expression evaluates to false.

3. Final Answer:

   false -> Option A

4. Quick Check:

   10 > 20 = false [OK]

Hint: Compare values carefully; 10 > 20 is false [OK]

Common Mistakes:

• Assuming 10 > 20 is true
• Confusing output with variable values
• Expecting a number instead of boolean

4. Identify the error in the following Go code snippet:

package main
import "fmt"
func main() {
    a := 5
    b := 10
    if a = b {
        fmt.Println("Equal")
    }
}

medium

A. Variables 'a' and 'b' are not declared properly

B. The '=' operator is used instead of '==' in the if condition

C. Missing parentheses around the if condition

D. fmt.Println syntax is incorrect

Solution

1. Step 1: Check the if condition syntax

   The condition uses 'a = b' which is an assignment, not a comparison.

2. Step 2: Correct the operator for comparison

   To compare values, '==' must be used instead of '='.

3. Final Answer:

   The '=' operator is used instead of '==' in the if condition -> Option B

4. Quick Check:

   Use '==' for comparison, not '=' [OK]

Hint: Use '==' to compare, '=' only assigns [OK]

Common Mistakes:

• Using '=' instead of '==' in conditions
• Thinking parentheses are mandatory in Go if
• Assuming fmt.Println syntax is wrong

5. Given the following Go code, what will be the output?

package main
import "fmt"
func main() {
    a := 15
    b := 15
    c := 20
    result := (a == b) && (c > b)
    fmt.Println(result)
}

hard

A. true

B. false

C. Compilation error

D. 15

Solution

1. Step 1: Evaluate the first comparison (a == b)

   Both a and b are 15, so (a == b) is true.

2. Step 2: Evaluate the second comparison (c > b)

   c is 20 and b is 15, so (c > b) is true.

3. Step 3: Combine with logical AND

   Both conditions are true, so true && true is true.

4. Final Answer:

   true -> Option A

5. Quick Check:

   (15 == 15) && (20 > 15) = true [OK]

Hint: Both conditions true? Result is true [OK]

Common Mistakes:

• Confusing && with || operator
• Thinking one true means overall false
• Expecting numeric output instead of boolean