Go：接口

接口既约定

Go 语言中接口是抽象类型，与具体类型不同，不暴露数据布局、内部结构及基本操作，仅提供一些方法，拿到接口类型的值，只能知道它能做什么，即提供了哪些方法。

func Fprintf(w io.Writer, format string, args ...interface{}) (int, error)func Printf(format string, args ...interface{}) (int, error) {return Fprintf(os.Stdout, format, args...)
}func Sprintf(format string, args ...interface{}) string {var buf bytes.BufferFprintf(&buf, format, args...)return buf.String()
}

fmt.Fprintf函数用于格式化输出，其第一个形参是io.Writer接口类型。io.Writer接口封装了基础写入方法，定义了Write方法，要求将数据写入底层数据流，并返回实际写入字节数等。

package io// Writer接口封装了基础的写入方法
type Writer interface {// Write 从 p 向底层数据流写入 len(p) 个字节的数据// 返回实际写入的字节数 (0 <= n <= len(p))// 如果没有写完，那么会返回遇到的错误// 在 Write 返回 n < len(p) 时，err 必须为非 nil// Write 不允许修改 p 的数据，即使是临时修改// 实现时不允许残留 p 的引用Write(p []byte) (n int, err error)
}

这一接口定义了fmt.Fprintf和调用者之间的约定，调用者提供的具体类型（如*os.File 、*bytes.Buffer ）需包含与Write方法签名和行为一致的方法，保证fmt.Fprintf能使用满足该接口的参数，体现了可取代性，即只要满足接口，具体类型可相互替换。

type ByteCounter intfunc (c *ByteCounter) Write(p []byte) (int, error) {*c += ByteCounter(len(p))return len(p), nil
}

以ByteCounter类型为例，它实现了Write方法，满足io.Writer接口约定，可在fmt.Fprintf中使用。

package fmt// 在字符串格式化时如果需要一个字符串
// 那么就调用这个方法来把当前值转化为字符串
// Print 这种不带格式化参数的输出方式也是调用这个方法
type Stringer interface {String() string
}

fmt包还有fmt.Stringer接口，定义了String方法。类型实现该方法，就能在字符串格式化时将自身转化为字符串输出，如之前的Celsius 、*IntSet类型添加String方法后，可满足该接口，实现特定格式输出。

接口类型

接口类型定义了一套方法，具体类型要实现某接口，必须实现该接口定义的所有方法。如io.Writer接口抽象了所有可写入字节的类型，像文件、内存缓冲区等，具体类型若要符合io.Writer ，就得实现其Write方法。

package iotype Reader interface {Read(p []byte) (n int, err error)
}type Closer interface {Close() error
}

Reader接口：抽象了所有可读取字节的类型，定义了Read方法，用于从类型中读取数据。
Closer接口：抽象了所有可关闭的类型，如文件、网络连接等，定义了Close方法。

type ReadWriter interface {ReaderWriter
}type ReadWriteCloser interface {ReaderWriterCloser
}type ReadWriter interface {Read(p []byte) (n int, err error)Write(p []byte) (n int, err error)
}type ReadWriter interface {Read(p []byte) (n int, err error)Writer
}

可通过组合已有接口得到新接口，如ReadWriter接口由Reader和Writer接口组合而成，ReadWriteCloser接口由Reader 、Writer和Closer接口组合而成，这种方式称为嵌入式接口，类似嵌入式结构，可直接使用组合后的接口，无需逐一写出其包含的方法。
三种声明效果一致，方法定义顺序无意义，关键是接口的方法集合。

实现接口

具体类型实现接口需实现接口定义的所有方法，如*os.File实现了io.Reader 、Writer 、Closer和ReaderWriter接口，*bytes.Buffer实现了Reader 、Writer和ReaderWriter接口。

var w io.Writer
w = os.Stdout         // OK: *os.File有Write方法
w = new(bytes.Buffer) // OK: *bytes.Buffer有Write方法
w = time.Second       // 编译错误: time.Duration缺少Write方法var rwc io.ReadWriteCloser
rwc = os.Stdout         // OK: *os.File有Read、Write、Close方法
rwc = new(bytes.Buffer) // 编译错误: *bytes.Buffer缺少Close方法// 当右侧表达式也是一个接口时，该规则也有效：
w = rwc                 // OK: io.ReadWriteCloser有Write方法
rwc = w                 // 编译错误: io.Writer 缺少Close方法

