Ejemplos de funciones anónimas

Solo algunos dialectos admiten funciones anónimas, ya sea como dfns , en el estilo tácito o una combinación de ambos.

f ← ​​{ ⍵ × ⍵ } Como una dfn f 1 2 3 1 4 9 g ← ⊢× ⊢ Como un tren tácito 3 ( fork ) g 1 2 3 1 4 9 h ← × ⍨ Como una función tácita derivada h 1 2 3 1 4 9

La función anónima no es compatible con el lenguaje de programación C estándar , pero sí con algunos dialectos de C, como GCC ^{[ 1 ]} y Clang .

( { return_type anonymous_functions_name ( parameters ) { function_body } anonymous_functions_name ; } )

#include <stdio.h>// Esta es la definición de la función anónima #define lambda(l_ret_type, l_arguments, l_body) \  ({ \  l_ret_type l_anonymous_functions_name l_arguments \  l_body \  &l_anonymous_functions_name; \  })#define FOR_EACH_IN_ARRAY(fe_arrType, fe_arr, fe_fn_body) \ { \  for (int i = 0; i < sizeof(fe_arr) / sizeof(fe_arrType); i++) { \  fe_arr[i] = fe_fn_body(&fe_arr[i]); \  } \ }typedef struct { int a ; int b ; } IntegerPair ;void printElements ( const IntegerPair arr [], size_t n ) { for ( int i = 0 ; i < n ; ++ i ) { printf ( "%d %d \n " , arr [ i ]. a , arr [ i ]. b ); } }int main ( int argc , char * argv []) { IntegerPair pairArray [] = { { 0 , 1 }, { 2 , 3 }, { 4 , 5 } };printElements ( a , 3 ); // la función anónima se proporciona como función para el foreach FOR_EACH_IN_ARRAY ( IntegerPair , pairArray , lambda ( IntegerPair , ( void * item ), { int temp = ( * ( IntegerPair * ) item ).a ; ( * ( IntegerPair * ) item ) .a = ( * ( IntegerPair * ) item ) .b ; ( * ( IntegerPair * ) item ) .b = temp ; return ( * ( IntegerPair * ) item ) ; } ) ); printElements ( pairArray , 3 ); return 0 ; }

^ T ( parámetros ) { cuerpo }

#include <stdio.h> #include <dispatch/dispatch.h>int main ( int argc , char * argv []) { void ( ^ count_loop )() = ^ { for ( int i = 0 ; i < 100 ; i ++ ) { printf ( "%d \n " , i ); } printf ( "ah ah ah \n " ); };// Pasar como parámetro a otra función dispatch_async ( dispatch_get_global_queue ( DISPATCH_QUEUE_PRIORITY_DEFAULT , 0 ), count_loop );// Invocar directamente count_loop ();devolver 0 ; }

C++ (desde C++11 ) admite funciones anónimas (técnicamente objetos de función ), llamadas expresiones lambda , ^{[ 3 ]} que tienen la forma: donde " " tiene la forma " en ese orden; cada uno de estos componentes es opcional". Si está ausente, el tipo de retorno se deduce de las instrucciones como si fuera para una función con un tipo de retorno declarado .[captures]<template-parameters>(params) specsrequires (...) -> returns { body }specsspecifiersexceptionattributes -> trailing-return-typereturnauto

A partir de C++20 , los parámetros de plantilla también se pueden declarar explícitamente en el área.<template-parameters>

Este es un ejemplo de expresión lambda, con un atributo :[[nodiscard]]

auto f = []( int x , int y ) [[ nodiscard ]] -> int { return x + y ; };

C++ también admite cierres , aquí llamados capturas. Las capturas se definen entre corchetes [y ]en la declaración de la expresión lambda. Este mecanismo permite capturar estas variables por valor o por referencia. La siguiente tabla lo demuestra:

// Sin capturas, la lambda es implícitamente convertible a un puntero a función. auto a = [] -> void {}; // x se captura por valor e y se captura por referencia. auto b = [ x , & y ] -> void {}; // Cualquier variable externa se captura implícitamente por referencia si se usa. auto c = [ & ] -> void {}; // Cualquier variable externa se captura implícitamente por valor si se usa. auto d = [ = ] -> void {}; // x se captura por valor. Otras variables se capturarán por referencia. auto e = [ & , x ] -> void {}; // z se captura por referencia. Otras variables se capturarán por valor. auto f = [ = , & z ] -> void {};

