Logical operators in Go - Step-by-Step Execution

Concept Flow - Logical operators

Start

↓

Evaluate Left Operand

↓

Evaluate Right Operand

↓

Apply Logical Operator

↓

Result: true or false

↓

End

Logical operators combine two true/false values and produce a true or false result.

Execution Sample

Go

package main
import "fmt"
func main() {
  a := true
  b := false
  fmt.Println(a && b)
  fmt.Println(a || b)
  fmt.Println(!a)
}

This code shows how AND, OR, and NOT logical operators work with true and false values.

Execution Table

Step	Expression	Left Operand	Right Operand	Operator	Result
1	a && b	true	false	AND (&&)	false
2	a || b	true	false	OR (||)	true
3	!a	true	N/A	NOT (!)	false

💡 All logical operations evaluated, program ends.

Variable Tracker

Variable	Initial	After Step 1	After Step 2	After Step 3
a	true	true	true	true
b	false	false	false	false
result	N/A	false	true	false

Key Moments - 2 Insights

Why does 'a && b' result in false even though 'a' is true?

Because AND (&&) needs both operands to be true. Here, 'b' is false, so the whole expression is false (see execution_table row 1).

What does the NOT operator (!) do to 'a'?

NOT (!) flips the value. Since 'a' is true, '!a' becomes false (see execution_table row 3).

Visual Quiz - 3 Questions

Look at the execution table, what is the result of 'a || b' at step 2?

A undefined

B false

C true

D error

💡 Hint

Check execution_table row 2 under Result column.

At which step does the NOT operator (!) get applied?

A Step 3

B Step 2

C Step 1

D No NOT operator used

💡 Hint

Look at the Operator column in execution_table for '!'.

If 'b' was true, what would be the result of 'a && b' at step 1?

A false

B true

C false and true

D error

💡 Hint

AND needs both true to be true; see execution_table row 1 and variable_tracker for 'b'.

Concept Snapshot

Logical operators combine true/false values:
- AND (&&): true if both true
- OR (||): true if one true
- NOT (!): flips true/false
Used to make decisions in code.

Full Transcript

This example shows how logical operators work in Go. We start with two variables: a is true, b is false. The AND operator (&&) checks if both are true; since b is false, the result is false. The OR operator (||) checks if at least one is true; since a is true, the result is true. The NOT operator (!) flips the value of a from true to false. These operators help combine conditions in programming.

Practice

1. Which logical operator in Go means AND and returns true only if both conditions are true?

easy

A. !

B. ||

C. &

D. &&

Solution

1. Step 1: Understand the meaning of logical AND

   The AND operator returns true only when both conditions it connects are true.

2. Step 2: Identify Go's AND operator

   In Go, the AND operator is written as &&, which matches the description.

3. Final Answer:

   && -> Option D

4. Quick Check:

   AND = && [OK]

Hint: AND is &&, OR is ||, NOT is ! [OK]

Common Mistakes:

• Confusing & (bitwise AND) with && (logical AND)
• Mixing OR (||) with AND (&&)
• Using ! as AND operator

2. Which of the following is the correct syntax for the logical NOT operator in Go?

easy

A. not x

B. !x

C. ~x

D. x!

Solution

1. Step 1: Recall Go syntax for logical NOT

   In Go, the logical NOT operator is a single exclamation mark placed before the variable or expression.

2. Step 2: Match options with correct syntax

   !x uses !x, which is the correct syntax for NOT in Go.

3. Final Answer:

   !x -> Option B

4. Quick Check:

   NOT = ! [OK]

Hint: NOT always uses ! before the condition [OK]

Common Mistakes:

• Writing 'not x' like in some other languages
• Using ~ which is bitwise NOT, not logical NOT
• Placing ! after the variable

3. What is the output of this Go code snippet?

package main
import "fmt"
func main() {
    a := true
    b := false
    fmt.Println(a && !b || b)
}

medium

A. true

B. false

C. Syntax error

D. Compilation error

Solution

1. Step 1: Evaluate !b

   b is false, so !b is true.

2. Step 2: Evaluate a && !b

   a is true and !b is true, so a && !b is true.

3. Step 3: Evaluate (a && !b) || b

   true || false is true.

4. Final Answer:

   true -> Option A

5. Quick Check:

   True AND NOT False OR False = True [OK]

Hint: Evaluate NOT first, then AND, then OR [OK]

Common Mistakes:

• Evaluating OR before AND
• Forgetting to negate b
• Assuming false || true is false

4. Identify the error in this Go code snippet:

package main
import "fmt"
func main() {
    x := true
    y := false
    if x & y {
        fmt.Println("Both true")
    }
}

medium

A. Using & instead of && in if condition

B. Missing parentheses around condition

C. fmt.Println syntax error

D. Variable declaration error

Solution

1. Step 1: Check logical operators in if condition

   The code uses & which is bitwise AND, not logical AND.

2. Step 2: Identify correct operator for boolean logic

   Logical AND in Go is &&, so & causes a type error here.

3. Final Answer:

   Using & instead of && in if condition -> Option A

4. Quick Check:

   Logical AND needs &&, not & [OK]

Hint: Use && for logical AND, & is bitwise [OK]

Common Mistakes:

• Using & instead of && for booleans
• Assuming & works like && in conditions
• Ignoring compiler error messages

5. Given a variable score (int), which condition correctly checks if score is between 50 and 100 inclusive using logical operators in Go?

hard

A. score >= 50 || score <= 100

B. score > 50 && score < 100

C. score >= 50 && score <= 100

D. score > 50 || score < 100

Solution

1. Step 1: Understand the range condition

   We want score to be at least 50 and at most 100, so both conditions must be true.

2. Step 2: Choose correct logical operator

   AND (&&) combines conditions that both must be true; OR (||) would allow values outside the range.

3. Step 3: Check inclusivity

   Using >= and <= includes 50 and 100 themselves.

4. Final Answer:

   score >= 50 && score <= 100 -> Option C

5. Quick Check:

   Between means AND, not OR [OK]

Hint: Use && to combine conditions that both must be true [OK]

Common Mistakes:

• Using || which allows values outside range
• Using > and < excludes boundary values
• Confusing AND and OR logic