Función [Lenguaje de programación GO]

función

---

---

---

1. ¿Qué es una función?

• Las funciones son bloques básicos de código que realizan una tarea.
• El lenguaje Go tiene al menos una función main().
• Las funciones se pueden usar para dividir diferentes funciones y, lógicamente, cada función realiza una tarea específica.
• Una declaración de función le dice al compilador el nombre de la función, el tipo de devolución y los parámetros.

1. Declaración de función

El formato de la definición de la función del lenguaje Go es el siguiente:

func functionName( [parameter list] ) [returnType] {
    
    
		函数体
}

package main

import "fmt"

/*
	-- 函数是基本的代码块，用于执行一个任务
	-- Go 语言最少有个 main() 函数
	-- 可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务
	-- 函数声明告诉了编译器函数的名称，返回类型和参数
*/

func main() {
    
    

	fmt.Println(add(3, 4))

}

// func 函数名 (参数，参数....) 函数调用后的返回值 {
    
    
//  函数体 ： 执行一段代码
//  return  返回结果
//}

func add(a, b int) int {
    
    
	c := a + b
	return c
}

producción

2. Declaración y llamada de función

• función sin parámetros y sin valor de retorno
• funcion con un parametro
• función con dos parámetros
• tiene una función que devuelve el valor
• Funciones con múltiples valores de retorno

package main

import "fmt"

func main() {
    
    

	c := add(3, 4)
	fmt.Println(c)
	onePrint("guan")
	x, y := swap("guan", "hello")
	fmt.Println(x, y)
}

// - 无参数无返回值函数
func Println() {
    
    
	fmt.Println("printinfo")
}

// - 有一个参数的函数
func onePrint(name string) {
    
    
	fmt.Println("name")
}

// - 有两个参数的函数
// - 有一个返回值的函数
func add(a, b int) int {
    
    
	c := a + b
	return c
}

// - 有多个返回值的函数
func swap(x, y string) (string, string) {
    
    
	return y, x
}

producción

3. Parámetros formales y parámetros reales

Parámetro formal: al definir una función, el parámetro utilizado para recibir datos entrantes de otros puertos es el parámetro formal

Parámetro real: al llamar a una función, los datos reales pasados ​​​​al parámetro formal se denominan parámetro real

package main

func main() {
    
    
	maxNum := max(6, 8)
	println(maxNum)

}

// - max 两个数字比大小
// 形式参数：定义函数时，用来接收外埠传入数据的参数，就是形式参数
// 实际参数：调用函数时，传给形参的实际数据叫做实际参数
func max(num1, num2 int) int {
    
    
	var result int
	if num1 > num2 {
    
    
		result = num1
	} else {
    
    
		result = num2
	}
	// 一个函数定义上有返回值，那么函数中必须使用return语句
	// 返回值
	// 调用处需要使用变量接收结果
	return result
}

Cuatro, parámetros variables

Concepto: si se determina el tipo de parámetro de una función, pero el número es incierto, se pueden usar parámetros variables.

func myfunc(arg ... int) {
    
    }
// arg ... int 告诉go这个函数接收不定数量的参数，类型全部是int

package main

import "fmt"

func main() {
    
    
	getSum(1, 2, 3, 4, 5, 6, 7, 8)
}

// ... 可变参数
func getSum(nums ...int) {
    
    
	sum := 0
	// x.len(),获取元素长度
	for i := 0; i < len(nums); i++ {
    
    
		// x[i] 通过下标取出数据
		sum += nums[i]
	}
	fmt.Println("总和：", sum)
}

producción

5. Pasar por valor y pasar por referencia

Según las características del almacenamiento de datos:

• Datos de tipo value: la operación es data body, int, string, bool, float64, array...
• Tipo de datos de Yinchuan: la operación es la dirección del segmento de datos, mapa, chan...

pasar por valor

package main

import "fmt"