Las variables capturadas por valor son constantes por defecto. Si se añaden mutabledespués de la lista de parámetros, dejan de ser constantes.

C++14 y versiones posteriores admiten init-capture, por ejemplo:

usando std :: unique_ptr ;unique_ptr < int > ptr = std :: make_unique < int > ( 42 );// La asignación de copia se elimina para un puntero único auto a = [ ptr ] -> void { // ... };// OK auto b = [ ptr = std :: move ( ptr )] -> void { // ... };// Se requiere mutable para modificar 'i' auto counter = [ i = 0 ]() mutable -> int { return i ++ ; };contador (); // 0 contador (); // 1 contador (); // 2

Los dos ejemplos siguientes demuestran el uso de una expresión lambda:

usando std :: vector ;vector < int > someList { 1 , 2 , 3 , 4 , 5 }; int total = 0 ; std :: ranges :: for_each ( someList , [ & total ]( int x ) -> void { total += x ; } ); // Tenga en cuenta que std::ranges::fold_left es una alternativa preferible aquí

Esto calcula el total de todos los elementos de la lista. La variable totalse almacena como parte del cierre de la función lambda. Dado que es una referencia a la variable de pila total, puede cambiar su valor.

usando std :: vector ;vector < int > someList { 1 , 2 , 3 , 4 , 5 }; int total = 0 ; int value = 5 ; std :: ranges :: for_each ( someList , [ & total , value , this ]( int x ) -> void { total += x * value * this -> someFunc (); } );

Esto hará totalque se almacene como referencia, pero valuese almacenará como una copia.

La captura de thises especial. Solo se puede capturar por valor, no por referencia. Sin embargo, en C++17 , el objeto actual se puede capturar por valor (denotado por *this), o se puede capturar por referencia (denotado por this). thissolo se puede capturar si la función contenedora más cercana es una función miembro no estática. La expresión lambda tendrá el mismo acceso que el miembro que la creó, en términos de miembros protegidos/privados.

Si thisse captura, ya sea explícita o implícitamente, también se comprueba el alcance de los miembros de la clase incluidos. El acceso a los miembros thisno requiere el uso explícito de this->sintaxis.

La implementación interna específica puede variar, pero se espera que una función lambda que captura todo por referencia almacene el puntero de pila real de la función en la que se crea, en lugar de referencias individuales a variables de pila. Sin embargo, dado que la mayoría de las funciones lambda son pequeñas y de ámbito local, son candidatas ideales para la optimización en línea y, por lo tanto, no necesitan almacenamiento adicional para referencias.

Si se invoca un objeto de cierre que contiene referencias a variables locales después del ámbito de bloque más interno de su creación, el comportamiento es indefinido .

Las funciones lambda son objetos de función de un tipo dependiente de la implementación; el nombre de este tipo solo está disponible para el compilador, por lo que las lambdas pueden verse como tipos generados por el compilador que implementan una operator(). Debido a que el tipo de una lambda está especificado por el compilador, generalmente se almacena en autopara la deducción de tipos . Las lambdas también pueden almacenarse en , pero esto usa borrado de tipo , mientras que almacenar en un puntero de función no permite capturas en la lambda. Si el usuario desea tomar una función lambda como parámetro, el tipo de parámetro debe ser un tipo de plantilla, o debe crear un o un objeto similar para capturar el valor de la lambda. El uso de la palabra clave puede ayudar a almacenar la función lambda,std::function<R(Ts...)>std::functionauto

