Una función anónima en programación es un tipo especial de funciones que se declaran en el lugar de uso y no reciben un identificador único para acceder a ellas. Compatible con muchos lenguajes de programación .
Por lo general, cuando se crean funciones anónimas, se las llama directamente o se asigna una referencia a la función a una variable , que luego se puede usar para llamar indirectamente a esta función. Pero en este último caso, la función anónima recibe un nombre y deja de ser anónima. Si una función anónima se refiere a variables que no están contenidas en su cuerpo (captura), entonces dicha función se llama cierre . Una expresión lambda es una construcción sintáctica común a muchos lenguajes para definir una función anónima.
La sintaxis para escribir funciones anónimas para diferentes lenguajes de programación en la mayoría de los casos varía mucho.
| Idioma | Ejemplo de notación de suma |
|---|---|
| AS3 | función ( x : int , y : int ): int { devuelve x + y ;} |
| C# | ( x , y ) => x + y |
| C++ | Introducido en C++11. El agarre y el cuerpo deben estar presentes. Forma larga [1] :
[ captura ]( parámetros ) atributos de excepciones mutables - > return_type { cuerpo }
Ejemplo [2] :
[]( int x , int y ){ devuelve x + y ; }
C ++ 14 agregó la capacidad de usar funciones lambda con auto[3] : auto lambda = []( auto x , auto y ) { return x + y ;}; Una función anónima puede capturar como variables separadas, así:en un ; auto f = [ a ](){ devuelve a ;} y todas las variables externas: por referencia [&] o por copia [=] . También puede combinar estos enfoques: por ejemplo, capturar todas las variables por referencia y ciertos parámetros por copia. Para poder modificar las variables capturadas por valor, debe especificar la palabra clave mutable al declarar una función. C++14 agrega la capacidad de inicializar variables lambda en una captura. Por ejemplo:[ a = std :: cadena {}](){ devuelve a ;} |
| CaféScript | (x, y) -> x + y |
| D | // forma abreviada con inferencia de tipo automático auto a = (( x , y ) => x + y )( 2 , 3 ); // notación de formato largo (bloque de llaves) con inferencia de tipo automático auto aa = ( x , y ) { return x + y ; }( 2 , 3 ); // Detección automática del compilador del tipo de función anónima: función o delegado automático b = ( int x , int y ) => x + y ; auto bb = ( int x , int y ) { return x + y ; }; // las funciones no tienen acceso a variables externas auto c = function ( int x , int y ) => x + y ; auto cc = función ( int x , int y ) { return x + y ; }; // los delegados tienen acceso a las variables externas auto d = delegado ( int x , int y ) => x + y ; auto dd = delegar ( int x , int y ) { return x + y ; }; // delegado que toma una variable int y devuelve un valor doble auto f = delegado doble ( int x ) { return 5.0 / x ; }; |
| Delphi (desde la versión 2009) | función ( x , y : entero ) : entero empieza resultado := x + y ; fin ; |
| Erlang | divertido ( X , Y ) -> X + Y fin |
| Octava GNU | @( x , y ) x + y |
| Vamos | Z := func () int { retornar X + Y }() |
| maravilloso | { x , y -> x + y } |
| Haskell | \ x y -> x + y |
| Java (desde la versión 8) | // sin parámetro () -> System . fuera _ println ( "Hola mundo" ); // con un solo parámetro (Este ejemplo es una función de identidad). un -> un //con una sola expresión ( a , b ) -> a + b // con información de tipo explícito ( ID largo , nombre de cadena ) -> "id:" + id + ", nombre:" + nombre // con un bloque de código ( a , b ) -> { return a + b ;} // con múltiples sentencias en el cuerpo lambda. Requiere un bloque de código. // Este ejemplo también incluye una expresión lambda anidada, así como un cierre. ( id , nuevoPrecio ) -> { Opcional < Producto > mayBeProduct = findProduct ( id ); mayBeProduct . ifPresent ( producto -> producto . setPrecio ( nuevoPrecio )); devolver mayBeProduct . obtener (); } |
| JavaScript | Una expresión de función de flecha siempre se declara sin nombre. Se agregaron funciones de flecha al estándar ECMAScript 6 (también conocido como ECMAScript 2015) [4] .
// Función de flecha. ES6+ (ES2015+)
( x , y ) => x + y ;
Declarar una función a través de una expresión de función sin especificar un nombre. Este método se describió por primera vez en la especificación del estándar ECMAScript 3 [5] [6] .
// expresión de la función.
Función ES3+ ( x , y ) { devuelve x + y }
La creación dinámica de una función por un constructor de un objeto Función (Function constructor) siempre se declara sin nombre. Una notación más corta para la creación de funciones dinámicas es una llamada de función que llama automáticamente al constructor de funciones con los mismos parámetros. Estas formas de crear funciones han existido desde las primeras especificaciones, comenzando con ECMAScript First Edition [7] [8] . // Creación dinámica de una función por el constructor de funciones. ES1+ nueva función ( 'x' , 'y' , 'return x + y' ) // Notación más corta. Función ES1+ ( 'x' , 'y' , 'retornar x + y' ) |
| Lúa | función ( x , y ) devuelve x + y fin |
| arce | ( x , y ) -> x + y |
| Matemática |
#1 + #2 &
o Función [ #1 + #2 ]o Función [{ x , y }, x + y ] [9] [10] |
| MATLAB | f =@( x , y ) x + y |
| Máxima | lambda ([ x,y ] , x+y ) |
| Nim | proceso ( x , y : int ): int = x * y |
| PascalABC.NET | ( x , y ) -> x + y |
| Perl | sub { regresar $_ [ 0 ] + $_ [ 1 ] } [once] |
| PHP | // PHP 7.4+
fn ( $x , $y ) => $x + $y ;
Las funciones de flecha se agregaron en PHP 7.4 [12] . // Función de PHP 5.3+ ( $x , $y ) use ( $a , & $b ) { return $x + $y ; }Aquí $a, $b son variables capturadas, mientras que la variable $b también está cerrada [13] [14] . // PHP 4.0.1+ create_function ( ' $x, $y' , 'return $x + $y;' )Crear una función anónima con create_function [15] . Este método está en desuso desde PHP 7.2.0. |
| Potencia Shell | { parámetro ( $x , $y ) $x + $y } [dieciséis] |
| Pitón | lambda x , y : x + y [17] |
| R | función ( x , y ) x + y |
| rubí | lambda { | x , y | x + y } [Dieciocho] |
| Óxido | | x : i32 , y : i32 | x + y |
| Scala |
Sin especificar el contexto, debe especificar el tipo de variables: ( x : Int , y : Int ) => x + yPero en lugares donde se puede inferir el tipo, se pueden usar formas abreviadas: ( 1 a 100 ) reducir (( a , b ) => a + b )O incluso más corto, usando sustituciones automáticas '_': ( 1 a 100 ) reducir ( _ + _ ) |
| Esquema , ceceo común | ( lambda ( x y ) ( + x y )) |
| SML | fn ( x , y ) => x + y |
| Rápido | // 1 opción let f : ( Int , Int ) -> Int = { x , y devuelve x + y } // 2da opción sea f : ( Int , Int ) -> Int = { x , y en x + y } /* Nombres de parámetros abreviados */ // 1ra opción let f : ( Int , Int ) -> Int = { return $0 + $1 } // 2da opción sea f : ( Int , Int ) -> Int = { $0 + $1 } |
| mecanografiado | // Una expresión de función de flecha siempre se declara sin nombre ( x , y ) => x + y // expresión de función (expresión de función) sin nombre function ( x , y ) { return x + y } // Creación dinámica de una función // por un constructor de objetos Function (Function constructor) // siempre declarada sin nombre new Function ( 'x' , 'y' , 'return x + y' ) // Notación más corta para la creación de funciones dinámicas. // Llamar a una función invoca automáticamente // al constructor de la función con los mismos parámetros Función ( 'x' , 'y' , 'return x + y' ) |
| Prólogo visual | {( X , Y ) = X + Y } |