Bilgisayar altyapısı olmayan bir kişi için, Bilgisayar Bilimi dünyasında lambda nedir?

Lambda, Lambda Analizinden gelir ve programlamada anonim işlevlere atıfta bulunur.

Bu neden havalı? Hızlı atma işlevlerini adlandırmadan yazmanıza izin verir. Ayrıca kapaklar yazmak için güzel bir yol sağlar. Bu güçle böyle şeyler yapabilirsiniz.

piton

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

Python snippet'inden görebileceğiniz gibi, işlev toplayıcı x argümanını alır ve başka bir y argümanını alan anonim bir fonksiyon veya lambda döndürür. Bu anonim işlev, işlevlerden işlevler oluşturmanıza olanak tanır. Bu basit bir örnek, ama lambda ve kapakların sahip olduğu güç iletmelidir.

Diğer dillerde örnekler

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

düzen

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

C # 3.5 veya üstü

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

hızlı

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 bkz Bu yayını

// 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

Yakut

Ruby, bir işlevi çağırmakla aynı sözdizimini kullanarak lambda diyemeyeceğinizden biraz farklıdır, ancak yine de lambdas vardır.

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

Ruby Ruby olduğu için lambdas için bir stenografi vardır, böylece adderbu şekilde tanımlayabilirsiniz :

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

R,

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

Bir lambda, satır içi olarak tanımlanan bir işlev türüdür. Bir lambda ile birlikte genellikle bir işleve, lambda'ya veya başka bir şekilde referans verebilen bir çeşit değişken tipine sahipsiniz.

Örneğin, lambda kullanmayan bir C # kod parçası:

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

Bu sadece iki sayı boyunca değil, Hesaplama çağırır, hesaplamanın sonuçlarını almak için Hesap Makinesi içinde hangi yöntemi aramak için.

C # 2.0'da yukarıdaki kodu kısaltan anonim yöntemler aldık:

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

Ve sonra C # 3.0'da kodu daha da kısaltan lambdas var:

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

"Lambda" ismi sadece tarihi bir eserdir. Tek konuştuğumuz, değeri bir işlev olan bir ifadedir.

Basit bir örnek (sonraki satır için Scala kullanımı):

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

burada foreachyönteme ilişkin argüman anonim bir işlev için bir ifadedir. Yukarıdaki satır aşağı yukarı böyle bir şey yazmakla aynıdır (oldukça gerçek bir kod değil, ama fikri anlayacaksınız):

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

ancak aşağıdakilerle uğraşmanıza gerek kalmaz:

1. İşlevi başka bir yerde bildirme (ve kodu daha sonra tekrar ziyaret ettiğinizde araması gerekir).
2. Yalnızca bir kez kullandığınız bir şeyi adlandırma.

Değerleri işlemeye alıştıktan sonra, bunlar olmadan yapmak zorunda olduğunuz her ifadeyi adlandırmak için aptalca görünmektedir, örneğin:

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

İfadeyi ihtiyacınız olan yere yazmak yerine:

println(2 * a + b)

Kesin gösterim dilden dile değişir; Yunanca her zaman gerekli değildir! ;-)

Sadece lambda ifadelerine sahip resmi bir sistem olan lambda hesabı anlamına gelir , tek argümanı için bir işlev alan ve bir işlev döndüren bir işlevi temsil eder. Lambda hesabındaki tüm fonksiyonlar bu tiptedir, yani λ : λ → λ.

Lisp, anonim işlev değişmezlerini adlandırmak için lambda kavramını kullandı. Bu lambda, x ve y olmak üzere iki argüman alan ve ürünlerini döndüren bir işlevi temsil eder:

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