func main() {
    
    
	// 定义一个数组
	arr1 := [4]int{
    
    1, 2, 3, 4}
	fmt.Println("arr1默认数据", arr1)
	update(arr1)
	fmt.Println("arr1 调用函数后数据", arr1)

	// arr2 的数据是 从arri 复制兴的，所以是不可的空间
	// 修改 arr2 并不会影响 arr 1
	// 值传递：传递的是数据的副本，修改数据，对于原始约数据没有影响
	// 值类型的数据，默认都是值传递：基础炎型、array、struct
}

func update(arr2 [4]int) {
    
    
	fmt.Println("arr2 接以数据", arr2)
	arr2[0] = 10
	fmt.Println("arr2 修改后数据", arr2)
}

Notas de salida

:

• Si un parámetro de función es un parámetro variable y hay otros parámetros, el parámetro variable debe colocarse al final de la lista.
• Una función puede tener como máximo un parámetro variable en su lista de parámetros.

6. El alcance de las variables en las funciones

• Ámbito: el ámbito en el que se puede utilizar la variable
• Variables locales: las variables definidas dentro de una función se denominan variables locales.

package main

import "fmt"

func main() {
    
    
	// 函数体内的局部变量
	y := 66
	if z := 1; z <= 10 {
    
    
		// 语句内的局部变量
		y := 88
		fmt.Println(y) // 局部变量，就近原则
		fmt.Println(z)
	}
	fmt.Println(y)
	//fmt.Println(z) // # command-line-arguments
	// .\hello.go:15:14: undefined: z
}

func gun01() {
    
    
	// x 为局部变量
	x := 1
	println(x)
}

func gun02() {
    
    
	// fmt.Println(a) //不能在使用在其他函数定义的变量
}

• Todas las variables: las variables definidas fuera de la función se denominan variables globales

package main

import "fmt"

// 全局变量
var num int = 99

func main() {
    
    
	//num := 1
	fmt.Println(num)
	gun01()
	gun02()
}

func gun01() {
    
    
	//num := 2
	println(num)
}

func gun02() {
    
    
	//num := 3
	fmt.Println(num)
}

producción

Siete, diferir

defer Semántica: defer, delay

En el lenguaje Go, use la palabra clave defer para retrasar la ejecución de una función o método.

package main

import "fmt"

func main() {
    
    
	num := 1
	fmt.Println(num)
	defer gun01() // 会被延迟到最后执行
	gun02()
}

func gun01() {
    
    
	num := 2
	println(num)
}

func gun02() {
    
    
	num := 3
	fmt.Println(num)
}

producción

diferir función o método: se retrasa la ejecución de una función o método

• Puede agregar varias declaraciones diferidas en la función, 当函数执行到最后时,这些defer语句会按照逆序执行,最后该函数返回especialmente cuando está realizando algunas operaciones de apertura de recursos y necesita regresar con anticipación si encuentra un error, debe cerrar el recurso correspondiente antes de regresar; de lo contrario, es fácil causar fugas de recursos y otros problemas
• Si hay muchas llamadas para diferir, diferir adopta el modo de última conversación, primero en salir (pila).

package main

import "fmt"

func main() {
    
    
	num := 1
	num01 := 6
	fmt.Println(num)
	defer gun01() // 会被延迟到最后执行
	defer gun02()
	defer fmt.Println(num01)
}

func gun01() {
    
    
	num := 2
	println(num)
}

func gun02() {
    
    
	num := 3
	fmt.Println(num)
}

producción

import "fmt"

func main() {
    
    
	num := 1
	a := 6
	fmt.Println(num)
	defer gun01(a) // 在执行a++之前，参数就已经传递进去了，在最后执行
	a++
	fmt.Println(a)

}

func gun01(x int) {
    
    

	println(x)
}

producción

8. Investigación sobre la naturaleza de las funciones

package main

import "fmt"

// func() 本身就是一个数据类型
func main() {
    
    
	// f1 如果不加括号，函数也是一个变量
	// f1() 如果加了括号，那就成了函数的调用
	fmt.Print("%T\n", f1)

	// f1 看着对应函数名对应函数体的地址 0xbbfd60
	// f1() 带括号就是将函数直接调用

	// 直接定义一个函数类型的变量
	fmt.Println()
	var x func(int, int)
	fmt.Println(x)

	// 将格式相同的f1给x进行函数赋值
	x = f1
	fmt.Println(x) // 和f1地址相同

	f1(1, 2)
	x(10, 20) //x也是函数类型的，可以直接调用
}

