Anonym funktion

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 7 april 2018; kontroller kräver 29 redigeringar .

En anonym funktion i programmering  är en speciell typ av funktioner som deklareras på användningsplatsen och som inte får en unik identifierare för att komma åt dem. Stöds i många programmeringsspråk .

Vanligtvis, när man skapar anonyma funktioner, anropas de antingen direkt, eller så tilldelas en referens till funktionen en variabel , som sedan kan användas för att indirekt anropa denna funktion. Men i det senare fallet får den anonyma funktionen ett namn och upphör att vara anonym. Om en anonym funktion hänvisar till variabler som inte finns i dess kropp (capture), så kallas en sådan funktion en closure . Ett lambdauttryck är en syntaktisk konstruktion som är gemensam för många språk för att definiera en anonym funktion.

Syntax

Syntaxen för att skriva anonyma funktioner för olika programmeringsspråk varierar i de flesta fall kraftigt.

Språk Exempel på tilläggsbeteckning
AS3 funktion ( x : int , y : int ): int { return x + y ;}
C# ( x , y ) => x + y
C++ Introducerad i C++11. Greppet och kroppen måste finnas. Lång form [1] : [ capture ] ( parametrar ) föränderliga undantagsattribut - > return_type { body } Exempel [2] : []( int x , int y ){ return x + y ; }

C++14 lade till möjligheten att använda lambda-funktioner med auto[3] :

auto lambda = []( auto x , auto y ) { return x + y ;}; En anonym funktion kan fånga in som separata variabler, som så:int a ; auto f = [ a ](){ return a ;} och alla externa variabler: genom referens [&] eller genom kopia [=] . Du kan också kombinera dessa metoder: till exempel fånga alla variabler genom referens och vissa parametrar genom att kopiera. För att kunna modifiera variabler som fångas av värde, måste du ange det mutable nyckelordet när du deklarerar en funktion. C++14 lägger till möjligheten att initiera lambdavariabler i en infångning. Till exempel:[ a = std :: sträng {}](){ return a ;}
CoffeeScript (x, y) -> x + y
D // kort form med autotypinferens auto  a  =  (( x ,  y )  =>  x  +  y )( 2 ,  3 ); // lång form notation (klasparenteser block) med automatisk typ inferens auto  aa  =  ( x ,  y )  {  return  x  +  y ;  }( 2 ,  3 ); // kompilator autodetektering av anonym funktionstyp: funktion eller delegat auto  b  =  ( int  x ,  int  y )  =>  x  +  y ; auto  bb  =  ( int  x ,  int  y )  {  retur  x  +  y ;  }; // funktioner har inte tillgång till externa variabler auto  c  =  function ( int  x ,  int  y )  =>  x  +  y ; auto  cc  =  funktion ( int  x ,  int  y )  {  return  x  +  y ;  }; // delegater har tillgång till externa variabler auto  d  =  delegate ( int  x ,  int  y )  =>  x  +  y ; auto  dd  =  delegat ( int  x ,  int  y )  {  return  x  +  y ;  }; // delegate som tar en int-variabel och returnerar ett dubbelt värde auto  f  =  delegate  double ( int  x )  {  return  5.0  /  x ;  };
Delphi (sedan 2009 version) funktion ( x , y : heltal ) : heltal startresultat : = x + y ; slut ;
Erlang kul ( X , Y ) -> X + Y slut
GNU Octave @( x , y ) x + y
gå Z := func () int { return X + Y }()
Häftig { x , y -> x + y }
Haskell \ x y -> x + y
Java (sedan version 8) // utan parameter () -> System . ut . println ( "Hej världen." ); // med en enda parameter (Detta exempel är en identitetsfunktion). a -> a //med ett enda uttryck ( a , b ) -> a + b // med explicit typinformation ( Long id , String name ) -> "id: " + id + ", name:" + name // med ett kodblock ( a , b ) -> { return a + b ;} // med flera påståenden i lambdakroppen. Det kräver ett kodblock. // Det här exemplet inkluderar också ett kapslat lambda-uttryck samt en stängning. ( id , newPrice ) -> { Valfritt < Product > mayBeProduct = findProduct ( id ); mayBeProduct . ifPresent ( produkt -> produkt . setPrice ( newPrice )); return mayBeProduct . få (); }
JavaScript Ett pilfunktionsuttryck deklareras alltid utan namn. Pilfunktioner har lagts till i standarden ECMAScript 6 (även känd som ECMAScript 2015) [4] . // Pilfunktion. ES6+ (ES2015+) ( x , y ) => x + y ; Deklarera en funktion genom ett funktionsuttryck utan att ange ett namn. Denna metod beskrevs först i specifikationen för ECMAScript 3-standarden [5] [6] . // Funktionsuttryck. ES3+ funktion ( x , y ) { return x + y }

Dynamiskt skapande av en funktion av en konstruktör av ett funktionsobjekt (Funktionskonstruktor) deklareras alltid utan namn. En kortare notation för att skapa dynamiska funktioner är ett funktionsanrop som automatiskt anropar funktionskonstruktorn med samma parametrar. Dessa sätt att skapa funktioner har funnits sedan de tidigaste specifikationerna, från och med ECMAScript First Edition [7] [8] .

// Dynamiskt skapande av en funktion av funktionskonstruktorn. ES1+ ny funktion ( 'x' , 'y' , 'return x + y' ) // Kortare notation. ES1+ Funktion ( 'x' , 'y' , 'return x + y' )
Lua funktion ( x , y ) returnerar x + y slut
lönn ( 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 ] } [elva]
PHP // PHP 7.4+ fn ( $x , $y ) => $x + $y ;

Pilfunktioner lades till i PHP 7.4 [12] .

