En anonym funktion i programmering er en speciel slags funktioner , der er deklareret på brugsstedet og ikke modtager en unik identifikator for at få adgang til dem. Understøttet i mange programmeringssprog .
Normalt, når du opretter anonyme funktioner, kaldes de enten direkte, eller en reference til funktionen tildeles en variabel , som så kan bruges til indirekte at kalde denne funktion. Men i sidstnævnte tilfælde får den anonyme funktion et navn og ophører med at være anonym. Hvis en anonym funktion refererer til variabler, der ikke er indeholdt i dens krop (capture), så kaldes en sådan funktion en lukning . Et lambda-udtryk er en syntaktisk konstruktion, der er fælles for mange sprog til at definere en anonym funktion.
Syntaksen til at skrive anonyme funktioner til forskellige programmeringssprog varierer i de fleste tilfælde meget.
| Sprog | Eksempel på tilføjelsesnotation |
|---|---|
| AS3 | funktion ( x : int , y : int ): int { return x + y ;} |
| C# | ( x , y ) => x + y |
| C++ | Introduceret i C++11. Grebet og kroppen skal være til stede. Lang form [1] :
[ fangst ] ( parametre ) foranderlige undtagelsesattributter - > return_type { body }
Eksempel [2] :
[]( int x , int y ){ return x + y ; }
C++14 tilføjede muligheden for at bruge lambda-funktioner med auto[3] : auto lambda = []( auto x , auto y ) { return x + y ;}; En anonym funktion kan fange som separate variabler, som sådan:int a ; auto f = [ a ](){ return a ;} og alle eksterne variabler: ved reference [&] eller ved kopi [=] . Du kan også kombinere disse fremgangsmåder: for eksempel indfange alle variabler ved reference og visse parametre ved at kopiere. For at kunne ændre variabler, der er fanget af værdi, skal du angive det mutable nøgleord , når du erklærer en funktion. C++14 tilføjer muligheden for at initialisere lambda-variabler i en capture. For eksempel:[ a = std :: streng {}](){ return a ;} |
| CoffeeScript | (x, y) -> x + y |
| D | // kort form med auto type inferens auto a = (( x , y ) => x + y )( 2 , 3 ); // lang form notation (parentes blok) med automatisk type inferens auto aa = ( x , y ) { return x + y ; }( 2 , 3 ); // compiler autodetektion af anonym funktionstype: funktion eller delegeret auto b = ( int x , int y ) => x + y ; auto bb = ( int x , int y ) { return x + y ; }; // funktioner har ikke adgang til eksterne variabler auto c = funktion ( int x , int y ) => x + y ; auto cc = funktion ( int x , int y ) { return x + y ; }; // delegerede har adgang til eksterne variabler auto d = delegate ( int x , int y ) => x + y ; auto dd = delegeret ( int x , int y ) { return x + y ; }; // delegeret, der tager en int-variabel og returnerer en dobbelt værdi auto f = delegat double ( int x ) { return 5.0 / x ; }; |
| Delphi (siden 2009 version) | funktion ( x , y : heltal ) : heltal begyndelse resultat := x + y ; ende ; |
| Erlang | sjov ( X , Y ) -> X + Y ende |
| GNU Octave | @( x , y ) x + y |
| gå | Z := func () int { return X + Y }() |
| Groovy | { x , y -> x + y } |
| Haskell | \ x y -> x + y |
| Java (siden version 8) | // uden parameter () -> System . ud . println ( "Hej verden." ); // med en enkelt parameter (dette eksempel er en identitetsfunktion). a -> a //med et enkelt udtryk ( a , b ) -> a + b // med eksplicit type information ( Langt id , Strengnavn ) -> "id: " + id + ", navn :" + navn // med en kodeblok ( a , b ) -> { return a + b ;} // med flere udsagn i lambda-kroppen. Det kræver en kodeblok. // Dette eksempel inkluderer også et indlejret lambda-udtryk samt en lukning. ( id , newPrice ) -> { Valgfri < Produkt > mayBeProduct = findProduct ( id ); mayBeProduct . ifPresent ( produkt -> produkt . sætPris ( nyPris )); return mayBeProduct . få (); } |
| JavaScript | Et pilfunktionsudtryk er altid erklæret uden et navn. Pilefunktioner er blevet tilføjet til ECMAScript 6 (også kendt som ECMAScript 2015) [4] standarden .
// Pile funktion. ES6+ (ES2015+)
( x , y ) => x + y ;
Erklære en funktion gennem et funktionsudtryk uden at angive et navn. Denne metode blev først beskrevet i specifikationen af ECMAScript 3-standarden [5] [6] .
// Funktionsudtryk. ES3+
funktion ( x , y ) { return x + y }
Dynamisk oprettelse af en funktion af en konstruktør af et funktionsobjekt (Funktionskonstruktør) er altid erklæret uden et navn. En kortere notation for dynamisk funktionsoprettelse er et funktionskald, der automatisk kalder funktionskonstruktøren med de samme parametre. Disse måder at skabe funktioner på har eksisteret siden de tidligste specifikationer, startende med ECMAScript First Edition [7] [8] . // Dynamisk oprettelse af en funktion af funktionskonstruktøren. ES1+ ny funktion ( 'x' , 'y' , 'return x + y' ) // Kortere notation. ES1+ Funktion ( 'x' , 'y' , 'return x + y' ) |
| Lua | funktion ( x , y ) returnerer x + y ende |
| ahorn | ( x , y ) -> x + y |
| Mathematica |
#1 + #2 &
eller Funktion [ #1 + #2 ]eller Funktion [{ 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 ] } [elleve] |
| PHP | // PHP 7.4+
fn ( $x , $y ) => $x + $y ;
Pilefunktioner blev tilføjet i PHP 7.4 [12] . // PHP 5.3+ funktion ( $x , $y ) use ( $a , & $b ) { return $x + $y ; }Her er $a, $b opfangede variable, mens variablen $b også er lukket [13] [14] . // PHP 4.0.1+ create_function ( '$x, $y' , 'return $x + $y;' )Oprettelse af en anonym funktion med create_function [15] . Denne metode er blevet forældet siden PHP 7.2.0. |
| PowerShell | { param ( $x , $y ) $x + $y } [16] |
| Python | lambda x , y : x + y [17] |
| R | funktion ( x , y ) x + y |
| rubin | lambda { | x , y | x + y } [atten] |
| Rust | | x : i32 , y : i32 | x + y |
| Scala |
Uden at angive konteksten skal du angive typen af variabler: ( x : Int , y : Int ) => x + yMen på steder, hvor typen kan udledes, kan stenografiske former bruges: ( 1 til 100 ) reducere (( a , b ) => a + b )Eller endnu kortere, ved at bruge "_" auto-substitutioner: ( 1 til 100 ) reducer ( _ + _ ) |
| Skema , Almindelig Lisp | ( lambda ( x y ) ( + x y )) |
| SML | fn ( x , y ) => x + y |
| Swift | // 1 mulighed lad f : ( Int , Int ) -> Int = { x , y til gengæld x + y } // 2. mulighed lad f : ( Int , Int ) -> Int = { x , y in x + y } /* Forkortede parameternavne */ // 1. mulighed lad f : ( Int , Int ) -> Int = { return $0 + $1 } // 2. mulighed lad f : ( Int , Int ) -> Int = { $0 + $1 } |
| maskinskrift | // Et pilfunktionsudtryk er altid erklæret uden et navn ( x , y ) => x + y // Funktionsudtryk (funktionsudtryk) uden en navnefunktion ( x , y ) { return x + y } // Dynamisk oprettelse af en funktion // af en funktionsobjektkonstruktør (Funktionskonstruktør) // altid erklæret uden navn ny funktion ( 'x' , 'y' , 'return x + y' ) // Kortere notation til dynamisk funktionsoprettelse. // Kaldning af en funktion kalder automatisk // funktionskonstruktøren med de samme parametre Funktion ( 'x' , 'y' , 'return x + y' ) |
| Visuel prolog | {( X , Y ) = X + Y } |