完成promise

const PENDING = 'pending'
const RESOLVED = 'resolved'
const REJECTED = 'rejected'
function MyPromise(fn){
 const that = this
  that.state = PENDING
  that.value = null
  that.resolvedCallbacks = []
  that.rejectedCallbacks = [] 
  function resolve(value) {
    if(that.state === PENDING) {
      that.state = RESOLVED
      that.value = value
      that.resolvedCallbacks.map(cb => cb(that.value))
    }
  }    
  function reject(value) {
    if(that.state === PENDING){
      that.state = REJECTED
      that.value = value;
      that.rejectedCallbacks.map(cb => cb(that.value));
    }
  }
  try {
    fn(resolve, reject)
  } catch (e) {
    reject(e)
  }
}    
MyPromise.prototype.then = function(onFulfilled, onRejected) {
  const that = this
  //对传入的两个参数做推断，假如不是函数将其转为函数
  onFulfilled = 
    typeof onFulfilled === 'function'
    ? onFulfilled 
    : v => v  // onFulfilled = v => v
  onRejected = 
    typeof onRejected === 'function'
    ? onRejected
    : r => {
      throw r
    }
  if(that.state === PENDING) {
    that.resolvedCallbacks.push(onFulfilled)
    that.rejectedCallbacks.push(onRejected)
  }
  else if(that.state === RESOLVED) {
    onFulfilled(that.value)
  }
  else {
    onRejected(that.value)
  }
}
new MyPromise((resolve, reject) => {
  setTimeout(() => {
    resolve('胜利的回调数据')
  }, 1000)
}).then(value => {
  console.log('Promise.then:  ', value)
})

大数相加

1.末端加上末端，假如大于即是10，发生进位。假如没有进位就是0.2.倒数第二位加上倒数第二位，再加上进位，假如大于即是10，发生进位。3.倒数第三位加上倒数第三位，再加上进位，假如大于即是10，发生进位。。。。直到加完数字小的位数。第一轮回完毕，举行第二轮回。第二轮回是指，数字较小（或许长度较短）的数字已加完完毕了。剩下的就是第一轮回加完后，剩下的进位与剩下的相加。

//bigNumberA和bigNumberB运用字符串存储，否则会自动转化为科学计数
let bigNumberAdd = (bigNumberA, bigNumberB) => {
    let A  = (bigNumberA + '').split('');
    let B = (bigNumberB + '').split('');
    let aLen = A.length, bLen = B.length, cLen = Math.max(aLen, bLen) + 1;
    let result = [], prefix = 0;
    for (let i = 0; i< cLen -1; i++ ) {
        let a = aLen - i - 1 >= 0 ? parseInt(A[aLen - i - 1]) : 0, b = bLen - i - 1 >= 0 ? parseInt(B[bLen - i - 1]) : 0;
    result[i] = (a + b + prefix) % 10;
        prefix = Math.floor((a + b + prefix) / 10);
    }
    return result.reverse().join('');
};
bigNumberAdd('45486646468484544661134868968','544545867466464646');

纯js写一个动画，5s由快到慢，速率自定义

animation ease

完成一个三角形

.triangle{
width:0;
height:0;
border-left:50px solid transparent;
border-right:50px solid transparent;
border-buttom:100px solid yellow;
}

快排是怎样完成的

冒泡排序？

手写二分查找

手写求一个字符串中涌现次数最多且长度最长的子串

反转链表

var reverseList=function(head){
if(head===null||head.next===null){
return head;
}
var new_head=reverseList(head.next);
head.next.next=head;
head.next=null;
return new_head;
};

图片懒加载怎么做？

防抖

函数防抖就是在函数须要频仍触发的情况下，只要充足的余暇时刻，才实行一次。
典范运用

• 百度搜刮框在输入稍有停马上才更新引荐热词。

• 拖拽

  function debounce(handler, delay){
   delay = delay || 300;
   var timer = null;
   return function(){
     var _self = this,
         _args = arguments;    
     clearTimeout(timer);
     timer = setTimeout(function(){
       handler.apply(_self, _args);
     }, delay);
   }
  
  
  }
  

撙节

一个函数只要在大于实行周期时才实行，周期内调用不实行。彷佛水滴积累到肯定水平才会触发一次着落一样。
典范运用：

• 抢券时猖獗点击，既要限定次数，又要保证先点先发出要求
• 窗口调解

• 页面转动

  function throttle(handler, wait){

   wait = wait || 300;
   var lastTime = 0;
   return function(){
     var _self = this,
     _args = arguments;
     var nowTime = new Date().getTime();
     if((nowTime - lastTime) > wait){
       handler.apply(_self, _args);
       lastTime = nowTime;
     }
   }
   }
  

js中最大整数是多少？

9开首

数组扁平化是指将一个多维数组变成一维数组

[1, [2, 3, [4, 5]]] ——> [1, 2, 3, 4, 5]
递归法：

function flatten(arr) {
  let res = [];
  arr.map(item => {
    if(Array.isArray(item)) {
      res = res.concat(flatten(item))
    } else {
      res.push(item);
    }
  })
  return res;
}

js怎样存储一个数据？

cookie，session,localStorage,sessionStorage

正则表达式

nginx的合适做什么，反向代办，正向代办

http 中假如想要运用缓存须要设置哪些字段

Expires、Cache-Control、(强缓存)
Last-Modified、Etag。(协商缓存)

哪些数组会返回一个新的数组

map、filter、concat、slice

剖析302、303、304、404、400状况码

对称加密和非对称加密有哪些区分？又有哪些运用

websocket 怎样传输文件

WebSocket发送图片时刻，我发起是举行图片紧缩，最好把图片紧缩在100K之内。
websocket发送大文件的时刻，经由我的测试，假如客户端衔接的服务器端的量比较大，分段发送，然后保存到数据库。

你用node平常做什么？（包装数据，转发要求）

react怎样优化

react的diff算法

历程与线程

历程是操纵系统资源分派的基本单位，而线程是使命调理和实行的基本单位。
个顺序至少有一个历程,一个历程至少有一个线程。