想象一下，你有一家餐厅提供送货服务，你的订单需要在30分钟内完成。关键是客户通常不在乎你是骑自行车送食物还是赤脚送食物，只要你保持食物的温度并系好。因此，让我们将这个习惯用法转换为带有匿名和定义的传输函数的Javascript。

下面我们定义了交付的方式，也就是我们定义了函数的名称：

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

如果我们使用箭头/lambda函数来完成此传输会怎么样：

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

你看，对客户来说并没有什么区别，也并没有浪费时间去思考如何发送食物。只要发送它。

顺便说一句，我不推荐用可乐烤串，这就是为什么上面的代码会给你错误。玩得高兴

lambda演算是一种一致的替代数学理论。例如，在学校数学中，人们可以看到x+y=5与x−y=1配对。除了处理单个方程的方法外，还可以将这两个方程的信息放在一起，前提是交叉方程的替换是合乎逻辑的。Lambda演算编纂了进行这些替换的正确方法。

假设y=x−1是第二个方程的有效重排，这：λy=x–1表示用符号x−1代替符号y的函数。现在想象将λy应用于第一个方程中的每个项。如果项是y，则执行替换；否则什么都不做。如果你在纸上这样做，你会看到应用λy将如何使第一个方程可解。

这是一个没有任何计算机科学或编程的答案。

我能想到的最简单的编程示例来自http://en.wikipedia.org/wiki/Joy_（编程语言）#如何工作：

下面是如何在命令中定义平方函数编程语言（C）：int平方（int x）{返回x*x；}变量x是一个形式参数，由实际调用函数时要平方的值。在函数中语言（方案）将定义相同的功能：（定义正方形（λ（x）（*x x）））这在很多方面都不同，但它仍然使用形式参数x以相同的方式。

---

补充：http://imgur.com/a/XBHub

lambda是一种内联定义的函数类型。除了lambda之外，通常还有某种类型的变量类型，可以保存对函数lambda或其他函数的引用。

例如，这里有一段不使用lambda的C#代码：

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

这调用Calculator，不仅传递两个数字，还传递要在Calculator中调用的方法以获得计算结果。

在C#2.0中，我们得到了匿名方法，这将上述代码缩短为：

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

然后在C#3.0中，我们得到了lambdas，这使得代码更短：

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来自Lambda演算，指编程中的匿名函数。

为什么这么酷？它允许您在不命名的情况下编写快速丢弃函数。它还提供了一种编写闭包的好方法。有了这种力量，你可以做这样的事情。

蟒蛇

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

从Python片段中可以看到，函数加法器接受一个参数x，并返回一个接受另一个参数y的匿名函数或lambda。该匿名函数允许您从函数创建函数。这是一个简单的例子，但它应该传达lambdas和闭包的强大功能。

其他语言示例

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

计划

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

C#3.5或更高

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

敏捷的

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

哈斯克尔

(\x y -> x + y) 

Java查看此帖子

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

科特林

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

Ruby

Ruby稍有不同，因为不能使用与调用函数完全相同的语法调用lambda，但它仍然有lambda。

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

Ruby是Ruby，有一个lambdas的简写，所以您可以这样定义加法器：

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

R

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

我喜欢这篇文章中对Lambdas的解释：LINQ的演变及其对C#设计的影响。这对我来说很有意义，因为它为Lambdas展示了一个真实的世界，并将其作为一个实际的例子。

他们的快速解释：Lambdas是将代码（函数）视为数据的一种方式。

在CS的上下文中，lambda函数是一个抽象的数学概念，它解决了数学表达式的符号求值问题。在这种情况下，lambda函数与lambda项相同。

但在编程语言中，这是不同的。这是一段被宣布为“到位”的代码，可以作为“一流公民”传递。这个概念似乎很有用，因此它几乎进入了所有流行的现代编程语言（参见lambda函数everwhere post）。