Parámetros de función de Go

FunciónEn Golang se utiliza para ejecutar tareas específicas y devolver resultados al llamador. Las funciones también pueden ejecutar ciertas tareas sin devolver ningún contenido. Golang admite dos formas de transmitir parámetros a la función, es decir,Transmisión por valor o llamada por valoryTransmisión por referencia o transmisión por referencia.Por defecto, Golang utiliza la forma de llamada por valor para transmitir parámetros a la función.

Términos básicos de transmisión de parámetros a la función:

• El parámetro transmitido a la función se llama parámetro real.

• El parámetro recibido por la función se llama parámetro de forma.

Llamada por valor

En esta transmisión de parámetros, el valor del parámetro real se copia al parámetro de forma de la función, y ambos tipos de parámetros se almacenan en diferentes ubicaciones de almacenamiento. Por lo tanto, cualquier cambio realizado dentro de la función no se reflejará en el parámetro real del llamador.

示例1:En el siguiente programa, puede ver que el valor de Z no puede modificarse mediante la función ModifyModificación.

package main
import "fmt"
//　Modificación de valor de la función
func modify(Z int) {
　　　　Z =　70
}
func main() {
　　　　var Z int =　10
　　　　fmt.Printf("Antes de la llamada a la función, el valor de Z es = %d", Z)
　　　　//Llamada por valor
　　　　modify(Z)
　　　　fmt.Printf("\nDespués de la llamada a la función, el valor de Z es = %d", Z)
}

输出：

Antes de la llamada a la función, el valor de Z es =　10
函数调用后，Z的值为 =　10

示例2:在下面的程序中，交换函数无法交换值，因为我们正在使用按值调用。

package main
import "fmt"
//交换值的函数
func swap(x, y int) int {
　　　　//取一个临时变量
　　　　var tmp int
　　　　tmp = x
　　　　x = y
　　　　y = tmp
　　　　return tmp
}
func main() {
　　　　var f int =　700
　　　　var s int =　900
　　　　fmt.Printf("函数调用前的值\n")
　　　　fmt.Printf("f = %d and s = %d\n", f, s)
　　　　swap(f, s)
　　　　fmt.Printf("\n函数调用后的值\n")
　　　　fmt.Printf("f = %d and s = %d", f, s)
}

输出：

函数调用前的值
f =　700 and s =　900
函数调用后的值
f =　700 and s =　900

引用调用

在这里，您将使用Pointers(指针)的概念。解引用运算符*用于访问地址中的值。地址运算符＆用于获取任何数据类型的变量的地址。实际参数和形式参数都指向相同的位置，因此在函数内部所做的任何更改实际上都会反映在调用者的实际参数中。

示例1:在函数调用中，我们传递变量的地址，并使用解引用运算符*修改值。因此，在函数即Modify之后，您将找到更新后的值。

package main
import "fmt"
//　修改值的函数
func modifydata(Z　*int) {
　　　　*Z =　70
}
func main() {
　　　　var Zz int =　10
　　　　fmt.Printf("函数调用前，Zz的值为 = %d", Zz)
　　　　//通过引用调用传递变量Z地址
　　　　modifydata(&Zz)
　　　　fmt.Printf("\n函数调用后，Zz的值为 = %d", Zz)
}

输出：

函数调用前，Zz的值为 =　10
函数调用后，Zz的值为 =　70

示例2:通过使用按引用调用，交换函数将能够交换值，如下所示。

package main
import "fmt"
//交换值的函数，将指针指向整数
func swap(x, y　*int) int {
　　　　//临时存储变量
　　　　var tmp int
　　　　tmp =　*x
　　　　*x =　*y
　　　　*y = tmp
　　　　return tmp
}
func main() {
　　　　var f int =　700
　　　　var s int =　900
　　　　fmt.Printf("函数调用前的值\n")
　　　　fmt.Printf("f = %d y s = %d\n", f, s)
　　　　//通过引用调用
　　　　//传递变量地址
　　　　swap(&f, &s)
　　　　fmt.Printf("\n函数调用后的值\n")
　　　　fmt.Printf("f = %d y s = %d", f, s)
}

输出：

函数调用前的值
f =　700 y s ==　900
函数调用后的值
f =　900 y s ==　700