Dart 中的 Switch 语句使用 == 比较 integer、string、或者编译时常量。
比较的对象必须都是同一个类的实例（并且不是 其子类）

每个非空的 case 语句都必须有一个 break 语句。
另外还可以通过 continue、 throw 或 者 return 来结束非空 case 语句。
当没有 case 语句匹配的时候，可以使用 default 语句来匹配这种默认情况。

```dart
var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    executeClosed();
    break;
  case 'PENDING':
    executePending();
    break;
  case 'APPROVED':
    executeApproved();
    break;
  case 'DENIED':
    executeDenied();
    break;
  case 'OPEN':
    executeOpen();
    break;
  default:
    executeUnknown();
}

// 在 Dart 中的空 case 语句中可以不要 break 语句：
var command = 'CLOSED';
switch (command) {
  case 'CLOSED': // Empty case falls through.
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}

//  使用 continue 语句跳转到对应的标签（label）处继续执行
var command = 'CLOSED';
switch (command) {
  case 'CLOSED':
    executeClosed();
    continue nowClosed;
    // Continues executing at the nowClosed label.
nowClosed:
  case 'NOW_CLOSED':
    // Runs for both CLOSED and NOW_CLOSED.
    executeNowClosed();
    break;
}
```


dart.md

switch 是编写一连串 if - else 语句的简便方法。
它运行第一个值等于条件表达式的 case 语句。

Go 只运行选定的 case，而非之后所有的 case。
Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。
除非以 fallthrough 语句结束，否则分支会自动终止。
Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

```go
package main
import (
  "fmt"
  "runtime"
)
func main() {
  fmt.Print("Go runs on ")
  switch os := runtime.GOOS; os {
    case "darwin":
      fmt.Println("OS X.")
    case "linux":
      fmt.Println("Linux.")
    default:
      // freebsd, openbsd,
      // plan9, windows...
      fmt.Printf("%s.\n", os)
  }
}
// Go runs on Linux.


// switch 的 case 语句从上到下顺次执行，直到匹配成功时停止。
package main
import (
  "fmt"
  "time"
)
func main() {
  fmt.Println("When's Saturday?")
  fmt.Println(time.Now())
  fmt.Println(time.Saturday)
  today := time.Now().Weekday()
  switch time.Saturday {
    case today + 0:
      fmt.Println("Today.")
    case today + 1:
      fmt.Println("Tomorrow.")
    case today + 2:
      fmt.Println("In two days.")
    default:
      fmt.Println("Too far away.")
  }
}
// When's Saturday?
// 2009-11-10 23:00:00 +0000 UTC m=+0.000000001
// Saturday
// Too far away.


// 没有条件的 switch 同 switch true 一样。
// 这种形式能将一长串 if-then-else 写得更加清晰。
package main
import (
  "fmt"
  "time"
)
func main() {
  t := time.Now()
  fmt.Println(t)
  switch {
    case t.Hour() < 12:
      fmt.Println("Good morning!")
    case t.Hour() < 17:
      fmt.Println("Good afternoon.")
    default:
      fmt.Println("Good evening.")
  }
}

func unhex(c byte) byte {
  switch {
  case '0' <= c && c <= '9':
    return c - '0'
  case 'a' <= c && c <= 'f':
    return c - 'a' + 10
  case 'A' <= c && c <= 'F':
    return c - 'A' + 10
  }
  return 0
}

// switch 并不会自动下溯，但 case 可通过逗号分隔来列举相同的处理条件。
func shouldEscape(c byte) bool {
  switch c {
  case ' ', '?', '&', '=', '#', '+', '%':
    return true
  }
  return false
}
```

类型开关 (type switch) 比较类型而非值。可以用来发现一个接口值的类型。

```go
whatAmI := func(i interface{}) {
  switch t := i.(type) {
  case bool:
    fmt.Println("I'm a bool")
  case int:
    fmt.Println("I'm an int")
  default:
    fmt.Printf("Don't know type %T\n", t)
  }
}
whatAmI(true)
whatAmI(1)
whatAmI("hey")
// I'm a bool
// I'm an int
// Don't know type string
```


go.md

## match 提供了 `@` 符号来绑定变量到名称：

```rust
// `age` 函数，返回一个 `u32` 值。
fn age() -> u32 {
    15
}
fn main() {
    println!("Tell me what type of person you are");
    match age() {
        0             => println!("I haven't celebrated my first birthday yet"),
        // 可以直接匹配（`match`） 1 ..= 12，但那样的话孩子会是几岁？
        // 相反，在 1 ..= 12 分支中绑定匹配值到 `n` 。现在年龄就可以读取了。
        n @ 1  ..= 12 => println!("I'm a child of age {:?}", n),
        n @ 13 ..= 19 => println!("I'm a teen of age {:?}", n),
        // 不符合上面的范围。返回结果。
        n             => println!("I'm an old person of age {:?}", n),
    }
}
```

```rust
fn some_number() -> Option<u32> {
    Some(42)
}
fn main() {
    match some_number() {
        // 得到 `Some` 可变类型，如果它的值（绑定到 `n` 上）等于 42，则匹配。
        Some(n @ 42) => println!("The Answer: {}!", n),
        // 匹配任意其他数字。
        Some(n)      => println!("Not interesting... {}", n),
        // 匹配任意其他值（`None` 可变类型）。
        _            => (),
    }
}
```


条件选择