Bu şekilde sıralı olarak uygulanabilir ( 50'ye kadar değerlendirilir ):

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

Lambda hesabı tutarlı bir matematiksel ikame teorisidir. Okul matematiğinde örneğin biriyle x+y=5eşleştirilir x−y=1. Tek tek denklemleri manipüle etmenin yollarının yanı sıra, çapraz denklem ikamelerinin mantıklı bir şekilde yapılması şartıyla, bu ikiden gelen bilgileri bir araya getirmek de mümkündür. Lambda hesabı bu ikameleri yapmak için doğru yolu kodlar.

y = x−1İkinci denklemin geçerli bir yeniden düzenlemesi göz önüne alındığında , bu: sembolün λ y = x−1yerine kullanılan bir işlev anlamına gelir . Şimdi ilk denklemdeki her terime uyguladığınızı düşünün . Bir terim ikameyi gerçekleştirirse; aksi halde hiçbir şey yapmayın. Eğer bunu kağıt üzerinde yaparsanız, bunu uygularken ilk denklemi nasıl çözülebilir hale getireceksiniz.x−1yλ yyλ y

Bu herhangi bir bilgisayar bilimi veya programlama olmadan bir cevaptır.

Aklıma gelen en basit programlama örneği http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works :

kare fonksiyonunun zorunlu bir programlama dilinde (C) nasıl tanımlanacağı aşağıda açıklanmıştır:

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

X değişkeni, işlev çağrıldığında karesi alınacak gerçek değerle değiştirilen resmi bir parametredir. İşlevsel bir dilde (Şema) aynı işlev tanımlanır:

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

Bu birçok yönden farklıdır, ancak yine de biçimsel x parametresini aynı şekilde kullanır.

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

Biraz fazla basitleştirilmiş: lambda işlevi diğer işlevlere aktarılabilen ve mantığa erişilen bir işlevdir.

C # lambda sözdizimi genellikle anonim delegelerle aynı şekilde basit yöntemlerle derlenir, ancak aynı zamanda parçalanabilir ve mantığı okunabilir.

Örneğin (C # 3'te):

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

LinqToSql bu işlevi (x> 15) okuyabilir ve ifade ağaçlarını kullanarak yürütmek için gerçek SQL'e dönüştürebilir.

Yukarıdaki ifade şöyle olur:

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

Bu, normal yöntemlerden veya anonim delegelerinden farklıdır (bunlar sadece derleyici büyüsüdür) çünkü okunamazlar .

C # 'da lambda sözdizimi kullanan tüm yöntemler ifade ağaçlarına derlenemez (yani gerçek lambda fonksiyonları). Örneğin:

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

Şimdi ifade ağacı okunamıyor - SomeComplexCheck öğesi parçalanamıyor. SQL deyimi, burada olmadan yürütülür ve verilerdeki her satır yerleştirilir SomeComplexCheck.

Lambda fonksiyonları anonim yöntemlerle karıştırılmamalıdır. Örneğin:

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

Bunun da 'satır içi' işlevi vardır, ancak bu sefer sadece derleyici büyüsüdür - C # derleyicisi bunu otomatik olarak oluşturulmuş bir adla yeni bir örnek yöntemine böler.

Anonim yöntemler okunamaz ve bu nedenle mantık lambda işlevleri için olduğu gibi çevrilemez.

Bu makalede Lambdas'ın açıklamasını seviyorum: LINQ'nun Evrimi ve C # Tasarımına Etkisi . Lambdas için gerçek bir dünya gösterdiğinden ve bunu pratik bir örnek olarak ortaya koyduğundan, bana çok mantıklı geldi.

Kısa açıklamaları: Lambdalar kodu (fonksiyonları) veri olarak görmenin bir yoludur.

Ruby'deki bir lambda örneği aşağıdaki gibidir:

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

hello.call

Aşağıdaki çıktıyı üretecek:

Hello
I am inside a proc

@Brian Lamdaları her zaman C #, LINQ ve LINQ olmayan operatörlerde kullanıyorum. Misal:

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

C # önce, Ajax terimi bile önce, AJAX işlevlerine geri çağrılar için JavaScript anonim işlevleri kullandım:

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

Bununla birlikte, C # 's lambda sözdizimi ile ilginç olan şey, kendi türlerinin çıkartılamamasıdır (yani, var foo = (x, y) => x * y) yazamazsınız, ancak hangi türe bağlı olduklarına bağlı olarak atandığında, ifadeyi temsil eden delegeler veya soyut sözdizimi ağaçları olarak derlenirler (LINQ nesne eşleyicileri "dile entegre" sihirlerini böyle yapar).

LISP'deki Lambda'lar da bir teklif operatörüne aktarılabilir ve daha sonra bir liste listesi olarak geçilebilir. Bazı güçlü makrolar bu şekilde yapılır.

Soru resmen büyük ölçüde cevaplandı, bu yüzden bu konuda daha fazla eklemeye çalışmayacağım.

Matematik veya programlama hakkında çok az şey bilen veya hiç bilmeyen birine çok basit, gayri resmi kelimelerle, onu biraz girdi alan, bazı işler yapan ve çıktı üreten, belirli bir adı olmayan küçük bir "makine" veya "kutu" olarak açıklayacağım , ama nerede olduğunu biliyoruz ve sadece bu bilgi ile kullanıyoruz.

Pratik olarak konuşursak, bir fonksiyonun ne olduğunu bilen biri için, onlara isimsiz bir fonksiyon olduğunu söyleyebilirim, genellikle hafızada sadece o hafızaya atıfta bulunarak kullanılabilecek bir noktaya (genellikle bir değişken - fonksiyon işaretçileri kavramını duymuşlarsa, onları benzer bir kavram olarak kullanırdım) - bu cevap güzel temelleri (kapanışlardan bahsedilmiyor vb.) kapsar, ancak bir nokta kolayca elde edilebilir.

Anonim bir işlev olarak düşünebilirsiniz - işte daha fazla bilgi: Wikipedia - Anonim İşlev

Burada bir C ++ 11 örneği göremediğim için, devam edip bu güzel örneği buradan göndereceğim . Arama yaptıktan sonra bulabildiğim en açık dile özgü örnek.

Merhaba Lambdas, sürüm 1

template<typename F>

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

Merhaba Lambdas, sürüm 2:

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

Makro ikamesi ve çok aynı amaca hizmet gibi görünüyor ExecScript {} ve Evaluate () işlevleri olan Visual FoxPro çalıştığım için başımı lambda ifadeler etrafında kaydırma sorunum var.

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

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

Resmi lambdas kullanmak için kesin bir fayda (sanırım) derleme zamanı denetimi: Fox çalıştırmaya çalışana kadar yukarıdaki metin dizesini yazıp yazmadığınızı bilemez.

Bu, veriye dayalı kod için de yararlıdır: tüm rutinleri veritabanındaki not alanlarına depolayabilir ve daha sonra bunları çalışma zamanında değerlendirebilirsiniz. Bu, kaynağa gerçekten erişmeden uygulamanın bir kısmını değiştirmenizi sağlar. (Ama bu tamamen başka bir konu.)

Bilgisayar altyapısı olmayan bir kişi için, Bilgisayar Bilimi dünyasında lambda nedir?

Basit ve okunabilir python kodlarında sezgisel olarak adım adım göstereceğim.

Kısacası, bir lambda sadece anonim ve satır içi bir işlevdir.

lambdasTemel aritmetik geçmişi olan bir birinci sınıf öğrencisi olarak anlamak için ödevden başlayalım .

Ödevin planı 'isim = değer' dir, bakınız:

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

'x', 'y' adlardır ve 1, 'değer' değerlerdir. Matematikte bir fonksiyon deneyin

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

Hata raporları,
bir matematik kodunu doğrudan kod olarak yazamazsınız, 'n' tanımlanmalı veya bir değere atanmalıdır.

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

Şimdi çalışır, eğer iki ayrı satırı bir araya getirmekte ısrar ederseniz. Orada geliyorlambda

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

Hata bildirilmedi.

Bu bir bakışta, lambdamatematikte yaptığınız gibi doğrudan bir fonksiyona tek bir satıra yazmanızı sağlar.

Daha sonra göreceğiz.

Şimdi 'ödev'i daha derinlemesine incelemeye devam edelim.

Yukarıda gösterildiği gibi, eşittir sembolü =basit veri (1 ve 'değer') türü ve basit ifade (n ** 2 + 2 * n + 1) için çalışır.

Bunu dene:

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

Basit ifadeler için çalışır, python 7'de 11 tür vardır . Basit ifadeler - Python 3.6.3 belgeleri

Bileşik ifadeye ne dersiniz,

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

defÇalışmasını sağlamak için geliyor

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

Tada, analiz et, 'm' isim, 'n ** 2 + 2 * n + 1' değerdir. :'=' değişkenidir.
Sadece anlamak için, her şey ödevden başlar ve her şey ödevdir.

Şimdi dön lambda, 'm' adında bir fonksiyonumuz var

Deneyin:

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

Burada iki 'm' ismi var, fonksiyonun mzaten bir adı var, kopyalanmış.

Şu şekilde biçimlendiriyor:

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

Akıllı bir strateji değil, bu yüzden hata raporları

Bunlardan birini silmeli, isimsiz bir fonksiyon ayarlamalıyız.

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

Buna 'anonim işlev' denir

Sonuç olarak,

1. lambda matematikte olduğu gibi bir düz satıra bir fonksiyon yazmanızı sağlayan bir satır içi fonksiyonda
2. lambda anonim

Bu yardımcı olur umarım.

Adı olmayan bir işlevdir. Örneğin, c #

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

5'ten büyük sayıları döndürmek için.

number => number > 5

buradaki lambda kısmı. Bir parametre (sayı) alan ve bir boole değeri (sayı> 5) döndüren bir işlevi temsil eder. GetMatchingItems yöntemi, bu lambda'yı koleksiyondaki tüm öğeler için kullanır ve eşleşen öğeleri döndürür.

JavaScript, örneğin, işlevler her şey aynı karışık tip olarak kabul edilir ( int, string, float, bool). Bu nedenle, anında işlevler oluşturabilir, bunları bir şeylere atayabilir ve daha sonra geri çağırabilirsiniz. Yararlı ama aşırı kullanmak istediğiniz bir şey değil, ya da kodunuzu sizden sonra korumak zorunda olan herkesi karıştıracaksınız ...

Bu tavşan deliğinin ne kadar derine gittiğini görmek için oynadığım bazı kodlar:

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

CS bağlamında bir lambda işlevi, matematiksel ifadelerin sembolik değerlendirilmesi sorununu ele alan soyut bir matematiksel kavramdır. Bu bağlamda lambda işlevi lambda terimi ile aynıdır .

Ancak programlama dillerinde bu farklı bir şeydir. "Yerinde" olarak beyan edilen ve "birinci sınıf vatandaş" olarak iletilebilen bir kod parçasıdır. Bu kavramın neredeyse tüm popüler modern programlama dillerine gelmesi için yararlı olduğu görülmüştür (bkz. Lambda fonksiyonları her yerde post).

A Lambda Functionveya a Small Anonymous Function, kodunuzda geçirilebilen ve kullanılabilen bağımsız bir işlevsellik bloğudur. - Lambda farklı programlama dillerinde farklı isimler alır Lambdaiçinde Python ve KOTLIN , Closureiçinde Swift veya Blockiçinde C ve Objective-C . Lambda'nın anlamı bu diller için oldukça benzer olsa da, bazen küçük farklılıklar vardır.

Lambda'nın (Kapatma) Swift 4.2'de sort () yöntemiyle nasıl çalıştığını görelim - normal işlevden en kısa ifadeye kadar:

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

1. Normal İşlev

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


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

2. Kapanış İfadesi

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

3. Satır İçi Kapatma İfadesi

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

4. Bağlamdan Çıkarma Türü

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

5. Tek İfadeli Kapatmalardan Örtülü Getiriler

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

6. Steno Argüman İsimleri

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

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

7. Operatör Yöntemleri

reverseOrder = coffee.sorted(by: >)

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

Bu yardımcı olur umarım.

Ben de aldım. Bunu JS ile denedim:

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

2 ila 4 ekler ve sonra 6 ile sonuç verir. Ancak bazen okumak zor :(

Ayrıca ilginç bir forEach işlevi yaptım:

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

Bu yöntem, bir diziyi yineler ve konsola yazdırılması durumunda bir eylem gerçekleştirir. Şimdi de labmdasların neden güçlü olduğunu anlıyorum.

Bilgisayar programlamasında lambda, harici bir kaynaktan bazı argümanlar alan bir kod parçasıdır (ifade, ifade veya bunlardan oluşan bir grup). Her zaman anonim bir işlev olmamalıdır - bunları uygulamak için birçok yolumuz vardır.

Matematikçilerin sahip olmadığı ifadeler, ifadeler ve işlevler arasında açık bir ayrımımız var.

Programlamada "işlev" kelimesi de farklıdır - "işlev", yapılması gereken bir dizi adımdır "(Latince" gerçekleştirme "den). Matematikte bu değişkenler arasındaki korelasyon ile ilgili bir şeydir.

İşlevsel diller matematik formüllerine mümkün olduğunca benzer olmaya çalışmaktadır ve sözcükleri neredeyse aynı anlama gelmektedir. Ancak diğer programlama dillerinde farklıdır.

Soru tam olarak cevaplandı, ayrıntılara girmek istemiyorum. Pasta sayısal hesaplama yazarken kullanımı paylaşmak istiyorum.

Bir lambda örneği var (anonim işlev)

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

Newton-Raphson yönteminin bir modülünü yazarken, birinci ve ikinci dereceden türev olarak kullanıldı. (Newton – Raphson yönteminin ne olduğunu bilmek istiyorsanız, lütfen " https://en.wikipedia.org/wiki/Newton%27s_method adresini ziyaret edin. " .

Çıktı aşağıdaki gibi

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

f=98.000000       df=20.000000

Teslimat seçeneğine sahip bir restoranınız olduğunu ve 30 dakikadan kısa sürede yapılması gereken bir siparişiniz olduğunu düşünün. Asıl nokta, müşteriler yemeklerini bir araba ile bisikletle ya da yalınayak gönderirseniz, yemeği sıcak ve bağlı tuttuğunuz sürece umursamazsınız. Yani bu deyimi anonim ve tanımlı taşıma işlevleriyle Javascript'e dönüştürelim.

Aşağıda sunumumuzun yolunu, yani bir fonksiyona bir isim tanımladık:

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

Bu aktarımı gerçekleştirmek için ok / lambda işlevlerini kullanırsak:

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

Müşteri için fark olmadığını ve nasıl yiyecek gönderileceğini düşünmek için zaman kaybetmediğinizi görüyorsunuz. Sadece onu gönder.

BTW, ben kola kebap önermiyoruz bu yüzden üst kodları size hata verecektir. İyi eğlenceler.