# Funciones ## Declaración ```text nombre :: arg1, arg2, … argn { … } ``` o, con la palabra reservada `function`: ```text function nombre(arg1, arg2) { … } ``` Ambas formas son iguales. ```dkl suma :: a, b { return a + b } saludo :: n { return "Hola " + n } sin_argumentos :: { } function tres() { return 3 } do print(suma(2, 3)) do print(saludo("Ana")) do print(sin_argumentos()) do print(suma(suma(1, 2), tres())) ``` ```text 5 Hola Ana 0 6 ``` Reglas: - **Declare la función antes del código que la llama.** Llamarla antes da `Función: … no reconocida o no registrada`. - El número de parámetros es **fijo**: llamar con menos o más da `Número de parámetros incorrectos en la llamada`. - Toda función devuelve un valor; sin `return`, devuelve **0**. - Cada función tiene su propio ámbito: sus variables locales existen solo mientras se ejecuta y no ve las variables locales de quien la llama. - Los nombres no distinguen mayúsculas. ```dkl do print(despues(1)) despues :: x { return x } ``` ```text {1} Error en expresión: Función: despues no reconocida o no registrada [ejemplo.dkl][Ln= 7] ``` ## Parámetros por valor y por referencia Un parámetro es **por valor** si no lleva prefijo: la función recibe una copia del número o la cadena. Un parámetro que recibe un **objeto** (registro, lista, conexión) se declara con `&`: la función trabaja sobre el mismo objeto que le pasaron. ```dkl cambia :: a { a = a + 100 return a } x = 1 do print(cambia(x)) do print(x) llena :: &r, valor { r<"campo">: valor } agrega :: &l, v { do list.addstr(l, v) } new reg { @"x": 1 } do llena(reg, "nuevo") do print(to.json(reg)) ref l = list.create() do agrega(l, "a") do agrega(l, "b") do print(to.json(l)) ``` ```text 101 1 {"x":1,"campo":"nuevo"} ["a","b"] ``` ## Devolver un objeto Una función puede devolver un registro o una lista; quien la llama lo recibe con `ref`: ```dkl crea_cliente :: nombre, rfc { new c { @"nombre": nombre @"rfc": rfc } return c } ref c = crea_cliente("Ana", "XAXX010101000") do print(to.json(c)) ``` ```text {"nombre":"Ana","rfc":"XAXX010101000"} ``` Si asigna ese resultado a una variable de valor (`n = crea_cliente(…)`) recibe el índice del objeto, un número sin utilidad. ## Recursión ```dkl fact :: n { if n <= 1 { return 1 } return n * fact(n - 1) } fib :: n { if n < 2 { return n } return fib(n - 1) + fib(n - 2) } do print(fact(10)) do print(fact(25)) do print(fib(15)) ``` ```text 3628800 15511210043330985984000000 610 ``` En 2.0 la profundidad máxima de recursión sube a unos 2,946 niveles (en 1.x eran unos 1,989). Para recorridos más profundos use un ciclo. ## Funciones dentro de funciones Se puede declarar una función dentro de otra. Hágalo dentro de un `codeblock` (o `module`) con espacio de nombres explícito, para que el nombre no dependa de dónde se invoque la función padre: ```dkl padre :: x { codeblock ":interno" { hijo :: y { return y * 10 } } return interno.hijo(x) } do print(padre(4)) do print(padre(5)) ``` ```text 40 50 ``` En 1.x, en un servidor FastCGI, las funciones anidadas fallaban a partir de la segunda petición; en 2.0 funcionan en todas. Una función anidada se registra en la tabla **global** de funciones cuando se ejecuta la función padre: desde ese momento también se puede llamar desde afuera, no ve las variables de la padre (solo sus parámetros y las globales `@`) y, si dos funciones tienen el mismo nombre completo, gana la última que se registró. Detalles y ejemplos en [Funciones anidadas y referencias a funciones](/es/devkron/2.0/lenguaje/imperativo/funciones-anidadas-y-referencias.md). Los espacios de nombres, `alias` y `namespace` están en [Organización del programa](/es/devkron/2.0/lenguaje/imperativo/organizacion.md). ## Funciones abiertas: go, expose y that Una **función abierta** ejecuta, en un punto de su código, un bloque que le pasa quien la llama. Es como un *callback*: la función controla el recorrido y el que llama decide qué hacer en cada paso. - En la función, `that` (solo) marca dónde se ejecuta el bloque externo. - `expose v1, v2` publica variables locales de la función, de **solo lectura**, para el bloque. - Quien llama usa `go`: ```text go función [(expuesta:alias, …)] [with(argumentos)] [-> resultado | ->* resultado_ref] { bloque } ``` ```dkl iterar :: max { expose index for index = 0; index < max { that } return "Fin" } go iterar (index:i) with(3) -> r { do print("i=" + str(i)) } do print(r) ``` ```text i=0 i=1 i=2 Fin ``` El bloque se ejecuta en el ámbito de **quien llama**: puede leer y modificar sus variables (`total = total + v`), además de leer las expuestas con su alias. Con `->* r` el resultado se recibe como referencia. Las funciones `foreach.*` de `functions.dkh` son funciones abiertas; vea [Sentencias](/es/devkron/2.0/lenguaje/imperativo/sentencias.md). Un ejemplo de la vida real: recorrer los renglones de una consulta y acumular. ```dkl cada_partida :: &lista { expose i, cantidad, precio for i = 0; i < list.count(lista) { ref p = list.obj(lista, i) cantidad = @@(p, "#cant") precio = @@(p, "#precio") that } return list.count(lista) } ref partidas = from.json("[{\"cant\":3,\"precio\":19.99},{\"cant\":1,\"precio\":1500},{\"cant\":2.5,\"precio\":0.333}]") subtotal = 0 go cada_partida (cantidad:c, precio:p) with(partidas) -> n { subtotal = subtotal + c * p } do print(str(n) + " partidas, subtotal " + str(round(subtotal, 2))) ``` ```text 3 partidas, subtotal 1560.80 ``` Restricciones: - `that` solo, fuera de una función, da `La sentencia 'that' sin argumentos ni retorno solo puede usarse en el contexto de una función`. - El bloque solo puede usar con alias variables que la función haya expuesto (`La variable '…' no está expuesta por la función que incorpora código`). - En `go` escriba el nombre completo de la función: los `alias` no valen. - Los argumentos de `with( )` no pueden ser llamadas a funciones (`go f (…) with(list.of(1, 2))` es error de sintaxis 109): calcule antes el valor en una variable. Qué pasa con lo que se hace dentro del bloque: | Dentro del bloque de un `go` | Efecto | |---|---| | leer o asignar una variable de quien llama | permitido: es el ámbito de quien llama | | asignar a un alias | no cambia la función ni da error; crea una variable de quien llama con ese nombre | | `alias -> lista` | error `La variable mapeada no está disponible`: copie antes a una variable local | | `return valor` | sale de la función que contiene el `go` (en el nivel principal, termina el programa) | | `break` | rompe el ciclo de quien llama (sin ciclo, sale de la función con 0) | Las reglas completas, con ejemplos, están en [Funciones abiertas y bloques `go`](/es/devkron/2.0/lenguaje/imperativo/funciones-abiertas.md). ## Referencias a funciones `point f to función` y `that f(…) -> r` permiten guardar una función en una variable y llamarla después. La referencia se puede pasar como parámetro, guardar en listas y registros y devolver con `return`. Vea [Sentencias](/es/devkron/2.0/lenguaje/imperativo/sentencias.md) y [Funciones anidadas y referencias a funciones](/es/devkron/2.0/lenguaje/imperativo/funciones-anidadas-y-referencias.md). ## Funciones con $ (2.0) Los nombres de funciones y parámetros pueden empezar con `$`: `$doble :: $v { return $v * 2 }`. Vea [Novedades](/es/devkron/2.0/lenguaje/novedades-2.0/identificadores-dolar.md).