注册 登录  
 加关注
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

snoopyxdy的博客

https://github.com/DoubleSpout

 
 
 

日志

 
 

golang入门(2)  

2013-08-28 13:59:59|  分类: golang |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |
函数的定义看起来像这样:

type mytype int 
func (p mytype) funcname(q int) (r,s int) { return 0,0 }

1、保留字 func 用于定义一个函数;
2、函数可以定义用于特定的类型,这类函数更加通俗的称呼是 method。这部分称作 receiver 而它是可选的。
3、funcname 是你函数的名字
4、int 类型的变量 q 作为输入参数。参数用 pass-by-value 方式传递,意味着它们会被复制
变量 r 和 s 是这个函数的命名返回值。在 Go 的函数中可以返回多个值。参阅第 32 页的 “多值返回”。如果不想对返回的参数命名,只需要提供类型:(int,int)。如果只有一个返回值,可以省略圆括号。如果函数是一个子过程,并且没有任何返回值,也可以省略这些内容
5、这是函数体,注意 return 是一个语句,所以包裹参数的括号是可选的。

这里有两个例子,左边的函数没有返回值,右边的只是简单的将输入返回。

func subroutine(in int) {
   return
}

func identity(in int) int {
    return in
}

可以随意安排函数定义的顺序,编译器会在执行前扫描每个文件。所以函数原型在 Go 中都是过期的旧物。Go 不允许函数嵌套。然而你可以利用匿名函数实现它

递归函数跟其他语言是一样的:

func rec(i int) {
if i == 10 {
return
}
rec(i+1)
fmt.Printf("%d ", i)
}

这会打印:9 8 7 6 5 4 3 2 1 0。

作用域
在 Go 中,定义在函数外的变量是全局的,那些定义在函数内部的变量,对于函数来说是局部的。如果命名覆盖——一个局部变量与一个全局变量有相同的名字——在函数执行的时候,局部变量将覆盖全局变量。


多值返回
Go 一个非常特别的特性(对于编译语言而言)是函数和方法可以返回多个值(Python 和 Perl 同样也可以)。这可以用于改进一大堆在 C 程序中糟糕的惯例用法:修改参数的方式,返回一个错误(例如遇到 EOF 则返回 -1)。在 Go 中,Write 返回一个计数值和一个错误:“是的,你写入了一些字节,但是由于设备异常,并不是全部都写入了。”。 os 包中的 *File.Write 是这样声明的:

func (file *File) Write(b []byte) (n int, err error)

如同文档所述,它返回写入的字节数,并且当 n != len(b) 时,返回非 nil的 error。这是 Go 中常见的方式。
类似的方法避免了传递指针模拟引用参数来返回值。这里有个样例函数,从字节数组的指定位上取得数值,返回这个值和下一个位置。
func nextInt(b []byte, i int) (int, int) {
x := 0
// 假设所有的都是数字
for ; i < len(b); i++ {
x = x*10 + int(b[i])-'0'
}
return x, i
}

你可以在输入的数组中扫描数字,像这样:

a := []byte{'1', '2', '3', '4'}
var x int
for i := 0; i < len(a); { //没有 i++
x, i = nextInt(a, i)
println(x)
}


命名返回值
Go 函数的返回值或者结果参数可以指定一个名字,并且像原始的变量那样使用,就像输入参数那样。如果对其命名,在函数开始时,它们会用其类型的零值初始化;如果函数在不加参数的情况下执行了 return 语句,结果参数的当前值会作为返回值返回。用这个特性,允许(再一次的)用较少的代码做更多的
名字不是强制的,但是它们可以使得代码更加健壮和清晰: 这是文档。例如命名 int 类型的 nextPos 返回值,就能说明哪个代表哪个。

func nextInt(b []byte, pos int) (value, nextPos int) { /* ... */ }

由于命名结果会被初始化并关联于无修饰的 return,它们可以非常简单并且清晰。这里有一段 io.ReadFull 的代码,很好的运用了它:

func ReadFull(r Reader, buf []byte) (n int, err error) {
for len(buf) > 0 && err == nil {
var nr int
nr, err = r.Read(buf)
n += nr
buf = buf[nr:len(buf)]
}
return
}


延迟代码
假设有一个函数,打开文件并且对其进行若干读写。在这样的函数中,经常有提前返回的地方。如果你这样做,就需要关闭正在工作的文件描述符。这经常导致产生下面的代码:
func ReadWrite() bool {
file.Open("file")
// 做一些工作
if failureX {
file.Close()
return false
}
if failureY {
file.Close()
return false
}
file.Close()
return true
}