接口赋值规则 ：当表达式实现接口时可赋值给对应接口类型变量，若右侧表达式也是接口，要满足接口间方法包含关系。如io.ReadWriteCloser接口包含io.Writer接口方法，实现前者的类型也实现了后者。

type IntSet struct { /*... */ }
func (*IntSet) String() stringvar _ = IntSet{}.String() // 编译错误: String 方法需要*IntSet 接收者var s IntSet
var _ = s.String() // OK: s 是一个变量，&s有 String 方法var _ fmt.Stringer = &s // OK
var _ fmt.Stringer = s // 编译错误: IntSet缺少String 方法

类型方法与接口实现的关系：类型的方法接收者有值类型和指针类型，编译器可隐式处理值类型变量调用指针方法（前提变量可变）。如IntSet类型String方法接收者为指针类型，不能从无地址的IntSet值调用，但可从IntSet变量调用，且*IntSet实现了fmt.Stringer接口。

var any interface{}
any = true
any = 12.34
any = "hello"
any = map[string]int{"one": 1}
any = new(bytes.Buffer)

interface{}为空接口类型，对实现类型无方法要求，可把任何值赋给它，如fmt.Println 、errorf等函数能接受任意类型参数就是利用了空接口。但不能直接使用空接口值，需通过类型断言等方法还原实际值。

隐式声明

编译器可隐式判断类型实现接口，如*bytes.Buffer的任意值（包括nil ）都实现了io.Writer接口，可简化变量声明。非空接口常由指针类型实现，但也有其他引用类型可实现接口，如slice 、map 、函数类型等，且基本类型也能通过定义方法实现接口，如time.Duration实现了fmt.Stringer 。

type Text interface {Pages() intWords() intPageSize() int
}type Audio interface {Stream() (io.ReadCloser, error)RunningTime() time.DurationFormat() string // 比如 "MP3"、"WAV"
}type Video interface {Stream() (io.ReadCloser, error)RunningTime() time.DurationFormat() string // 比如 "MP4"、"WMV"Resolution() (x, y int)
}type Streamer interface {Stream() (io.ReadCloser, error)RunningTime() time.DurationFormat() string
}

接口用于抽象分组：以管理或销售数字文化商品的程序为例，定义多种具体类型（如Album 、Book等），可针对不同属性定义接口（如Artifacts 、Pages 、Audio 、Video ），还可进一步组合接口（如Streamer ）。Go 语言可按需定义抽象和分组，不用修改原有类型定义，从具体类型提取共性用接口表示。

使用 flag.Value 来解析参数

var period = flag.Duration("period", 1*time.Second, "sleep period")func main() {flag.Parse()fmt.Printf("Sleeping for %v...", *period)time.Sleep(*period)fmt.Println()
}

以实现睡眠指定时间功能的程序为例，通过flag.Duration函数创建time.Duration类型的标志变量period ，用户可用友好方式指定时长，如50ms 、2m30s等，程序进入睡眠前输出睡眠时长。

package flag// Value 接口代表了存储在标志内的值
type Value interface {String() stringSet(string) error
}

flag.Value接口定义了String和Set方法。String方法用于格式化标志对应的值，输出命令行帮助消息，实现该接口的类型也是fmt.Stringer ；Set方法用于解析传入的字符串参数并更新标志值，是String方法的逆操作。

自定义实现flag.Value接口

// *celsiusFlag 满足 flag.Value 接口
type celsiusFlag struct{ Celsius }func (f *celsiusFlag) Set(s string) error {var unit stringvar value float64fmt.Sscanf(s, "%f%s", &value, &unit) // 无须检查错误switch unit {case "C", "°C":f.Celsius = Celsius(value)return nilcase "F", "°F":f.Celsius = FToC(Fahrenheit(value))return nil}return fmt.Errorf("invalid temperature %q", s)
}

定义celsiusFlag类型，内嵌Celsius类型，因已有String方法，只需实现Set方法来满足flag.Value接口。Set方法中，使用fmt.Sscanf从输入字符串解析浮点值和单位，根据单位（C或F ）进行摄氏温度和华氏温度转换，若输入无效则返回错误。

