Golang 通关初级（3）
原文https://tour.golang.org/welcome/1 方法Go 没有类。不过你可以为结构体类型定义方法。 方法就是一类带特殊的 接收者 参数的函数。 方法接收者在它自己的参数列表内，位于 func 关键字和方法名之间。 在此例中， ToString 方法拥有一个名为 p ，类型为 People 的接收者。 package main
import (
"fmt"
)
type People struct {
age int
name string
}
func (p People) ToString() string {
ageStr := fmt.Sprintf("%d ",p.age)
return ageStr + p.name
}
func main() {
a := People{
12,"Victor",}
fmt.Println(a.ToString())
}
输出： 12 Victor 方法即函数 记住：方法只是个带接收者参数的函数。 现在这个 toString 的写法就是个正常的函数，功能并没有什么变化。 package main
import (
"fmt"
)
type People struct {
age int
name string
}
func ToString(p People) string {
ageStr := fmt.Sprintf("%d ",}
fmt.Println(ToString(a))
}
输出： 12 Victor 你也可以为非结构体类型声明方法。 在此例中，我们看到了一个带 Abs 方法的数值类型 MyFloat 。 你只能为在同一包内定义的类型的接收者声明方法， 而不能为其它包内定义的类型（包括 int 之类的内建类型）的接收者声明方法。 （译注：就是接收者的类型定义和方法声明必须在同一包内；不能为内建类型声明方法。） package main
import (
"fmt"
"math"
)
type MyFloat float64 // MyFloat 就是 float64，不过 把名字换成了 MyFloat 而已
func (f MyFloat) Abs() float64 {
if f < 0 {
return float64(-f)
}
return float64(f)
}
func main() {
f := MyFloat(-math.Sqrt2)
fmt.Println(f.Abs())
}
输出： 1.4142135623730951 指针接收者你可以为指针接收者声明方法。 这意味着对于某类型 T ，接收者的类型可以用 *T 的文法。 （此外， T 不能是像 *int 这样的指针。） 例如，这里为 *People定义了 ChangeName方法。 指针接收者的方法可以修改接收者指向的值（就像 ChangeName 在这做的）。 由于方法经常需要修改它的接收者，指针接收者比值接收者更常用。 试着移除ChangeName函数声明中的 * ，观察此程序的行为如何变化。 若使用值接收者，那么 ChangeName 方法会对原始 People 值的副本进行操作。 （对于函数的其它参数也是如此。） ChangeName 方法必须用指针接受者来更改 main 函数中声明的 People 的值。 package main
import (
"fmt"
)
type People struct {
age int
name string
}
func ToString(p People) string {
result := fmt.Sprintf("年龄：%d,名字 %s ",p.age,p.name)
return result
}
func (p *People) ChangeName(name string) {
p.name = name
}
func main() {
a := People{
12,}
fmt.Println(ToString(a))
a.ChangeName("Afra55")
fmt.Println(ToString(a))
}
输出： 年龄：12,名字 Victor 年龄：12,名字 Afra55 指针与函数现在我们要把 ChangeName 方法重写为函数。 package main
import (
"fmt"
)
type People struct {
age int
name string
}
func ToString(p People) string {
result := fmt.Sprintf("年龄：%d,p.name)
return result
}
func ChangeName(p *People,name string) {
p.name = name
}
func main() {
a := People{
12,}
fmt.Println(ToString(a))
ChangeName(&a,"Afra55")
fmt.Println(ToString(a))
}
输出： 年龄：12,名字 Afra55 如果去掉函数 ChangeName 参数 中的 .main.go:28: cannot use &a (type *People) as type People in argument to ChangeName
由上可见 指针参数的函数必须接受一个指针，而以指针为接收者的方法被调用时，接收者既能为值又能为指针。下面再举个例子： 方法与指针重定向package main
import "fmt"
type Vertex struct {
X,Y float64
}
func (v *Vertex) Scale(f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func ScaleFunc(v *Vertex,f float64) {
v.X = v.X * f
v.Y = v.Y * f
}
func main() {
v := Vertex{3,4}
v.Scale(2)
ScaleFunc(&v,10)
p := &Vertex{4,3}
p.Scale(3)
ScaleFunc(p,8)
fmt.Println(v,p)
}
输出： {60 80} &{96 72}
由上例可知带指针参数的函数必须接受一个指针： var v Vertex
ScaleFunc(v) // 编译错误！
ScaleFunc(&v) // OK
而以指针为接收者的方法被调用时，接收者既能为值又能为指针： var v Vertex
v.Scale(5) // OK
p := &v
p.Scale(10) // OK
对于语句 v.Scale(5) ，即便 v 是个值而非指针，带指针接收者的方法也能被直接调用。 也就是说，由于 Scale 方法有一个指针接收者，为方便起见，Go 会将语句 v.Scale(5) 解释为 (&v).Scale(5) 。 同样的事情也发生在相反的方向: package main
import (
"fmt"
"math"
)
type Vertex struct {
X,Y float64
}
func (v Vertex) Abs() float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func AbsFunc(v Vertex) float64 {
return math.Sqrt(v.X*v.X + v.Y*v.Y)
}
func main() {
v := Vertex{3,4}
fmt.Println(v.Abs())
fmt.Println(AbsFunc(v))
p := &Vertex{4,3}
fmt.Println(p.Abs())
fmt.Println(AbsFunc(*p))
}
输出： 5 5 5 5 接受一个值作为参数的函数必须接受一个指定类型的值： var v Vertex
fmt.Println(AbsFunc(v)) // OK
fmt.Println(AbsFunc(&v)) // 编译错误！
而以值为接收者的方法被调用时，接收者既能为值又能为指针： var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK
这种情况下，方法调用 p.Abs() 会被解释为 (*p).Abs() 。 选择值或指针作为接收者使用指针接收者的原因有二： 首先，方法能够修改其接收者指向的值。 其次，这样可以避免在每次调用方法时复制该值。若值的类型为大型结构体时，这样做会更加高效。 通常来说，所有给定类型的方法都应该有值或指针接收者，但并不应该二者混用。 接口接口类型 是由一组方法签名定义的集合。 接口类型的值可以保存任何实现了这些方法的值。 package main
import (
"fmt"
)
type IHuman interface {
ClearHair(drop int) int
}
type People struct {
age int
hairNum int
name string
}
type MyHairNumber int
func (h MyHairNumber) ClearHair(drop int) int {
d := int(h) - drop
return d
}
func (p *People) ClearHair(drop int) int {
return p.hairNum - drop
}
// 错误1： method redeclared: People.ClearHair
func (p People) ClearHair(drop int) int {
return p.hairNum - drop
}
func main() {
var i IHuman
a := MyHairNumber(1000)
i = a
fmt.Println(i.ClearHair(3000))
b := People{
12, 19000,"Who?",}
i = &b
fmt.Println(i.ClearHair(3000))
// 错误2: 下面一行，b 是一个 People（而不是 *People）
// 所以没有实现 ClearHair.
i = b
fmt.Println(i)
}
上面的代码有两处错误，去掉错误后，正确输出： -2000 16000
由于 ClearHair 方法只为 *People （指针类型）定义， 因此 People （值类型）并未实现 IHuman 。 接口与隐式实现 类型通过实现一个接口的 所有方法 来实现该接口。 既然无需专门显式声明，也就没有“implements“关键字。 隐式接口从接口的实现中解耦了定义，这样接口的实现可以出现在任何包中，无需提前准备。 因此，也就无需在每一个实现上增加新的接口名称，这样同时也鼓励了明确的接口定义。 接口值 在内部，接口值可以看做包含值和具体类型的元组： (value,type) 接口值调用方法时会执行其底层类型的同名方法。 package main
import ( "fmt" ) type I interface { M() } type People struct { name string age int } func (p *People) M() { p.age += 1 fmt.Printf("age = %v,name = %sn",p.name) } type Wife float64 func (w Wife) M() { fmt.Println(w) } func main() { var i I i = &People{ "Victor",22,} showIDetail(i) i.M() i = Wife(25) showIDetail(i) i.M() } func showIDetail(i I) { fmt.Printf("(%v,%T)n",i,i) }
输出： (&{Victor 22},*main.People)
age = 23,name = Victor
(25,main.Wife)
25
底层值为 nil 的接口值 即便接口内的具体值为 nil，方法仍然会被 nil 接收者调用。 在一些语言中，这会触发一个空指针异常，但在 Go 中通常会写一些方法来优雅地处理它（如本例中的 M 方法）。 注意： 保存了 nil 具体值的接口其自身并不为 nil 。 package main
import (
"fmt"
)
type I interface {
M()
}
type People struct {
name string
age int
}
func (p *People) M() {
if p == nil {
fmt.Println("<nil>")
return
}
p.age += 1
fmt.Printf("age = %v,p.name)
}
func main() {
var i I
var p *People
i = p
// 保存了 nil 具体值的接口其自身并不为 nil
if i != nil {
fmt.Println("i 不为 nil")
}
showIDetail(i)
i.M()
i = &People{
"Victor", 22,}
showIDetail(i)
i.M()
}
func showIDetail(i I) {
fmt.Printf("(%v,i)
}
输出： i 不为 nil
(<nil>,*main.People)
<nil>
(&{Victor 22},*main.People)
age = 23,name = Victor
nil 接口值 nil 接口值既不保存值也不保存具体类型。 为 nil 接口调用方法会产生运行时错误，因为接口的元组内并未包含能够指明该调用哪个 具体 方法的类型。 package main
import "fmt"
type I interface {
M()
}
func main() {
var i I
describe(i)
i.M()
}
func describe(i I) {
fmt.Printf("(%v,i)
}
报错： panic: runtime error: invalid memory address or nil pointer dereference
空接口 指定了零个方法的接口值被称为 空接口： interface{}
空接口可保存任何类型的值。 （因为每个类型都至少实现了零个方法。） 空接口被用来处理未知类型的值。 例如， package main
import "fmt"
func main() {
var i interface{}
describe(i)
i = 42
describe(i)
i = "hello"
describe(i)
}
func describe(i interface{}) {
fmt.Printf("(%v,i)
}
输出： (<nil>,<nil>)
(42,int)
(hello,string)
类型断言 类型断言 提供了访问接口值底层具体值的方式。 t := i.(T)
该语句断言接口值 i 保存了具体类型 T ，并将其底层类型为 T 的值赋予变量 t 。 若 i 并未保存 T 类型的值，该语句就会触发一个恐慌。 为了 判断 一个接口值是否保存了一个特定的类型， 类型断言可返回两个值：其底层值以及一个报告断言是否成功的布尔值。 t,ok := i.(T)
若 i 保存了一个 T ，那么 t 将会是其底层值，而 ok 为 true 。 否则， ok 将为 false 而 t 将为 T 类型的零值，程序并不会产生恐慌。 请注意这种语法和读取一个映射时的相同之处。 package main
import "fmt"
func main() {
var i interface{} = "hello"
s := i.(string)
fmt.Println(s)
s,ok := i.(string)
fmt.Println(s,ok)
f,ok := i.(float64)
fmt.Println(f,ok)
f = i.(float64) // panic
fmt.Println(f)
}
输出： hello
hello true
0 false
panic: interface conversion: interface is string,not float64
类型选择 类型选择 是一种按顺序从几个类型断言中选择分支的结构。 类型选择与一般的 switch 语句相似，不过类型选择中的 case 为类型（而非值）， 它们针对给定接口值所存储的值的类型进行比较。 switch v := i.(type) {
case T:
// v 的类型为 T
case S:
// v 的类型为 S
default:
// 没有匹配，v 与 i 的类型相同
}
类型选择中的声明与类型断言 i.(T) 的语法相同，只是具体类型 T 被替换成了关键字 type 。 此选择语句判断接口值 i 保存的值类型是 T 还是 S 。 在 T 或 S 的情况下，变量 v 会分别按 T 或 S 类型保存 i 拥有的值。 在默认（即没有匹配）的情况下，变量 v 与 i 的接口类型和值相同。 package main
import (
"fmt"
)
func showType(i interface{}) {
switch v := i.(type) {
case int:
fmt.Printf("%v + %v = %vn",v,v+v)
// 回顾知识点： fallthrough
case string:
fmt.Println(i)
default:
fmt.Printf("This value type is : %T,value is %vn",i)
}
}
func main() {
showType(21)
showType("Hello You")
showType(false)
}
输出： 21 + 21 = 42
Hello You
This value type is : bool,value is false
Stringerfmt 包中定义的 Stringer 是最普遍的接口之一。 type Stringer interface { String() string }
Stringer 是一个可以用字符串描述自己的类型。 package main
import "fmt"
type Person struct {
Name string
Age int
}
func (p Person) String() string {
return fmt.Sprintf("%v (%v years)",p.Name,p.Age)
}
func main() {
a := Person{"Victor Yang", 22}
z := Person{"Victor Afra55", 8888}
fmt.Println(a,z)
}
输出： Victor Yang (22 years) Victor Afra55 (8888 years) 练习：Stringer 通过让 IPAddr 类型实现 fmt.Stringer 来打印点号分隔的地址。 例如， package main
import "fmt"
type IPAddr [4]byte
// TODO: Add a "String() string" method to IPAddr.
func (ip IPAddr) String() string {
var resurt string
for i,v := range ip {
resurt += fmt.Sprintf("%v",v)
if i < len(ip)-1 {
resurt += "."
}
}
return resurt
}
func main() {
hosts := map[string]IPAddr{
"loopback": {127, 0, 1},"googleDNS": {8, 8, 8},}
for name,ip := range hosts {
fmt.Printf("%v: %vn",name,ip)
}
}
输出： loopback: 127.0.0.1
googleDNS: 8.8.8.8
错误Go 程序使用 error 值来表示错误状态。 与 fmt.Stringer 类似， error 类型是一个内建接口： type error interface { Error() string }
（与 fmt.Stringer 类似， fmt 包在打印值时也会满足 error 。） 通常函数会返回一个 error 值，调用的它的代码应当判断这个错误是否等于 nil 来进行错误处理。 i,err := strconv.Atoi("42")
if err != nil {
fmt.Printf("couldn't convert number: %vn",err)
return
}
fmt.Println("Converted integer:",i)
error 为 nil 时表示成功；非 nil 的 error 表示失败。 package main
import (
"fmt"
"time"
)
type MyError struct {
When time.Time
What string
}
func (e *MyError) Error() string {
return fmt.Sprintf("at %v,%s",e.When,e.What)
}
func run() error {
return &MyError{
time.Now(),"it didn't work",}
}
func main() {
if err := run(); err != nil {
fmt.Println(err)
}
}
输出： at 2016-07-18 17:06:17.6694247 +0800 CST,it didn't work
练习：错误 创建一个新的类型 type ErrorFloat64 float64
并为其实现 func (e ErrorFloat64 ) Error() string
方法使其拥有 error 值，通过 ErrNegativeSqrt(-2).Error() 调用该方法应返回 “cannot Sqrt negative number: -2” 。 注意： 在 Error 方法内调用 fmt.Sprint(ef) 会让程序陷入死循环。可以通过先转换 ef 来避免这个问题： 编写 Sqrt 函数，使其接受一个负数时，返回 ErrorFloat64 值。 package main
import (
"fmt"
"math"
)
type ErrorFloat64 float64
func (ef ErrorFloat64) Error() string {
return fmt.Sprintf("cannot Sqrt negative number: %v",float64(ef))
}
func Sqrt(f float64) (float64,error) {
if f < 0 {
return 0,ErrorFloat64(f)
} else {
return math.Sqrt(f),nil
}
}
func main() {
fmt.Println(Sqrt(2))
fmt.Println(Sqrt(-2))
}
输出： 1.4142135623730951 <nil>
0 cannot Sqrt negative number: -2
Readerio 包指定了 io.Reader 接口， 它表示从数据流的末尾进行读取。 Go 标准库包含了该接口的许多实现， 包括文件、网络连接、压缩和加密等等。 io.Reader 接口有一个 Read 方法： func (T) Read(b []byte) (n int,err error)
Read 用数据填充给定的字节切片并返回填充的字节数和错误值。 在遇到数据流的结尾时，它会返回一个 io.EOF 错误。 示例代码创建了一个 strings.Reader 并以每次 8 字节的速度读取它的输出。 package main
import (
"fmt"
"io"
"strings"
)
func main() {
r := strings.NewReader("Hello,Victor Afra")
b := make([]byte,8)
for {
n,err := r.Read(b)
fmt.Printf("n = %v,err = %v,b = %vn",n,err,b)
fmt.Printf("b[:n] = %vn",b[:n])
if err == io.EOF {
break
}
}
}
输出： n = 8,err = <nil>,b = [72 101 108 108 111 44 32 86]
b[:n] = [72 101 108 108 111 44 32 86]
n = 8,b = [105 99 116 111 114 32 65 102]
b[:n] = [105 99 116 111 114 32 65 102]
n = 2,b = [114 97 116 111 114 32 65 102]
b[:n] = [114 97]
n = 0,err = EOF,b = [114 97 116 111 114 32 65 102]
b[:n] = []
图像image 包定义了 Image 接口： package image type Image interface { （请参阅文档了解全部信息。） color.Color 和 color.Model 类型也是接口，但是通常因为直接使用预定义的实现 image.RGBA 和 image.RGBAModel 而被忽视了。这些接口和类型由image/color包定义。 package main
import (
"fmt"
"image"
)
func main() { img := image.NewRGBA(image.Rect(0,0,100,100)) fmt.Println(img.Bounds()) fmt.Println(img.ColorModel()) fmt.Println(img.At(0,32).RGBA()) }
输出： (0,0)-(100,100)
&{0x49a490}
0 0 0 0 （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |