复习

[mtonhuang]

<script>
      /* shopee前端 */

      /*
      写一个class 对 主站搜索的关键词队列进行记忆和排序 队列最大维护n个关键词
      比如用户依次输入 维护5个
      a b c d e d e a
      结果需要为
      a e d c b （最近搜索的排前）
      */

      class Point {
        constructor(val, n) {
          this.val = val;
          this.n = n;
        }
        toSort() {
          const map = new Map();
          this.val
            .split('')
            .reverse()
            .forEach((item, index) => {
              map.set(item);
            });
          return [...map.keys()].splice(0, this.n).join('');
        }
      }
      var p = new Point('abcdedea', 5);
      // 'aedcb'
      console.log(p.toSort());
      console.log(Point === Point.prototype.constructor);
      console.log(p.constructor === Point.prototype.constructor);
      console.log(p.__proto__ === Point.prototype);

      // ==================================================

      const arr = [1, 4, 9];
      const newArr = arr.map(
        (x) => {
          console.log(x + this.a);
          return x + this.a;
        },
        { a: 1 }
      );
      console.log(newArr);

      // ===================================================

      window.name = 'linklogis';
      function A() {
        this.name = 123;
      }
      A.prototype.getA = function () {
        return this.name + 1;
      };
      let a = new A();
      let funcA = a.getA;
      funcA();
      console.log(funcA());

      // ===================================================
      // es6的扩展运算符 ... 相当于 Object.assign -> 第一层深拷贝,第二层以后浅拷贝。
      // let aClone = { ...a }; 等同于 let aClone = Object.assign({}, a);
      let obj1 = { a: 1, b: { c: 2 } };
      let obj2 = { ...obj1 };
      obj1.a = 3;
      console.log(obj1); // {a:3,b:{c:2}}
      console.log(obj2); // {a:1,b:{c:2}}
      obj2.a = 4;
      console.log(obj1); // {a:1,b:{c:2}}
      console.log(obj2); // {a:4,b:{c:2}}
      obj2.b.c = 5;
      console.log(obj1); // {a:1,b:{c:5}}
      console.log(obj2); // {a:1,b:{c:5}

      // ===================================================

      new Promise((resolve, reject) => {
        resolve('success');
      })
        .then(() => {
          throw Error('oh');
        })
        .catch((error) => {
          return 'yes';
        })
        .catch((error) => console.log(error.message))
        .then((error) => console.log(error.message));

      // ===================================================

      var p1 = new Promise(function (res, rej) {
        console.log('promise 1');
        res();
      });
      setTimeout(function () {
        console.log('setTime0');
      });
      var p2 = new Promise(function (res, rej) {
        setTimeout(() => {
          res(1);
        }, 0);
      });
      setTimeout(function () {
        console.log('setTime1');
      });
      for (let i = 0; i < 3; i++) {
        p2.then(function (val) {
          console.log('promise then -' + i);
        });
      }
      Promise.resolve().then(() => {
        console.log('promise then');
      });
      p1.then(function () {
        console.log('promise 1 resolved');
      });
      console.log('finished');

      // ===================================================

      const input = [
        { province: '广东', city: '深圳', area: '宝安' },
        { province: '广东', city: '深圳', area: '南山' },
        { province: '广东', city: '汕头', area: '潮阳' },
        { province: '广东', city: '广州', area: '天河' },
        { province: '浙江', city: '杭州', area: '西湖' },
      ];
      function updateList() {
        let output = [];
        input.forEach((item) => {
          let provinceIdx = output.findIndex((sitem) => sitem.value === item.province);
          if (provinceIdx === -1) {
            output.push({
              value: item.province,
              children: [
                {
                  value: item.city,
                  children: [
                    {
                      value: item.area,
                    },
                  ],
                },
              ],
            });
          } else {
            let cityIdx = output[provinceIdx].children.findIndex(
              (csitem) => csitem.value === item.city
            );
            if (cityIdx === -1) {
              output[provinceIdx].children.push({
                value: item.city,
                children: [{ value: item.area }],
              });
            } else {
              output[provinceIdx].children[cityIdx].children.push({
                value: item.area,
              });
            }
          }
        });
        return output;
      }

      console.log(updateList(input), 2131231);

      // const output = [
      //   {
      //     value: '广东',
      //     children: [
      //       {
      //         value: '深圳',
      //         children: [{ value: '宝安' }, { value: '南山' }],
      //       },
      //       {
      //         value: '汕头',
      //         children: [{ value: '潮阳' }],
      //       },
      //     ],
      //   },
      //   {
      //     value: '浙江',
      //     children: [
      //       {
      //         value: '杭州',
      //         children: '西湖',
      //       },
      //     ],
      //   },
      // ];

      // ===================================================

      // 求一个数平方根，保留三位小数

      function funSqrt(x) {
        let left = 1,
          right = x;
        while (left <= right) {
          let mid = left + ((right - left) >> 1);
          if (mid <= x / mid) {
            if (mid + 1 > x / (mid + 1)) {
              return mid;
            }
            left = mid + 1;
          } else {
            right = mid - 1;
          }
        }
        return 0;
      }

      /* 富途前端 */

      // 实现Promise.all 有一个失败就输出，否则全部

      let promise1 = new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve('1');
        }, 1000);
      });
      let promise2 = new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve('2');
        }, 3000);
      });
      let promise3 = new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve('3');
        }, 1000);
      });
      // console.log(promise1);
      // console.log(promise2);
      // console.log(promise3);
      // Promise.all([promise1, promise2, promise3])
      //   .then((res) => {
      //     console.log(res);
      //   })
      //   .catch((err) => console.log(err));

      Promise.testAll = function (promiseArr) {
        return new promise((resolve, reject) => {
          let arr = [],
            num = 0;
          promiseArr.forEach((item, index) => {
            Promise.resolve(item)
              .then((res) => {
                arr[index] = res;
                num += 1;
                if (num === promiseArr.length) resolve(arr);
              })
              .catch((error) => {
                reject(error);
              });
          });
        });
      };

      // 实现Promise.race 输出最快promise
      Promise.testRace = function (promiseArr) {
        return new promise((resolve, reject) => {
          promiseArr.forEach((item) => {
            Promise.resolve(item)
              .then((res) => {
                resolve(res);
              })
              .catch(() => {
                reject();
              });
          });
        });
      };

      // 实现Promise.any 全部失败输出，否则任意一个
      Promise.any = function (promiseArr) {
        return new promise((resolve, reject) => {
          let arr = [],
            num = 0;
          promiseArr.forEach((item, index) => {
            Promise.resolve(item)
              .then()
              .catch((err) => {
                arr[index] = { status: 'reject', val: err };
                num += 1;
                if (num === promiseArr.length) reject(new Error('没有promise成功'));
              });
          });
        });
      };

      // 爬楼梯 记忆化递归
      /* 1.先对n为0这种特殊情况进行处理，然后n为1和2时直接return即可
         2.memo数组：存储中间结果，避免重复计算
         3.接下来就是判断memo[n]是否存在，如果计算过即存在，直接返回，无需重复计算；若不存在，则进行递归计算，为前两个之和。
      */
      const memo = new Map();
      var climbStairs = function (n) {
        const memo = [];
        if (n === 0) return 1;
        if (n <= 3) return n;
        if (memo[n]) {
          return memo[n];
        } else {
          memo[n] = climbStairs(n - 1) + climbStairs(n - 2);
        }
        return memo[n];
        /* 或者 map实现
        if (n === 0) return 1;
        if (n <= 3) return n;
        if (memo.get(n)) {
          return memo.get(n);
        } else {
          memo.set(n, climbStairs(n - 1) + climbStairs(n - 2));
        }
        return memo.get(n);
      */
      };

      console.log(climbStairs(6));

      // 爬楼梯 常规
      var climbStairs1 = function (n) {
        const memo = [];
        memo[0] = 1;
        memo[1] = 1;
        for (let i = 2; i <= n; i++) {
          memo[n] = memo[n - 1] + memo[n - 2];
        }
        return memo[n];
      };

      /*  22. 括号生成
      数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
      示例 1：
      输入：n = 3
      输出：["((()))","(()())","(())()","()(())","()()()"]
      示例 2：
      输入：n = 1
      输出：["()"]
      */

      var generateParenthesis = function (n) {
        let set = new Set(['()']);
        for (let i = 2; i <= n; i++) {
          let setChild = new Set();
          for (let item of set) {
            for (let j = 0; j < item.length; j++) {
              setChild.add(item.slice(0, j) + '()' + item.slice(j));
            }
          }
          set = setChild;
        }
        return [...set];
      };

      /*前端基础*/

      // 原型链
      // prototype => 原型对象 ；constructor => 我们称为构造函数,因为它指回构造函数本身
      // 对象原型(proto) 和构造函数( prototype )原型对象里面都有一个属性 constructor属性
      let Fun = function () {}; // => 构造函数
      let fun = new Fun(); // => 实例对象

      // 构造函数 <-> 原型对象 实例对象 <-> 实例对象
      Fun.prototype == fun.__proto__;
      Fun.prototype.constructor === Fun;
      fun.__proto__.constructor === Fun;

      // 实现call
      Function.prototype.callTest = function (context) {
        context = context || window;
        context.fn = this;
        let args = [];
        for (let i = 0; i < arguments.length; i++) {
          args.push('arguments[' + i + ']');
        }
        // var result = context.fn(...args);
        var result = eval('context.fn(' + args + ')'); // eval里的args会自动执行array.toString()
        delete context.fn;
        return result;
      };

      // 实现深拷贝
      function deepClone(obj, hash = new WeakMap()) {
        // 用hash值记录防止循环引用
        if (hash.has(ojb)) {
          return obj;
        }
        let res = null;
        const reference = [Date, Set, RegExp, WeakSet, Map, WeakMap, Error];
        if (reference.includes(obj?.constructor)) {
          res = new obj.constructor(obj);
        } else if (Array.isArray(obj)) {
          res = [];
          obj.forEach((item, index) => {
            res[index] = deepClone(item);
          });
        } else if (typeof obj === 'object' && obj !== null) {
          res = {};
          for (const key in obj) {
            // JavaScript 并没有保护 hasOwnProperty 这个属性名,
            // 可能存在你使用的对象也有这个属性，所以可以使用 Object 原型上的 hasOwnProperty 属性
            if (Object.hasOwnProperty.call(obj, key)) {
              // 偷懒就是直接 obj.hasOwnProperty(key)
              res[key] = deepClone(obj[key]);
            }
          }
          // 用hash值记录防止循环引用
          hash.set(obj, res);
        } else {
          res = obj;
        }
        return res;
      }
    </script>