Az anonim függvény a programozásban olyan speciális funkciók , amelyek a felhasználás helyén deklaráltak, és nem kapnak egyedi azonosítót a hozzáférésükhöz. Számos programozási nyelven támogatott .
Általában anonim függvények létrehozásakor vagy közvetlenül hívják meg őket, vagy a függvényre való hivatkozást hozzárendeljük egy változóhoz , amely azután a függvény közvetett meghívására használható. De az utóbbi esetben az anonim függvény nevet kap, és megszűnik anonim lenni. Ha egy névtelen függvény olyan változókra hivatkozik, amelyek nem szerepelnek a törzsében (capture), akkor az ilyen függvényt lezárásnak nevezzük . A lambda-kifejezés egy olyan szintaktikai konstrukció , amely sok nyelvben közös anonim függvények meghatározására.
Az anonim függvények írásának szintaxisa a különböző programozási nyelvekhez a legtöbb esetben nagyon eltérő.
| Nyelv | Példa a kiegészítés jelölésére |
|---|---|
| AS3 | function ( x : int , y : int ): int { return x + y ;} |
| C# | ( x , y ) => x + y |
| C++ | C++11 nyelven bevezetve. A markolatnak és a testnek jelen kell lennie. Hosszú forma [1] :
[ capture ]( paraméterek ) mutable kivételek attribútumok - > return_type { body }
[2] példa :
[]( int x , int y ){ return x + y ; }
A C++14 hozzáadta a lambda függvények használatának lehetőségét a auto[3] -mal : auto lambda = []( auto x , auto y ) { return x + y ;}; Az anonim függvények külön változóként rögzíthetők, például:int a ; auto f = [ a ](){ return a ;} és minden külső változó: hivatkozással [&] vagy másolattal [=] . Ezeket a megközelítéseket kombinálhatja is: például az összes változót hivatkozással, bizonyos paramétereket pedig másolással rögzíthet. Az értékkel rögzített változók módosításához meg kell adnia a változó kulcsszót a függvény deklarálásakor. A C++14 lehetőséget ad a lambda-változók inicializálására a rögzítésben. Például:[ a = std :: string {}](){ return a ;} |
| CoffeeScript | (x, y) -> x + y |
| D | // rövid forma auto típusú következtetéssel auto a = (( x , y ) => x + y )( 2 , 3 ); // hosszú alakú jelölés (kapcsos zárójelek blokkja) automatikus típuskövetkeztetéssel auto aa = ( x , y ) { return x + y ; }( 2 , 3 ); // fordító névtelen függvénytípus automatikus felismerése: függvény vagy delegálás auto b = ( int x , int y ) => x + y ; auto bb = ( int x , int y ) { return x + y ; }; // a függvények nem férnek hozzá a külső változókhoz auto c = function ( int x , int y ) => x + y ; auto cc = function ( int x , int y ) { return x + y ; }; // a küldöttek hozzáférhetnek a külső változókhoz auto d = delegate ( int x , int y ) => x + y ; auto dd = delegált ( int x , int y ) { return x + y ; }; // delegate, amely int változót vesz fel és dupla értéket ad vissza auto f = delegate double ( int x ) { return 5.0 / x ; }; |
| Delphi (2009-es verzió óta) | függvény ( x , y : integer ) : egész szám kezdési eredmény := x + y ; vége ; |
| Erlang | móka ( X , Y ) -> X + Y vége |
| GNU Octave | @( x , y ) x + y |
| megy | Z := func () int { return X + Y }() |
| Groovy | { x , y -> x + y } |
| Haskell | \ x y -> x + y |
| Java (8-as verzió óta) | // paraméter nélkül () -> Rendszer . ki . println ( "Szia, világ." ); // egyetlen paraméterrel (Ez a példa egy identitásfüggvény). a -> a //egyetlen kifejezéssel ( a , b ) -> a + b // kifejezett típusinformációkkal ( Long id , String name ) -> "id: " + id + ", name:" + name // kódblokkkal ( a , b ) -> { return a + b ;} // több utasítással a lambda törzsben. Kódblokkot igényel. // Ez a példa egy beágyazott lambda kifejezést és egy lezárást is tartalmaz. ( id , newPrice ) -> { Optional < Product > mayBeProduct = findProduct ( id ); lehet, hogy Termék . ifPresent ( termék -> termék . setPrice ( newPrice )); visszatérés mayBeProduct . kap (); } |
| JavaScript | A nyíl függvénykifejezéseket mindig név nélkül deklarálják. Az ECMAScript 6 (más néven ECMAScript 2015) [4] szabvány nyílfüggvényekkel bővült .
// Nyíl függvény. ES6+ (ES2015+)
( x , y ) => x + y ;
Függvény deklarálása függvénykifejezésen keresztül név megadása nélkül. Ezt a módszert először az ECMAScript 3 szabvány specifikációjában írták le [5] [6] .
// Függvénykifejezés. ES3+
függvény ( x , y ) { return x + y }
A függvénynek egy függvényobjektum konstruktora (Function constructor) általi dinamikus létrehozása mindig név nélkül történik. A dinamikus függvény létrehozásának rövidebb jelölése egy függvényhívás, amely automatikusan meghívja a függvénykonstruktort ugyanazokkal a paraméterekkel. A függvények létrehozásának ilyen módjai a legkorábbi specifikációk óta léteznek, kezdve az ECMAScript First Edition-től [7] [8] . // Egy függvény dinamikus létrehozása a függvénykonstruktorral. ES1+ új függvény ( 'x' , 'y' , 'return x + y' ) // Rövidebb jelölés. ES1+ függvény ( 'x' , 'y' , 'return x + y' ) |
| Lua | függvény ( x , y ) visszatér x + y vége |
| juharfa | ( x , y ) -> x + y |
| Mathematica |
#1 + #2 &
vagy Funkció [ #1 + #2 ]vagy függvény [{ 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 ] } [tizenegy] |
| PHP | // PHP 7.4+
fn ( $x , $y ) => $x + $y ;
Nyílfüggvények kerültek hozzáadásra a PHP 7.4-ben [12] . // PHP 5.3+ függvény ( $x , $y ) use ( $a , & $b ) { return $x + $y ; }Itt $a, $b rögzített változók, míg a $b változó szintén zárt [13] [14] . // PHP 4.0.1+ create_function ( '$x, $y' , 'return $x + $y;' )Névtelen függvény létrehozása a create_function [15] segítségével . Ez a módszer a PHP 7.2.0 óta elavult. |
| PowerShell | { param ( $x , $y ) $x + $y } [16] |
| Piton | lambda x , y : x + y [17] |
| R | függvény ( x , y ) x + y |
| rubin | lambda { | x , y | x + y } [tizennyolc] |
| Rozsda | | x : i32 , y : i32 | x + y |
| Scala |
A kontextus megadása nélkül meg kell adnia a változók típusát: ( x : Int , y : Int ) => x + yDe olyan helyeken, ahol a típusra lehet következtetni, használhatók a gyorsított formák: ( 1 -től 100 - ig ) csökkenti ( ( a , b ) => a + b )Vagy még rövidebb, '_' automatikus helyettesítések használatával: ( 1 -től 100 - ig ) csökkenti ( _ + _ ) |
| Scheme , Common Lisp | ( lambda ( x y ) ( + x y )) |
| SML | fn ( x , y ) => x + y |
| Gyors | // 1 opció legyen f : ( Int , Int ) - > Int = { x , y cserében x + y } // 2. opció legyen f : ( Int , Int ) -> Int = { x , y in x + y } /* Paraméternevek rövidítése */ // 1. opció legyen f : ( Int , Int ) -> Int = { return $0 + $1 } // 2. opció legyen f : ( Int , Int ) -> Int = { $0 + $1 } |
| gépelt | // Egy nyílfüggvény kifejezés mindig név nélkül deklarálva ( x , y ) => x + y // Függvénykifejezés (függvénykifejezés) név nélkül függvény ( x , y ) { return x + y } // Funkció dinamikus létrehozása // függvényobjektum konstruktorral (Function constructor) // mindig név nélkül deklarálva new Function ( 'x' , 'y' , 'return x + y' ) // Rövidebb jelölés a dinamikus függvény létrehozásához. // Egy függvény meghívása automatikusan meghívja // a függvénykonstruktort ugyanazokkal a paraméterekkel a függvény ( 'x' , 'y' , 'return x + y' ) |
| Visual Prolog | {( X , Y ) = X + Y } |