Untuk seseorang tanpa latar belakang komputer, apa itu lambda di dunia Ilmu Komputer?

Lambda berasal dari Kalkulus Lambda dan mengacu pada fungsi anonim dalam pemrograman.

Kenapa ini keren? Hal ini memungkinkan Anda untuk menulis fungsi membuang cepat tanpa menamai mereka. Ini juga menyediakan cara yang bagus untuk menulis penutupan. Dengan kekuatan itu kamu bisa melakukan hal seperti ini.

Python

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

Seperti yang dapat Anda lihat dari potongan Python, fungsi adder mengambil argumen x, dan mengembalikan fungsi anonim, atau lambda, yang membutuhkan argumen lain y. Fungsi anonim itu memungkinkan Anda membuat fungsi dari fungsi. Ini adalah contoh sederhana, tetapi harus menyampaikan kekuatan lambdas dan penutupan miliki.

Contoh dalam bahasa lain

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

Skema

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

C # 3.5 atau lebih tinggi

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

Cepat

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 melihat posting ini

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

Rubi

Ruby sedikit berbeda karena Anda tidak dapat memanggil lambda menggunakan sintaks yang sama persis dengan memanggil fungsi, tetapi masih memiliki lambda.

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

Ruby menjadi Ruby, ada singkatan untuk lambdas, sehingga Anda dapat mendefinisikan adderdengan cara ini:

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

R

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

Lambda adalah jenis fungsi, didefinisikan inline. Bersama dengan lambda Anda juga biasanya memiliki beberapa jenis tipe variabel yang dapat menyimpan referensi ke suatu fungsi, lambda atau lainnya.

Misalnya, berikut adalah sepotong kode C # yang tidak menggunakan lambda:

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

Ini panggilan Kalkulator, melewati tidak hanya dua angka, tetapi metode mana untuk memanggil dalam Kalkulator untuk mendapatkan hasil perhitungan.

Di C # 2.0 kami mendapat metode anonim, yang mempersingkat kode di atas menjadi:

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

Dan kemudian di C # 3.0 kami mendapat lambdas yang membuat kode lebih pendek:

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

Nama "lambda" hanyalah artefak sejarah. Yang kita bicarakan hanyalah ekspresi yang nilainya fungsi.

Contoh sederhana (menggunakan Scala untuk baris berikutnya) adalah:

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

di mana argumen ke foreachmetode adalah ekspresi untuk fungsi anonim. Baris di atas kurang lebih sama dengan menulis sesuatu seperti ini (bukan kode yang sebenarnya, tetapi Anda akan mendapatkan ide):

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

kecuali bahwa Anda tidak perlu repot dengan:

1. Mendeklarasikan fungsi di tempat lain (dan harus mencarinya ketika Anda kembali kode nanti).
2. Memberi nama sesuatu yang hanya Anda gunakan sekali.

Setelah Anda terbiasa menjalankan nilai-nilai, harus melakukannya tanpa nilai-nilai itu tampak sama konyolnya dengan yang diminta untuk menyebutkan setiap ekspresi, seperti:

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

alih-alih hanya menulis ekspresi di mana Anda membutuhkannya:

println(2 * a + b)

Notasi persis bervariasi dari bahasa ke bahasa; Bahasa Yunani tidak selalu dibutuhkan! ;-)

Ini mengacu pada kalkulus lambda , yang merupakan sistem formal yang hanya memiliki ekspresi lambda, yang mewakili fungsi yang mengambil fungsi untuk satu-satunya argumen dan mengembalikan fungsi. Semua fungsi dalam kalkulus lambda adalah dari jenis itu, yaitu λ : λ → λ,.

Lisp menggunakan konsep lambda untuk memberi nama literal fungsi anonimnya. Lambda ini mewakili fungsi yang mengambil dua argumen, x dan y, dan mengembalikan produk mereka:

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

Itu dapat diterapkan in-line seperti ini (mengevaluasi hingga 50 ):

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

