Was ist ein Lambda in der Welt der Informatik für eine Person ohne Comp-Sci-Hintergrund?

Lambda stammt aus dem Lambda-Kalkül und bezieht sich auf anonyme Funktionen in der Programmierung.

Warum ist das cool? Sie können damit schnell wegwerfbare Funktionen schreiben, ohne sie zu benennen. Es bietet auch eine gute Möglichkeit, Verschlüsse zu schreiben. Mit dieser Kraft können Sie solche Dinge tun.

Python

def adder(x):
    return lambda y: x + y
add5 = adder(5)
add5(1)
6

Wie Sie dem Python-Snippet entnehmen können, nimmt der Funktionsaddierer ein Argument x auf und gibt eine anonyme Funktion oder Lambda zurück, die ein anderes Argument y akzeptiert. Mit dieser anonymen Funktion können Sie Funktionen aus Funktionen erstellen. Dies ist ein einfaches Beispiel, aber es sollte die Kraft vermitteln, die Lambdas und Verschlüsse haben.

Beispiele in anderen Sprachen

Perl 5

sub adder {
    my ($x) = @_;
    return sub {
        my ($y) = @_;
        $x + $y
    }
}

my $add5 = adder(5);
print &$add5(1) == 6 ? "ok\n" : "not ok\n";

JavaScript

var adder = function (x) {
    return function (y) {
        return x + y;
    };
};
add5 = adder(5);
add5(1) == 6

JavaScript (ES6)

const adder = x => y => x + y;
add5 = adder(5);
add5(1) == 6

Planen

(define adder
    (lambda (x)
        (lambda (y)
           (+ x y))))
(define add5
    (adder 5))
(add5 1)
6

C # 3.5 oder höher

Func<int, Func<int, int>> adder = 
    (int x) => (int y) => x + y; // `int` declarations optional
Func<int, int> add5 = adder(5);
var add6 = adder(6); // Using implicit typing
Debug.Assert(add5(1) == 6);
Debug.Assert(add6(-1) == 5);

// Closure example
int yEnclosed = 1;
Func<int, int> addWithClosure = 
    (x) => x + yEnclosed;
Debug.Assert(addWithClosure(2) == 3);

Schnell

func adder(x: Int) -> (Int) -> Int{
   return { y in x + y }
}
let add5 = adder(5)
add5(1)
6

PHP

$a = 1;
$b = 2;

$lambda = fn () => $a + $b;

echo $lambda();

Haskell

(\x y -> x + y) 

Java siehe diesen Beitrag

// The following is an example of Predicate : 
// a functional interface that takes an argument 
// and returns a boolean primitive type.

Predicate<Integer> pred = x -> x % 2 == 0; // Tests if the parameter is even.
boolean result = pred.test(4); // true

Lua

adder = function(x)
    return function(y)
        return x + y
    end
end
add5 = adder(5)
add5(1) == 6        -- true

Kotlin

val pred = { x: Int -> x % 2 == 0 }
val result = pred(4) // true

Rubin

Ruby unterscheidet sich insofern geringfügig, als Sie ein Lambda nicht mit genau der gleichen Syntax wie das Aufrufen einer Funktion aufrufen können, es jedoch weiterhin Lambdas enthält.

def adder(x)
  lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6

Da Ruby Ruby ist, gibt es eine Abkürzung für Lambdas. Sie können also Folgendes definieren adder:

def adder(x)
  -> y { x + y }
end

R.

adder <- function(x) {
  function(y) x + y
}
add5 <- adder(5)
add5(1)
#> [1] 6

Ein Lambda ist eine Art von Funktion, die inline definiert wird. Zusammen mit einem Lambda haben Sie normalerweise auch einen Variablentyp, der einen Verweis auf eine Funktion, ein Lambda oder etwas anderes enthalten kann.

Hier ist zum Beispiel ein C # -Code, der kein Lambda verwendet:

public Int32 Add(Int32 a, Int32 b)
{
    return a + b;
}

public Int32 Sub(Int32 a, Int32 b)
{
    return a - b;
}

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, Add);
    Calculator(10, 23, Sub);
}

