Golang 函数

Posted 2020-09-09 小黑~

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Golang 函数相关的知识，希望对你有一定的参考价值。

函数声明

func (p myType ) funcName ( a, b int , c string ) ( r , s int ) {

return

}

func 关键字
(p myType) 表明函数所属于的类型对象！，即为特定类型定义方法，可以省去不写，即为普通的函数（这里我们主要讲解普通的函数）
函数名
参数 (可以不声明)
返回值（可以不声明）
函数体

调用标准函数

Golang 提供了大量的包和实用函数供用户使用，这些函数被称为标准函数。常见的标准包有 fmt, math, os, time bytes 一般包名都是小写。、
标准包的消息可以在 Go安装目录的 pkg 下面查看，也可以使用godoc 查看。

使用一个函数前首先，导入包名
通过包名，调用函数

调用自定义函数

通常，一个可执行的Go程序一般都有一个 main 包，在 main包中必须声明一个 main 函数。

调用外部包的函数

如果需要调用外部包的函数，那么需要导入这个包，才能调用相关函数（首字母必须大写）。

调用内置函数

13个内置函数，这些内置函数，非常有用。
len()：可以获取数组，字符串，切片的长度
panic() 可以直接作用于系统底层，用于错误处理。

变参函数

形式参数的类型和个数都是可以变化的。
典型的变参函数有： fmt.Printf(), fmt.Scanf() exec.Command() 等

变参函数的声明

func functionName (variableArgumetName ... dataType) returnValue {...}

（1）变参的类型是”…类型“，而且变参必须是函数的最后一个参数。如果函数还有其他的参数，比如放在变参的前面。 func f1(a int ,s string, args ...int) {...}
（2）不定长的变参，实际上就是一个切片，可以使用 range 进行遍历。

变参函数的传递

一个变参函数，如何将这些变参传递给另外一个变参函数呢？
因为实际上变参就是一个切片，所以可以进行全部的传递，也可以进行部分的传递。

任意类型的变参函数

当用户希望传递不同类型的参数的时候，就像 fmt.Printf() 可以接受 int string 等各种类型。
此时，应该指定变参类型为为 空接口 interface{}

func f1(args... interface{})  //指定变参类型为 interface{}

在Go语言中，interface{} 可以指向任何数据类型，所以可以使用 interface{}定义任意类型的变参。 同时 interface{] 也是类型安全的。

package main

import (
    "fmt"
)

func main() {
    f1(2, "go", 8, "language", ‘a‘, false, "A", 3.24)
}
// 采用 interface {} 作为类型
func f1(args ...interface{}) {

    var num = make([]int, 0, 6)
    var str = make([]string, 0, 6)
    var ch = make([]int32, 0, 6)   //字符类型，是int32的哦！
    var other = make([]interface{}, 0, 6) //采用 interface{}作为类型

    for _, arg := range args {
        switch v := arg.(type) {  //这个是什么用法?
        case int:
            num = append(num, v)
        case string:
            str = append(str, v)
        case int32:  //这里 ‘a‘ 被统计到了 int32中。
            ch = append(ch, v)
        default:
            other = append(other, v)
        }
    }

    fmt.Println(num)
    fmt.Println(str)
    fmt.Println(ch)
    fmt.Println(other)
}
输出为：
[2 8]
[go language A]
[97]
[false 3.24]

可以看到： Go 语言是类型安全的。 int 类型和 int32不是同一个类型，但是应该是兼容的。字符字面值被当做rune类型（也就是 int32 类型，但是不是 int类型）

匿名函数

声明：

func (参数列表)(返回值){函数体}  //注意没有函数名，所以称为匿名函数
func (a, b int) int {
    return (a + b)
}

可以随时在代码里定义匿名函数，并且将这个匿名函数赋值给一个变量。
可以随时定义匿名函数，并且执行这个匿名函数。（声明函数的时候，直接执行！）

package main

import (
    "fmt"
)

func main() {
    //声明 并且直接将 匿名函数 赋值 给变量f
    f := func(a, b int) int {
        return a + b
    }
    // 对函数类型的变量尽心调用
    sum := f(2, 3)  
    fmt.Println(sum)
    // 声明 并且 直接执行 匿名函数
    sum = func(a, b int) int {
        return a + b
    }(2, 3)
    fmt.Println(sum)
}