【golang】函数的使用

一.无参数无返回值函数

package main
import "fmt"

/**
* 无参数无返回值
*/
func helloFunc(){
    fmt.Println("Hello World!")
}

func  main()  {
    helloFunc()
}

运行结果：

Hello World!

二.有参数无返回值，可以传递一个或多个参数

package main
import "fmt"

/**
* 有参数无返回值，同类型参数可以合并在一起写，用“,”分隔
*/
func helloFunc(str1,str2 string,num int){
    fmt.Println(str1)
    fmt.Println(str2)
    fmt.Println(num)
}

func  main()  {
    helloFunc("Hello World!","Tom",1)
}

运行结果：

Hello World!
Tom
1

三.不定参数

1.只有不定参数的情况，调用时可以传递0个或多个参数，传入的参数作为一个数组在函数中使用。

package main
import "fmt"

/**
* 不定参数,实际传递的参数可以是0个或者多个
*/
func helloFunc(strs ...string){
    for index,value := range strs{
        fmt.Println(index,"-",value)
    }
}

func  main(){
    helloFunc()
    helloFunc("Hello","World","!")
    helloFunc("Happy","New","Year")
}

运行结果：

0 - Hello
1 - World
2 - !
0 - Happy
1 - New
2 - Year

2.有普通参数和不定参数，不定参数必须放在最后一位。

package main
import "fmt"

/**
* 不定参数和普通参数一起使用，不定参数必须放在最后一位
*/
func helloFunc(person1,person2 string,strs ...string){
    fmt.Print(person1)
    fmt.Print(" and ")
    fmt.Print(person2," ")
    for _,value := range strs{
        fmt.Print(value," ")
    }
}

func  main(){
    //传递参数的时候，前面的参数不可省略，不定参数可以是1个或者多个
    helloFunc("Tom","Jerry")
    fmt.Println()
    helloFunc("Tom","Jerry","Happy","New","Year","!")
}

运行结果：

Tom and Jerry 
Tom and Jerry Happy New Year !

3.不定参数的传递，全部传递或者遍历所需要的参数传递

package main
import "fmt"

/**
* 这是一个不定参数的函数，将调用helloFunc2,把自己接收到的不定参数传给helloFunc2
*/
func helloFunc(strs ...string){
    //传递整个不定参数
    helloFunc2(strs...)
    fmt.Println("---------------分割线---------------")
    //传递部分不定参数,“...”一定不能省略
    helloFunc2(strs[:2]...)
    fmt.Println("---------------分割线---------------")
    helloFunc2(strs[2:]...)
}

func helloFunc2(strs ...string){
    for _,value := range strs{
        fmt.Println(value)
    }
}

func  main(){
    helloFunc("Tom","Jerry","Happy","New","Year","!")
}

运行结果：

Tom
Jerry
Happy
New
Year
!
---------------分割线---------------
Tom
Jerry
---------------分割线---------------
Happy
New
Year
!

四.有返回值的函数

1.单个返回值

package main
import "fmt"

func addOne(originNum int) int{
    return originNum+1
}

func main(){
    num := addOne(314)
    fmt.Println(num)
}

运行结果：

315

2.给返回值指定变量名，这种写法可以提高代码的可阅读性

package main
import "fmt"

/**
 给返回值定义变量名，在方法中对返回值的变量进行赋值，
 即不需要在return后面写返回值，但return关键词不能省略
*/
func addOne(originNum int) (num int){
    num = originNum+1
    return
}

func main(){
    num := addOne(314)
    fmt.Println(num)
}

3.多个返回值，golang支持多个返回值，既可以用变量来定义返回值，也可以直接return返回值，推荐使用变量定义返回值

• 不定义返回值变量名，返回值写在return后面，多个返回值以“,”分隔

package main
import "fmt"

func cacl(num1,num2 int) (int ,int){
    sum := num1 + num2
    diff := num1 - num2
    return sum,diff
}

func main(){
    sum,diff := cacl(33,22)
    fmt.Println(sum,diff)
}

运行结果：

55 11

• 使用变量定义返回值，在方法里面对返回值变量赋值即可

package main
import "fmt"

func cacl(num1,num2 int) (sum,diff int){
    sum = num1 + num2
    diff = num1 - num2
    return
}

func main(){
    sum,diff := cacl(33,22)
    fmt.Println(sum,diff)
}

运行结果：

55 11