auto myLambdaFunc = [ & ]( int x ) -> void { // ... };auto myHeapLambdaFunc = new auto ([ = ]( int x ) -> void { // ... });

Aquí hay un ejemplo de cómo almacenar funciones anónimas en variables, vectores y matrices, y cómo pasarlas como parámetros con nombre:

importar std ;usando std :: function ; usando std :: vector ;double eval ( function < double ( double ) > f , double x = 2.0 ) { return f ( x ); }int main ( int argc , char * argv []) { function < double ( double ) > f0 = []( double x ) -> double { return 1.0f ; };auto f1 = []( double x ) -> double { return x ; };decltype ( f0 ) fa [ 3 ] = { f0 , f1 , []( double x ) -> double { return x * x ; }};vector < decltype ( f0 ) > fv = { f0 , f1 }; fv . push_back ([]( double x ) -> double { return x * x ; });for ( size_t i = 0 ; i < fv . size (); ++ i ) { std :: println ( "{}" , fv [ i ]( 2.0 )); }for ( size_t i = 0 ; i < 3 ; ++ i ) { std :: println ( "{}" , fa [ i ]( 2.0 )); }for ( decltype ( f0 ) & f : fv ) { std :: println ( "{}" , f ( 2.0 )); }for ( decltype ( f0 ) & f : fa ) { std :: println ( "{}" , f ( 2.0 )); }std :: println ( "{}" , f ( 2.0 )); std :: println ( "{}" , eval ( f0 )); std :: println ( "{}" , eval ( f1 )); std :: println ( "{}" , eval ([]( double x ) -> double { return x * x ; })); }

Una expresión lambda con una especificación de captura vacía ( []) puede convertirse implícitamente en un puntero a función del mismo tipo con el que se declaró la lambda. Por lo tanto, esto es válido:

auto aLambdaFunc = []( int x ) -> void { // ... }; void ( * funcPtr )( int ) = aLambdaFunc ; funcPtr ( 4 ); // llama a la lambda.

Desde C++14 , los parámetros de función de una expresión lambda se pueden declarar con auto. La expresión lambda resultante se denomina expresión lambda genérica y es esencialmente una plantilla de función anónima, ya que las reglas para la deducción de tipos de los parámetros auto son las mismas que las de la deducción de argumentos de plantilla.

Desde C++17 , una lambda puede declararse como constexpr, y desde C++20 , constevalcon la semántica habitual. Estos especificadores van después de la lista de parámetros, como mutable. A partir de C++23 , la lambda también puede ser staticsi no tiene capturas. Los especificadores staticy mutableno se pueden combinar.

Desde C++23, una expresión lambda puede ser recursiva a través de un parámetro explícito thiscomo primer parámetro:

auto fibonacci = []( this auto self , int n ) -> void { return n <= 1 ? n : self ( n - 1 ) + self ( n - 2 ); }; fibonacci ( 7 ); // 13

Además, C++23 modificó la sintaxis para que se puedan omitir los paréntesis en el caso de una expresión lambda que no recibe argumentos, incluso si tiene un especificador. También estableció que una secuencia de especificadores de atributos que aparece antes de la lista de parámetros, los especificadores de lambda o el especificador noexcept (debe haber uno de ellos) se aplica al operador de llamada a función o a la plantilla de operador del tipo de cierre. De lo contrario, se aplica al tipo del operador de llamada a función o de la plantilla de operador. Anteriormente, dicha secuencia siempre se aplicaba al tipo del operador de llamada a función o de la plantilla de operador del tipo de cierre, lo que hacía, por ejemplo, imposible usar el atributo con expresiones lambda.[[noreturn]]

En C# , la compatibilidad con funciones anónimas se ha profundizado a través de las distintas versiones del compilador del lenguaje. La versión 3.0 del lenguaje, lanzada en noviembre de 2007 con .NET Framework v3.5, ofrece compatibilidad total con funciones anónimas. ^{[ 4 ] : 7–8 [ 5 ] : 26} C# las denomina expresiones lambda , siguiendo la versión original de las funciones anónimas, el cálculo lambda . ^{[ 6 ] [ 4 ] : 7–8, 91 [ 5 ] : 91}

usando el sistema ;// el primer int es el tipo x' // el segundo int es el tipo de retorno // <see href="http://msdn.microsoft.com/en-us/library/bb549151.aspx" /> Func < int , int > foo = x => x * x ; Console . WriteLine ( foo ( 7 ));

Aunque la función es anónima, no se puede asignar a una variable de tipo implícito, porque la sintaxis lambda puede usarse para denotar una función anónima o un árbol de expresiones, y el compilador no puede decidir automáticamente la elección. ^{[ 4 ] : 101–103} Por ejemplo, esto no funciona:

usando el sistema ;// ¡NO compilará! Func < int , int > foo = ( int x ) => x * x ;

Sin embargo, una expresión lambda puede participar en la inferencia de tipos y puede usarse como argumento de un método , por ejemplo, para usar funciones anónimas con la capacidad Map disponible con System.Collections.Generic.List(en el ConvertAll()método):

usando System.Collections.Generic ;// Inicializar la lista: List < int > values ​​= new ( 7 , 13 , 4 , 9 , 3 ); // Aplicar la función anónima a todos los elementos de la lista y devolver la nueva lista List < int > foo = values ​​. ConvertAll ( d => d * d ); // El resultado de la variable foo es de tipo System.Collections.Generic.List<Int32>

Las versiones anteriores de C# tenían un soporte más limitado para funciones anónimas. C# v1.0, introducido en febrero de 2002 con .NET Framework v1.0, proporcionó soporte parcial para funciones anónimas mediante el uso de delegados . ^{[ 4 ] : 6} C# los denomina expresiones lambda , siguiendo la versión original de funciones anónimas, el cálculo lambda . ^{[ 4 ] : 91} Esta construcción es algo similar a los delegados de PHP. En C# 1.0, los delegados son como punteros a funciones que se refieren a un método con nombre explícito dentro de una clase. (Pero a diferencia de PHP, el nombre no es necesario en el momento en que se usa el delegado). C# v2.0, lanzado en noviembre de 2005 con .NET Framework v2.0, introdujo el concepto de métodos anónimos como una forma de escribir bloques de instrucciones en línea sin nombre que se pueden ejecutar en una invocación de delegado. ^{[ 4 ] : 6–7} C# 3.0 continúa admitiendo estas construcciones, pero también admite la construcción de expresiones lambda.

Este ejemplo se compilará en C# 3.0 y muestra las tres formas:

espacio de nombres Wikipedia.Ejemplos ;usando el sistema ;public class TestDriver { delegate int SquareDelegate ( int d ); static int Square ( int d ) { return d * d ; } static void Main ( string [] args ) { // C# 1.0: Se necesita la sintaxis original del delegado // inicialización con un método con nombre. SquareDelegate A = new ( Square ); Console . WriteLine ( A ( 3 )); // C# 2.0: Un delegado se puede inicializar con // código en línea, llamado "método anónimo". Este // método toma un int como parámetro de entrada. SquareDelegate B = delegate ( int d ) { return d * d ; }; Console . WriteLine ( B ( 5 )); // C# 3.0. Un delegado se puede inicializar con // una expresión lambda. La lambda toma un int y devuelve un int. // El tipo de x es inferido por el compilador. SquareDelegate C = x => x * x ; Console . Console.WriteLine ( C ( 7 )); // C# 3.0. Un delegado que acepta una entrada y // devuelve una salida también se puede declarar implícitamente con el tipo Func<> . System.Func < int , int > D = x = > x * x ; Console.WriteLine ( D ( 9 ) ) ; } }

En el caso de la versión C# 2.0, el compilador de C# toma el bloque de código de la función anónima y crea una función privada estática. Internamente, la función obtiene un nombre generado, por supuesto; este nombre generado se basa en el nombre del método en el que se declara el Delegado. Pero el nombre no se expone al código de la aplicación excepto mediante reflexión . ^{[ 4 ] : 103} En el caso de la versión C# 3.0, se aplica el mismo mecanismo.

Utilizando elfunciónpalabra clave:

fn = función (){ // instrucciones };

O utilizando una función flecha:

fn = () => { // instrucciones };fn = () => singleExpression // singleExpression se devuelve implícitamente. No es necesario usar las llaves ni la palabra clave return.fn = singleParam => { // si la función flecha tiene solo un parámetro, no es necesario usar paréntesis // instrucciones }fn = ( x , y ) => { // si la función flecha tiene cero o varios parámetros, es necesario usar paréntesis // instrucciones }

CFML admite cualquier instrucción dentro de la definición de la función, no solo expresiones.

CFML admite funciones anónimas recursivas:

factorial = función ( n ){ return n > 1 ? n * factorial ( n - 1 ) : 1 ; };

Las funciones anónimas de CFML implementan el cierre.

D utiliza delegados en línea para implementar funciones anónimas. La sintaxis completa para un delegado en línea es

ReturnType delegate ( Args args ) { // cuerpo }

Si no hay ambigüedad, se pueden omitir el tipo de retorno y la palabra clave delegate .

( x ) { return x * x ; } delegate ( x ) { return x * x ; } // si se necesita más verbosidad ( int x ) { return x * x ; } // si no se puede inferir el tipo de parámetro delegate ( int x ) { return x * x ; } // lo mismo delegate double ( int x ) { return x * x ; } // si el tipo de retorno debe forzarse manualmente

Desde la versión 2.0, D asigna cierres en el montón a menos que el compilador pueda demostrar que no es necesario; la scopepalabra clave se puede usar para forzar la asignación en la pila. Desde la versión 2.058, es posible usar la notación abreviada:

x => x * x ; ( int x ) => x * x ; ( x , y ) => x * y ; ( int x , int y ) => x * y ;

Se puede asignar una función anónima a una variable y usarla de esta manera:

auto sqr = ( double x ) { return x * x ; }; double y = sqr ( 4 );

Dart admite funciones anónimas. ^{[ 7 ]}

var sqr = ( x ) => x * x ; print ( sqr ( 5 ));

o

imprimir ((( x ) => x * x )( 5 ));

Delphi introdujo las funciones anónimas en la versión 2009.

demostración del programa ;tipo TSimpleProcedure = referencia al procedimiento ; TSimpleFunction = referencia a la función ( const x : cadena ) : entero ;var x1 : TProcedimientoSimple ; y1 : TFunciónSimple ;begin x1 := procedure begin Writeln ( 'Hola Mundo' ) ; end ; x1 ; //invocar el método anónimo recién definidoy1 := function ( const x : string ) : Integer begin Result := Length ( x ) ; end ; Writeln ( y1 ( 'bar' )) ; end .

PascalABC.NET admite funciones anónimas mediante sintaxis lambda.

begin var n := 10000000 ; var pp := ( 1 .. n ) . Select ( x -> ( Random , Random )) . Where ( p -> Sqr ( p [ 0 ]) + Sqr ( p [ 1 ]) < 1 ) . Count / n * 4 ; Print ( pp ) ; end .

Elixir utiliza el cierrefn para funciones anónimas. ^{[ 8 ]}

iex> suma = fn ( a , b ) -> a + b end iex> suma . ( 4 , 3 ) 7 iex> cuadrado = fn ( x ) -> x * x end iex> Enum . map [ 1 , 2 , 3 , 4 ], cuadrado [1, 4, 9, 16]

Erlang utiliza una sintaxis para funciones anónimas similar a la de las funciones con nombre. ^{[ 9 ]}

% Función anónima vinculada a la variable Square Square = fun ( X ) -> X * X end .% Función nombrada con la misma funcionalidad cuadrado ( X ) -> X * X .

Go admite funciones anónimas. ^{[ 10 ]}

foo := func ( x int ) int { return x * x } fmt . Println ( foo ( 10 ))

Haskell utiliza una sintaxis concisa para las funciones anónimas (expresiones lambda). Se supone que la barra invertida se asemeja a λ.

\ x -> x * x

Las expresiones lambda están totalmente integradas con el motor de inferencia de tipos y admiten toda la sintaxis y las características de las funciones "ordinarias" (excepto el uso de múltiples definiciones para la coincidencia de patrones, ya que la lista de argumentos solo se especifica una vez).

map ( \ x -> x * x ) [ 1 .. 5 ] -- devuelve [1, 4, 9, 16, 25]

Los siguientes son todos equivalentes:

f x y = x + y f x = \ y -> x + y f = \ x y -> x + y

En Haxe , las funciones anónimas se llaman lambda y utilizan la sintaxis function(argument-list) expression;.

var f = function ( x ) return x * x ; f ( 8 ); // 64( función ( x , y ) devuelve x + y )( 5 , 6 ); // 11

Java admite funciones anónimas, llamadas expresiones Lambda , a partir de JDK 8. ^{[ 11 ]}

Una expresión lambda consta de una lista de parámetros formales separados por comas y encerrados entre paréntesis, un token de flecha ( ->), y un cuerpo. Los tipos de datos de los parámetros siempre se pueden omitir, al igual que los paréntesis si solo hay un parámetro. El cuerpo puede constar de una instrucción o un bloque de instrucciones. ^{[ 12 ]}

import java.util.Optional ; import java.util.function.BiFunction ; import java.util.function.BinaryOperator ; import java.util.function.Function ;// Sin parámetros Runnable r = () -> System . out . println ( "Hola, mundo!" );// Con un parámetro (este ejemplo es una función identidad). Función < Objeto , Objeto > identidad = a -> a ;// Con una expresión BinaryOperator < Integer > add = ( a , b ) -> a + b ;// Con información de tipo explícita y un bloque de código BiFunction < Long , String , String > formatter = ( long id , String name ) -> { String . format ( "id: %f, name: %s" , id , name ); }// Con múltiples declaraciones en el cuerpo de la lambda. Necesita un bloque de código. // Este ejemplo también incluye dos expresiones lambda anidadas (la primera también es un cierre). BiFunction < Long , Double , Double > getPriceOrDefault = ( double id , double defaultPrice ) -> { Optional < Product > product = productList . stream () . filter ( p -> p . getId () == id ) . findFirst ();return producto . map ( Producto :: obtenerPrecio ()) . orElse ( precio predeterminado ); }

Las expresiones lambda no pueden especificar throwscláusulas. Las expresiones lambda en sí mismas no son expresiones completas de tipos concretos, sino más bien expresiones polimórficas, cuyo tipo está influenciado por el tipo de destino circundante en lugar de estarlo completamente por su propio contenido.

import java.util.function.Function ;// Inválido, ya que las expresiones lambda en sí mismas no tienen un tipo independiente var f = ( int x ) -> x + 1 ; // En su lugar debería ser: Function < Integer , Integer > f = x -> x + 1 ;

Las expresiones lambda implementan alguna interfaz funcional de destino (como java.lang.Runnable, etc.), que es cualquier interfaz que define solo un método (excluyendo aquellas que se heredan de java.lang.Object); adicionalmente se puede anotar con @FunctionalInterfacepara que el compilador imponga que una interfaz es realmente una interfaz funcional. ^{[ 13 ] [ 12 ]}

clase pública Calculadora { interfaz MatemáticasEntero { int operación ( int a , int b );default IntegerMath swap () { return ( a , b ) -> operation ( b , a ); } }private static int apply ( int a , int b , IntegerMath op ) { return op.operation ( a , b ) ; }​public static void main ( String [] args ) { IntegerMath addition = ( a , b ) -> a + b ; IntegerMath subtraction = ( a , b ) -> a - b ; System . out . printf ( "40 + 2 = %d%n" , apply ( 40 , 2 , addition )); System . out . printf ( "20 - 10 = %d%n" , apply ( 20 , 10 , subtraction )); System . out . printf ( "10 - 20 = %d%n" , apply ( 20 , 10 , subtraction . swap ())); } }

En este ejemplo, se declara una interfaz funcional llamada IntegerMath. Las expresiones lambda que implementan IntegerMathse pasan al apply()método que se va a ejecutar. Los métodos predeterminados como swapdefinen métodos en funciones.

Java 8 introdujo otro mecanismo llamado referencia de método (el ::operador) para crear una expresión lambda en un método existente. Una referencia de método no indica el número ni el tipo de argumentos, ya que estos se extraen del método abstracto de la interfaz funcional.

IntBinaryOperator suma = Entero :: suma ;

En el ejemplo anterior, la interfaz funcional IntBinaryOperatordeclara un método abstracto int applyAsInt(int, int), por lo que el compilador busca un método int sum(int, int)en la clase java.lang.Integer.

IntegerMath anonymousClass = new IntegerMath () { @Override public int operation ( int a , int b ) { return a + b ; } };IntegerMath lambdaExpression = ( a , b ) -> a + b ;

Runnable r = () -> System . out . println ( "Hola" );// Podría imprimir algo como: // class org.wikipedia.examples.Main$$Lambda$1/0x0000000800b00440 System . out . println ( r . getClass ());

Runnable r1 = () -> {}; Runnable r2 = () -> {};System.out.println ( r1 == r2 ) ; // Puede imprimir verdadero o falso; lo determina la JVM

JavaScript / ECMAScript admite funciones anónimas.

alerta (( función ( x ) { devolver x * x ; })( 10 ));

ES6 admite la sintaxis de "función flecha", donde un símbolo => separa la lista de parámetros de la función anónima del cuerpo:

alerta (( x => x * x )( 10 ));

Esta estructura se usa a menudo en los Bookmarklets . Por ejemplo, para cambiar el título del documento actual (visible en la barra de título de su ventana ) a su URL , el siguiente bookmarklet puede parecer que funciona.

documento.título = ubicación.href ;​​​​

Sin embargo, dado que la instrucción de asignación devuelve un valor (la propia URL), muchos navegadores crean una nueva página para mostrar dicho valor.

En su lugar, se puede utilizar una función anónima que no devuelva ningún valor:

( función () { documento . título = ubicación . href ; })();

La instrucción de función en el primer par de paréntesis (exterior) declara una función anónima, que luego se ejecuta cuando se usa con el último par de paréntesis. Esto es casi equivalente a lo siguiente, que rellena el entorno con, fa diferencia de una función anónima.

var f = function () { document . title = location . href ; }; f ();

Utilice void() para evitar nuevas páginas para funciones anónimas arbitrarias:

void ( function () { return document . title = location . href ; }());

o simplemente:

void ( document.title = location.href ) ;​​​

JavaScript presenta sutilezas sintácticas en la semántica de la definición, invocación y evaluación de funciones anónimas. Estos matices implícitos son consecuencia directa de la evaluación de expresiones entre paréntesis. Las siguientes construcciones, denominadas expresiones de función invocadas inmediatamente, ilustran este concepto:

( función () { /* ... */ }())

y

( función () { /* ... */ })()

Representando " function () { /* ... */ }" por f, la forma de las construcciones son un paréntesis dentro de un paréntesis (f())y un paréntesis aplicado a un paréntesis (f)().

Nótese la ambigüedad sintáctica general de una expresión entre paréntesis, los argumentos entre paréntesis de una función y los paréntesis que rodean los parámetros formales en la definición de una función. En particular, JavaScript define un ,operador (coma) en el contexto de una expresión entre paréntesis. ¡No es mera coincidencia que las formas sintácticas coincidan para una expresión y los argumentos de una función (ignorando la sintaxis de los parámetros formales de la función)! Si fno se identifica en las construcciones anteriores, se convierten en (())y ()(). La primera no proporciona ninguna pista sintáctica de ninguna función residente, pero la segunda DEBE evaluar la primera expresión entre paréntesis como una función para ser JavaScript válido. (Nota: por ejemplo, los ()' podrían ser ([], {}, 42, "abc", function () {}) siempre que la expresión se evalúe como una función).

Además, una función es una instancia de objeto (de igual manera, los objetos son instancias de función) y los corchetes de notación literal de objeto, {}para el código entre llaves, se utilizan al definir una función de esta manera (a diferencia de usar new Function(...)). En un sentido muy amplio y no riguroso (especialmente porque las vinculaciones globales están comprometidas), una secuencia arbitraria de instrucciones JavaScript entre llaves, {stuff}, puede considerarse un punto fijo de

( función () { ( función () { ( ... {( función () { /* cosas */ }() )} ... ) }() ) }() )

Más correctamente, pero con salvedades,

( función () { /* cosas */ }() ) ~= fixedPointOf ( función () { return función () { return ... { return función () { /* cosas */ }() } ... }() }())

Observe las implicaciones de la función anónima en los fragmentos de JavaScript que siguen:

• function () { /* ... */ }()sin rodear ()'s generalmente no es legal
• (f = function () { /* ... */ })no "olvida" fglobalmente a diferencia de(function f () { /* ... */ })

Las métricas de rendimiento para analizar la complejidad espacial y temporal de las llamadas a funciones, la pila de llamadas , etc., en un motor intérprete de JavaScript se implementan fácilmente con estas últimas construcciones de funciones anónimas. A partir de las implicaciones de los resultados, es posible deducir algunos detalles de la implementación recursiva frente a la iterativa de un motor, especialmente la recursión de cola .

En Julia, las funciones anónimas se definen utilizando la sintaxis (arguments)->(expression),

julia> f = x- > x * x ; f ( 8 ) 64 julia> (( x , y ) -> x + y )( 5 , 6 ) 11

Kotlin admite funciones anónimas con la sintaxis {arguments -> expression},

val sum = { x : Int , y : Int -> x + y } sum ( 5 , 6 ) // devuelve 11 val even = { x : Int -> x % 2 == 0 } even ( 4 ) // devuelve true

Lisp y Scheme admiten funciones anónimas mediante la construcción "lambda", que hace referencia al cálculo lambda . Clojure admite funciones anónimas con la forma especial "fn" y la sintaxis de lectura #().

( lambda ( arg ) ( * arg arg ))

( función ( lambda ( arg ) ( hacer algo arg )))

; usando comillas marcadas #' ( lambda ( arg ) ( hacer algo arg )) ; usando la macro lambda: ( lambda ( arg ) ( hacer algo arg ))

( mapcar #' ( lambda ( x ) ( * x x )) ' ( 1 2 3 4 )) ; -> (1 4 9 16)

(( lambda ( x y ) ( + ( sqrt x ) ( sqrt y ))) 10.0 12.0 )

( setf ( symbol-function 'sqr ) ( lambda ( x ) ( * x x ))) ; lo que nos permite llamarlo usando el nombre SQR: ( sqr 10.0 )

( define ( somename arg ) ( do-something arg ))

( define algúnnombre ( lambda ( arg ) ( hacer algo arg )))

( fn [ x ] ( + x 3 ))

# ( + % %2%3 ) ; Define una función anónima que toma tres argumentos y los suma.

( definición de función [ arg ] ( + 3arg ) )

( def func ( fn [ arg ] ( + 3 arg )))

En Lua (al igual que en Scheme), todas las funciones son anónimas. Una función con nombre en Lua es simplemente una variable que contiene una referencia a un objeto función. ^{[ 18 ]}

Así, en Lua

función foo ( x ) devuelve 2 * x fin

es simplemente azúcar sintáctico para

foo = función ( x ) devuelve 2 * x fin

Un ejemplo de cómo usar funciones anónimas para ordenar en orden inverso:

tabla.ordenar ( red , función ( a , b ) devolver a . nombre > b . nombre fin )

Wolfram Language es el lenguaje de programación de Mathematica . Las funciones anónimas son importantes en la programación de este último. Existen varias formas de crearlas. A continuación se muestran algunas funciones anónimas que incrementan un número. La primera es la más común. #1Se refiere al primer argumento y &marca el final de la función anónima.

#1 + 1 & Función [ x , x + 1 ] x \ [ Función ] x + 1

Por ejemplo:

f := #1 ^ 2 & ; f [ 8 ] 64 #1 + #2 & [ 5 , 6 ] 11

Además, Mathematica cuenta con una construcción adicional para crear funciones anónimas recursivas. El símbolo '#0' se refiere a la función completa . La siguiente función calcula el factorial de su entrada:

Si [ #1 == 1 , 1 , #1 * #0 [ #1 -1 ]] &

Por ejemplo, el factorial de 6 sería:

Si [ #1 == 1 , 1 , #1 * #0 [ #1 -1 ]] & [ 6 ] 720

Las funciones anónimas en MATLAB u Octave se definen utilizando la sintaxis @(argument-list)expression. Cualquier variable que no se encuentre en la lista de argumentos se hereda del ámbito que la contiene y se captura por valor.

>> f = @( x ) x * x ; f ( 8 ) ans = 64 >> (@( x , y ) x + y )( 5 , 6 ) % Solo funciona en Octave ans = 11

En Maxima, las funciones anónimas se definen utilizando la sintaxis lambda(argument-list,expression),

f : lambda ([ x ], x * x ); f ( 8 ); 64lambda ([ x , y ], x + y )( 5 , 6 ); 11

Los distintos dialectos de ML admiten funciones anónimas.

diversión x -> x * 2

( fun x -> x * x ) 20 // 400

fn arg => arg * arg

Nim admite funciones anónimas de múltiples líneas y múltiples expresiones. ^{[ 21 ]}

var anon = proc ( var1 , var2 : int ): int = var1 + var2 assert anon ( 1 , 2 ) == 3

Ejemplo de varias líneas:

var anon = func ( x : int ): bool = if x > 0 : result = true else : result = falseafirmar anónimo ( 9 )

Las funciones anónimas pueden pasarse como parámetros de entrada de otras funciones:

var ciudades = @[ "Frankfurt" , "Tokio" , "Nueva York" ]ciudades.ordenar ( proc ( x , y : cadena ) : int = cmp ( x.len , y.len ) )​​​​​

Una función anónima es básicamente una función sin nombre.

Before 4.0.1, PHP had no anonymous function support.^[23]

$foo = create_function ( '$x' , 'return $x*$x;' ); $bar = create_function ( " \$ x" , "return \$ x* \$ x;" ); echo $foo ( 10 );

$x = 3 ; $func = function ( $z ) { return $z * 2 ; }; echo $func ( $x ); // imprime 6

$x = 3 ; $func = function () use ( & $x ) { $x *= 2 ; }; $func (); echo $x ; // imprime 6