func CelsiusFlag(name string, value Celsius, usage string) *Celsius {f := celsiusFlag{value}flag.CommandLine.Var(&f, name, usage)return &f.Celsius
}

CelsiusFlag函数封装相关逻辑，返回指向内嵌Celsius字段的指针，并通过flag.CommandLine.Var方法将标志加入命令行标记集合。

接口值

接口值由具体类型（动态类型）和该类型对应的值（动态值）两部分组成。在 Go 语言中，类型是编译时概念，不是值，接口值的类型部分用类型描述符表示。

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

初始化：接口变量初始化为零值，即动态类型和动态值都为nil ，此时为nil接口值，调用其方法会导致程序崩溃。

将*os.File类型的os.Stdout赋给io.Writer接口变量w ，会隐式转换，动态类型设为*os.File ，动态值为os.Stdout副本，调用w.Write实际调用(*os.File).Write 。

将*bytes.Buffer类型的new(bytes.Buffer)赋给w ，动态类型变为*bytes.Buffer ，动态值为新分配缓冲区指针，调用w.Write会追加内容到缓冲区。
再将nil赋给w ，动态类型和动态值又变回nil 。
比较：接口值可使用==和!=操作符比较，两个接口值nil或动态类型完全一致且动态值相等时相等。但当动态类型一致，动态值不可比较（如 slice ）时，比较会导致崩溃。接口值可作为map的键和switch语句操作数，但需注意动态值的可比较性。
获取动态类型：处理错误或调试时，可使用fmt包的%T格式化动词获取接口值的动态类型，其内部通过反射实现。

注意：含有空指针的非空接口

