1.0.1+0.2约等于0.3

2.  /* reduce求和 */   
  let arr = [1, 2, 3, 4];
      /* reduce求和 */
      const sum = arr.reduce((pre, cur) => {
        return pre + cur;
      });
// sum = 10

3./* 计算数组中每个元素出现的次数  */
      let names = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
      const nameNum = names.reduce((pre, cur) => {
        if (cur in pre) {
          pre[cur]++;
        } else {
          pre[cur] = 1;
        }
        return pre;
      }, {}); // reduce第二个参数设定为初始值(这里为{})
// {Alice: 2, Bob: 1, Tiff: 1, Bruce: 1}

4./* 数组去重 */
      let arr = [1, 2, 3, 4, 4, 1];
      let newArr = arr.reduce((pre, cur) => {
        if (pre.includes(cur)) {
          // includes() 方法用于判断字符串是否包含指定的子字符串，如果找到匹配的字符串则返回 true，否则返回 false。
          return pre;
        } else {
          return pre.concat(cur); // concat() 方法用于连接两个或多个数组,该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
        }
      }, []);

5.  /* 数组降维 */
     //  将二维数组转化为一维
      let arr = [
        [0, 1],
        [2, 3],
        [4, 5],
      ];
      let newArr = arr.reduce((pre, cur) => {
        return pre.concat(cur);
      }, []);

6. // 将多维数组转化为一维
      let arr = [
        [0, 1],
        [2, 3],
        [4, [5, 6, 7]],
      ];
      const newArr = function (arr) {
        return arr.reduce(
          // isArray() 方法用于判断一个对象是否为数组,如果对象是数组返回 true，否则返回 false。
          (pre, cur) => pre.concat(Array.isArray(cur) ? newArr(cur) : cur), // 使用递归
          []
        );
      };

7.vue2双向绑定原理：数据劫持: vue.js 则是采用数据劫持结合发布者-订阅者模式的方式，通过Object.defineProperty()来劫持各个属性的setter，getter，在数据变动时发布消息给订阅者，触发相应的监听回调。

8.flex: 1等于flex-grow：1 flex-shrink：1 flex-basis：0%。

9.基本类型：Number Boolean  String  undefined null
   引用类型：Object  Function
   基本类型的数据是存放在栈内存中的，而引用类型的数据是存放在堆(由程序员分配释放)内存中的

10.  // 定义一个深拷贝函数  接收目标target参数
    function deepClone(target) {
      // 定义一个变量
      let result;
      // 如果当前需要深拷贝的是一个对象的话
      if (typeof target === "object") {
        // 如果是一个数组的话
        if (Array.isArray(target)) {
          result = []; // 将result赋值为一个数组，并且执行遍历
          for (let i in target) {
            // 递归克隆数组中的每一项
            result.push(deepClone(target[i]));
          }
          // 判断如果当前的值是null的话；直接赋值为null
        } else if (target === null) {
          result = null;
          // 判断如果当前的值是一个RegExp对象的话，直接赋值
        } else if (target.constructor === RegExp) {
          result = target;
        } else {
          // 否则是普通对象，直接for in循环，递归赋值对象的所有值
          result = {};
          for (let i in target) {
            // for in得到对对象的key或数组,字符串的下标
            result[i] = deepClone(target[i]);
          }
        }
        // 如果不是对象的话，就是基本数据类型，那么直接赋值
      } else {
        result = target;
      }
      // 返回最终结果
      return result;
    }

11. js冒泡排序
function bSort(arr) {
      // len = 5
      let len = arr.length;
      for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - 1 - i; j++) {
          // 相邻元素两两对比，元素交换，大的元素交换到后面
          if (arr[j] > arr[j + 1]) {
            let temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
          }
        }
      }
      return arr;
    }

    //举个数组
    let myArr = [20, 18, 27, 19, 35];
    //使用函数
    bSort(myArr);

12.箭头函数体内的this对象，就是定义该函数时所在的作用域(父级)指向的对象，而不是使用时所在的作用域指向的对象。

13.this的值是在函数执行时决定的，不是在函数定义时决定

14.实现new
     function myNew(Func, ...args) {
          // 1.创建一个新对象
          const obj = {}
          // 2.新对象原型指向构造函数原型对象
          obj.__proto__ = Func.prototype
          // 3.将构建函数的this指向新对象
          /** apply接受两个参数，第一个参数是this的指向，第二个参数是函数接受的参数，以数组      
         的形式传入,改变this指向后原函数会立即执行，且此方法只是临时改变this指向一次 */
          let result = Func.apply(obj, args)
          // 4.根据返回值判断
          return result instanceof Object ? result : obj
      }