Golang switch 进阶

一. case 表达式中的子表达式应该不重复

bad(编译不通过) :
第九行和第十一行的 3 重复了

package main

import "fmt"

var a = []uint{1, 2, 3, 4, 5, 6}

func main() {
	switch 1 {
	case 1, 2, 3:
		fmt.Println("1 or 2 or 3")
	case 3, 4:
		fmt.Println("3 or 4")
	}
}

good :

package main

import "fmt"

var a = []uint{1, 2, 3, 4, 5, 6}

func main() {
	switch 1 {
	case 1, 2, 3:
		fmt.Println("1 or 2 or 3")
	case 4:
		fmt.Println("4")
	}
}

二. 使用表达值突破 一 的限制

三个case中都包含2，但是由于前两个case是表达式a[1], 这个是可以正常运行的

package main

import "fmt"

var a = []uint{1, 2, 3, 4, 5, 6}

func main() {
	switch uint(4) {
	case 1, a[1], 3:
		fmt.Println("1 or 2 or 3")
	case a[1], 4:
		fmt.Println("2 or 4")
	case 2:
		fmt.Println("2")
	}
}

三. case 类型匹配

switch p1.(type)

1. 这里要求 p1 实现了某个 接口
2. case中的表达式是这个 接口的具体实现类型

example 1 (good) :

package main

import "fmt"

var b uint8
var c byte

type MyInt interface {
	pr()
}

type MI int
type BMI int

func (M MI) pr() {
	fmt.Println(M)
}

func (M BMI) pr() {
	fmt.Println(M)
}

func main() {
	var d MyInt
	d = MI(b)
	switch d.(type) {
	case MI:
		fmt.Println("BMI")
	case BMI:
		fmt.Println("BMI")
	}
}

example 2(good):

package main

import "fmt"

var a string
var b uint8

func main() {
	d := interface{}(b)
	switch d.(type) {
	case string:
		fmt.Println("string")
	case uint8:
		fmt.Println("unit8")
	}
}

example 3(bad)：
违反了 一，因为 byte 本质就是 unit8 , 编译不通过

package main

import "fmt"

var a string
var b uint8

func main() {
	d := interface{}(b)
	switch d.(type) {
	case string:
		fmt.Println("string")
	case uint8:
		fmt.Println("unit8")
	case byte:
		fmt.Println("byte")
	}
}

example 4(bad) :
b非接口类型，编译不通过

package main

import "fmt"

var a string
var b uint8

func main() {
    switch b.(type) {
       case string:
       fmt.Println("string")
       case uint8:
       fmt.Println("unit8")
   }
}

四. switch 中的自动类型转换

switch <value> :
case <case-value>

如果case-value 是常量，会尝试进行自动类型转换后，再和 value 匹配
right :

package main

import "fmt"

func main() {
	switch 1 + 1 {
	case 2:
		fmt.Println(2)
	}
}

error : main.go:8:7: invalid case b in switch on 1 + 1 (mismatched types int64 and int)

package main

import "fmt"

func main() {
	b := int64(2)
	switch 1 + 1 {
	case b: 
		fmt.Println(2)
	}
}