Dies ruft Calculator auf und gibt nicht nur zwei Zahlen weiter, sondern auch die Methode, die im Calculator aufgerufen werden muss, um die Ergebnisse der Berechnung zu erhalten.

In C # 2.0 haben wir anonyme Methoden erhalten, die den obigen Code verkürzen auf:

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a + b;
    });
    Calculator(10, 23, delegate(Int32 a, Int32 b)
    {
        return a - b;
    });
}

Und dann haben wir in C # 3.0 Lambdas bekommen, was den Code noch kürzer macht:

public delegate Int32 Op(Int32 a, Int32 b);

public void Calculator(Int32 a, Int32 b, Op op)
{
    Console.WriteLine("Calculator: op(" + a + ", " + b + ") = " + op(a, b));
}

public void Test()
{
    Calculator(10, 23, (a, b) => a + b);
    Calculator(10, 23, (a, b) => a - b);
}

Der Name "Lambda" ist nur ein historisches Artefakt. Wir sprechen nur von einem Ausdruck, dessen Wert eine Funktion ist.

Ein einfaches Beispiel (mit Scala für die nächste Zeile) ist:

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

Dabei ist das Argument für die foreachMethode ein Ausdruck für eine anonyme Funktion. Die obige Zeile entspricht mehr oder weniger dem Schreiben von so etwas (nicht ganz realer Code, aber Sie werden auf die Idee kommen):

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

außer dass Sie sich nicht darum kümmern müssen:

1. Deklarieren Sie die Funktion an einer anderen Stelle (und müssen Sie danach suchen, wenn Sie den Code später erneut aufrufen).
2. Benennen Sie etwas, das Sie nur einmal verwenden.

Sobald Sie es gewohnt sind, Werte zu funktionieren, erscheint es so dumm, auf sie verzichten zu müssen, wie es erforderlich ist, um jeden Ausdruck zu benennen, wie zum Beispiel:

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

anstatt nur den Ausdruck dort zu schreiben, wo Sie ihn brauchen:

println(2 * a + b)

Die genaue Notation variiert von Sprache zu Sprache. Griechisch ist nicht immer erforderlich! ;-);

Es bezieht sich auf den Lambda-Kalkül , ein formales System, das nur Lambda-Ausdrücke enthält, die eine Funktion darstellen, die eine Funktion als einziges Argument verwendet und eine Funktion zurückgibt. Alle Funktionen in der Lambda-Rechnung sind von diesem Typ, dhλ : λ → λ .

Lisp verwendete das Lambda-Konzept, um seine anonymen Funktionsliterale zu benennen. Dieses Lambda stellt eine Funktion dar, die zwei Argumente, x und y, akzeptiert und ihr Produkt zurückgibt:

(lambda (x y) (* x y)) 

Es kann wie folgt inline angewendet werden (ergibt 50 ):

((lambda (x y) (* x y)) 5 10)

Der Lambda-Kalkül ist eine konsistente mathematische Substitutionstheorie. In der Schulmathematik sieht man zum Beispiel x+y=5gepaart mit x−y=1. Neben Möglichkeiten zur Manipulation einzelner Gleichungen ist es auch möglich, die Informationen aus diesen beiden zusammenzustellen, vorausgesetzt, die Ersetzungen über Kreuzgleichungen erfolgen logisch. Der Lambda-Kalkül kodifiziert den richtigen Weg, um diese Substitutionen durchzuführen.

Vorausgesetzt, dies y = x−1ist eine gültige Neuordnung der zweiten Gleichung, λ y = x−1bedeutet dies: eine Funktion, die x−1das Symbol durch die Symbole ersetzt y. Stellen Sie sich nun vor, Sie wenden λ yauf jeden Term in der ersten Gleichung an. Wenn ein Begriff vorhanden ist, yführen Sie die Ersetzung durch. sonst nichts tun. Wenn Sie dies auf Papier tun, werden Sie sehen, wie Sie das anwendenλ y der ersten Gleichung die erste Gleichung lösbar wird.

Das ist eine Antwort ohne Informatik oder Programmierung.

Das einfachste Programmierbeispiel, das ich mir vorstellen kann, stammt von http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works :

