变量|常量-函数|匿名函数|箭头函数-闭包-高阶函数

变量|常量-函数|匿名函数|箭头函数-闭包-高阶函数

1. 实例演示变量与常量的区别;
2. 函数与匿名函数的区别
3. 箭头函数的参数特征
4. 闭包原理与实现并演示它
5. 四种高阶函数，全部实例演示，并理解回调和纯函数是什么，写出你的答案

1. 实例演示变量与常量的区别

• 变量：可以先声明，后赋值，再更新；
• 常量：必须在声明时赋值，后不能更新和删除。
• 变量和常量都不可重复声明（var 声明除外）

// 变量
let a;
// 未初始化变量，输出 undefined
console.log(a);
// 变量赋值
a = 0;
// 输出 0
console.log(a);
// 变量更新
a = 1;
// 输出 1
console.log(a);
// 初始化时赋值
let b = 2;
// 输出 2
console.log(b);
// 常量
const c = 3;
// 输出 3
console.log(c);

2. 函数与匿名函数的区别

• 函数：有函数名，函数可以重写；
• 匿名函数：没有函数名的函数，可以赋值给一个常量，防止重写，更新。

// 函数
function sum1(a, b) {
    return a + b;
}
// 函数输出 1 + 2 输出 3
console.log(sum1(1, 2));
// 匿名函数
const sum2 = function(a, b) {
    return a + b;
}
// 匿名函数 2 + 3 输出 5
console.log(sum2(2, 3));

3. 箭头函数的参数特征

• 箭头函数简化匿名函数的声明
• 箭头函数参数特征：
  • 没有参数时，参数 () 不能省略
  • 只有一个参数时，参数 () 可以省略
  • 两个或多个参数，参数 () 不能省
  • 多条语句时，函数体 {} 不能省

// 没有参数时，参数 () 不能省略
let sum = () => true;
// 返回 true
console.log(sum());
// 只有一个参数时，参数 () 可以省略 
sum = (a) => a;
sum = a => a;
// 返回 0
console.log(sum(0));
// 两个或多个参数，参数 () 不能省
sum = (a, b) => a + b;
// 返回 3;
console.log(sum(1, 2));
// 多条语句时，函数体 {} 不能省
sum = (a, b) => {
    let c = a + b;
    return c;
}
// 返回 5
console.log(sum(2, 3));

4. 闭包原理与实现并演示它

• 闭包：能访问自由变量的函数
• 自由变量：存在函数调用的上下文中，不是函数自身的参数变量，也不是函数内部的私有变量

let x = 1;
// 函数 y 内访问自由变量 x，函数 y 是闭包函数
let y = () => x;
// 返回 1
console.log(y());
// 函数 s 内访问自由变量 x ，函数 s 是闭包函数
let s = () => {
    // 变量 y 对函数 s 是私有变量
    let y = x + 1;
    // 变量 y 对函数 z 是自由变量，函数 z 也是闭包函数 
    let z = () => x + y;
    return z;
}
// 返回 3
console.log(s()());

5. 四种高阶函数，全部实例演示，并理解回调和纯函数是什么，写出你的答案

高阶函数: 使用函数为参数或者将函数做为返回值的函数

• 回调函数：使用函数作为参数传递

// 回调函数
let fa = a => a();
let foo = () => 'foo';
// 把函数 foo 作为参数传递给函数 fa，foo 是回调函数
console.log(fa(foo));

• 偏函数：简化声明

// 偏函数：简化声明
fa = (a, b) => {
    return c => a + b + c;
}
// 返回 6
console.log(fa(1, 2)(3));

• 柯里化：简化调用参数

// 柯里化：简化调用参数
fa = a => b => c => a + b + c;
// 返回 9
console.log(fa(2)(3)(4));

• 纯函数：返回值只能受到传入的参数影响

// 纯函数
fa = a => a;
console.log(fa(true));