O funcție anonimă în programare este un tip special de funcții care sunt declarate la locul de utilizare și nu primesc un identificator unic pentru a le accesa. Suportat în multe limbaje de programare .
De obicei, atunci când se creează funcții anonime, acestea fie sunt apelate direct, fie o referință la funcție este atribuită unei variabile , care poate fi apoi folosită pentru a apela indirect această funcție. Dar în acest din urmă caz, funcția anonimă primește un nume și încetează să mai fie anonimă. Dacă o funcție anonimă se referă la variabile care nu sunt conținute în corpul său (captură), atunci o astfel de funcție se numește închidere . O expresie lambda este un construct sintactic comun multor limbi pentru definirea unei funcții anonime.
Sintaxa pentru scrierea funcțiilor anonime pentru diferite limbaje de programare variază în majoritatea cazurilor foarte mult.
| Limba | Exemplu de notație suplimentară |
|---|---|
| AS3 | funcția ( x : int , y : int ): int { return x + y ;} |
| C# | ( x , y ) => x + y |
| C++ | Introdus în C++11. Prinderea și corpul trebuie să fie prezente. Forma lungă [1] :
[ capture ]( parametri ) atribute mutabile excepții - > return_type { body }
Exemplu [2] :
[]( int x , int y ){ return x + y ; }
C++14 a adăugat capacitatea de a utiliza funcții lambda cu auto[3] : auto lambda = []( auto x , auto y ) { return x + y ;}; O funcție anonimă poate captura ca variabile separate, astfel:int a ; auto f = [ a ](){ return a ;} și toate variabilele externe: prin referință [&] sau prin copie [=] . De asemenea, puteți combina aceste abordări: de exemplu, capturați toate variabilele prin referință și anumiți parametri prin copie. Pentru a putea modifica variabilele capturate după valoare, trebuie să specificați cuvântul cheie mutabil atunci când declarați o funcție. C++14 adaugă capacitatea de a inițializa variabile lambda într-o captură. De exemplu:[ a = std :: șir {}](){ returnează a ;} |
| CoffeeScript | (x, y) -> x + y |
| D | // formă scurtă cu inferență de tip auto auto a = (( x , y ) => x + y )( 2 , 3 ); // notație lungă (bloc acolade) cu inferență automată de tip auto aa = ( x , y ) { return x + y ; }( 2 , 3 ); // autodetecția compilatorului a tipului de funcție anonimă: funcție sau delegat auto b = ( int x , int y ) => x + y ; auto bb = ( int x , int y ) { return x + y ; }; // funcțiile nu au acces la variabile externe auto c = function ( int x , int y ) => x + y ; auto cc = function ( int x , int y ) { return x + y ; }; // delegații au acces la variabile externe auto d = delegate ( int x , int y ) => x + y ; auto dd = delegat ( int x , int y ) { return x + y ; }; // delegat care ia o variabilă int și returnează o valoare dublă auto f = delegate double ( int x ) { return 5.0 / x ; }; |
| Delphi (din versiunea din 2009) | function ( x , y : integer ) : integer start rezultat := x + y ; sfârşitul ; |
| Erlang | distracție ( X , Y ) -> X + Y final |
| GNU Octave | @( x , y ) x + y |
| merge | Z := func () int { return X + Y }() |
| Macabru | { x , y -> x + y } |
| Haskell | \ x y -> x + y |
| Java (din versiunea 8) | // fără parametru () -> System . afară . println ( "Bună ziua, lume." ); // cu un singur parametru (Acest exemplu este o funcție de identitate). a -> a //cu o singură expresie ( a , b ) -> a + b // cu informații de tip explicite ( ID lung , Nume șir ) -> "id: " + id + ", nume:" + nume // cu un bloc de cod ( a , b ) -> { return a + b ;} // cu mai multe instrucțiuni în corpul lambda. Este nevoie de un bloc de cod. // Acest exemplu include și o expresie lambda imbricată, precum și o închidere. ( id , newPrice ) -> { Optional < Product > mayBeProduct = findProduct ( id ); mayBeProduct . ifPresent ( produs -> produs . setPrice ( newPrice )); returnează mayBeProduct . obține (); } |
| JavaScript | O expresie a funcției săgeată este întotdeauna declarată fără nume. Funcțiile săgeată au fost adăugate la standardul ECMAScript 6 (cunoscut și ca ECMAScript 2015) [4] .
// Funcția săgeată. ES6+ (ES2015+)
( x , y ) => x + y ;
Declararea unei funcții printr-o expresie de funcție fără a specifica un nume. Această metodă a fost descrisă pentru prima dată în specificația standardului ECMAScript 3 [5] [6] .
// Expresia funcției.
Funcția ES3+ ( x , y ) { return x + y }
Crearea dinamică a unei funcții de către un constructor al unui obiect Function (constructor Funcție) este întotdeauna declarată fără nume. O notație mai scurtă pentru crearea unei funcții dinamice este un apel Function care apelează automat constructorul Function cu aceiași parametri. Aceste moduri de a crea funcții există încă de la cele mai vechi specificații, începând cu ECMAScript First Edition [7] [8] . // Crearea dinamică a unei funcții de către constructorul Function. ES1+ Funcție nouă ( 'x' , 'y' , 'return x + y' ) // Notație mai scurtă. Funcția ES1+ ( 'x' , 'y' , 'return x + y' ) |
| Lua | funcția ( x , y ) returnează x + y final |
| arțar | ( x , y ) -> x + y |
| Mathematica |
#1 + #2 și
sau Funcția [ # 1 + # 2 ]sau Funcția [{ x , y }, x + y ] [9] [10] |
| MATLAB | f =@( x , y ) x + y |
| Maxima | lambda ([ x,y ] , x+y ) |
| Nim | proc ( x , y : int ): int = x * y |
| PascalABC.NET | ( x , y ) -> x + y |
| Perl | sub { return $_ [ 0 ] + $_ [ 1 ] } [unsprezece] |
| PHP | // PHP 7.4+
fn ( $x , $y ) => $x + $y ;
Funcțiile de săgeți au fost adăugate în PHP 7.4 [12] . // Funcția PHP 5.3+ ( $x , $y ) folosește ( $a , & $b ) { return $x + $y ; }Aici $a, $b sunt variabile capturate, în timp ce variabila $b este de asemenea închisă [13] [14] . // PHP 4.0.1+ create_function ( '$x, $y' , 'return $x + $y;' )Crearea unei funcții anonime cu create_function [15] . Această metodă a fost depreciată începând cu PHP 7.2.0. |
| PowerShell | { param ( $x , $y ) $x + $y } [16] |
| Piton | lambda x , y : x + y [17] |
| R | funcția ( x , y ) x + y |
| rubin | lambda { | x , y | x + y } [optsprezece] |
| Rugini | | x : i32 , y : i32 | x + y |
| Scala |
Fără a specifica contextul, trebuie să specificați tipul de variabile: ( x : Int , y : Int ) => x + yDar în locurile în care tipul poate fi dedus, se pot folosi forme scurte: ( 1 la 100 ) reduce (( a , b ) => a + b )Sau chiar mai scurt, folosind auto-substituții „_”: ( 1 la 100 ) reduce ( _ + _ ) |
| Scheme , Lisp comun | ( lambda ( x y ) ( + x y )) |
| SML | fn ( x , y ) => x + y |
| Rapid | // 1 opțiune fie f : ( Int , Int ) -> Int = { x , y în retur x + y } // A doua opțiune fie f : ( Int , Int ) -> Int = { x , y în x + y } /* Nume de parametri scurtate */ // Prima opțiune lasă f : ( Int , Int ) -> Int = { return $0 + $1 } // A doua opțiune fie f : ( Int , Int ) -> Int = { $0 + $1 } |
| dactilografiat | // O expresie a funcției săgeată este întotdeauna declarată fără nume ( x , y ) => x + y // Expresie funcție (expresie funcție) fără o funcție de nume ( x , y ) { return x + y } // Crearea dinamică a unei funcții // de către un constructor de obiect Function (constructor Funcție) // întotdeauna declarată fără nume Funcție nouă ( 'x' , 'y' , 'return x + y' ) // Notație mai scurtă pentru crearea unei funcții dinamice. // Apelarea unei funcții invocă automat // constructorul Funcție cu aceiași parametri Funcție ( 'x' , 'y' , 'return x + y' ) |
| Prolog vizual | {( X , Y ) = X + Y } |