So könnte die Quadratfunktion in einer imperativen Programmiersprache (C) definiert werden:

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

Die Variable x ist ein formaler Parameter, der durch den tatsächlichen Wert ersetzt wird, der beim Aufruf der Funktion quadriert werden soll. In einer funktionalen Sprache (Schema) würde dieselbe Funktion definiert werden:

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

Dies unterscheidet sich in vielerlei Hinsicht, verwendet jedoch immer noch den formalen Parameter x auf dieselbe Weise.

Hinzugefügt: http://imgur.com/a/XBHub

Etwas vereinfacht: Eine Lambda-Funktion kann an andere Funktionen weitergegeben werden und auf ihre Logik wird zugegriffen.

In C # wird die Lambda-Syntax häufig wie anonyme Delegaten zu einfachen Methoden kompiliert, sie kann jedoch auch aufgeschlüsselt und ihre Logik gelesen werden.

Zum Beispiel (in C # 3):

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

LinqToSql kann diese Funktion lesen (x> 15) und sie in das eigentliche SQL konvertieren, um sie mithilfe von Ausdrucksbäumen auszuführen.

Die obige Aussage lautet:

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

Dies unterscheidet sich von normalen Methoden oder anonymen Delegaten (die eigentlich nur Compiler-Magie sind), da sie nicht gelesen werden können .

Nicht alle Methoden in C #, die Lambda-Syntax verwenden, können zu Ausdrucksbäumen kompiliert werden (dh zu tatsächlichen Lambda-Funktionen). Zum Beispiel:

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

Jetzt kann der Ausdrucksbaum nicht gelesen werden - SomeComplexCheck kann nicht zerlegt werden. Die SQL-Anweisung wird ohne das Wo ausgeführt, und jede Zeile in den Daten wird durchlaufen SomeComplexCheck.

Lambda-Funktionen sollten nicht mit anonymen Methoden verwechselt werden. Zum Beispiel:

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

Dies hat auch eine 'Inline'-Funktion, aber diesmal ist es nur Compiler-Magie - der C # -Compiler teilt dies in eine neue Instanzmethode mit einem automatisch generierten Namen auf.

Anonyme Methoden können nicht gelesen werden, daher kann die Logik nicht wie bei Lambda-Funktionen übersetzt werden.

Ich mag die Erklärung von Lambdas in diesem Artikel: Die Entwicklung von LINQ und seine Auswirkungen auf das Design von C # . Es hat für mich sehr viel Sinn gemacht, da es eine reale Welt für Lambdas zeigt und sie als praktisches Beispiel darstellt.

Ihre schnelle Erklärung: Lambdas sind eine Möglichkeit, Code (Funktionen) als Daten zu behandeln.

Ein Beispiel für ein Lambda in Ruby lautet wie folgt:

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

hello.call

Erzeugt die folgende Ausgabe:

Hello
I am inside a proc

@Brian Ich verwende Lambdas die ganze Zeit in C #, in LINQ- und Nicht-LINQ-Operatoren. Beispiel:

string[] GetCustomerNames(IEnumerable<Customer> customers)
 { return customers.Select(c=>c.Name);
 }

Vor C # habe ich anonyme Funktionen in JavaScript für Rückrufe auf AJAX-Funktionen verwendet, bevor der Begriff Ajax überhaupt geprägt wurde:

getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});

Das Interessante an der Lambda-Syntax von C # ist jedoch, dass ihr Typ allein nicht abgeleitet werden kann (dh Sie können var foo = (x, y) => x * y nicht eingeben), aber je nachdem, um welchen Typ es sich handelt zugewiesen, werden sie als Delegaten oder abstrakte Syntaxbäume kompiliert, die den Ausdruck darstellen (so machen LINQ-Objekt-Mapper ihre "sprachintegrierte" Magie).

Lambdas in LISP können auch an einen Angebotsoperator übergeben und dann als Listenliste durchlaufen werden. Auf diese Weise werden einige leistungsstarke Makros erstellt.

Die Frage wird formal sehr gut beantwortet, daher werde ich nicht versuchen, mehr dazu hinzuzufügen.

