È una funzione che non ha nome. Ad esempio in c # è possibile utilizzare

numberCollection.GetMatchingItems<int>(number => number > 5);

per restituire i numeri che sono maggiori di 5.

number => number > 5

è la parte lambda qui. Rappresenta una funzione che accetta un parametro (numero) e restituisce un valore booleano (numero> 5). Il metodo GetMatchingItems utilizza questo lambda su tutti gli elementi della raccolta e restituisce gli elementi corrispondenti.

Alla domanda è stata data una risposta completa, non voglio entrare nei dettagli. Voglio condividere l'utilizzo durante la scrittura di calcoli numerici in ruggine.

C'è un esempio di lambda (funzione anonima)

let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };

Quando stavo scrivendo un modulo di metodo Newton-Raphson, era usato come derivato del primo e del secondo ordine. (Se vuoi sapere qual è il metodo di Newton-Raphson, visita " https://en.wikipedia.org/wiki/Newton%27s_method ".

L'output come segue

println!("f={:.6}      df={:.6}", f(10.0), df(10.0))

f=98.000000       df=20.000000

Ho capito anche io. Ho provato in JS con questo:

var addAndMult = function(x) {
        return (function(y) {
            return (function(z) {
                return (x+y)*z; 
                });
            });
        };

Aggiunge 2 a 4 quindi muta il risultato per 6. Tuttavia trovo che a volte sia difficile da leggere :(

Inoltre ho reso interessante una funzione per ogni:

var forEach = function(arr) {
            return (function(x) {
            for (var i=0; arr[i]; i++) {
                 x(arr[i]);
             }
        });
    }

forEach ([1,2,3,4,5]) (console.log);

Questo metodo itererà un array ed eseguirà un'azione, nel caso stampi sulla console. Ora capisco anche perché i labmdas sono potenti.

Il calcolo lambda è una teoria matematica coerente di sostituzione. Nella matematica scolastica si vede ad esempio x+y=5 abbinato a x−y=1 . Insieme ai modi di manipolare le singole equazioni è anche possibile mettere le informazioni da questi due insieme, a condizione che le sostituzioni delle equazioni incrociate avvengano logicamente. Il calcolo Lambda codifica il modo corretto di fare queste sostituzioni.

Dato che y = x−1 è un riarrangiamento valido della seconda equazione, questo: λ y = x−1 significa una funzione che sostituisce i simboli x−1 per il simbolo y . Ora immagina di applicare λ y a ciascun termine nella prima equazione. Se un termine è y eseguire la sostituzione; altrimenti non fare nulla. Se lo fai su carta vedrai come applicare quel λ y renderà la prima equazione risolvibile.

Questa è una risposta senza alcun computer o programmazione.

L'esempio di programmazione più semplice a cui riesco a pensare proviene da http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works :

ecco come la funzione quadrata potrebbe essere definita in un linguaggio di programmazione imperativo (C):

int square(int x)
{
    return x * x;
}

La variabile x è un parametro formale che viene sostituito dal valore effettivo da squadrare quando viene chiamata la funzione. In un linguaggio funzionale (Schema) si definirà la stessa funzione:

(define square
  (lambda (x) 
    (* x x)))

Questo è diverso in molti modi, ma usa ancora il parametro formale x allo stesso modo.

Aggiunto: http://imgur.com/a/XBHub

http://imgur.com/a/XBHub

Il nome "lambda" è solo un manufatto storico. Tutto ciò di cui stiamo parlando è un'espressione il cui valore è una funzione.

Un semplice esempio (usando Scala per la riga successiva) è:

args.foreach(arg => println(arg))

dove l'argomento del metodo foreach è un'espressione per una funzione anonima. La riga sopra è più o meno la stessa di scrivere qualcosa come questo (codice non proprio reale, ma avrai l'idea):

void printThat(Object that) {
  println(that)
}
...
args.foreach(printThat)

tranne che non devi preoccuparti di:

1. Dichiarare la funzione da qualche altra parte (e doverla cercare quando si rivisita il codice successivamente).
2. Dare un nome a qualcosa che stai usando solo una volta.

Una volta che sei abituato a funzionare con i valori, doverli fare a meno di loro sembra sciocco come dover nominare ogni espressione, ad esempio:

int tempVar = 2 * a + b
...
println(tempVar)

invece di limitarti a scrivere l'espressione dove ne hai bisogno:

println(2 * a + b)

La notazione esatta varia da una lingua all'altra; Il greco non è sempre richiesto! ;-)

In Javascript, ad esempio, le funzioni sono considerate come lo stesso tipo misto di tutto il resto ( int , string , float , bool ). In quanto tale, è possibile creare funzioni al volo, assegnarle alle cose e richiamarle in un secondo momento. È utile ma non è qualcosa che si desidera utilizzare eccessivamente o confonderai tutti quelli che devono mantenere il tuo codice dopo di te ...

Questo è un codice con cui stavo giocando per vedere quanto è profonda questa tana del coniglio:

var x = new Object;
x.thingy = new Array();
x.thingy[0] = function(){ return function(){ return function(){ alert('index 0 pressed'); }; }; }
x.thingy[1] = function(){ return function(){ return function(){ alert('index 1 pressed'); }; }; }
x.thingy[2] = function(){ return function(){ return function(){ alert('index 2 pressed'); }; }; }

for(var i=0 ;i<3; i++)
    x.thingy[i]()()();

La domanda è formalmente risposta molto, quindi non cercherò di aggiungere altro su questo.

In parole molto semplici e informali a qualcuno che sa molto poco o nulla sulla matematica o sulla programmazione, lo spiegherei come una piccola "macchina" o "scatola" che prende un po 'di input, fa funzionare e produce un output, non ha un nome particolare , ma sappiamo dove è e solo con questa conoscenza, lo usiamo.

In pratica, per una persona che sa cosa sia una funzione, direi che è una funzione che non ha nome, di solito messo a un punto in memoria che può essere usato semplicemente facendo riferimento a quella memoria (di solito tramite l'uso di una variabile - se hanno sentito parlare del concetto dei puntatori di funzione, li userei come un concetto simile) - questa risposta copre le basi piuttosto (non si parla di chiusure ecc.) ma si può ottenere facilmente il punto.

Leggermente semplificato: una funzione lambda è quella che può essere passata ad altre funzioni e alla sua logica.

In C # la sintassi lambda viene spesso compilata con metodi semplici allo stesso modo dei delegati anonimi, ma può anche essere scomposta e la sua logica viene letta.

Ad esempio (in C # 3):

LinqToSqlContext.Where( 
    row => row.FieldName > 15 );

LinqToSql può leggere quella funzione (x> 15) e convertirla nell'effettivo SQL da eseguire usando gli alberi di espressione.

La dichiarazione sopra diventa:

select ... from [tablename] 
where [FieldName] > 15      --this line was 'read' from the lambda function

Questo è diverso dai metodi normali o dai delegati anonimi (che sono davvero solo magia del compilatore) perché non possono essere letti .

Non tutti i metodi in C # che usano la sintassi lambda possono essere compilati in alberi di espressioni (cioè funzioni lambda reali). Per esempio:

LinqToSqlContext.Where( 
    row => SomeComplexCheck( row.FieldName ) );

Ora l'albero delle espressioni non può essere letto - SomeComplexCheck non può essere scomposto. L'istruzione SQL verrà eseguita senza il punto e ogni riga dei dati verrà inserita in SomeComplexCheck .

Le funzioni Lambda non devono essere confuse con metodi anonimi. Per esempio:

LinqToSqlContext.Where( 
    delegate ( DataRow row ) { 
        return row.FieldName > 15; 
    } );

Questo ha anche una funzione "in linea", ma questa volta è solo magia del compilatore - il compilatore C # lo dividerà in un nuovo metodo di istanza con un nome generato automaticamente.

I metodi anonimi non possono essere letti e quindi la logica non può essere tradotta come può per le funzioni lambda.

Mi piace la spiegazione di Lambdas in questo articolo: L'evoluzione di LINQ e il suo impatto sul design di C # . Per me ha molto senso perché mostra un mondo reale per Lambdas e lo costruisce come esempio pratico.

La loro rapida spiegazione: Lambda è un modo per trattare il codice (funzioni) come dati.

Nella programmazione per computer, lambda è un pezzo di codice (istruzione, espressione o un gruppo di essi) che accetta alcuni argomenti da una fonte esterna. Non deve sempre essere una funzione anonima: abbiamo molti modi per implementarle.

Abbiamo una chiara separazione tra espressioni, affermazioni e funzioni, che i matematici non hanno.

Anche la parola "funzione" in programmazione è diversa - abbiamo "la funzione è una serie di passi da fare" (dal latino "perform"). In matematica è qualcosa sulla correlazione tra le variabili.

Le lingue funzionali stanno cercando di essere il più possibile simili alle formule matematiche e le loro parole significano quasi la stessa cosa. Ma in altri linguaggi di programmazione lo abbiamo diverso.

Puoi considerarlo come una funzione anonima - ecco alcune informazioni in più: Wikipedia - Funzione anonima

Solo perché non riesco a vedere un esempio di C ++ 11, andrò avanti e pubblicherò questo bell'esempio da here . Dopo la ricerca, è l'esempio specifico più chiaro che ho trovato.

Ciao, Lambdas, versione 1

template<typename F>

void Eval( const F& f ) {
        f();
}
void foo() {
        Eval( []{ printf("Hello, Lambdas\n"); } );
}

Ciao, Lambdas, versione 2:

void bar() {
    auto f = []{ printf("Hello, Lambdas\n"); };
    f();
}

Un esempio di lambda in Ruby è il seguente:

hello = lambda do
    puts('Hello')
    puts('I am inside a proc')
end

hello.call

Genererà il seguente risultato:

Hello
I am inside a proc