上一节:
下一节:

  Go语言 函数

  • 函数

    函数是一起执行任务的一组语句。每个Go程序至少都有一个函数，即main()。您可以将代码分成单独的函数。如何在不同功能之间划分代码由您决定，但是从逻辑上讲，划分应确保每个函数执行特定任务。函数声明告诉编译器有关函数名称，返回类型和参数的信息。函数定义提供函数的实际主体。Go标准库提供了程序可以调用的许多内置函数。例如，函数len()接受各种类型的参数并返回类型的长度。如果将字符串传递给该字符串，则该函数以字节为单位返回字符串的长度。如果将数组传递给它，该函数将返回数组的长度。函数也称为方法，子例程或过程。

  • 定义函数

    
func function_name( [parameter list] ) [return_types]
{
   body of the function
}
    Go编程语言中的函数定义由函数头和函数体组成。这是函数的所有部分-
    • func -它开始一个函数的声明。
    • function_name -这是函数的实际名称。函数名称和参数列表共同构成函数签名。
    • parameter -参数就像一个占位符。调用函数时，将一个值传递给参数。此值称为实际参数或自变量。参数列表是指函数参数的类型，顺序和数量。参数是可选的；也就是说，一个函数可能不包含任何参数。
    • return_types - 函数可以返回值列表。return_types是函数返回的值的数据类型的列表。某些函数执行所需的操作而不返回值。在这种情况下，不需要return_type。
    • 函数体(body) -它包含定义函数功能的语句的集合。
    以下源代码显示了一个名为max()的函数。此函数采用两个参数num1和num2，并返回两个参数之间的最大值- 
    
/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}

  • 调用函数

    在创建Go函数时，您将定义函数的功能。要使用功能，您将必须调用该功能来执行定义的任务。当程序调用函数时，程序控制将转移到被调用函数。被调用函数执行已定义的任务，并且在执行其return语句或达到其函数结尾的右括号时，它将程序控制权返回给主程序。要调用一个函数，您只需要传递所需的参数及其函数名。如果函数返回一个值，则可以存储返回的值。例如- 
    
package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200
   var ret int

   /* calling a function to get max value */
   ret = max(a, b)

   fmt.Printf( "Max value is : %d\n", ret )
}

/* function returning the max between two numbers */
func max(num1, num2 int) int {
   /* local variable declaration */
   var result int

   if (num1 > num2) {
      result = num1
   } else {
      result = num2
   }
   return result 
}
    尝试一下
    我们保留了max()函数和main()函数，并编译了源代码。在运行最终可执行文件时，它将产生以下结果-- 
    
Max value is : 200

  • 从函数返回多个值

    Go函数可以返回多个值。例如- 
    
package main

import "fmt"

func swap(x, y string) (string, string) {
   return y, x
}
func main() {
   a, b := swap("Mahesh", "Kumar")
   fmt.Println(a, b)
}
    尝试一下
    编译并执行上述代码后，将产生以下结果- 
    
Kumar Mahesh

  • 函数参数

    如果函数要使用参数，则它必须声明接受参数值的变量。这些变量称为函数的形式参数。形式参数的行为类似于函数内部的其他局部变量，并在进入函数时创建并在退出时销毁。调用函数时，可以通过两种方式将参数传递给函数-
    按值传递
    此方法将参数的实际值复制到函数的形式参数中。在这种情况下，对函数内部参数的更改不会对参数产生影响。 
    
package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200

   fmt.Printf("Before swap, value of a : %d\n", a )
   fmt.Printf("Before swap, value of b : %d\n", b )

   /* calling a function to swap the values */
   swap(a, b)

   fmt.Printf("After swap, value of a : %d\n", a )
   fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x, y int) int {
   var temp int

   temp = x /* save the value of x */
   x = y    /* put y into x */
   y = temp /* put temp into y */

   return temp;
}
    尝试一下
    按引用传递：
    此方法将参数的地址复制到形式参数中。在函数内部，该地址用于访问调用中使用的实际参数。这意味着对参数所做的更改会影响参数。 
    
package main

import "fmt"

func main() {
   /* local variable definition */
   var a int = 100
   var b int = 200

   fmt.Printf("Before swap, value of a : %d\n", a )
   fmt.Printf("Before swap, value of b : %d\n", b )

   /* calling a function to swap the values.
   * &a indicates pointer to a ie. address of variable a and 
   * &b indicates pointer to b ie. address of variable b.
   */
   swap(&a, &b)

   fmt.Printf("After swap, value of a : %d\n", a )
   fmt.Printf("After swap, value of b : %d\n", b )
}
func swap(x *int, y *int) {
   var temp int
   temp = *x    /* save the value at address x */
   *x = *y    /* put y into x */
   *y = temp    /* put temp into y */
}
    尝试一下
    默认情况下，Go使用按值调用来传递参数。通常，这意味着函数中的代码无法更改用于调用函数的参数。上面的程序在调用max()函数时，使用了相同的方法。

  • 函数用法

    求值
    Go编程语言提供了灵活的函数，可以即时创建函数并将其用作值。在下面的示例中，我们使用函数定义初始化了一个变量。该函数变量的目的只是使用内置的math.sqrt()函数。例如- 
    
package main

import ("fmt" "math")

func main(){
   /* declare a function variable */
   getSquareRoot := func(x float64) float64 {
      return math.Sqrt(x)
   }

   /* use the function */
   fmt.Println(getSquareRoot(9))
}
    尝试一下
    函数闭包
    Go编程语言支持可以充当函数闭包的匿名函数。当我们要内联定义函数而不传递任何名称时，将使用匿名函数。在我们的示例中，我们创建了一个函数getSequence()，该函数返回另一个函数。此函数的目的是关闭上层函数的变量i形成闭包。例如- 
    
package main

import "fmt"

func getSequence() func() int {
   i:=0
   return func() int {
      i+=1
      return i  
   }
}

func main(){
   /* nextNumber is now a function with i as 0 */
   nextNumber := getSequence()  

   /* invoke nextNumber to increase i by 1 and return the same */
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   fmt.Println(nextNumber())
   
   /* create a new sequence and see the result, i is 0 again*/
   nextNumber1 := getSequence()  
   fmt.Println(nextNumber1())
   fmt.Println(nextNumber1())
}
    尝试一下
    方法
    Go编程语言支持称为方法的特殊类型的函数。在方法声明语法中，存在一个“接收器”来表示该函数的容器。该接收器可用于使用“.”操作符调用函数。例如-
    语法：： 
    
func (variable_name variable_data_type) function_name() [return_type]{
   /* function body*/
}

    
package main

import (
   "fmt" 
   "math" 
)

/* define a circle */
type Circle struct {
   x,y,radius float64
}

/* define a method for circle */
func(circle Circle) area() float64 {
   return math.Pi * circle.radius * circle.radius
}

func main(){
   circle := Circle{x:0, y:0, radius:5}
   fmt.Printf("Circle area: %f", circle.area())
}
    尝试一下
上一节:
下一节: