保证代码质量

单元测试：

示例代码：

var add = (a, b)=> a + b;
var expect = function(res){
    return {
        toBe: (actual)=>{
            if (res !== actual){
                throw new Error("期望值与预期值不符！");
            }
        }
    };
};
expect(add(1,2)).toBe(3);
var test = (desc, func)=>{
    try {
        func();
    }
    catch(e){
        console.log(`${desc}没有通过测试`);
    }
};
test("加法测试", ()=>{
    expect(add(1,2)).toBe(3);
});

Jest 单元测试框架：

Jest的安装：
1. 安装node， npm i -D jest 或 yarn add -D jset
2.npm ls jest 来查看是否安装成功；

单元测试步骤：

math.js

var add = function(a,b){
    return a+b;
}
module.exports = {add};

math.test.js

const {add} = require("./math");
test("加法测试", ()=>{
    expect(add(2,2)).toBe(3);
});

{
  "name": "",
  "version": "",
  "scripts": {
    "test": "jest"
  },
  "devDependencies": {
    "jest": "^25.2.4"
  }
}

命令式编程：详细的命令机器怎么去处理一件事情以达到你想要的结果。

函数式编程：
函数式编程是一种编程范式，是一种构建计算机程序结构和元素的风格。它把计算看做是对数据函数的评估，避免了状态变化和数据的可变。

代码示例：

let arr = [1,2,3,4];
let newArr = (arr, fn) =>{
    let res = [];
    for(let i = 0; i < arr.length; i++){
        res.push(fn(arr[i]));
    }
    return res;
};
let add = (item) => item + 1;
let double = (item) => item * 2;
let sum = newArr(arr, add);
let multiple = newArr(arr, double);
console.log(sum);
console.log(multiple);

纯函数：
如果函数的调用参数相同，则永远返回相同的结果。他不依赖于程序执行期间函数任何状态或数据的变化，必须只依赖于其输入参数。

函数副作用：
当调用函数时，除了返回函数值之外，还对主调用函数产生附加的影响；例如，修改全局或修改参数等。

保证函数无副租用的特性：
1,函数入口使用参数运算，而不修改它；
2.函数内不修改函数外的变量；
3运算结果通过函数返回给外部（而不是通过修改参数使外部获得改变）；

可变性和不可变性：
可变性是指一个变量创建以后可以任意修改；
不可变性是指一个变量，一旦创建，就永远不会发生改变，不可变性是函数式编程的核心概念。

相关代码示例：

// 函数式编程思想
let arr = [1, 2, 3, 4];
let newArr = (arr, fn) => {
  let res = [];
  for (let i = 0; i < arr.length; i++) {
    res.push(fn(arr[i]));
  }
  return res;
}
let add = item => item + 5;
let multi = item => item * 5;
let sum = newArr(arr, add);
let product = newArr(arr,multi);
console.log(sum);
console.log(product);
// 纯函数
let discount = 0.8;
let price = calculatePrice(200);
console.log(price); // 160
discount = 0.9;
price = calculatePrice(200);
console.log(price); // 180
let a = 5;
let foo = () => a = a * 10;
foo();
console.log(a); // 50
// 依赖注入
const foo = (d, log, something) => {
  const dt = d.toISOString();
  return log(`${dt}: ${something}`);
}
const something = '你好网易';
const d = new Date();
const log = console.log.bind(console);
foo(d,log,something);
// 深拷贝
let data = { count: 1 };
let foo = (data) => {
  let lily = JSON.parse(JSON.stringify(data));
  lily.count = 3;
}
console.log(data.count);
// 调用foo函数
foo(data);
console.log(data.count);