Kalkulus lambda adalah teori substitusi matematika yang konsisten. Dalam matematika sekolah kita melihat misalnya x+y=5berpasangan dengan x−y=1. Bersamaan dengan cara untuk memanipulasi persamaan individual, juga memungkinkan untuk menyatukan informasi dari kedua persamaan ini, asalkan penggantian persamaan silang dilakukan secara logis. Kalkulus Lambda mengkodifikasi cara yang benar untuk melakukan penggantian ini.

Mengingat bahwa y = x−1ini adalah penataan ulang yang valid dari persamaan kedua, ini: λ y = x−1berarti fungsi pengganti simbol x−1untuk simbol y. Sekarang bayangkan menerapkan λ ysetiap istilah dalam persamaan pertama. Jika suatu term ykemudian melakukan substitusi; jika tidak lakukan apa-apa. Jika Anda melakukannya di atas kertas, Anda akan melihat bagaimana penerapannya λ yakan membuat persamaan pertama dapat dipecahkan.

Itu jawaban tanpa ilmu komputer atau pemrograman.

Contoh pemrograman paling sederhana yang dapat saya pikirkan berasal dari http://en.wikipedia.org/wiki/Joy_(programming_language)#How_it_works :

di sini adalah bagaimana fungsi kuadrat dapat didefinisikan dalam bahasa pemrograman imperatif (C):

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

Variabel x adalah parameter formal yang digantikan oleh nilai aktual yang akan dikuadratkan saat fungsi dipanggil. Dalam bahasa fungsional (Skema) fungsi yang sama akan didefinisikan:

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

Ini berbeda dalam banyak hal, tetapi masih menggunakan parameter formal x dengan cara yang sama.

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

Sedikit disederhanakan: fungsi lambda adalah fungsi yang dapat diteruskan ke fungsi lain dan logikanya diakses.

Dalam C # lambda sintaks sering dikompilasi ke metode sederhana dengan cara yang sama seperti delegasi anonim, tetapi juga dapat dipecah dan logikanya dibaca.

