Método: código de finalización o un conjunto de funciones.
Proceso general: métodos necesarios para la entrada, el método devuelve el resultado.
mecanismo de llamada a la función subyacente Análisis:
área de pila : tipos de datos básicos se asignan generalmente a la zona de pila, hay un compilador de análisis de escape.
Montón : tipos de datos de referencia general asignados a la región montón, hay un compilador de análisis de escape.
Los códigos de área : área de memoria de almacenamiento de códigos
Al llamar a un procedimiento, llamadas a funciones tienen un profundo conocimiento de lo que se ha hecho:
package main
import "fmt"
func calcu (a float64,b float64) (float64,float64) {
plus := a + b
minus := a - b
return plus,minus
}
func main() {
/*
第一步 main是一切程序的入口，首先现在内存栈区开辟一块空间存储变量
a=5 b=3 都是基本变量，一般存在内存栈区
*/
var (
a float64 = 5
b float64 = 3
)
/*
第二步 调用函数，将两个变量的值传入函数中，系统在内存栈区开辟另一块儿空间放入被调用函数，
这个地方的函数的内存与main程序的内存空间完全是两个用户空间，这也就是说为何被调用函数如果
没有返回值，就是两个完全不相干的函数调用，也就失去了调用意义，调用结束返回后，return结束
被调用函数，并且返回值，编译器就会将这部分垃圾回收，回到main()中继续走完
*/
max, min := calcu(a,b)
/*
第三部 执行接下来main中的其他语句，直到执行完成后，编译器回收所有占据内存的垃圾。
*/
fmt.Println(max)
fmt.Println(min)
}
llamadas a funciones recursivas
- Una función en el cuerpo de la función de llamadas en sí misma es llamada recursiva.
- caso:
principal del paquete
de importación "FMT"
FUNC recu (n-float64) {
IF n-> 2 {
N-
recu (n-) // iteración recu recu interior (), cada éxito sección transversal iteración tiene un espacio de usuario separados unos de otras variables impacto.
El else {}
fmt.Println ( "n- =", n-)
} // fin hasta que la función no tiene valor de retorno, así que no hay nueva generación de valor
}
FUNC main () {
var A = float64. 4
(A) // no recu cualquier valor de retorno, por lo que el siguiente después de la llamada no produce ninguna salida
}
-
Recursiva siempre quiere poner fin a las condiciones de recursividad infinitamente cerca, o es una recursión infinita, bucle infinito.
-
Cuando se termina una función, o el retorno encontró, volverá, que cumplen con la llamada vuelve a quién, y cuando la función está acabada o de retorno, la función del sistema en sí será destruida, ya no ocupan espacio en la memoria.
-
Ejercicio llamada recursiva: recursiva calcula utilizando el número de Fibonacci, a la enésima entero aleatorio, se encontró que el número de columnas de valor es la cantidad?
package main import "fmt" func fbnq(n int) int { if n == 1 || n==2 { return 1 } else { return fbnq(n-1) + fbnq(n-2) } } func main() { res := fbnq(6) fmt.Println(res) } -
valor de la función, conocida f (1) = 3, f (n) = 2 * f (n) + 1, cuando se asignen a n se obtiene f (n) debe ser?
package main import "fmt" func f(n int) int { if n == 1 { return 3 } else { return 2*f(n-1) + 1 } } func main() { res := f(6) fmt.Println(res) } -
Mono comiendo melocotones, el primer día de comer la mitad de los melocotones, y luego comer una décima días que sólo se encuentra un melocotón, la búsqueda de un total de cuántos melocotones
package main import ( "fmt" ) func f(n int) int { if n == 10 { return 1 } else { return (f(n+1) + 1) * 2 //其实这个else有问题，需要限定范围，1<n<10 } } func main() { res := f(1) fmt.Println(res) }
Nota discutir los detalles de la función y
8. La lista de parámetros puede ser plural, la lista devuelta puede ser plural, se debe añadir la pluralidad de valor de retorno de los soportes.
9. El listas de parámetros y el valor de retorno de tipo de datos puede ser una lista de los tipos de valor puede ser de tipo usado.
10. La primera letra del nombre de función no puede ser un número, ya que la primera letra del caso decide si la función se invoca otros paquetes, por lo que al igual que para comprender, similar al público la capital de Java, en minúsculas es privada.
11. La función de alcance: la función es una variable local, función externa no tiene efecto, una función correspondiente a un espacio de usuario.
12. Los tipos de datos básicos y las matrices se hacen pasar los valores por defecto, en la función modificada, que no afectará el valor original.
O entender el valor de copias, y no afectará el valor de la función de llamada en sí.
13. Si desea cambiar la función de la variable por variables externas dentro de la función, la dirección de la variable y puede pasar, el puntero de función en forma variable, que se pasa por referencia en el principal impacto sobre los valores.
**举例值传递，函数在变量+10后，并不会影响主函数中n值不变。**
```
package main
import "fmt"
func test(n int) int {
n = n + 10
fmt.Println("test n = ",n)
return n
}
func main() {
var n int = 10
test(n)
fmt.Println("main n = ",n)
} // main n=10
```
**举例指针传递，函数在指针取值后，影响到主函数中的n，使n+10变为了20：**
```
package main
import "fmt"
func test1(n *int) int {
*n = *n + 10
fmt.Println("test n = ",*n)
return *n
}
func main() {
var n int = 10
test1(&n)
fmt.Println("main n = ",n)
} //main n=20
```
-
Golang no soporta la sobrecarga de funciones tradicionales, permitió dos funciones con el mismo nombre de, incluso si el número de diferentes parámetros también.
-
Golang también una función del tipo de datos se puede asignar a una variable que es una función del tipo de una variable, una función puede ser llamada por la variable, la variable se apreciará que facilitar funciones de la memoria a una función add = variables de alias, la función de () no hay problema, entonces la variable () sin ningún problema.
-
Las funciones también pueden hacer argumentos para la llamada,
package main import "fmt" func getSum (n1 int,n2 int) int { return n1 + n2 } func ff (ff func(int,int) int, num1 int, num2 int) int { // ff类型为函数类型，与getSum一致，再传 n1 ,n2 形参， 再返回一个int返回值 return ff(num1 , num2) } func main() { res2 := ff(getSum,10,20) fmt.Println(res2) } -
Para simplificar las definiciones de tipo de datos, Go soporta tipos de datos personalizados: tipo corresponde a Myint // int int alias añadido , Myint var xx (en realidad int)
está preferiblemente redacción se trata como una función del parámetro, tipo myfunc FUNC (int, int) int // myfunc tipo corresponde a un único parámetro de función dual tipo de retorno -
Apoyo a la función devuelve el valor de la llamada: func cuando el definido valor de retorno definición func (int n1, int n2) (suma int, sub int) {...} // Esto devolverá dos valores se definen directamente, no existe una secuencia de puntos a. Por último, esta función sólo tiene que volver, y no es necesario añadir nada a cambio.
-
Dos más valor devuelto puede ser usada _ ignorado , sólo quiero conseguir uno, no quiero otra.
-
Go admite parámetros variables, por ejemplo func getSum (args ... int) ( suma int) {...} // args ... siete bytes son indispensables, 0 para pasar una pluralidad de parámetros.
func getSum (float64 n1, args ... INT) (suma int) {...} // pasar una float64, pasar 1 a la pluralidad de parámetros int
args se una rebanada, los valores respectivos se puede acceder por args [i], se entiende que se matrices dinámicas.Caso: Para func getSum (args ... int) (suma int) {...} cómo pasar parámetros:
package main import "fmt" func get1Sum (n1 int, args... int) int { //args可以变成其他的字符，vars也可以，但是一般约定俗成，不要乱改。 sum := n1 //可变参数args一定要放在形参列表里的最后 for i := 0 ; i < len(args) ; i++ { sum += args[i] } return sum } func main() { res := get1Sum(1,2,3,4,5) fmt.Println(res) }