In sehr einfach, informell Worten an jemanden, der sehr wenig oder gar nichts über Mathematik oder Programmierung weiß, würde ich es als eine kleine "Maschine" oder "Box" erklären, die einige Eingaben nimmt, einige Arbeiten macht und einige Ausgaben erzeugt, keinen bestimmten Namen hat , aber wir wissen, wo es ist und nur durch dieses Wissen nutzen wir es.

In der Praxis würde ich einer Person, die weiß, was eine Funktion ist, sagen, dass es sich um eine Funktion ohne Namen handelt, die normalerweise an einen Punkt im Speicher gesetzt wird, der nur durch Verweisen auf diesen Speicher verwendet werden kann (normalerweise über die Verwendung von eine Variable - wenn sie von dem Konzept der Funktionszeiger gehört haben, würde ich sie als ähnliches Konzept verwenden) - diese Antwort deckt die hübschen Grundlagen ab (keine Erwähnung von Verschlüssen usw.), aber man kann den Punkt leicht verstehen.

Sie können sich das als anonyme Funktion vorstellen - hier einige weitere Informationen: Wikipedia - Anonyme Funktion

Nur weil ich hier kein C ++ 11-Beispiel sehen kann, werde ich dieses schöne Beispiel von hier aus veröffentlichen . Nach der Suche ist es das klarste sprachspezifische Beispiel, das ich finden konnte.

Hallo Lambdas, Version 1

template<typename F>

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

Hallo Lambdas, Version 2:

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

Ich habe Probleme, mich mit Lambda-Ausdrücken zu beschäftigen, weil ich in Visual FoxPro arbeite, das über eine Makrosubstitution und die Funktionen ExecScript {} und Evaluate () verfügt, die anscheinend dem gleichen Zweck dienen.

? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");

FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)

Ein klarer Vorteil der Verwendung formaler Lambdas ist (ich nehme an) die Überprüfung der Kompilierungszeit: Fox wird nicht wissen, ob Sie die obige Textzeichenfolge eingeben, bis er versucht, sie auszuführen.

Dies ist auch für datengesteuerten Code nützlich: Sie können ganze Routinen in Memofeldern in der Datenbank speichern und sie dann einfach zur Laufzeit auswerten. Auf diese Weise können Sie einen Teil der Anwendung optimieren, ohne tatsächlich auf die Quelle zugreifen zu müssen. (Aber das ist insgesamt ein anderes Thema.)

Was ist ein Lambda in der Welt der Informatik für eine Person ohne Comp-Sci-Hintergrund?

Ich werde es Schritt für Schritt intuitiv in einfachen und lesbaren Python-Codes veranschaulichen.

Kurz gesagt, ein Lambda ist nur eine anonyme Inline-Funktion.

Beginnen wir mit der Aufgabe, um lambdasals Neuling mit Hintergrundwissen der Grundrechenarten zu verstehen .

Die Blaupause der Zuweisung lautet "Name = Wert", siehe:

In [1]: x = 1
   ...: y = 'value'
In [2]: x
Out[2]: 1
In [3]: y
Out[3]: 'value'

'x', 'y' sind Namen und 1, 'Wert' sind Werte. Versuchen Sie eine Funktion in Mathematik

In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined

Fehlerberichte,
Sie können eine Mathematik nicht direkt als Code schreiben, 'n' sollte definiert oder einem Wert zugewiesen werden.

In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396

Es funktioniert jetzt, was ist, wenn Sie darauf bestehen, die beiden getrennten Linien zu einer zu kombinieren. Da kommtlambda

In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>

Es wurden keine Fehler gemeldet.

Dies ist ein Blick darauf lambda, es ermöglicht Ihnen, eine Funktion in einer einzigen Zeile wie in der Mathematik direkt in den Computer zu schreiben.

Wir werden es später sehen.

Lassen Sie uns weiter tiefer in die 'Aufgabe' eintauchen.

Wie oben dargestellt, =funktioniert das Gleichheitszeichen für den Typ einfacher Daten (1 und 'Wert') und den einfachen Ausdruck (n ** 2 + 2 * n + 1).

Versuche dies:

In [15]: x = print('This is a x')
This is a x
In [16]: x
In [17]: x = input('Enter a x: ')
Enter a x: x