在这里有许多重复的代码。为了解决这些,Go 有了 defer 语句。在 defer 后指定的函数会在函数退出前调用。
上面的代码可以被改写为下面这样。将 Close 对应的放置于 Open 后,能够使函数更加可读、健壮。

func ReadWrite() bool {
file.Open("file")
defer file.Close()   file.Close() 被添加到了 defer 列表
// 做一些工作
if failureX {
return false   Close() 现在自动调用
}
if failureY {
return false   这里也是
}
return true
}

可以将多个函数放入 “延迟列表”中

for i := 0; i < 5; i++ {
defer fmt.Printf("%d ", i)
}

延迟的函数是按照后进先出(LIFO)的顺序执行,所以上面的代码打印: 4 3 2 1 0。
利用 defer 甚至可以修改返回值,假设正在使用命名结果参数和函数符号

func f() (ret int) { //ret 初始化为零
defer func() {
ret++//ret 增加为 1
}()
return 10//返回的是 11 而不是 10!
}


变参
接受变参的函数是有着不定数量的参数的。为了做到这点,首先需要定义函数使其接受变参:

func myfunc(arg ...int) {}

arg ... int 告诉 Go 这个函数接受不定数量的参数。注意,这些参数的类型全部是 int。在函数体中,变量 arg 是一个 int 类型的 slice:

for _, n := range arg {
fmt.Printf("And the number is: %d\n", n)
}

如果不指定变参的类型,默认是空的接口 interface{}(参阅第 6 章)。假设有另一个变参函数叫做 myfunc2,下面的例子演示了如何向其传递变参:

func myfunc(arg ...int) {
myfunc2(arg...)   按原样传递
myfunc2(arg[:2]...)   传递部分
}


函数作为值
就像其他在 Go 中的其他东西一样,函数也是值而已。它们可以像下面这样赋值给变量:

func main() {
a := func() {   定义一个匿名函数,并且赋值给 a
println("Hello")
}   这里没有 ()
a()   调用函数
}

函数作为值,也会被用在其他一些地方,例如 map。这里将整数转换为函数:

var xs = map[int]func() int{
1: func() int { return 10 },
2: func() int { return 20 },
3: func() int { return 30 }, //必须有逗号
/* ... */
}


回调
当函数作为值时,就可以很容易的传递到其他函数里,然后可以作为回调。首先定义一个函数,对整数做一些 “事情”:
这个函数的标识是 func printit(int),或者没有函数名的:func(int)。创建新的函数使用这个作为回调,需要用到这个标识:

func callback(y int, f func(int)) { //f 将会保存函数
f(y) //调用回调函数 f 输入变量 y
}


恐慌(Panic)和恢复(Recover)
Go 没有像 Java 那样的异常机制:不能抛出一个异常。作为替代,它使用了恐慌和恢复(panic-and-recover)机制。一定要记得,这应当作为最后的手段被使用,你的代码中应当没有,或者很少的令人恐慌的东西。这是个强大的工具,明智的使用它。

Panic
是一个内建函数,可以中断原有的控制流程,进入一个令人恐慌的流程中。当函数 F 调用 panic,函数 F 的执行被中断,并且 F 中的延迟函数会正常执行,然后 F 返回到调用它的地方。在调用的地方, F 的行为就像调用了 panic。这一过程继续向上,直到程序崩溃时的所有goroutine 返回。恐慌可以直接调用 panic 产生。也可以由运行时错误产生,例如访问越界的数组。

Recover
是一个内建的函数,可以让进入令人恐慌的流程中的 goroutine 恢复过来。recover 仅在延迟函数中有效。在正常的执行过程中,调用 recover 会返回 nil 并且没有其他任何效果。如果当前的 goroutine 陷入恐慌,调用 recover 可以捕获到 panic 的输入值,并且恢复正常的执行。

这个函数检查作为其参数的函数在执行时是否会产生 panic:

unc throwsPanic(f func()) (b bool) {
defer func() {
    if x := recover(); x != nil {
    b = true
    }
}()
f()
return
}

1.定义一个新函数 throwsPanic 接受一个函数作为参数,参看 “函数作为值”。当这个函数产生 panic,就返回 true,否则返回 false;
2.定义了一个利用 recover 的 defer 函数,如果当前的 goroutine 产生了 panic,这个 defer 函数能够发现。当 recover() 返回非 nil 值,设置 b 为 true;
3.调用作为参数接收的函数。
4.返回 b 的值。由于 b 是命名返回值


  评论这张
 
阅读(1426)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2016