learngo/11-if/questions/2-logical-operators.md

Which one below is not one of the logical operators of Go?

1. ||
2. != CORRECT
3. !
4. &&

2: That's the "not equal" operator. It's a comparison operator, not a logical operator.

Which one of these types is returned by a logical operator?

1. int
2. byte
3. bool CORRECT
4. float64

3: That's right. All the logical operators return an untyped bool value (true or false).

Which one of these can be used as an operand to a logical operator?

1. int
2. byte
3. bool CORRECT
4. float64

3: That's right. All the logical operators expect a bool value (or a bool expression that yields a bool value).

Which expression below equals to the sentence below?

"age is equal or above 15 and hair color is yellow"

1. age > 15 || hairColor == "yellow"
2. age < 15 || hairColor != "yellow"
3. age >= 15 && hairColor == "yellow" CORRECT
4. age > 15 && hairColor == "yellow"

What does this program print?

package main
import "fmt"

func main() {
    var (
        on  = true
        off = !on
    )

    fmt.Println(!on && !off)
    fmt.Println(!on || !off)
}

1. true true
2. true false
3. false true CORRECT
4. false false
5. error

3: !on is false. !off is true. So, !on && !off is false. And, !on || !off is true.

What does this program print?

package main
import "fmt"

func main() {
    on := 1
    fmt.Println(on == true)
}

1. true
2. false
3. error CORRECT

3: on is int, while true is a bool. So, there's a type mismatch error here. Go is not like other C based languages where 1 equals to true.

What does this code print?

// Note: "a" comes before "b"
a := "a" > "b"
b := "b" <= "c"
fmt.Println(a || b)

1. "a"
2. "b"
3. true CORRECT
4. false
5. error

1-2: Logical operators return a bool value only.

3: Order is like so: "a", "b", "c". So, "a" > "b" is false. "b" <= "c" is true. So, a || b is true.

5: There isn't an error. Strings are actually numbers, so, they're ordered and can be compared using the ordering operators.

What does the following program print?

// Let's say that there are two functions like this:
//
//   super() which returns true and prints "super ".
//   duper() which returns false and prints "duper ".
//
// Remember: Logical operators short-circuit.

package main
import "fmt"

func main() {
    _ = duper() && super()
    _ = super() || duper()
}

// Don't mind about these functions.
// Just focus on the problem.
// These are here just for you to understand it better.
func super() bool {
    fmt.Print("super ")
    return true
}

func duper() bool {
    fmt.Print("duper ")
    return false
}

1. "super duper super duper "
2. "duper super " CORRECT
3. "duper super super duper "
4. "super duper "

1, 3: Remember: Logical operators short-circuit.

2: That's right.

In: duper() && super(), duper() returns false, so, logical AND operator short-circuits and doesn't call super(); so it prints: "duper ".

Then, in: super() || duper(), super() returns true, so, logical OR operator short circuits and doesn't call duper(); so it prints "super ".

4: Think again.

Example program is here.