186 lines
4.5 KiB
Markdown
186 lines
4.5 KiB
Markdown
## What's the difference between if and switch statements?
|
|
1. If statement controls the execution flow but the switch statement does not
|
|
2. If statement is much more readable alternative to a switch statement
|
|
3. Switch statement is much more readable alternative to a if statement *CORRECT*
|
|
|
|
> **1:** They both control the execution flow.
|
|
>
|
|
> **2:** Sometimes true, but, for complex if statements, switch statement can make them much more readable.
|
|
|
|
|
|
## What type of values you can use as a switch condition?
|
|
```go
|
|
switch condition {
|
|
// ....
|
|
}
|
|
```
|
|
1. int
|
|
2. bool
|
|
3. string
|
|
4. Any type of values *CORRECT*
|
|
|
|
> **4:** Unlike most other C based languages, in Go, a switch statement is actually a syntactic-sugar for a if statement. This means that, Go converts a switch statement into an if statement behind the scenes. So, any type of values can be used as a condition.
|
|
|
|
|
|
## What type of values you can use as the case conditions for the following switch statement?
|
|
```go
|
|
switch false {
|
|
case condition:
|
|
// ...
|
|
}
|
|
```
|
|
1. int
|
|
2. bool *CORRECT*
|
|
3. string
|
|
4. Any type of values
|
|
|
|
> **2:** Yes, you can only use bool values because in the example, the switch's condition is a bool.
|
|
|
|
|
|
## What type of values you can use as the case conditions for the following switch statement?
|
|
```go
|
|
switch "go" {
|
|
case condition:
|
|
// ...
|
|
}
|
|
```
|
|
1. int
|
|
2. bool
|
|
3. string *CORRECT*
|
|
4. Any type of values
|
|
|
|
> **3:** Yes, you can only use string values because in the example, the switch's condition is a string.
|
|
|
|
|
|
## What's the problem in the following code?
|
|
```go
|
|
switch 5 {
|
|
case 5:
|
|
case 6:
|
|
case 5:
|
|
}
|
|
```
|
|
1. Case clauses don't have any statements
|
|
2. The same constants are used multiple times in case conditions *CORRECT*
|
|
3. Switch condition cannot be an untyped int
|
|
|
|
> **2:** That's right. 5 is used by multiple case clauses as case conditions. It should be used only once.
|
|
|
|
|
|
## When the following code runs, which case will be executed?
|
|
```go
|
|
weather := "hot"
|
|
switch weather {
|
|
case "very cold", "cold":
|
|
// ...
|
|
case "very hot", "hot":
|
|
// ...
|
|
default:
|
|
// ...
|
|
}
|
|
```
|
|
1. None of them
|
|
2. The first case clause
|
|
3. The second case clause *CORRECT*
|
|
4. The default clause
|
|
|
|
> **3:** That's right. When switch's condition is either "hot" or "very hot", the 2nd case will be executed.
|
|
|
|
|
|
## When the following code runs, which clause will be executed?
|
|
```go
|
|
switch weather := "too hot"; weather {
|
|
default:
|
|
// ...
|
|
case "very cold", "cold":
|
|
// ...
|
|
case "very hot", "hot":
|
|
// ...
|
|
}
|
|
```
|
|
1. None of them
|
|
2. The first case clause
|
|
3. The second case clause
|
|
4. The default clause *CORRECT*
|
|
|
|
> **4:** That's right. The switch's condition doesn't match to any of the case conditions, so the default clause will be executed as a last resort. And the default clause can be in any place inside a switch statement.
|
|
|
|
|
|
## When the following code runs, which case will be executed?
|
|
```go
|
|
switch weather := "too hot"; weather {
|
|
case "very cold", "cold":
|
|
// ...
|
|
case "very hot", "hot":
|
|
// ...
|
|
}
|
|
```
|
|
1. None of them *CORRECT*
|
|
2. The first case clause
|
|
3. The second case clause
|
|
4. The default clause
|
|
|
|
> **1:** That's right. The switch's condition doesn't match to any of the case conditions, and there isn't a default clause. So, none of the clauses will be executed.
|
|
|
|
|
|
## What does the following program print?
|
|
```go
|
|
richter := 2.5
|
|
|
|
switch r := richter; {
|
|
case r < 2:
|
|
fallthrough
|
|
case r >= 2 && r < 3:
|
|
fallthrough
|
|
case r >= 5 && r < 6:
|
|
fmt.Println("Not important")
|
|
case r >= 6 && r < 7:
|
|
fallthrough
|
|
case r >= 7:
|
|
fmt.Println("Destructive")
|
|
}
|
|
```
|
|
1. Nothing
|
|
2. "Not important" *CORRECT*
|
|
3. "Destructive"
|
|
|
|
> **2:** That's right! When fallthrough is used, the following clause will be executed without checking its condition.
|
|
|
|
|
|
## What's the problem in the following code?
|
|
```go
|
|
richter := 14.5
|
|
|
|
switch r := richter; {
|
|
case r >= 5 && r < 6:
|
|
fallthrough
|
|
fmt.Println("Moderate")
|
|
default:
|
|
fmt.Println("Unknown")
|
|
case r >= 7:
|
|
fmt.Println("Destructive")
|
|
}
|
|
```
|
|
1. default clause should be the last clause
|
|
2. default clause should have a fallthrough statement
|
|
3. The first case should use the fallthrough statement as its last statement *CORRECT*
|
|
|
|
> **3:** That's right! In a case block, fallthrough can only be used as the last statement.
|
|
|
|
|
|
## What does the following program print?
|
|
```go
|
|
n := 8
|
|
|
|
switch {
|
|
case n > 5, n < 1:
|
|
fmt.Println("n is big")
|
|
case n == 8:
|
|
fmt.Println("n is 8")
|
|
}
|
|
```
|
|
1. Nothing
|
|
2. "n is 8"
|
|
3. "n is big" *CORRECT*
|
|
|
|
> **3:** That's right! Switch runs top-to-bottom and case conditions run left-to-right. Here, 1st case's 1st condition expression (which is n > 5) will yield true, so the 1st case will be executed. |