Misalnya (dalam C # 3):

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

LinqToSql dapat membaca fungsi itu (x> 15) dan mengubahnya menjadi SQL aktual untuk dieksekusi menggunakan pohon ekspresi.

Pernyataan di atas menjadi:

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

Ini berbeda dari metode normal atau delegasi anonim (yang sebenarnya hanyalah kompiler ajaib) karena mereka tidak dapat dibaca .

Tidak semua metode dalam C # yang menggunakan sintaks lambda dapat dikompilasi ke pohon ekspresi (yaitu fungsi lambda yang sebenarnya). Contohnya:

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

Sekarang pohon ekspresi tidak dapat dibaca - SomeComplexCheck tidak dapat dipecah. Pernyataan SQL akan dijalankan tanpa di mana, dan setiap baris dalam data akan dimasukkan SomeComplexCheck.

Fungsi Lambda tidak harus bingung dengan metode anonim. Contohnya:

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

Ini juga memiliki fungsi 'inline', tapi kali ini hanya kompiler ajaib - kompiler C # akan membagi ini menjadi metode instance baru dengan nama yang di-autogenerasi.

Metode anonim tidak dapat dibaca, sehingga logikanya tidak dapat diterjemahkan seperti untuk fungsi lambda.

Saya suka penjelasan Lambdas dalam artikel ini: Evolusi LINQ Dan Dampaknya Terhadap Desain C # . Bagi saya itu masuk akal karena menunjukkan dunia nyata untuk Lambdas dan membangunnya sebagai contoh praktis.

Penjelasan cepat mereka: Lambdas adalah cara untuk memperlakukan kode (fungsi) sebagai data.

Contoh lambda di Ruby adalah sebagai berikut:

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

hello.call

Akan menghasilkan output berikut:

Hello
I am inside a proc

@Brian Saya menggunakan lambdas sepanjang waktu di C #, di operator LINQ dan non-LINQ. Contoh:

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

Sebelum C #, saya menggunakan fungsi anonim di JavaScript untuk panggilan balik ke fungsi AJAX, sebelum istilah Ajax bahkan diciptakan:

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

Hal yang menarik dengan sintaks lambda C #, adalah bahwa pada tipe mereka sendiri tidak dapat disimpulkan (yaitu, Anda tidak dapat mengetik var foo = (x, y) => x * y) tetapi tergantung pada jenis mereka ditugaskan untuk, mereka akan dikompilasi sebagai delegasi atau pohon sintaksis abstrak yang mewakili ekspresi (yang adalah bagaimana pemetaan objek LINQ melakukan sihir "bahasa-terintegrasi").

Lambdas di LISP juga dapat diteruskan ke operator kutipan dan kemudian dilalui sebagai daftar daftar. Beberapa makro yang kuat dibuat dengan cara ini.

Pertanyaan ini dijawab secara formal, jadi saya tidak akan mencoba menambahkan lebih banyak tentang ini.

Dalam kata - kata informal yang sangat sederhana kepada seseorang yang hanya tahu sedikit atau tidak sama sekali tentang matematika atau pemrograman, saya akan menjelaskannya sebagai "mesin" atau "kotak" kecil yang membutuhkan input, membuat beberapa pekerjaan dan menghasilkan beberapa output, tidak memiliki nama tertentu , tapi kami tahu di mana itu dan hanya dengan pengetahuan ini, kami menggunakannya.

Secara praktis, untuk orang yang tahu apa fungsi itu, saya akan memberi tahu mereka bahwa itu adalah fungsi yang tidak memiliki nama, biasanya dimasukkan ke titik dalam memori yang dapat digunakan hanya dengan merujuk ke memori itu (biasanya melalui penggunaan sebuah variabel - jika mereka telah mendengar tentang konsep fungsi pointer, saya akan menggunakannya sebagai konsep yang serupa) - jawaban ini mencakup dasar-dasar yang cantik (tidak menyebutkan penutupan dll) tetapi orang bisa mendapatkan poin dengan mudah.

Anda dapat menganggapnya sebagai fungsi anonim - inilah beberapa info lebih lanjut: Wikipedia - Fungsi Anonim

Hanya karena saya tidak dapat melihat contoh C ++ 11 di sini, saya akan melanjutkan dan memposting contoh yang bagus dari sini . Setelah mencari, itu adalah contoh spesifik bahasa paling jelas yang bisa saya temukan.

Halo, Lambdas, versi 1

template<typename F>

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

Halo, Lambdas, versi 2:

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

Saya mengalami kesulitan membungkus kepala saya di sekitar ekspresi lambda karena saya bekerja di Visual FoxPro, yang memiliki subtitusi Makro dan fungsi ExecScript {} dan Evaluate (), yang tampaknya melayani banyak tujuan yang sama.

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

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

Satu manfaat pasti untuk menggunakan lambda formal adalah (saya berasumsi) memeriksa waktu kompilasi: Fox tidak akan tahu apakah Anda mengetikkan string teks di atas sampai ia mencoba menjalankannya.

Ini juga berguna untuk kode yang digerakkan oleh data: Anda dapat menyimpan seluruh rutinitas dalam bidang memo dalam database dan kemudian hanya mengevaluasinya pada saat dijalankan. Ini memungkinkan Anda mengubah sebagian aplikasi tanpa benar-benar memiliki akses ke sumbernya. (Tapi itu topik lain sama sekali.)

Untuk seseorang tanpa latar belakang komputer, apa itu lambda di dunia Ilmu Komputer?

Saya akan mengilustrasikannya secara intuitif langkah demi langkah dalam kode python yang sederhana dan mudah dibaca.

Singkatnya, lambda hanyalah fungsi anonim dan sebaris.

Mari kita mulai dari tugas untuk dipahami lambdassebagai mahasiswa baru dengan latar belakang aritmatika dasar.

Cetak biru penugasan adalah 'the name = value', lihat:

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

'x', 'y' adalah nama dan 1, 'nilai' adalah nilai. Coba fungsi dalam matematika

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

Laporan kesalahan,
Anda tidak dapat menulis matematika secara langsung sebagai kode, 'n' harus didefinisikan atau ditugaskan ke suatu nilai.

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

Ini berfungsi sekarang, bagaimana jika Anda bersikeras menggabungkan dua baris yang terpisah menjadi satu. Datanglambda

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

Tidak ada kesalahan yang dilaporkan.

Ini sekilas lambda, memungkinkan Anda untuk menulis fungsi dalam satu baris seperti yang Anda lakukan dalam matematika ke komputer secara langsung.

Kami akan melihatnya nanti.

Mari kita lanjutkan menggali lebih dalam pada 'tugas'.

Seperti yang diilustrasikan di atas, simbol sama =berfungsi untuk tipe data sederhana (1 dan 'nilai') dan ekspresi sederhana (n ** 2 + 2 * n + 1).

Coba ini:

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

Ini berfungsi untuk pernyataan sederhana, ada 11 jenis di python 7. Pernyataan sederhana - dokumentasi Python 3.6.3

Bagaimana dengan pernyataan majemuk,

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

Hadir defmemungkinkannya bekerja

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

Tada, analisis, 'm' adalah nama, 'n ** 2 + 2 * n + 1' adalah nilai. :adalah varian dari '='.
Temukan, jika hanya untuk pemahaman, semuanya dimulai dari penugasan dan semuanya penugasan.

Sekarang kembali ke lambda, kita memiliki fungsi bernama 'm'

Mencoba:

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

Ada dua nama 'm' di sini, fungsinya msudah memiliki nama, digandakan.

Ini memformat seperti:

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

Ini bukan strategi yang cerdas, jadi laporkan kesalahan

Kami harus menghapus salah satunya, mengatur fungsi tanpa nama.

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

Ini disebut 'fungsi anonim'

Kesimpulannya,

1. lambda dalam fungsi sebaris yang memungkinkan Anda untuk menulis fungsi dalam satu garis lurus seperti halnya dalam matematika
2. lambda adalah anonim

Semoga ini membantu.

Ini adalah fungsi yang tidak memiliki nama. Untuk misalnya dalam c # Anda dapat menggunakan

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

untuk mengembalikan angka yang lebih besar dari 5.

number => number > 5

adalah bagian lambda di sini. Ini mewakili fungsi yang mengambil parameter (angka) dan mengembalikan nilai boolean (angka> 5). Metode GetMatchingItems menggunakan lambda ini pada semua item dalam koleksi dan mengembalikan item yang cocok.

Dalam Javascript, misalnya, fungsi diperlakukan sebagai jenis campuran yang sama seperti segala sesuatu yang lain ( int, string, float, bool). Dengan demikian, Anda dapat membuat fungsi dengan cepat, menetapkannya untuk beberapa hal, dan memanggilnya kembali nanti. Ini berguna tetapi, bukan sesuatu yang ingin Anda gunakan berlebihan atau Anda akan membingungkan semua orang yang harus menjaga kode Anda setelah Anda ...

Ini adalah beberapa kode yang saya mainkan untuk melihat seberapa dalam lubang kelinci ini:

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

Dalam konteks CS fungsi lambda adalah konsep matematika abstrak yang menangani masalah evaluasi simbolik ekspresi matematika. Dalam konteks itu fungsi lambda sama dengan istilah lambda .

Tetapi dalam bahasa pemrograman itu sesuatu yang berbeda. Itu adalah bagian dari kode yang dinyatakan "di tempat", dan yang dapat diedarkan sebagai "warga negara kelas satu". Konsep ini tampaknya berguna sehingga masuk ke hampir semua bahasa pemrograman modern yang populer (lihat fungsi lambda di mana saja posting).

A Lambda Function, atau a Small Anonymous Function, adalah blok fungsi mandiri yang dapat diedarkan dan digunakan dalam kode Anda. Lambda memiliki nama berbeda dalam berbagai bahasa pemrograman - Lambdadengan Python dan Kotlin ,Closure dalam Swift , atau Blockdalam C dan Objective-C . Meskipun makna lambda sangat mirip untuk bahasa-bahasa ini, terkadang ada sedikit perbedaan.

Mari kita lihat bagaimana Lambda (Penutupan) bekerja di Swift 4.2 dengan metode sortir () - dari fungsi normal hingga ekspresi terpendek:

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

1. Fungsi Normal

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


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

2. Ekspresi Penutupan

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

3. Ekspresi Penutupan Inline

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

4. Jenis Inferring Dari Konteks

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

5. Pengembalian Tersirat dari Penutupan Ekspresi Tunggal

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

6. Nama Argumen Singkatan

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

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

7. Metode Operator

reverseOrder = coffee.sorted(by: >)

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

Semoga ini membantu.

Saya mengerti juga. Saya sudah mencobanya di JS dengan yang ini:

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

Ia menambah 2 hingga 4 lalu memvariasikan hasilnya dengan 6. Namun saya terkadang kesulitan membaca :(

Saya juga sudah membuat fungsi forEach yang menarik:

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

Metode ini akan mengulangi larik dan melakukan tindakan - dalam hal ini pencetakan ke konsol. Sekarang saya juga mengerti mengapa labmdas sangat kuat.

Dalam pemrograman komputer, lambda adalah bagian dari kode (pernyataan, ekspresi atau sekelompok dari mereka) yang mengambil beberapa argumen dari sumber eksternal. Itu tidak harus selalu menjadi fungsi anonim - kami memiliki banyak cara untuk mengimplementasikannya.

Kami memiliki pemisahan yang jelas antara ekspresi, pernyataan, dan fungsi, yang tidak dimiliki oleh ahli matematika.

Kata "fungsi" dalam pemrograman juga berbeda - kami memiliki "fungsi adalah serangkaian langkah yang harus dilakukan" (dari bahasa Latin "perform"). Dalam matematika itu adalah sesuatu tentang korelasi antar variabel.

Bahasa fungsional berusaha menjadi serupa dengan rumus matematika mungkin, dan kata-katanya hampir sama. Tetapi dalam bahasa pemrograman lain kami memilikinya berbeda.

Pertanyaannya telah dijawab sepenuhnya, saya tidak ingin masuk ke detail. Saya ingin berbagi penggunaan saat menulis perhitungan numerik dengan karat.

Ada contoh lambda (fungsi anonim)

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

Ketika saya sedang menulis modul metode Newton-Raphson, itu digunakan sebagai turunan urutan pertama dan kedua. (Jika Anda ingin tahu apa itu metode Newton – Raphson, silakan kunjungi " https://en.wikipedia.org/wiki/Newton%27s_method ".

Output sebagai berikut

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

f=98.000000       df=20.000000

Bayangkan bahwa Anda memiliki restoran dengan opsi pengiriman dan Anda memiliki pesanan yang perlu dilakukan dalam waktu kurang dari 30 menit. Intinya adalah klien biasanya tidak peduli jika Anda mengirim makanan mereka dengan sepeda dengan mobil atau bertelanjang kaki selama Anda menjaga makanan tetap hangat dan diikat. Jadi mari kita ubah idiom ini ke Javascript dengan fungsi transportasi anonim dan terdefinisi.

Di bawah ini kami menentukan cara pengiriman kami alias kami mendefinisikan nama ke fungsi:

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

Bagaimana jika kita akan menggunakan fungsi panah / lambda untuk melakukan transfer ini:

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

Anda lihat tidak ada perbedaan untuk klien dan tidak ada waktu untuk memikirkan cara mengirim makanan. Kirimkan saja.

Btw, saya tidak merekomendasikan kebap dengan coke, inilah mengapa kode atas akan memberi Anda kesalahan. Selamat bersenang-senang.