func f1(a, b int) {
    
    
	fmt.Printf("a:%d,b:%d\n", a, b)
}

函数在 Go 语言中是复合类型，可以看做是一种特殊的变量。
Nombre de la función ( ): el resultado de retorno de la llamada
Nombre de la función: la dirección de memoria que apunta al cuerpo de la función, un tipo especial de variable de puntero

9. Funciones anónimas

package main

import "fmt"

// func() 本身就是一个数据类型
func main() {
    
    
	f1()
	f2 := f1 //函数本身也是一个变量
	f2()

	// 匿名函数
	f3 := func() {
    
    
		fmt.Println("f3函数")
	}
	f3()

	func() {
    
    
		fmt.Println("f4函数")
	}() // 匿名函数本身可以调用自己

	func(a, b int) {
    
    
		fmt.Println(a, b)
		fmt.Println("f5函数")
	}(3, 4) // 匿名函数本身可以调用自己

	x := func(a, b int) int {
    
    
		fmt.Println("f6函数")
		return a + b

	}(3, 4) // 匿名函数本身可以调用自己
	fmt.Println(x)
}

func f1() {
    
    
	fmt.Println("f1函数")
}

El lenguaje Go admite la programación funcional:
1. Use una función anónima como parámetro de otra función y devuelva la llamada a una función
2. Use una función anónima como valor de retorno de otra función para formar una estructura de cierre

10. Función de devolución de llamada

Según las características de los tipos de datos en el lenguaje Go, 可以将一个函数作为另外一个函数的参数.
fun1(), fun2() usan la función fun1 como parámetro de la función fun2

función fun2: llamada función de orden superior, una función que recibe una función como parámetro

función fun1: llamada función de devolución de llamada, como parámetro de otra función

package main

import "fmt"

func main() {
    
    
	r1 := Sum(1, 1)
	fmt.Println(r1)

	r2 := oper(5, 5, Sum)
	fmt.Println(r2)

	r3 := oper(10, 5, Sub)
	fmt.Println(r3)

	r4 := oper(10, 5, func(a int, b int) int {
    
    
		if b == 0 {
    
    
			fmt.Println("除数不能为0")
			return 0
		}
		return a / b
	})
	fmt.Println(r4)
}

// 高阶函数,可以接收一个函数作为参数
func oper(a, b int, f func(int, int) int) int {
    
    
	r := f(a, b)
	return r

}

func Sum(a, b int) int {
    
    
	return a + b
}

func Sub(a, b int) int {
    
    
	return a - b
}

producción

Once, cierre

• En una función externa, hay una función de capa humana. En esta función de capa humana, se operarán las variables locales de la función de capa externa. La función de capa externa regresará y pasará a esta función de capa humana. Las variables de la parte espiritual del número interno de plumas y el número externo de orina se denominan colectivamente estructura de cierre.

• El ciclo de vida de las variables locales cambiará. Las variables locales normales se crearán con el ajuste de la función y se destruirán con el final de la función. Como estructura cerrada, las variables locales con el número de columnas externas no se destruirán con el cálculo de la función externa, porque se seguirá utilizando el certificado de función interna.

package main

import "fmt"

func main() {
    
    
	r1 := increment()
	fmt.Println(r1)

	v1 := r1()
	fmt.Println(v1)

	v2 := r1()
	fmt.Println(v2)
	fmt.Println(r1())
	fmt.Println(r1())
	fmt.Println(r1())

	r2 := increment()
	v3 := r2()
	fmt.Println(v3)
	fmt.Println(r1())
	fmt.Println(r2())
}

func increment() func() int {
    
    
	// 局部变量i
	i := 0
	// 定义一个匿名函数，给变量自增并返回
	f := func() int {
    
    
		i++
		return i
	}
	return f
}