Es funktioniert für einfache Anweisungen, es gibt 11 Arten von ihnen in Python 7. Einfache Anweisungen - Python 3.6.3-Dokumentation

Wie wäre es mit einer zusammengesetzten Aussage?

In [18]: m = n**2 + 2*n + 1 if n > 0
SyntaxError: invalid syntax
#or
In [19]: m = n**2 + 2*n + 1, if n > 0
SyntaxError: invalid syntax

Da kommt defes möglich zu funktionieren

In [23]: def m(n):
    ...:     if n > 0:
    ...:         return n**2 + 2*n + 1
    ...:
In [24]: m(2)
Out[24]: 9

Tada, analysiere es, 'm' ist der Name, 'n ** 2 + 2 * n + 1' ist der Wert. :ist eine Variante von '='.
Finden Sie es, wenn nur zum Verständnis, alles beginnt mit der Zuweisung und alles ist Zuweisung.

Kehren lambdawir nun zu zurück , wir haben eine Funktion namens 'm'

Versuchen:

In [28]: m = m(3)
In [29]: m
Out[29]: 16

Es gibt zwei Namen von 'm' hier, Funktion hat mbereits einen Namen, dupliziert.

Es formatiert wie:

In [27]: m = def m(n):
    ...:         if n > 0:
    ...:             return n**2 + 2*n + 1
    SyntaxError: invalid syntax

Es ist keine kluge Strategie, also Fehlerberichte

Wir müssen einen von ihnen löschen, eine Funktion ohne Namen setzen.

m = lambda n:n**2 + 2*n + 1

Es heißt "anonyme Funktion"

Abschließend,

1. lambda in einer Inline-Funktion, mit der Sie eine Funktion wie in der Mathematik in einer geraden Linie schreiben können
2. lambda ist anonym

Hoffe das hilft.

Es ist eine Funktion, die keinen Namen hat. Zum Beispiel in c # können Sie verwenden

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

um die Zahlen zurückzugeben, die größer als 5 sind.

number => number > 5

ist der Lambda-Teil hier. Es stellt eine Funktion dar, die einen Parameter (Zahl) annimmt und einen booleschen Wert (Zahl> 5) zurückgibt. Die GetMatchingItems-Methode verwendet dieses Lambda für alle Elemente in der Auflistung und gibt die übereinstimmenden Elemente zurück.

In Javascript, werden beispielsweise Funktionen wie der gleichen Mischtyp wie alles behandeln andere ( int, string, float, bool). Auf diese Weise können Sie Funktionen im laufenden Betrieb erstellen, sie Dingen zuweisen und sie später zurückrufen. Es ist nützlich, aber nicht etwas, das Sie übermäßig verwenden möchten, oder Sie werden jeden verwirren, der Ihren Code nach Ihnen pflegen muss ...

Dies ist ein Code, mit dem ich gespielt habe, um zu sehen, wie tief dieses Kaninchenloch geht:

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]()()();

Im Kontext von CS ist eine Lambda-Funktion ein abstraktes mathematisches Konzept, das sich mit einem Problem der symbolischen Bewertung mathematischer Ausdrücke befasst. In diesem Zusammenhang ist eine Lambda-Funktion dieselbe wie ein Lambda-Term .

Aber in Programmiersprachen ist es etwas anderes. Es ist ein Code, der als "an Ort und Stelle" deklariert ist und als "erstklassiger Bürger" weitergegeben werden kann. Dieses Konzept schien nützlich zu sein, so dass es in fast allen gängigen modernen Programmiersprachen verfügbar war (siehe Lambda-Funktionen überall im Beitrag).

A Lambda Functionoder a Small Anonymous Functionist ein in sich geschlossener Funktionsblock, der weitergegeben und in Ihrem Code verwendet werden kann. Lambda hat verschiedene Namen in verschiedenen Programmiersprachen - Lambdain Python und Kotlin , Closurein Swift oder Blockin C und Objective-C . Obwohl Lambdas Bedeutung für diese Sprachen ziemlich ähnlich ist, gibt es manchmal leichte Unterschiede.

