在js中，lambda表达式在计算机科学中表示匿名函数，理解为就是es6中的箭头函数——lambda表达式基本用法 & 箭头函数特点 & es6删除一个对象的属性，不改变原始对象

在js中，lambda表达式在计算机科学中表示匿名函数，理解为就是es6中的箭头函数——lambda表达式基本用法 & 箭头函数特点 & es6删除一个对象的属性，不改变原始对象

lambda在计算机科学中表示匿名函数，本质上是用来简化操作的。简单来说，是一种表示方法，代表了一定的输入和输出。

之所以lambda表达式又被称为箭头函数，是因为它的语法是这样的：

let func = (arg1,arg2,...,argN) => { expression; }

可能首次接触lambda表达式的童鞋会非常奇怪，不能理解，实际上非常简单，它其实就是以下代码的简写：

let func = function(arg1,arg2,...,argN){
	return expression;
}

区别在于函数表达式需要用到function关键词，而lambda表达式省略了这个关键字，转而在参数列表和函数体之间添加了一个=>，这也是箭头函数的来源。

比如：

let add = (a,b) => a+b;
//以上表达式等价于
/*
let add = function(a,b){
	return a+b;
}
*/

(a,b) => a+b表示创建一个函数，接收a、b两个参数，并返回二者的和。
这里省略了函数定义关键字function和return。

1、基本介绍

在 JavaScript 中，您可以将函数放入变量中或将其作为参数传递。

setTimeout(function () {
    console.log('1 second has passed!')
}, 1000)

比如：编写一个函数，它接受一个数字并以两种不同的方式返回该数字的两倍。

// anonymous function
function (num) {
  return num * 2
}
 
// lambda expression
(num) => {
  return num * 2
}

如果你并排看，很容易看出他们有什么样的对应关系！

// 匿名函数写为
function (argument) {/ * 逻辑代码 * /}
// 而 lambda 表达式写为
(argument) => {/ * some processing * /}。

Lambda 表达式有时被称为箭头函数，因为它们是使用箭头编写的。

• 由于使用了 lambda 表达式，8 个字符的“ function”现在变成了 2 个字符=>。

2、用法

允许您编写更短的 lambda 表达式的条件

实例1、函数只有一个参数

()仅当 from， lambda表达式定义函数只有一个参数时，您才能省略它。

1

let bol = x => !!x; //将变量x转为Boolean类型

//等价于
/* 
let bol = (x) => !!x;
*/

2

// before
(num) => {
  return num * 2
}
 
// after
num => {
  return num * 2
}

• 如果没有参数或者有两个或多个参数，则不能省略括号。

1

// 没有参数的表达式，需要使用空括号，但是不能使用
let hello_world = () => console.log('hello world');

2

// 0 arguments
() => {
  console.log('cannot omit parentheses！')
}
 
// 2 or more arguments
(a, b, c) => {
  return a + b + c
}

实例2、当有一个进程时

// before
() => {
  console.log('Hello world!')
}
 
// after
() => console.log('Hello world!')

• 当有两行或多行时，大括号不能省略。这是一个示例供您参考。

1

// 以上案例都是只有一行代码的函数，如果我们需要在函数体中写入多行代码，就需要为函数体加上{}同时使用return返回计算结果。
let add = () => {
	let n1 = prompt('其输入一个整数',0);
	let n2 = prompt('请输入一个整数',0);
	return +n1 + +n2;//计算两个输入值的和
}
console.log(add());

2

// cannot omit curly braces because there are 2 lines
(a, b) => {
  let result = a + b
  console.log(result)
}

实例3、当处理回调函数（只是一个return语句）时

如果唯一的处理是返回语句，则return除了大括号之外，您还可以省略该字母。

1 、在回调中使用lambda表达式（最常用）

function calculate(a,b,func){
	return func(a,b); //使用回调函数
}

//使用lambda传入一个函数用于回调
calculate(1,2,(a,b)=>a+b); //3
calculate(1,2,(a,b)=>a*b); //2

2

// before
(a, b) => {
  return a + b
}
 
// after
(a, b) => a + b

用 lambda 表达式编写要容易得多。

允许您使用示例编写更短的 lambda 表达式的条件，汇总如下：

场景——接收一个数字并将其加倍的函数按顺序转换为 lambda 表达式

// anonymous function
function (num) {
  return num * 2
}
 
// lambda expression (no omit)
(num) => {
  return num * 2
}
 
// omit () because there is only one argument
num => {
  return num * 2
}
 
// omit {} because there is only one processing
num => return num * 2
 
// omit letter 'return' because processing is only a return statement
num => num * 2  // 最简写法

• 最终形式num => num \* 2是实现您想要实现的目标的直观表达，将作为参数接收的值加倍。

3、箭头函数

3.1、() => {} 箭头函数的基本特点

es6中的箭头函数，通常来说会有几个特点：

• 箭头函数中的this会绑定在外部作用域
• 没有arguments
• 如果想返回一个对象记得加()包裹
• call和apply不能传入this

(() => {a: 1})() //返回值为undefiend，想返回对象，使用下面的方式
(() => ({a: 1})()

实例

es6 删除一个对象的属性，不改变原始对象

const obj =  {
  name: '李世民',
  gender: 'male',
  age: 24
};

const objNew = (({
	name,
	gender
}) => ({
	name,
	gender
}))(obj)

console.log(obj)  // {name: '李世民', gender: 'male', age: 24}
console.log(objNew)  // {name: '李世民', gender: 'male'}

场景——实现一个平方运算表达（x * x）

// js写法
(function (x) {
  return x * x;
})()

// 在平方的基础上再加2(x * x + 2): 
(function(x) {
  return x + x
})((function () {
  return x * x
})())

其实就是利用了匿名函数然后，再继续嵌套。
但是有了箭头函数，就可以更加简便地实现上面的操作：

(x => x + 2)((x => x * x)())

上面这种方式，不是特别优雅，可读性不好，需要一种能够更加优雅地方式。上面的行为抽象出来就是：前一个的输出作为后一个函数的输入，应该怎么实现呢？

Javascript中提供了reduce这一个方法。

const action = [
  x => x * x,
  x => x + 2
];

let res = action.reduce((res, cur) => cur(res), 2);

总结：从上面的过程可以看出来，有两个主要的关键过程：

• 1、箭头函数是一个匿名函数，简化书写
• 2、箭头函数作为变量传递给reduce函数的回调

所以箭头函数在很大程度上，简化了函数式的操作。其实lambda表达式，在Javascript中就是匿名函数。

3.2、箭头函数使用总结：

• 箭头函数适合纯函数的操作，比如map、filter、reduce等操作
• 箭头函数内部，一般不要使用this，因为this是和外部作用域绑定的，容易产生问题

实例1

function A() {
  this.foo = 1
}

A.prototype.bar = () => console.log(this.foo)

let a = new A()
a.bar()  //undefined

因为对象a，并没有构成一个作用域。

如果想让this指向A，可以这样写：

function A() {
  this.foo = 1;
  this.bar = () => {
    console.log('value', this.foo);
  }
}
let a = new A();
a.bar(); //1

因为bar的声明在函数A的作用域内部。

实例2

const A = {
  foo: 1,
  bar: () => {
    console.log('value', this.foo);
  }
}
let a = Object.create(A);
a.bar(); //undefined

如果想输出正常的值，应该使用function定义：

const A = {
  foo: 1,
  bar: function (){
    console.log('value', this.foo);
  }
}
let a = Object.create(A);
a.bar(); // value 1