笔试题

1、js 格式化数字，每三位加逗号

function toThousands(str, space) {
    let newStr = str
    let result = ''
    while (newStr.length > space) {
        result = ',' + newStr.slice(-space) + result
        newStr = newStr.slice(0, newStr.length - space)
    }
    if (newStr) {
        result = newStr + result
    }
    return result
}

console.log(toThousands('120060084009', 3))

2、自己实现apply方法

Function.prototype.apply = function (context = window) {
  context.fn = this
  let result;
  // 判断是否有第二个参数
  if (arguments[1]) {
    result = context.fn(...arguments[1])
  } else {
    result = context.fn()
  }
  delete context.fn()
  return result
}

3、自己实现bind方法

Function.prototype.myBind = function(){
    // 1、保存函数
    let _this = this;
    // 2、保存目标对象
    let context = arguments[0] || window;
    // 3、保存目标对象之外的参数,将其转化为数组;
    let rest = [].slice.call(arguments,1);
    // 4、返回一个待执行的函数
    return function F(){
        // 5、将二次传递的参数转化为数组;
        let rest2 = [].slice.call(arguments)
        if(this instanceof F){
          // 6、若是用new操作符调用,则直接用new 调用原函数,并用扩展运算符传递参数
          return new _this(...rest2)
        }else{
          //7、用apply调用第一步保存的函数，并绑定this，传递合并的参数数组，即context._this(rest.concat(rest2))
          _this.apply(context,rest.concat(rest2));
        }
    }
};  

4、ES5 实现 ES6 的extend

function classA(name) {
    this.name = name;
}
classA.prototype.getName = function() {
    return this.name;
}
function classB(name) {
    classA.call(this, name);
}
classB.prototype = new classA();
classB.prototype.constructor = classB;

5、自己实现instanceof方法

function myInstanceof(target, parent) {
    if(!target || !parent || !target.__proto__ || !parent.prototype){
        return false;
    }
    let current = targert
    while(current) {
        if(currrent.__proto__ === parent.prototype) {
            return true
        }
        current = current.__proto__
    }
    return false
}

6、打乱数组

var arr = [4, 1, 67, 12, 45, 121, 3];
arr.sort(function() {
    return (0.5 - Math.random())
})
console.log(arr)

7、有待请求接口100个，限制每次只能发出10个。即同一时刻最多有10个正在发送的请求。

每当10个之中有一个请求完成，则从待请求的接口中再取出一个发出。保证当前并发度仍旧为10。 直至最终请求完成。 原文链接blog.csdn.net/qq_38074118…

// 模仿一个fetch的异步函数，返回promise
function mockFetch(param) {
  return new Promise((resovle) => {
    setTimeout(() => {
      resovle(param);
    }, 2000);
  });
}

function limitedRequest(urls, maxNum) {
  const pool = [];
  const initSize = Math.min(urls.length, maxNum);
  for (let i = 0; i < initSize; i++) {
    pool.push(run(urls.splice(0, 1)));
  }
  // r 代表promise完成的resolve回调函数
  // r 函数无论什么样的结果都返回promise，来确保最终promise.all可以正确执行
  function r() {
    console.log('当前并发度：', pool.length);
    if (urls.length === 0) {
      console.log('并发请求已经全部发起');
      return Promise.resolve();
    }
    return run(urls.splice(0, 1));
  }
  // 调用一次请求
  function run(url) {
    return mockFetch(url).then(r);
  }
  // 全部请求完成的回调
  Promise.all(pool).then(() => {
    console.log('请求已经全部结束');
  });
}
limitedRequest([1, 2, 3, 4, 5, 6, 7, 8], 3);