空接口值不包含任何信息，动态类型和动态值均为nil ；而仅动态值为nil ，动态类型非nil的接口值，是含有空指针的非空接口，二者存在微妙区别，容易造成编程陷阱。
const debug = truefunc main() {var buf *bytes.Bufferif debug {buf = new(bytes.Buffer) // 启用输出收集}f(buf) // 注意: 微妙的错误if debug {//...使用 buf...}
}// 如果 out 不是 nil, 那么会向其写入输出的数据
func f(out io.Writer) {//...其他代码...if out!= nil {out.Write([]byte("done!\n"))}
}
示例：程序中当debug为true时，主函数创建*bytes.Buffer指针buf ，并在debug为true时初始化为new(bytes.Buffer) ，然后调用函数f ，f接收io.Writer接口类型参数out ，在out非nil时向其写入数据。
分析：当debug为false时，buf为nil ，将其传给f ，此时out的动态类型是*bytes.Buffer ，动态值为nil ，是含有空指针的非空接口。调用out.Write时，由于*bytes.Buffer类型的Write方法要求接收者非空，会导致程序崩溃。这是因为虽指针拥有的方法满足接口，但违背了方法隐式前置条件。
var buf io.Writer
if debug {buf = new(bytes.Buffer) // 启用输出收集
}
f(buf) // OK
解决：将main函数中buf类型修改为io.Writer ，这样在debug为false时，buf为nil ，符合io.Writer接口的零值状态，调用f时可避免将功能不完整的值传给接口，防止程序崩溃。

使用 sort.Interface 来排序

package sorttype Interface interface {Len() intLess(i, j int) bool // i, j 是序列元素的下标Swap(i, j int)
}

作用：sort包提供通用排序功能，sort.Interface接口用于指定通用排序算法与具体序列类型间的协议，使排序算法不依赖序列和元素具体布局，实现灵活排序。
定义：该接口有Len（返回序列长度）、Less（比较元素大小，返回bool ）、Swap（交换元素）三个方法。

type StringSlice []stringfunc (p StringSlice) Len() int {return len(p)
}
func (p StringSlice) Less(i, j int) bool {return p[i] < p[j]
}
func (p StringSlice) Swap(i, j int) {p[i], p[j] = p[j], p[i]
}sort.Sort(StringSlice(names))

示例：定义StringSlice类型，实现sort.Interface接口的三个方法，通过sort.Sort(StringSlice(names))可对字符串切片names排序。sort包还提供StringSlice类型和Strings函数，简化为sort.Strings(names) ，且这种技术可复用，添加额外逻辑实现不同排序方式。

复杂数据结构排序示例

type Track struct {Title  stringArtist stringAlbum  stringYear   intLength time.Duration
}var tracks = []*Track{{"Go", "Delilah", "From the Roots Up", 2012, length("3m38s")},{"Go Ahead", "Alicia Keys", "As I Am", 2007, length("4m36s")},{"Ready 2 Go", "Martin Solveig", "Smash", 2011, length("4m24s")},{"Go", "Moby", "Moby", 1992, length("3m37s")},
}func length(s string) time.Duration {d, err := time.ParseDuration(s)if err!= nil {panic(s)}return d
}func printTracks(tracks []*Track) {const format = "%v\t%v\t%v\t%v\t%v\n"tw := tabwriter.NewWriter(os.Stdout, 0, 8, 2,'', 0)fmt.Fprintf(tw, format, "Title", "Artist", "Album", "Year", "Length")fmt.Fprintf(tw, format, "----", "------", "-----", "----", "------")for _, t := range tracks {fmt.Fprintf(tw, format, t.Title, t.Artist, t.Album, t.Year, t.Length)}tw.Flush() // 计算各列宽度并输出表格
}type byArtist []*Trackfunc (x byArtist) Len() int {return len(x)
}
func (x byArtist) Less(i, j int) bool {return x[i].Artist < x[j].Artist
}
func (x byArtist) Swap(i, j int) {x[i], x[j] = x[j], x[i]
}sort.Sort(byArtist(tracks))type reverse struct{ i interface{} }func (r reverse) Less(i, j int) bool {return r.i.(Interface).Less(j, i)
}
func Reverse(data Interface) Interface {return reverse{data}
}sort.Reverse(byArtist(tracks))

音乐播放列表排序：定义Track结构体表示音乐曲目，tracks为*Track指针切片。要按Artist字段排序，定义byArtist类型实现sort.Interface接口，通过sort.Sort(byArtist(tracks))排序。若需反向排序，使用sort.Reverse函数，其内部基于嵌入sort.Interface的reverse类型实现。

type byYear []*Trackfunc (x byYear) Len() int {return len(x)
}
func (x byYear) Less(i, j int) bool {return x[i].Year < x[j].Year
}
func (x byYear) Swap(i, j int) {x[i], x[j] = x[j], x[i]
}sort.Sort(byYear(tracks))type customSort struct {t    []*Trackless func(x, y *Track) bool
}func (x customSort) Len() int {return len(x.t)
}
func (x customSort) Less(i, j int) bool {return x.less(x.t[i], x.t[j])
}
func (x customSort) Swap(i, j int) {x.t[i], x.t[j] = x.t[j], x.t[i]
}sort.Sort(customSort{tracks, func(x, y *Track) bool {if x.Title!= y.Title {return x.Title < y.Title}if x.Year!= y.Year {return x.Year < y.Year}if x.Length!= y.Length {return x.Length < y.Length}return false
}})func IntsAreSorted(values []int) bool {for i := 1; i < len(values); i++ {if values[i] < values[i-1] {return false}}return true
}

按其他字段排序：如按Year字段排序，定义byYear类型实现接口方法，调用sort.Sort(byYear(tracks)) 。customSort结构体类型，组合slice和函数，只需定义比较函数就能实现新排序。

http.Handler 接口

package httptype Handler interface {ServeHTTP(w ResponseWriter, r *Request)
}func ListenAndServe(address string, h Handler) error

http.Handler接口定义了ServeHTTP方法，接收http.ResponseWriter和*http.Request作为参数。ListenAndServe函数用于启动服务器，接收服务器地址和Handler接口实例，持续运行处理请求，直到出错。

error 接口

type error interface {Error() string
}

error是一个接口类型，定义了Error()方法，返回类型为string ，用于返回错误消息。

创建error实例的方法

package errorsfunc New(text string) error { return &errorString{text} }type errorString struct { text string }func (e *errorString) Error() string { return e.text }

errors.New函数：构造error最简单的方式，传入指定错误消息，返回包含该消息的error实例。error包中New函数通过创建errorString结构体指针实现，这样可避免布局变更问题，且保证每次创建的error实例不相等。

func Errorf(format string, args...interface{}) error {return errors.New(Sprintf(format, args...))
}

fmt.Errorf函数：更常用的封装函数，除创建error实例外，还提供字符串格式化功能，其内部调用errors.New 。

不同的error类型实现

errorString类型：满足error接口的最基本类型，通过结构体指针实现。
syscall.Errno类型：syscall包定义的数字类型，在 UNIX 平台上，其Error方法从字符串表格中查询错误消息，是系统调用错误的高效表示，也满足error接口。

类型断言

类型断言是作用于接口值的操作，形式为x.(T) ，x是接口类型表达式，T是断言类型，用于检查操作数的动态类型是否满足指定断言类型。

var w io.Writer
w = os.Stdout
f := w.(*os.File)    // 成功: f == os.Stdout
c := w.(*bytes.Buffer) // 崩溃: 接口持有的是 *os.File，不是 *bytes.Buffer

断言类型为具体类型：若T是具体类型，类型断言检查x的动态类型是否为T 。检查成功，结果为x的动态值，类型为T ；检查失败，操作崩溃。如w.(*os.File) ，当w动态类型是*os.File时成功，否则崩溃。

var w io.Writer
w = os.Stdout
rw := w.(io.ReadWriter) // 成功: *os.File 有 Read 和 Write 方法
w = new(ByteCounter)
rw = w.(io.ReadWriter) // 崩溃: *ByteCounter 没有 Read 方法

断言类型为接口类型：若T是接口类型，检查x的动态类型是否满足T 。成功则结果仍是接口值，动态类型和值不变，但接口方法集可能变化。如w.(io.ReadWriter) ，若w动态类型满足该接口，可获取更多方法。

w = rw               // io.ReadWriter 可以赋给 io.Writer
w = rw.(io.Writer) // 仅当 rw == nil 时失败var w io.Writer = os.Stdout
f, ok := w.(*os.File)    // 成功: ok, f == os.Stdout
b, ok := w.(*bytes.Buffer) // 失败:!ok, b == nil

空接口值：操作数为空接口值时，类型断言失败。一般很少从接口类型向更宽松类型做断言，多数情况与赋值一致，仅在操作nil时有区别。

if w, ok := w.(*os.File); ok {//...use w...
}

双返回值形式：在需检测断言是否成功的场景，类型断言可返回两个值，第二个布尔值表示断言是否成功。如f, ok := w.(*os.File) ，ok为true时，f为断言成功后的值，否则f为断言类型零值，常用于if表达式中进行条件操作。当操作数是变量时，可能出现返回值覆盖原有值的情况。

使用类型断言来识别错误

package osfunc IsExist(err error) bool
func IsNotExist(err error) bool
func IsPermission(err error) boolfunc IsNotExist(err error) bool {// 注意: 不健壮return strings.Contains(err.Error(), "file does not exist")
}

os包中文件操作返回的错误通常因文件已存储、文件没找到、权限不足三类原因产生。os包提供IsExist 、IsNotExist 、IsPermission等函数对错误分类。简单通过检查错误消息字符串判断错误的方法不可靠，因不同平台错误消息可能不同，在生产级代码中不够健壮。

结构化错误类型

package os// PathError 记录了错误以及错误相关的操作和文件路径
type PathError struct {Op   stringPath stringErr  error
}func (e *PathError) Error() string {return e.Op + " " + e.Path + ": " + e.Err.Error()
}

os包定义PathError类型表示与文件路径相关操作的错误，包含Op（操作）、Path（路径）、Err（底层错误）字段，还有类似的LinkError 。PathError的Error方法拼接字段返回错误字符串，其结构保留底层信息。很多客户端忽略PathError ，直接调用Error方法处理错误，但对于需区分错误的客户端，可使用类型断言检查错误类型。

在错误识别中的应用

var ErrNotExist = errors.New("file does not exist")// IsNotExist 返回一个布尔值，该值表明错误是否代表文件或目录不存在
// report that a file or directory does not exist. It is satisfied by
// ErrNotExist 和其他一些系统调用错误会返回 true
func IsNotExist(err error) bool {if pe, ok := err.(*PathError); ok {err = pe.Err}return err == syscall.ENOENT || err == ErrNotExist
}// 实际使用
_, err := os.Open("/no/such/file")
fmt.Println(os.IsNotExist(err)) // "true"

以IsNotExist函数为例，通过类型断言err.(*PathError)判断错误是否为PathError类型，若成功，进一步判断底层错误是否为syscall.ENOENT或等于自定义的ErrNotExist ，以此确定错误是否代表文件或目录不存在，展示了类型断言在准确识别错误类型中的作用。错误识别应在失败操作发生时处理，避免错误信息合并导致结构信息丢失。

通过接口类型断言来查询特性

性能优化场景引入

func writeHeader(w io.Writer, contentType string) error {if _, err := w.Write([]byte("Content-Type: ")); err!= nil {return err}if _, err := w.Write([]byte(contentType)); err!= nil {return err}//...
}// writeString 将 s 写入 w
// 如果 w 有 WriteString 方法，那么将直接调用该方法
func writeString(w io.Writer, s string) (n int, err error) {type stringWriter interface {WriteString(string) (n int, err error)}if sw, ok := w.(stringWriter); ok {return sw.WriteString(s) // 避免了内存复制}return w.Write([]byte(s)) // 分配了临时内存
}func writeHeader(w io.Writer, contentType string) error {if _, err := writeString(w, "Content-Type: "); err!= nil {return err}if _, err := writeString(w, contentType); err!= nil {return err}//...
}

在类似 Web 服务器向客户端响应 HTTP 头字段的场景中，io.Writer用于写入响应内容。因Write方法需字节切片，将字符串转换为字节切片会有内存分配和复制开销，影响性能。而很多实现io.Writer的类型（如*bytes.Buffer 、*os.File等）有WriteString方法，可避免临时内存分配。

利用接口类型断言优化

interface {io.WriterWriteString(s string) (n int, err error)
}

定义stringWriter接口，仅包含WriteString方法。通过类型断言w.(stringWriter)判断io.Writer接口变量w的动态类型是否满足该接口。若满足，直接调用WriteString方法避免内存复制；若不满足，再使用Write方法。将检查逻辑封装在writeString工具函数，并在writeHeader等函数中调用，避免代码重复。

接口特性约定与应用拓展

这种方式依赖于一种隐式约定，即若类型满足特定接口，其WriteString方法与Write([]byte(s))等效。此技术不仅适用于io包相关接口，在fmt.Printf内部，也通过类型断言从通用类型interface{}中识别error或fmt.Stringer接口，确定格式化方法，若不满足则用反射处理其他类型。

类型分支

接口的两种风格

第一种风格：像io.Reader 、io.Writer等接口，突出满足接口的具体类型之间的相似性，隐藏具体类型的布局和特有功能，强调接口方法。
第二种风格：将接口作为具体类型的联合，利用接口值容纳多种具体类型的能力，运行时通过类型断言区分类型并处理，强调具体类型，不注重信息隐藏，这种风格称为可识别联合。、

import "database/sql"func listTracks(db sql.DB, artist string, minYear, maxYear int) {result, err := db.Exec("SELECT * FROM tracks WHERE artist =? AND? <= year AND year <=?",artist, minYear, maxYear)//...
}func sqlQuote(x interface{}) string {if x == nil {return "NULL"} else if _, ok := x.(int); ok {return fmt.Sprintf("%d", x)} else if _, ok := x.(uint); ok {return fmt.Sprintf("%d", x)} else if b, ok := x.(bool); ok {if b {return "TRUE"}return "FALSE"} else if s, ok := x.(string); ok {return sqlQuoteString(s) // (not shown)} else {panic(fmt.Sprintf("unexpected type %T: %v", x, x))}
}// 优化
func sqlQuote(x interface{}) string {switch x := x.(type) {case nil:return "NULL"case int, uint:return fmt.Sprintf("%d", x) // 这里 x 类型为 interface{}case bool:if x {return "TRUE"}return "FALSE"case string:return sqlQuoteString(x) // (未显示具体代码)default:panic(fmt.Sprintf("unexpected type %T: %v", x, x))}
}

示例：以数据库 SQL 查询 API 为例，sqlQuote函数将参数值转为 SQL 字面量，原代码使用一系列类型断言的if - else语句，可通过类型分支（type switch ）简化。类型分支语句switch x.(type) ，操作数为接口值，分支基于接口值的动态类型判定，nil分支需x == nil ，default分支在其他分支不满足时执行，且不允许使用fallthrough 。类型分支还有扩展形式switch x := x.(type) ，能将提取的原始值绑定到新变量，使代码更清晰，如改写后的sqlQuote函数。类型分支可方便处理多种类型，但传入类型不匹配时会崩溃。