Was ist ein lambda (Funktion)?
-
08-06-2019 - |
Frage
Für eine person ohne eine comp-sci hintergrund, was ist ein lambda-Ausdruck in die Welt der informatik?
Lösung
Lambda kommt aus dem Lambda-Kalkül und bezieht sich auf anonyme Funktionen in der Programmierung.
Warum ist das cool?Es erlaubt Ihnen zu schreiben, schnell wegwerfen-Funktionen, ohne Benennung.Es bietet auch eine schöne Art und Weise zu schreiben, Verschlüsse.Mit dieser power können Sie Dinge wie diese tun.
Python
def adder(x):
return lambda y: x + y
add5 = adder(5)
add5(1)
6
Wie Sie sehen können aus dem snippet von Python, die Funktion adder nimmt ein argument x und gibt eine anonyme Funktion oder lambda-Ausdruck, der ein weiteres argument y.Dass die anonyme Funktion ermöglicht Ihnen das erstellen von Funktionen von Funktionen.Dies ist ein einfaches Beispiel, aber es sollte vermitteln die Kraft lambdas und closures.
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
Schema
(define adder
(lambda (x)
(lambda (y)
(+ x y))))
(define add5
(adder 5))
(add5 1)
6
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);
Swift
func adder(x: Int) -> (Int) -> Int{
return { y in x + y }
}
let add5 = adder(5)
add5(1)
6
PHP
$a = 1;
$b = 2;
$lambda = function () use (&$a, &$b) {
echo $a + $b;
};
echo $lambda();
Haskell
(\x y -> x + y)
Java finden dieser 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
Ruby
Ruby ist etwas anders, dass Sie nicht anrufen können einen lambda-Ausdruck mit genau der gleichen syntax wie eine Funktion aufrufen, aber es hat immer noch Lambda-Ausdrücke.
def adder(x)
lambda { |y| x + y }
end
add5 = adder(5)
add5[1] == 6
Ruby als Ruby, es ist eine Kurzform für lambdas, so können Sie festlegen, adder
auf diese Weise:
def adder(x)
-> y { x + y }
end
Andere Tipps
Ein lambda ist eine Art von Funktion, die inline definiert.Zusammen mit einer lambda-auch Sie haben in der Regel eine Art von Variablen Typ, dass kann halten eine Referenz auf eine Funktion, lambda oder auf andere Weise.
Zum Beispiel, hier ist eine C# - code, der nicht mit einem lambda-Ausdruck:
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);
}
Diese fordert, Taschenrechner, vorbei an nicht nur zwei zahlen, aber die Methode zum aufrufen von innen-Rechner um die Ergebnisse der Berechnung.
In C# 2.0 haben wir, anonyme Methoden, die verkürzt den obigen code:
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 in C# 3.0 haben wir Lambda-Ausdrücke, die den code noch kürzer:
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);
}
Es bezieht sich auf lambda-Kalkül,, das ist ein formales system, das nur lambda-Ausdrücke, die darstellen, eine Funktion, eine Funktion, seine alleinige argument und gibt eine Funktion.Alle Funktionen im lambda-Kalkül sind von dieser Art ist, D. H., λ : λ → λ
.
Lisp verwendet die lambda-Begriff, um seine anonyme Funktion-Literale.Dieser lambda-Ausdruck repräsentiert eine Funktion, die zwei Argumente x und y, und gibt Ihre Produkt:
(lambda (x y) (* x y))
Es kann angewendet werden, in-line, wie hier (auswertet 50):
((lambda (x y) (* x y)) 5 10)
Der name "lambda" ist ein historisches Artefakt.Alles, was wir sind reden über ist ein Ausdruck, dessen Wert eine Funktion ist.
Ein einfaches Beispiel (mit Scala für die nächste Zeile), ist:
args.foreach(arg => println(arg))
wo das argument die foreach
Methode ist ein Ausdruck für eine anonyme Funktion.Die obige Zeile ist mehr oder weniger das gleiche wie das schreiben so etwas wie diese (nicht ganz echten code, aber Sie bekommen die Idee):
void printThat(Object that) {
println(that)
}
...
args.foreach(printThat)
außer, dass Sie brauchen nicht zu belästigen mit:
- Deklarieren Sie die Funktion irgendwo anders (und mit zu sich, wenn Sie überdenken, den code später).
- Benennung etwas, das Sie nur einmal verwenden.
Sobald Sie sind verwendet, um die Funktion zu Werten, ohne Sie scheint so dumm, wie erforderlich ist, um den Namen jeder Ausdruck, wie:
int tempVar = 2 * a + b
...
println(tempVar)
anstatt nur zu schreiben, den Ausdruck, wo Sie es brauchen:
println(2 * a + b)
Die genaue Schreibweise variiert von Sprache zu Sprache;Griechisch ist nicht immer erforderlich!;-)
Der lambda-Kalkül ist eine konsistente mathematische Theorie der substitution.In der Schule Mathematik sieht man zum Beispiel x+y=5
gepaart mit x−y=1
.Zusammen mit Weise zu manipulieren einzelnen Gleichungen ist es auch möglich, die Informationen aus diesen beiden zusammen, vorausgesetzt, cross-Gleichung die Substitutionen erfolgt sind logisch.Lambda-Kalkül kodifiziert die richtige Art und Weise zu tun, diese Substitutionen.
Da y = x−1
eine gültige Neuordnung der zweiten Gleichung: λ y = x−1
eine Funktion ersetzen der Symbole x−1
für das symbol y
.Stellen Sie sich nun vor der Anwendung λ y
zu jedem Begriff in der ersten Gleichung.Wenn ein Begriff ist y
führen Sie dann die substitution;sonst nichts.Wenn Sie dies tun, auf dem Papier werden Sie sehen, wie die Anwendung, die λ y
wird die erste Gleichung lösbar ist.
Das ist eine Antwort ohne informatik oder Programmierung.
Der einfachste Programmierung Beispiel, das ich denken kann, kommt aus http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works:
hier ist, wie die quadratische Funktion kann definiert werden, in ein Imperativ Programmiersprache (C):
int square(int x) { return x * x; }
Die variable x ist eine formale parameter, die wird ersetzt durch die tatsächliche Wert quadriert, wenn die Funktion aufgerufen wird.In einem funktionalen Sprache (Schema) die gleiche Funktion definiert werden würde:
(define square (lambda (x) (* x x)))
Dies ist in vielerlei Hinsicht anders, aber es verwendet immer noch die formalen parameter x in der gleichen Weise.
Hinzugefügt: http://imgur.com/a/XBHub
Etwas vereinfacht:eine lambda-Funktion ist eine, die übergeben werden können, Runden auf andere Funktionen und der Logik zugänglich.
In C# - lambda-syntax ist oft zusammengestellt zu einfachen Methoden in gleicher Weise wie die anonymen Delegaten, aber es kann auch zerbrochen werden, und seine Logik zu Lesen.
Zum Beispiel (in C#3):
LinqToSqlContext.Where(
row => row.FieldName > 15 );
LinqToSql zu Lesen, dass die Funktion (x > 15) und konvertieren Sie es auf die eigentliche auszuführende SQL-Anweisung mithilfe von expression trees.
Die obige Erklärung wird:
select ... from [tablename]
where [FieldName] > 15 --this line was 'read' from the lambda function
Dies unterscheidet sich von normalen Methoden oder anonyme Delegaten (die nur compiler-Magie wirklich), weil Sie nicht Lesen.
Nicht alle Methoden in C# verwenden von lambda-syntax kompiliert werden kann, um die expression trees (d.h.tatsächliche lambda-Funktionen).Zum Beispiel:
LinqToSqlContext.Where(
row => SomeComplexCheck( row.FieldName ) );
Jetzt den Ausdruck Baum kann nicht gelesen werden - SomeComplexCheck nicht abgebaut werden kann.Die SQL-Anweisung wird ausgeführt, ohne die, wo, und jede Zeile in den Daten werden durch SomeComplexCheck
.
Lambda-Funktionen sollten nicht verwechselt werden mit den anonymen Methoden.Zum Beispiel:
LinqToSqlContext.Where(
delegate ( DataRow row ) {
return row.FieldName > 15;
} );
Dies hat auch eine "inline" - Funktion, aber dieses mal ist es nur compiler-Magie - der C# - compiler teilt diese aus, um eine neue Instanz-Methode mit einem automatisch generierten Namen.
Anonyme Methoden können nicht gelesen werden, und so die Logik, kann nicht übersetzt werden, als es für lambda-Funktionen.
Ich mag die Erklärung von Lambdas in diesem Artikel: Die Entwicklung Von LINQ Und Seine Auswirkungen Auf Das Design Von C#.Es hat sehr viel Sinn für mich, denn es gibt eine Reale Welt für Lambdas und baut es aus, wie ein Beispiel aus der Praxis.
Ihre kurze Erklärung:Lambdas sind eine Möglichkeit zur Behandlung von code (Funktionen) als Daten.
Ein Beispiel für einen lambda-Ausdruck in Ruby ist wie folgt:
hello = lambda do
puts('Hello')
puts('I am inside a proc')
end
hello.call
Wird genereate die folgende Ausgabe:
Hello
I am inside a proc
@Brian, ich Lambda-Ausdrücke die ganze Zeit in C#, LINQ und nicht-LINQ-Operatoren.Beispiel:
string[] GetCustomerNames(IEnumerable<Customer> customers)
{ return customers.Select(c=>c.Name);
}
Vor C#, die ich verwendet, anonyme Funktionen in JavaScript für Rückrufe, um AJAX-Funktionen, bevor der Begriff Ajax wurde sogar geprägt:
getXmlFromServer(function(result) {/*success*/}, function(error){/*fail*/});
Die interessante Sache mit C#'s lambda-syntax, obwohl, ist, dass Sie auf Ihren eigenen Typ kann nicht geschlossen werden (D. H., Sie können nicht Typ var foo = (x,y) => x * y), aber je nachdem, auf welche Art Sie zugewiesen sind, Sie werden kompiliert werden, wie Delegierte oder abstrakte syntax-Bäume, der Ausdruck (das ist, wie LINQ-Objekt-Mapper Ihre "Sprache-integrierte" magic).
Lambda-Ausdrücke in LISP kann auch übergeben werden, um ein Angebot operator und dann durchquert, als eine Liste von Listen.Einige mächtige Makros werden auf diese Weise gemacht.
Die Frage ist formal beantwortet sehr, also werde ich nicht versuchen zu hinzufügen mehr dazu.
Sehr einfach, informelle Worte, um jemanden, der weiß, dass sehr wenig oder gar nichts, auf Mathematik-oder Programmier -, würde ich erklären, dass es eine kleine "Maschine" oder "box", die einige Eingaben, macht einige Arbeit und produziert eine Ausgabe, hat keinen besonderen Namen, aber wir wissen, wo es ist und nur durch dieses wissen nutzen wir es.
Praktisch gesprochen, eine person, die weiß, was eine Funktion ist, würde ich Ihnen sagen, es ist eine Funktion, die keinen Namen hat, setzen in der Regel einen Punkt im Speicher, die verwendet werden können, nur durch den Bezug auf, dass der Speicher (in der Regel über die Verwendung von eine variable, die - wenn Sie gehört haben, über das Konzept der Funktionszeiger, ich würde Sie als ein ähnliches Konzept) - diese Antwort deckt das ziemlich Grundlagen (keine Erwähnung von Schließungen usw.), aber man kann die Stelle problemlos.
Sie können denken, es als eine anonyme Funktion - hier einige weitere Infos: Wikipedia - Anonyme Funktion
Nur weil ich kann nicht sehen, eine C++11-Beispiel hier, ich werde gehen Sie vor und stellen Sie dieses schöne Beispiel von hier.Nach der Suche, es ist die klarste Sprache 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 beim wickeln meinen Kopf um lambda-Ausdrücke, denn ich arbeite in Visual FoxPro, die Makro-substitution und die ExecScript{} und Auswerten () - Funktionen, die scheinen viel zu dienen dem gleichen Zweck.
? Calculator(10, 23, "a + b")
? Calculator(10, 23, "a - b");
FUNCTION Calculator(a, b, op)
RETURN Evaluate(op)
Ein großer Vorteil der Verwendung formale lambdas ist (ich nehme an) compile-time checking:Fox wird nicht wissen, ob Sie Tippfehler die Zeichenfolge oben, bis er versucht, es auszuführen.
Dies ist auch nützlich für data-driven code:Sie können Shop gesamten Routinen in memo-Felder in der Datenbank und dann einfach auswerten zu laufen-Zeit.So können Sie tweak Teil der Anwendung ohne Zugriff auf den Quellcode.(Aber das ist ein anderes Thema insgesamt.)
Für eine person ohne eine comp-sci hintergrund, was ist ein lambda-Ausdruck in die Welt der informatik?
Ich werde zeigen, Sie intuitiv Schritt für Schritt in einer einfachen und lesbaren python-codes.
Kurz gesagt, ein lambda-Ausdruck nur ein anonymes und inline-Funktion.
Beginnen wir bei der Zuordnung zu verstehen lambdas
als Neuling mit dem hintergrund der grundlegenden arithmetischen Funktionen.
Der Entwurf der Abtretung ist '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 der Mathematik
In [4]: m = n**2 + 2*n + 1
NameError: name 'n' is not defined
Fehler berichten
Sie können schreiben, eine mathematische direkt als code,'n' definiert werden soll oder ein Wert zugewiesen.
In [8]: n = 3.14
In [9]: m = n**2 + 2*n + 1
In [10]: m
Out[10]: 17.1396
Es funktioniert nun,was ist, wenn Sie darauf bestehen, auf die Kombination der beiden seperarte Linien zu einer.Es kommt lambda
In [13]: j = lambda i: i**2 + 2*i + 1
In [14]: j
Out[14]: <function __main__.<lambda>>
Keine Fehler gemeldet werden.
Dies ist ein Blick auf lambda
, es ermöglicht Ihnen das erstellen einer Funktion in einer einzigen Zeile, wie Sie in der mathematischen in die computer direkt.
Wir werden später zu sehen sein.
Lasst uns weiter an, tiefer zu Graben auf 'Zuordnung'.
Wie oben dargestellt, die-gleich-symbol =
funktioniert für einfache Daten - (1-und 'value') - Typ und einfachen Ausdruck(n**2 + 2*n + 1).
Versuchen Sie 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 Aussagen,es gibt 11 Arten von Ihnen in python 7.Einfache Aussagen — Python 3.6.3 Dokumentation
Wie über zusammengesetzte Anweisung,
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
Es kommt def
aktivieren Sie es arbeiten
In [23]: def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
...:
In [24]: m(2)
Out[24]: 9
Tada, analysieren es, 'm' name, 'n**2 + 2*n + 1" ist-Wert.:
ist eine Variante von '='.
Finden Sie es, wenn Sie einfach für das Verständnis, alles beginnt von Abtretung und alles Abtretung an.
Zurück lambda
, wir haben eine Funktion namens "m"
Versuchen:
In [28]: m = m(3)
In [29]: m
Out[29]: 16
Es gibt zwei Namen, die der 'm' - hier ist die Funktion m
schon einen Namen hat, dupliziert.
Es wird die Formatierung wie:
In [27]: m = def m(n):
...: if n > 0:
...: return n**2 + 2*n + 1
SyntaxError: invalid syntax
Es ist nicht eine kluge Strategie, so dass Fehler berichten
Wir haben so löschen Sie eine von Ihnen,legen Sie eine Funktion ohne Namen.
m = lambda n:n**2 + 2*n + 1
Es heißt 'anonyme Funktion'
Abschließend
lambda
in einer inline-Funktion, die Sie aktivieren eine Funktion schreiben in einer geraden Linie wie in der Mathematiklambda
anonym
Hoffe, das hilft.
Es ist eine Funktion, die keinen Namen hat.Für z.B.in c# können Sie
numberCollection.GetMatchingItems<int>(number => number > 5);
die Rückkehr der zahlen, die größer als 5.
number => number > 5
ist die lambda-Teil hier.Es repräsentiert eine Funktion, die einen parameter (Zahl) und gibt einen booleschen Wert (Zahl > 5).GetMatchingItems Methode verwendet das lambda auf alle Elemente in der Sammlung, und gibt die passenden Artikel.
In Javascript zum Beispiel, Funktionen behandelt werden, als die gleichen gemischten Typ, wie alles andere (int
, string
, float
, bool
).So können Sie Funktionen erstellen, die auf die Fliegen, ordnen Sie die Dinge, und rufen Sie später zurück.Es ist nützlich, aber nicht etwas, das Sie möchten, um über die Verwendung oder werden Sie verwirren, jeder, der zu erhalten Ihre code, nachdem Sie...
Dies ist ein code, ich spielte mit, um zu sehen, wie tief das Kaninchen-Loch 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 Rahmen der CS eine lambda-Funktion ist ein abstraktes mathematisches Konzept, das greift ein problem der symbolischen Auswertung mathematischer Ausdrücke.In diesem Zusammenhang eine lambda-Funktion ist die gleiche wie ein lambda-term.
Aber in Programmiersprachen ist es etwas anders.Es ist ein Stück code, das ist, erklärte: "in place", und übergeben werden kann, um wie ein "first-class citizen".Dieses Konzept erschien, um nützlich zu sein, so dass es kam in fast alle gängigen modernen Programmiersprachen (siehe lambda-Funktionen everwhere post).
Ich bekam es auch.Ich habe versucht, es in JS mit diesem:
var addAndMult = function(x) {
return (function(y) {
return (function(z) {
return (x+y)*z;
});
});
};
Es fügt 2 bis 4 dann mults das Ergebnis durch 6.Allerdings finde ich es manchmal schwer zu Lesen :(
Auch ich habe eine interessante forEach-Funktion:
var forEach = function(arr) {
return (function(x) {
for (var i=0; arr[i]; i++) {
x(arr[i]);
}
});
}
forEach([1,2,3,4,5]) (- Konsole.log);
Diese Methode wird Durchlaufen ein array und führt eine Aktion aus - in dem Fall Druck auf die Konsole.Jetzt habe ich auch bekommen, warum labmdas sind mächtig.
In computer-Programmierung, lambda-Ausdruck ist ein Stück code (Anweisung, Ausdruck oder eine Gruppe von Ihnen), die einige Argumente, die aus einer externen Quelle.Es muss nicht immer eine anonyme Funktion, - wir haben viele Möglichkeiten, diese umzusetzen.
Wir haben klare Trennung zwischen Ausdrücken, Anweisungen und Funktionen, die Mathematiker nicht haben.
Das Wort "Funktion" in der Programmierung ist auch anders - wir haben "die Funktion ist eine Reihe von Schritten zu tun" (aus dem lateinischen "ausführen").In der Mathematik ist es, etwas über die Korrelation zwischen den Variablen.
Funktionale Sprachen werden versuchen, so ähnlich wie mathematische Formeln wie möglich, und Ihre Worte bedeuten fast das gleiche.Aber auch in anderen Programmiersprachen haben wir es anders.
Ein
Lambda Function
, oder einSmall Anonymous Function
, ist ein Selbstversorger-block mit Funktionen, die sich übergeben und in Ihrem code verwendet haben.Lambda hat verschiedene Namen in verschiedenen Programmiersprachen –Lambda
in Python und Kotlin,Closure
in Swift, oderBlock
in C und Objective-C.Obwohl lambda Bedeutung ist Recht ähnlich, die für diese Sprachen hat es leichte Unterschiede manchmal.
Lassen Sie uns sehen, wie Lambda (Schließen) funktioniert in Swift 4.2 mit sorted () – Methode von der normalen Funktion bis zu den 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.Verschluss Ausdruck
reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in
return n1 > n2
})
3.Inline-Schließung Ausdruck
reverseOrder = coffee.sorted(by: { (n1: String, n2: String) -> Bool in return n1 > n2 } )
4.Herleitung Art Von Kontext
reverseOrder = coffee.sorted(by: { n1, n2 in return n1 > n2 } )
5.Implizite Renditen von Single-Expression Closures
reverseOrder = coffee.sorted(by: { n1, n2 in n1 > n2 } )
6.Kurzschrift-Argument-Namen
reverseOrder = coffee.sorted(by: { $0 > $1 } )
// $0 and $1 are closure’s first and second String arguments.
7.Betreiber Methoden
reverseOrder = coffee.sorted(by: >)
// RESULT: ["Ristretto", "Latte", "Espresso", "Cappuccino"]
Hoffe, das hilft.
Die Frage wurde vollständig beantwortet, ich will nicht in die details gehen.Ich möchte die Verwendung beim schreiben von numerischen Berechnung in rust.
Es ist ein Beispiel für einen lambda(anonyme Funktion)
let f = |x: f32| -> f32 { x * x - 2.0 };
let df = |x: f32| -> f32 { 2.0 * x };
Wenn ich schrieb ein Modul des Newton–Raphson-Methode, es verwendet wurde, als erste und zweite Ableitung.(Wenn Sie wollen wissen, was ist die Newton–Raphson-Methode, besuchen Sie bitte "https://en.wikipedia.org/wiki/Newton%27s_method".
Die Ausgabe wie die folgende
println!("f={:.6} df={:.6}", f(10.0), df(10.0))
f=98.000000 df=20.000000
Stell dir vor, du hast ein restaurant mit einer Lieferung option und Sie haben eine Bestellung, die getan werden muss, um in unter 30 Minuten.Der Punkt ist, Kunden in der Regel egal, wenn Sie senden Sie Ihre Nahrung durch das Fahrrad mit einem Auto oder barfuß, wie lange, wie Sie halten das Essen warm und gefesselt.So ermöglicht das konvertieren dieses idiom Javascript mit anonymen und definiert den Transport-Funktionen.
Unten definierten wir die Möglichkeit, unsere Lieferung aka definieren wir einen Namen für eine Funktion:
// ES5
var food = function withBike(kebap, coke) {
return (kebap + coke);
};
Was wären wir verwenden Pfeil - /lambda-Funktionen, um dies zu erreichen transfer:
// ES6
const food = (kebap, coke) => { return kebap + coke };
Sie sehen, es gibt keinen Unterschied für den Kunden und keine Zeit verschwenden zu denken über wie zu senden Essen.Schicken Sie es einfach.
Btw, ich nicht empfehlen den kebap mit Koks dies ist der Grund, warum Ober-codes geben Sie Fehler.Spaß haben.