网站开发的合同编写,网站成品超市,百度seo发帖推广,企业常用的网络推广策略Go语言程序设计-第7章–接口
接口类型是对其他类型行为的概括与抽象。
Go 语言的接口的独特之处在于它是隐式实现。对于一个具体的类型#xff0c;无须声明它实现了哪些接口#xff0c;只要提供接口所必须实现的方法即可。
7.1 接口即约定
7.2 接口类型
package iotype …Go语言程序设计-第7章–接口
接口类型是对其他类型行为的概括与抽象。
Go 语言的接口的独特之处在于它是隐式实现。对于一个具体的类型无须声明它实现了哪些接口只要提供接口所必须实现的方法即可。
7.1 接口即约定
7.2 接口类型
package iotype Reader interface {Read(p []byte) (n int, err error)
}type Closer interface {Close() error
}组合已有接口得到新的接口。
嵌入式声明
type ReadWriter interface {ReaderWriter
}直接声明
type ReadWriter interface {Read(p []byte) (n int, err error)Close() error
}混合声明
type ReadWriter interface {Read(p []byte) (n int, err error)Writer
}7.3 实现接口
接口的实现规则很简单仅当一个表达式实现了一个接口时这个表达式才可以赋值给接口。
var w io.Writer
w os.Stdout // OK *os.File 有 Writable 方法
w new(bytes.Buffer) // OK: * bytes.Buffer 有 Writable 方法
w time.Second // 编译错误 time.Duration 没有 Writable 方法如果方法的接收者是一个指针类型就不可以从一个无地址的对象上调用该方法如
type IntSet struct {}
func (*IntSet) String() stringvar _ IntSet{}.String() // 编译错误String 方法需要 *IntSet 接收者可以从一个 IntSet 变量上调用此方法
var s IntSet
var _ s.String() // OK: s 是一个变量s 有 String 方法。因为只有 *IntSet 有 String 方法所以也只有 *IntSet 实现了 fmt.Stringer 接口。
var _ fmt.Stringer s // OK
var _ fmt.Stringer s // 编译错误 IntSet 缺少 String 方法。可以把任何数据赋值给空接口类型。
var any interface{} // 空接口类型
any true
any 12.34
any hello
any map[string]int {one:1}
fmt.Println(any)判断是否实现接口只需要比较具体类型和接口类型的方法所以没有必要在具体类型的定义中声明这种关系。
非空的接口类型如 io.Writer通常由一个指针类型来实现特别是当接口类型的一个或多个方法暗示会修改接收者的情形。一个指向结构的指针才是最常见的方法接收者。
7.4 使用 flat.Value 来解析参数
tempflag.go
package mainimport (flagfmt
)type Celsius float64
type Fahrenheit float64func CToF(c Celsius) Fahrenheit { return Fahrenheit(c*9.0/5.0 32.0) }
func FToC(f Fahrenheit) Celsius { return Celsius((f - 32.0) * 5.0 / 9.0) }func (c Celsius) String() string { return fmt.Sprintf(%g°C, c) }/*
//!flagvalue
package flag// Value is the interface to the value stored in a flag.
type Value interface {String() stringSet(string) error
}
//!-flagvalue
*///!celsiusFlag
// *celsiusFlag satisfies the flag.Value interface.
type celsiusFlag struct{ Celsius }func (f *celsiusFlag) Set(s string) error {var unit stringvar value float64fmt.Sscanf(s, %f%s, value, unit) // no error check neededswitch 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//!CelsiusFlag// CelsiusFlag defines a Celsius flag with the specified name,
// default value, and usage, and returns the address of the flag variable.
// The flag argument must have a quantity and a unit, e.g., 100C.
func CelsiusFlag(name string, value Celsius, usage string) *Celsius {f : celsiusFlag{value}flag.CommandLine.Var(f, name, usage)return f.Celsius
}
var temp CelsiusFlag(temp, 20.0, the temperature)
func main() {flag.Parse()fmt.Println(*temp)
}7.5 接口值
一个接口类型的值简称接口值其实有两个部分一个具体类型和该类型的一个值。二者称为接口的动态类型和动态值。
用类型描述符来提供每个类型的具体信息比如它的名字和方法。对于一个接口值类型部分就用对应的类型描述符来表述。
如下四个语句中变量 w 有三个不同的值最初和最后是同一个值都是 nil
var w io.Writer
w os.Stdout
w new(bytes.Buffer)
w nil每个语句后 w 的值和相关的动态行为。第一个语句声明了 w: var w io.Writer 在 Go 语言中变量总是初始化为一个特定的值接口也不例外。接口的零值就是把它的动态类型和值都设置为 nil。
一个接口值是否是 nil 取决于它的动态类型所以现在这是一个 nil 接口值。可以用 w nil 或者 w ! nil 来检测一个接口值是否是 nil。
第二个语句把一个 *os.File 类型的值赋给了 w: w os.Stdout 这次赋值把一个具体类型隐私转换为一个接口类型它与对应的显式转换 io.Writer(os.Stdout) 等价。接口的动态类型会设置为指针类型 *os.File 的类型描述符它的动态值会设置为 os.Stdout 的副本即一个指向代表进程的标准输出的 os.File 类型的指针。
调用 w.Write([]byte(“hello”)) // 等价于 os.Stdout.Write([]byte(hello))
接口值可以用 和 ! 操作符来比较。
在比较两个接口值时如果两个接口值的动态类型一致但对应的动态值是不可比较的如 slice那么这个比较会导致宕机。
var w io.Writer
fmt.Printf(%T\n, w) // nilw os.Stdout
fmt.Printf(%T\n, w) // *os.Filew new(bytes.Buffer)
fmt.Printf(%T\n, w) // *bytes.Buffer注意含有空指针的非空接口 一个接口值是否是 nil 取决于它的动态类型。
const debug truefunc f(out io.Writer) {if out ! nil {out.Write([]byte(done!\n))}
}
func main() {var buf *bytes.Bufferif debug {buf new(bytes.Buffer) // 启用输出收集}f(buf)
}当 main 调用 f 时把一个类型为*bytes.Buffer 的空指针赋给了 out 参数所以 out 的动态类型是 *bytes.Buffer动态值是 nil。但是判断 out ! nil 判断的是它的动态类型所以 out ! nil 返回true。 调用 out.Write 时不允许接收者为空。
正确方法
var buf io.Writer
if debug {buf new(bytes.Buffer)
}
7.6 使用 sort.Interface 来排序
package sort
type Interface interface {Len() intLess(i, j int) bool // i, j 是序列元素的下标Swap(i, j int)
}要对序列排序需要先确定一个实现了如上三个方法的类型接着把 sort.Sort 函数应用到上面这类方法的实例上。
type StringSlice []string
func (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))7.7 http.Handler 函数
package http
type Handler interface {ServeHTTP(w ResponseWriter, r *Request)
}func ListenAndServe(address string, h Handler) errornet/http 包提供了一个请求多工转发器 ServeMux。
下面的代码中将 /list, price 这样的 URL 和对应的处理程序关联起来。
package mainimport (fmtlognet/http
)func main() {db : database{shoes: 50, socks: 5}mux : http.NewServeMux()//!mainmux.HandleFunc(/list, db.list)mux.HandleFunc(/price, db.price)//!-mainlog.Fatal(http.ListenAndServe(localhost:8000, mux))
}type database map[string]intfunc (db database) list(w http.ResponseWriter, req *http.Request) {for item, price : range db {fmt.Fprintf(w, %s: $%d\n, item, price)}
}func (db database) price(w http.ResponseWriter, req *http.Request) {item : req.URL.Query().Get(item)if price, ok : db[item]; ok {fmt.Fprintf(w, $%d\n, price)} else {w.WriteHeader(http.StatusNotFound) // 404fmt.Fprintf(w, no such item: %q\n, item)}
}7.8 error 接口
Error 是一个接口类型包含返回错误消息的方法
type error interface {Error() string
}func New(text string) error { return errorString{text}}type errorString struct {text string}func (e *errorString) Error() string { return e.Text }直接调用 errors.New 比较罕见一般使用 fmt.Errorf。
package jmtimport errorsfunc Errorf(format string, args ...interface{}) error {return errors.New(Sprintf(format, args...))
}7.10 断言类型
类型断言是一个作用在接口值上的操作写出来类似 x.(T), 其中 x 是一个接口类型的表达式而 T 是一个断言类型。类型断言会检查作为操作数的动态类型是否满足指定的断言类型。
if f, ok : w.(*os.File); ok {// 使用 f
}7.11 使用断言类型来识别错误
os.PathError
type PathError struct {Op stringPath stringErr error
}func (e *PathError) Error() string {return e.Op : e.Err.Error()
}可以根据类型断言来检查错误的特定类型这些类型包含的细节远远多于一个简单的字符串。
_, err : os.Open(/no/such/file)
fmt.Println(err)
fmt.Printf(%#v\n, err)7.12 通过接口类型断言来查询特性
func writeString(w io.Writer, s string)(n int, err error) {type stringWriter interface {WritesString(string) (n int, err error)}if sw, ok : w.(StringWriter); ok {return sw.WriteString(s) // 避免了内存复制}return w.Write([]byte(s))
}7.13 类型分支
类型分支与普通的分支语句类似差别是操作数改为 x.(type).
switch x.(type) {case nil: //case init, unit: //case bool: //
}