Mal sehen, wie Lambda (Closure) in Swift 4.2 mit der sorted () -Methode funktioniert - von der normalen Funktion bis zum kürzesten Ausdruck:

let coffee: [String] = ["Cappuccino", "Espresso", "Latte", "Ristretto"]

1. Normale Funktion

func backward(_ n1: String, _ n2: String) -> Bool {
    return n1 > n2
}
var reverseOrder = coffee.sorted(by: backward)


// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

2. Abschlussausdruck

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in
    return n1 > n2
})

3. Inline-Abschlussausdruck

reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )

4. Typ aus dem Kontext ableiten

reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )

5. Implizite Rückgaben von Einzelausdrucksabschlüssen

reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )

6. Kurzargumentnamen

reverseOrder = coffee.sorted(by: { $0 > $1 } )

// $0 and $1 are closure’s first and second String arguments.

7. Operatormethoden

reverseOrder = coffee.sorted(by: >)

// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]

Hoffe das hilft.

Ich habe es auch. Ich habe es in JS mit diesem versucht:

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

Es addiert 2 zu 4 und multipliziert dann das Ergebnis mit 6. Allerdings fällt es mir manchmal schwer zu lesen :(

Außerdem habe ich für jede Funktion eine interessante gemacht:

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);

Diese Methode iteriert ein Array und führt eine Aktion aus - im Fall des Druckens auf der Konsole. Jetzt verstehe auch ich, warum Labmdas mächtig sind.

In der Computerprogrammierung ist Lambda ein Code (Anweisung, Ausdruck oder eine Gruppe davon), der einige Argumente aus einer externen Quelle übernimmt. Es muss nicht immer eine anonyme Funktion sein - wir haben viele Möglichkeiten, sie zu implementieren.

Wir haben eine klare Trennung zwischen Ausdrücken, Aussagen und Funktionen, die Mathematiker nicht haben.

Das Wort "Funktion" in der Programmierung ist auch anders - wir haben "Funktion ist eine Reihe von Schritten zu tun" (aus dem Lateinischen "durchführen"). In der Mathematik geht es um die Korrelation zwischen Variablen.

Funktionale Sprachen versuchen, mathematischen Formeln so ähnlich wie möglich zu sein, und ihre Wörter bedeuten fast dasselbe. Aber in anderen Programmiersprachen haben wir es anders.

Die Frage wurde vollständig beantwortet, ich möchte nicht auf Details eingehen. Ich möchte die Verwendung beim Schreiben numerischer Berechnungen in Rost teilen.

Es gibt ein Beispiel für ein Lambda (anonyme Funktion)

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

Als ich ein Modul der Newton-Raphson-Methode schrieb, wurde es als Ableitung erster und zweiter Ordnung verwendet. (Wenn Sie wissen möchten, was die Newton-Raphson-Methode ist, besuchen Sie bitte " https://en.wikipedia.org/wiki/Newton%27s_method ".

Die Ausgabe wie folgt

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

f=98.000000       df=20.000000

Stellen Sie sich vor, Sie haben ein Restaurant mit Lieferoption und eine Bestellung, die in weniger als 30 Minuten erledigt werden muss. Der Punkt ist, dass es Kunden normalerweise egal ist, ob Sie ihr Essen mit dem Fahrrad mit dem Auto oder barfuß schicken, solange Sie das Essen warm und gefesselt halten. Lassen Sie uns diese Redewendung mit anonymen und definierten Transportfunktionen in Javascript konvertieren.

Im Folgenden haben wir die Art und Weise unserer Lieferung definiert, auch bekannt als Name für eine Funktion:

// ES5 
var food = function withBike(kebap, coke) {
return (kebap + coke); 
};

Was wäre, wenn wir Pfeil- / Lambda-Funktionen verwenden würden, um diese Übertragung durchzuführen:

// ES6    
const food = (kebap, coke) => { return kebap + coke };

Sie sehen, es gibt keinen Unterschied für den Kunden und keine Zeitverschwendung, darüber nachzudenken, wie man Lebensmittel verschickt. Schick es einfach.

Übrigens empfehle ich den Kebap mit Cola nicht. Deshalb geben Ihnen die oberen Codes Fehler. Habe Spaß.