Hydra

判断一个对象为空对象的几种方法

方法一:

将对象转换成字符串

let obj = {}
console.log(JSON.stringfy(obj) === "{}")

方法二:

for in 循环

let res = function(obj){
    for(let key in obj){
        return false;
    }
    return ture;
}
console.log(obj);

方法三:

console.log(Object.keys(obj).length);

方法四:

console.log(Object.getOwnPropertyNames(obj).length === 0)

用reduce实现Map

用reduce实现Map

Array.prototype._map = function (fn, thisArg){
        const result = [];
        this.reduce((prev, curr, index, array) => {
          result[index] = fn.call(thisArg, array[index], index, array);
        }, 0);
        return result;
      }

手写trim

String.prototype._trim = function (str){
        let i, j;
        for(i = 0; i < str.length; i++){
          if(str[i] !== ' ') break;
        }

        for(j = str.length - 1; j >= 0; j--){
          if(str[j] !== ' ') break;
        }
        return str.slice(i, j + 1);
      }

手写Promise

function proAll(promises){

        let len = promises.length;
        let result = Array(len);
        let countEnd = 0;

        return new Promise((resolve, reject) => {
          if(len === 0) resolve(result);

          for(let i = 0; i < len; i++){
            let promise = promises[i];

            Promise.resolve(promise).then(
              (data) => {
                result[countEnd++] = data;
                if(countEnd === len) resolve(result);
              },
              (err) => {
                reject(err);
              }
            );
          }
        });
      } 

      const promise1 = Promise.resolve(3);
      const promise2 = 42;
      const promise3 = new Promise((resolve, reject) => {
        setTimeout(resolve, 100, 'foo');
      });
      console.log(proAll([promise1, promise2, promise3]));

闭包的两个作用

// 封装私有变量
function Nin(){
        let private = 10;

        this.getPrivate = function (){
          return private;
        }

        this.addPrivate = function (){
          private++;
        }
      }

      let nin = new Nin();

      console.log(nin.private);

      console.log(nin.getPrivate());
      nin.addPrivate();
      console.log(nin.getPrivate());


// 处理回调函数

function fun(){
        let tick = 0;
        console.log("tick init", tick);
        const timer = setInterval(() => {
          if(tick < 100){
            console.log('tick is less then 100', tick);
            tick += 1;
          }
          else {
            clearInterval(timer);
            console.log('now tick is ', tick);
          }
        }, 10);
        
      }
      fun();

手写二叉树

function TreeNode(val, left, right){
      this.val = (val === undefined ? 0 : val);
      this.left = (left === undefined ? null : left);
      this.right = (right === undefined ? null : right);
    }

手写promise.race

function PromiseRace(promises){
      if(!Array.isArray(promises)) throw new Error('promise must be an array');

      return new Promise(function (resolve, reject) {
        promises.forEach(p => resolve(p), err => reject(err));
      })
    }

手写promise

class Promise{
  constructor(fn) {
    this.status = 'pending';
    this.resolve = undefined;
    this.reject = undefined;

    let resolve = val => {
      if(this.status === 'pending'){
        this.status = 'resolved';
        this.resolve = val;
      }
    }

    let reject = val => {
      if(this.status === 'pending'){
        this.status = 'rejected';
        this.reject = val;
      }
    }

    try {
      fn(resolve, reject);
    }
    catch(e) {
      reject(e);
    }
  }
  then (onResolved, onRejected){
    if(this.status === 'resolved') onResolved(this.resolve);
    if(this.status === 'rejected') onRejected(this.reject);
  }
}

手写防抖

function debounce(fn, wait){
      let timer = null;
      let args = arguments;
      return new function(){
        if(timer !== null){
          clearTimeout(timer)
        }
        else {
          timer = setTimeout(() => {
            fn.apply(this, args);
          }, wait);
        }
      }
    } 

手写节流

function throttle(fn, wait){
      let curTime = new Date();

      return function(){
        let context = this,
            args = arguments,
            nowTime = new Date();
          if(nowTime - curTime >= wait){
            fn.apply(context, args);
          }
      }
    }