Anonymní funkce v programování je speciální druh funkcí , které jsou deklarovány v místě použití a nedostávají jedinečný identifikátor pro přístup k nim. Podporováno v mnoha programovacích jazycích .
Obvykle se při vytváření anonymních funkcí buď volají přímo, nebo se odkaz na funkci přiřadí proměnné , kterou lze pak použít k nepřímému volání této funkce. Ale ve druhém případě dostane anonymní funkce jméno a přestane být anonymní. Pokud anonymní funkce odkazuje na proměnné, které nejsou obsaženy v jejím těle (capture), pak se taková funkce nazývá uzávěrka . Výraz lambda je syntaktický konstrukt společný mnoha jazykům pro definování anonymní funkce.
Syntaxe pro psaní anonymních funkcí pro různé programovací jazyky se ve většině případů velmi liší.
| Jazyk | Příklad zápisu sčítání |
|---|---|
| AS3 | funkce ( x : int , y : int ): int { return x + y ;} |
| C# | ( x , y ) => x + y |
| C++ | Představeno v C++ 11. Úchop a tělo musí být přítomny. Dlouhý tvar [1] :
[ zachytit ]( parametry ) atributy proměnných výjimek - > return_type { body }
Příklad [2] :
[]( int x , int y ){ return x + y ; }
C++14 přidal možnost používat funkce lambda s auto[3] : auto lambda = []( auto x , auto y ) { return x + y ;}; Anonymní funkce může zachytit jako samostatné proměnné, například:int a ; auto f = [ a ](){ return a ;} a všechny externí proměnné: odkazem [&] nebo kopií [=] . Tyto přístupy můžete také kombinovat: například zachytit všechny proměnné odkazem a určité parametry kopírováním. Abyste mohli upravovat proměnné zachycené hodnotou, musíte při deklaraci funkce zadat klíčové slovo proměnlivé . C++14 přidává možnost inicializovat proměnné lambda v zachycení. Například:[ a = std :: řetězec {}](){ return a ;} |
| CoffeeScript | (x, y) -> x + y |
| D | // krátký tvar s automatickým odvozováním typu auto a = (( x , y ) => x + y )( 2 , 3 ); // dlouhý zápis (závorky) s automatickým odvozováním typu auto aa = ( x , y ) { return x + y ; } ( 2,3 ) ; // autodetekce kompilátoru anonymní funkce typu: funkce nebo delegát auto b = ( int x , int y ) => x + y ; auto bb = ( int x , int y ) { return x + y ; }; // funkce nemají přístup k externím proměnným auto c = function ( int x , int y ) => x + y ; auto cc = funkce ( int x , int y ) { return x + y ; }; // delegáti mají přístup k externím proměnným auto d = delegát ( int x , int y ) => x + y ; auto dd = delegovat ( int x , int y ) { return x + y ; }; // delegát, který vezme proměnnou int a vrátí dvojitou hodnotu auto f = delegát double ( int x ) { return 5.0 / x ; }; |
| Delphi (od verze 2009) | funkce ( x , y : celé číslo ) : celé číslo začátek výsledek := x + y ; konec ; |
| Erlang | zábava ( X , Y ) -> X + Y konec |
| GNU Octave | @( x , y ) x + y |
| Jít | Z := func () int { return X + Y }() |
| Báječný | { x , y -> x + y } |
| Haskell | \ x y -> x + y |
| Java (od verze 8) | // bez parametru () -> System . ven . println ( "Ahoj světe." ); // s jedním parametrem (Tento příklad je funkce identity). a -> a //s jediným výrazem ( a , b ) -> a + b // s explicitní informací o typu ( Long id , String name ) -> "id: " + id + ", name:" + name // s blokem kódu ( a , b ) -> { return a + b ;} // s více příkazy v těle lambda. Vyžaduje blok kódu. // Tento příklad také zahrnuje vnořený výraz lambda a také uzávěr. ( id , newPrice ) -> { Optional < Product > mayBeProduct = findProduct ( id ); mayBeProduct . ifPresent ( produkt -> produkt . setPrice ( newPrice )); vrátit mayBeProduct . získat (); } |
| JavaScript | Výraz funkce šipky je vždy deklarován bez názvu. Do standardu ECMAScript 6 (známého také jako ECMAScript 2015) [4] byly přidány funkce šipek .
// Funkce šipky. ES6+ (ES2015+)
( x , y ) => x + y ;
Deklarace funkce prostřednictvím výrazu funkce bez zadání názvu. Tato metoda byla poprvé popsána ve specifikaci standardu ECMAScript 3 [5] [6] .
// Výraz funkce.
Funkce ES3+ ( x , y ) { return x + y }
Dynamické vytváření funkce konstruktorem objektu Function (konstruktor funkce) je vždy deklarováno bez názvu. Kratší zápis pro vytváření dynamických funkcí je volání funkce, které automaticky volá konstruktor Function se stejnými parametry. Tyto způsoby vytváření funkcí existují již od prvních specifikací, počínaje ECMAScript First Edition [7] [8] . // Dynamické vytvoření funkce konstruktorem Function. ES1+ nová funkce ( 'x' , 'y' , 'return x + y' ) // Kratší zápis. Funkce ES1+ ( 'x' , 'y' , 'return x + y' ) |
| Lua | funkce ( x , y ) návrat x + y konec |
| javor | ( x , y ) -> x + y |
| Mathematica |
#1 + #2 &
nebo Funkce [ #1 + #2 ]nebo Funkce [{ 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 ] } [jedenáct] |
| PHP | // PHP 7.4+
fn ( $x , $y ) => $x + $y ;
Funkce Arrow byly přidány v PHP 7.4 [12] . // Funkce PHP 5.3+ ( $x , $y ) use ( $a , & $b ) { return $x + $y ; }Zde $a, $b jsou zachycené proměnné, přičemž proměnná $b je rovněž uzavřena [13] [14] . // PHP 4.0.1+ create_function ( ' $x, $y' , 'return $x + $y;' )Vytvoření anonymní funkce pomocí create_function [15] . Tato metoda je zastaralá od PHP 7.2.0. |
| PowerShell | { param ( $x , $y ) $x + $y } [16] |
| Krajta | lambda x , y : x + y [17] |
| R | funkce ( x , y ) x + y |
| rubín | lambda { | x , y | x + y } [osmnáct] |
| Rez | | x : i32 , y : i32 | x + y |
| Scala |
Bez zadání kontextu musíte zadat typ proměnných: ( x : Int , y : Int ) => x + yAle v místech, kde lze typ odvodit, lze použít těsnopisné formy: ( 1 až 100 ) snížit ( ( a , b ) => a + b )Nebo ještě kratší pomocí automatických substitucí '_': ( 1 až 100 ) snížit ( _ + _ ) |
| Schéma , Common Lisp | ( lambda ( x y ) ( + x y )) |
| SML | fn ( x , y ) => x + y |
| Rychlý | // 1 možnost let f : ( Int , Int ) - > Int = { x , y zpět x + y } // 2. možnost let f : ( Int , Int ) -> Int = { x , y v x + y } /* Zkrácené názvy parametrů */ // 1. možnost let f : ( Int , Int ) -> Int = { return $0 + $1 } // 2. možnost let f : ( Int , Int ) -> Int = { $ 0 + $ 1 } |
| strojopis | // Výraz funkce šipka je vždy deklarován bez názvu ( x , y ) => x + y // Výraz funkce (výraz funkce) bez názvu function ( x , y ) { return x + y } // Dynamické vytváření funkce // konstruktorem objektu Function (konstruktor funkce) // vždy deklarováno bez názvu new Function ( 'x' , 'y' , 'return x + y' ) // Kratší zápis pro vytváření dynamických funkcí. // Volání funkce automaticky vyvolá // konstruktor Funkce se stejnými parametry Funkce ( 'x' , 'y' , 'return x + y' ) |
| Vizuální prolog | {( X , Y ) = X + Y } |