Frage

Für eine person ohne eine comp-sci hintergrund, was ist ein lambda-Ausdruck in die Welt der informatik?

War es hilfreich?

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

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

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:

  1. Deklarieren Sie die Funktion irgendwo anders (und mit zu sich, wenn Sie überdenken, den code später).
  2. 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

lambda

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

  1. lambda in einer inline-Funktion, die Sie aktivieren eine Funktion schreiben in einer geraden Linie wie in der Mathematik
  2. lambda 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 ein Small 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, oder Block 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.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top