// PHP 5.3+ funktion ( $x , $y ) use ( $a , & $b ) { return $x + $y ; }

Här är $a, $b infångade variabler, medan variabeln $b också är stängd [13] [14] .

// PHP 4.0.1+ create_function ( '$x, $y' , 'return $x + $y;' )

Skapa en anonym funktion med create_function [15] . Denna metod har föråldrats sedan PHP 7.2.0.

PowerShell { param ( $x , $y ) $x + $y } [16]
Pytonorm lambda x , y : x + y [17]
R funktion ( x , y ) x + y
rubin lambda { | x , y | x + y } [arton]
Rost | x : i32 , y : i32 | x + y
Scala

Utan att ange sammanhanget måste du ange typen av variabler:

( x : Int , y : Int ) => x + y

Men på platser där typen kan härledas, kan stenografiska former användas:

( 1 till 100 ) reducera (( a , b ) => a + b )

Eller ännu kortare, med "_" automatiska ersättningar:

( 1 till 100 ) reducera ( _ + _ )
Scheme , Common Lisp ( lambda ( x y ) ( + x y ))
SML fn ( x , y ) => x + y
Snabb // 1 alternativ låt f : ( Int , Int ) -> Int = { x , y i retur x + y } // Andra alternativet låt f : ( Int , Int ) -> Int = { x , y in x + y } /* Förkortade parameternamn */ // 1:a alternativet låt f : ( Int , Int ) -> Int = { return $0 + $1 } // 2nd alternativet låt f : ( Int , Int ) -> Int = { $0 + $1 }
maskinskriven // Ett pilfunktionsuttryck deklareras alltid utan ett namn ( x , y ) => x + y // Funktionsuttryck (funktionsuttryck) utan en namnfunktion ( x , y ) { return x + y } // Dynamiskt skapande av en funktion // av en funktionsobjektkonstruktör (Funktionskonstruktör) // deklareras alltid utan ett namn ny funktion ( 'x' , 'y' , 'return x + y' ) // Kortare notation för att skapa dynamiska funktioner. // Att anropa en funktion anropar automatiskt // Funktionskonstruktorn med samma parametrar Funktion ( 'x' , 'y' , 'return x + y' )
Visuell prolog {( X , Y ) = X + Y }

Se även

Anteckningar

  1. ↑ anonyma funktioner . Datum för åtkomst: 21 februari 2016. Arkiverad från originalet 21 februari 2016.
  2. ↑ C++11. Lambda uttryck . Hämtad 25 augusti 2010. Arkiverad från originalet 9 oktober 2010.
  3. ↑ Sutter, Herb Trip Report: ISO C++ Vårmöte 2013 . isocpp.org (20 april 2013). Hämtad 14 juni 2013. Arkiverad från originalet 20 augusti 2017.
  4. ↑ Pilfunktioner (HTML). MDN webbdokument . Mozillas utvecklarnätverk. Hämtad 27 september 2019. Arkiverad från originalet 19 augusti 2019.
  5. ↑ Språkspecifikation för ECMAScript . Edition 3 Final  (engelska) (PDF) . Arkiv mozilla.org S. 79 . Schweiz, CH-1204 Genève, 114 Rue du Rhone: ECMA (24 mars 2000) .  — Specifikation av ECMAScript-standarden (ECMA-262). Tredje upplagan. Hämtad 27 september 2019. Arkiverad från originalet 24 september 2019.
  6. ↑ Funktioner i JavaScript (HTML). MDN webbdokument . Mozillas utvecklarnätverk. Hämtad 27 september 2019. Arkiverad från originalet 3 september 2019.
  7. ↑ ECMAScript . Ett plattformsoberoende programmeringsspråk för allmänt bruk  (engelska) (PDF) . Arkiv mozilla.org S. 63-64 . Schweiz, CH-1204 Genève, 114 Rue du Rhone: ECMA (juni 1997) .  — Specifikation av ECMAScript-standarden (ECMA-262). Första upplagan. Hämtad 27 september 2019. Arkiverad från originalet 27 september 2019.
  8. ↑ Funktion (HTML). MDN webbdokument . Mozillas utvecklarnätverk. — Beskrivning av funktionsobjektet och funktionskonstruktorn för dynamiskt skapande av funktioner. Tillträdesdatum: 27 september 2019. Arkiverad 23 september 2019.
  9. ↑ Mathematica Documentation: Funktion (&) Arkiverad 5 april 2008.
  10. ↑ Funktion (&) . Wolfram Språk & System - Dokumentationscenter . Volfram. Hämtad 28 september 2019. Arkiverad från originalet 1 oktober 2019.
  11. ↑ perldoc perlref Arkiverad 2 januari 2018 på Wayback Machine 
  12. ↑ PHP Digest #152 (11–25 mars 2019) . Hämtad 7 maj 2019. Arkiverad från originalet 7 maj 2019.
  13. ↑ M. Zandstra, "PHP Objects, Patterns, and Practice", andra upplagan, Ed. Press, 2008.
  14. ↑ PHP-manual . Tillträdesdatum: 1 maj 2010. Arkiverad från originalet 16 februari 2013.
  15. ↑ PHP-manual . Hämtad 1 maj 2010. Arkiverad från originalet 10 augusti 2011.
  16. ↑ Förenkla datamanipulation i PowerShell med lambdafunktioner . Hämtad 27 september 2019. Arkiverad från originalet 27 september 2019.
  17. ↑ Handledningsavsnittet "Master Python in 24 Hours on Your Own" Arkiverad 30 april 2006.
  18. ↑ Beskrivning i programmering Ruby Arkiverad 11 april 2006.  (Engelsk)