基本写法

GO的函数基本写法是

func fun(){//无参数，无返回值
}
func fun(参数1 类型,参数2 类型){ //1个到多个参数，无返回值，在这里参数我只写了2个，可以写很多，我没使用...是因为在Go中...有着特殊的含义
}
func fun(参数1 类型,参数2 类型,参数3 ... 类型) 类型{ //1个到多个多个参数，一个返回值
//注意最后的参数3 ... 类型表示可变长的参数，这个参数必须是函数的最后一个参数
//因为是一个返回值所以没用()括起来，当然这个返回值也可以指定返回值的变量名
}
func fun(参数1 类型,参数2 类型,参数3 ... 类型) （返回值1 类型，返回值2 类型）{ //1个到多个多个参数，多个返回值
}

再次提醒，如果你要是让别的包可以调用这个函数，函数首字母一定大写。

还有就是import的注意事项：

1. 当前目录下的引用可以 “./sunny”，Go是不建议这种方式的
2. 默认的包文件放在$GOPATH/src/或者$GOROOT/src/下，$GOROOT/src/是Go自己的目录，我们自己写的包最好放在$GOPATH/src/下
3. 包中不能有main方法。
4. 同目录层中不需要import，可以直接用方法名调用

下图解释了Go的调用过程

下面用程序来解释

首先在当前目录下建立一个sunny目录，再次强调这个是不推荐的方式。
sunny.go

package sunny
import (
    "bytes"
    "errors"
    "fmt"
)
func Fun1() { //无参数，无返回值
    fmt.Println("This is function Fun1")
}
func Fun2(s1 string, s2 string) { //多个参数，没有返回值
    var buf bytes.Buffer
    buf.WriteString("This is ")
    buf.WriteString(s1)
    buf.WriteString(" ")
    buf.WriteString(s2)
    buf.WriteString(". ")
    fmt.Println(buf.String())
}
func Fun3(s1 string, s2 string) string { //多个参数，一个返回值，不指定返回值名称
    result := "This is "
    result += s1
    result += " "
    result += s2
    result += ". "
    return result
}
func Fun4(s1 string, s2 string) (result string) { //多个参数，一个返回值，指定返回值名称
    result = "This is "
    result += s1
    result += " "
    result += s2
    result += ". "
    return //也可以写成return result，不过简写更符合Go的习惯
}
func Fun5(s1 string, s2 string, s ...string) (string, error) {
    //多个参数,还包括可变长参数；多个返回值
    result := ""
    if len(s) == 0 {
        return "", errors.New("没有传递可变长变量") //生成一个简单的 error 类型
    }
    result = "This is "
    result += s1
    result += " "
    result += s2
    result += ". "
    for _, tmp := range s[:len(s)-1] {
        result += tmp
        result += "--"
    }
    for _, tmp := range s[len(s)-1:] {
        result += tmp
    }
    return result, nil
}

下面是调用的函数
pro04_1_1.go

package main
import (
    "fmt"
    "./sunny" //引入sunny.go
)
func main() {
    sunny.Fun1()                                //无参数，无返回值函数调用
    sunny.Fun2("function", "Fun2")              //多个参数，没有返回值函数调用
    fmt.Println(sunny.Fun3("function", "Fun3")) //多个参数，一个返回值，不指定返回值名称函数调用
    fmt.Println(sunny.Fun4("function", "Fun4")) //多个参数，一个返回值，指定返回值名称函数调用
    msg, err := sunny.Fun5("function", "Fun5")  //多个参数,还包括可变长参数；多个返回值函数调用，不过没有传递可变长参数
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(msg)
    }
    msg, err = sunny.Fun5("function", "Fun5", "a") //多个参数,还包括可变长参数；多个返回值函数调用，且传递了可变长参数
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(msg)
    }
    msg, err = sunny.Fun5("function", "Fun5", "a", "b", "c")
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println(msg)
    }
}

结果显示

下面在介绍哦一下——同目录层中不需要import，可以直接用方法名调用。在sunny目录下面再建立一个sunnyMatn.go文件

package sunny
func sunnyAdd(i int, j int) int {
    return i + j
}

在sunny.go里面添加

func Fun6() { //同目录层中不需要import，可以直接用方法名调用
    fmt.Println(sunnyAdd(2, 3))
}

在main函数里面添加

    sunny.Fun6()

结果显示

链接

• 目录
• 上一节
• 下一节