Golang函数的使用

ShawnLee_123 · · 366 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

函数

在GO语言中,函数的基本组成为func关键字,函数名,参数列表,返回值,函数体和返回语句。

1. 函数的定义

首先,我们通过一个最简单的加法函数来进行说明

package mymath

import "errors"

func Add(a int, b int) (ret int, err error) {
    if a < 0 || b < 0 { //假定函数只支持两个非负数相加
        err = errors.New("Should be non-negative numbers")
        return
    }
    return a + b, nil //支持多返回值
}

上面的函数中,(ret int, err error)表示多返回值,error是Go中特有的错误处理包。
后面我们会单独介绍这个包。

2. 函数调用

Go语言的函数调用非常简单,只要事先导入了该包。我们就可以按照如下方式调用。

import "mymath" //第1节中,我们定义了mymath包,这里我们导入这个包

c := mymath.Add(1, 2) 

注意在Go语言中,函数名以大写字母开头,才会被包导出,如果你不小心将上面的函数写为
func add(a int, b int),这样在mymath.add(1, 2)使用时,编译器会告诉你无法
找到add函数。也就是说,小写字母开头的函数,在包外部是不可引用的。

3. 不定参数

在C语言时代,大家都用过printf()函数,不定参数带给我们的方便想必大家已经领略过了。下面
我们看看Go语言是如何支持不定参数的。

3.1 不定参数类型

我们首先把函数定义为接收不定参数类型:

func myfunc(args ...int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

这段代码的意思是myfunc函数接收不定数量的参数,这些参数全是int,所以要按照如下方式
调用:

myfunc(1, 2, 3, 4)
myfunc(2, 3, 5)

在上面的不定参数定义中,形入...type格式的类型只能作为函数的参数类型存在。并且必须是
最后一个参数。\

语法糖(syntactic sugar) ...type这样的语法对语言的功能并没有影响,但是更方便程序员
的调用。通常来说,使用语法糖能够增加程序的可读性,从而减少程序出错的机会。
从内部实现上来说,类型...type本质上是一个数组切片,也就是[]type,这也是上面为什么能
用range遍历的原因。
如果没有...type语法糖,则开发者就必须这样写:

func myfunc(args []int) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

从函数的角度看,没有语法糖并没有什么影响,只是写法不同而已。
但是,从调用的角度来看,情况就完全不同。

myfunc([]int{1, 2, 3,4})

对比使用...type语法糖实现来看,调用时的写法会打不相同,语法糖使我们使用不定参数
更加便捷。

3.2 不定参数的传递

假设有另一个不定函数叫做myfunc2(arg ...int).

func myfunc(args ...int) {
    myfunc2(args...)  //按原样传递
    myfunc2(args[1:]...) //slice的特性在这里也可以使用
}

3.3 任意类型的不定参数

上面的例子中,我们将不定参数类型定为int型。下面我们来看看传递任意类型的实现。
我们不定参数类型知道为interface{},下面是fmt.Printf()函数原型

func Printf(format string, args ...interface{})

下面代码展示了如何分离传入的不同类型数据

package main

import "fmt"

func MyPrintf(args ...interface{}) {
    for _, arg := range args {
        switch arg.(type) {
            case int:
                fmt.Println(arg, "is an int value.")
            case string:
                fmt.Println(arg, "is an string value.")
            case int64:
                fmt.Println(arg, "is an int64 value.")
            case default:
                fmt.Println(arg, "is an unknown value.")
        }
    }
}

4. 多返回值

不同于C语言,Go语言一个函数可以有多个返回值,这样能让我们的代码更加简洁。
比如File.Read()函数,可以同时返回读取的字节数和错误信息,如果读取成功,则返回
值中的n为读取的字节数,err为nil。否则,err为错误信息。

Func (file *File) Read(b []byte) (n int, err error) {}

Go语言不需要强制命名返回值,但是命名返回值可以让代码更清晰,也可用于文档。
如果我们不想使用某个返回值,可以用 "_"忽略,例如:

n, _ := f.Read(buf) //忽略返回的错误信息

5. 匿名函数与闭包

匿名函数是指不需要定义函数名的一种函数实现方式。

5.1 匿名函数

匿名函数定义如下

func(a, b int, z float64) bool {
    return a*b < int(z)
}

匿名函数可以直接赋值给一个变量

f := func(x, y int) int {
    return x + y
}

func (ch chan int) {
    ch <- ACK
} (reply_chan) //花括号后面跟参数列表,表示函数调用

5.2 闭包

匿名函数是一个闭包。下面我们来了解一下闭包的概念,价值和应用场景。

基本概念

闭包是可以包含自由(未绑定到特定对象)变量的代码块。这些变量不在这个代码块内或者
任何全局上下文,而是在定义代码块的环境中定义。要执行的代码块为自由变量提供绑定的计算
环境(作用域)

闭包的价值

闭包的价值在于可以作为函数对象或者匿名函数。对象类型系统而言,这意味着不仅要表示数据,
还要表示代码。这些函数可以存储到变量中作为参数传递给其他函数,最重要的是能够被函数
动态创建和返回。

Go语言中的闭包

Go语言中的闭包同样也会引用到函数外的变量。闭包的实现确保只要闭包还被使用,那么,被闭包
引用的变量会一直存在。

package main

import (
    "fmt"
)

func main() {
    var j int = 5
    
    a := func() (func()) {
        var i int = 10
        return func() {
            fmt.Printf("i, j: %d, %d\n", i, j)
        }
    } ()
    
    a()
    
    j += 2
    
    a()
}

上述代码执行的结果为:

i, j: 10, 5
i, j: 10, 7

上面的例子中,变量a指向的闭包函数引用了局部变量i和j,i的值被隔离,在闭包之外不可被
修改。只要匿名函数内部才能修改i的值,保证了i的安全性。


有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:ShawnLee_123

查看原文:Golang函数的使用

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

366 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传