超全前端知识点总结解答求职笔记

写在前面
1、这是博主2019年的前端笔记，有自己的一些开发经验，也有网上找到的比较好的资料，做了一下总结。从最开始粗略整理到根据面试反馈不断完善，我觉得已经非常全面，可以说涵盖到了大部分前端面试的点，除了js、css、html，其他浏览器、框架、http、数据结构、算法等等全都有涉及。
2、因为是学习笔记，而且涉及条目很多（97个），虽然博主已经认真校对，但难免有失误之处，大家多多包涵。
3、这份总结，只能算作一个概要，详细的学习大家自行拓展。对于面试来说，这份总结只能让你对面试考察的点有一个粗略的感觉，但是想要真正脱颖而出，必须真的是自己在用，接触到，而不是泛泛而谈。
4、最后，不管是书本学习，做项目，还是找工作，都是一个练习+反馈的过程，秋招过程让我注意到了很多平时忽略的知识点，对于我来说是一个很好的成长过程，一起加油吧。

markdown版：https://github.com/Lindsayyyy/feiyu-notes
pdf版：https://pan.baidu.com/s/1ou4GVSVCg6HN1_V_UDP1ug   提取码wr3x 

内容太多，不直接贴在博客上了，下面放一些常考的编程题的js实现

1、数组去重

1、reduce， indexOf
function unique(arr) {
  return arr.reduce((prev, cur, index) => {
    // return prev.indexOf(cur) === -1 ? prev.concat(cur) : prev
    return arr.indexOf(cur) === index ? prev.concat(cur) : prev
    // 注意push concat返回值不同
    // if (prev.indexOf(cur) === -1) {
    //   prev.push(cur)
    // }
    // return prev
  }, [])
}
2、filter，indexOf
function unique(arr) {
  return arr.filter((cur, index) => {
    return arr.indexOf(cur) === index
  })
}
3、set
function unique(arr) {
  return [...new Set(arr)];
}
4、双层循环
function unique(arr) {
  var res = [];
  for (var i = 0; i < arr.length; i++) {
    for(var j = 0; j < res.length; j++) {
      if (res[j] === arr[i]) {
        break;
      }
    }
    if (j === res.length) {
      res.push(arr[i]);
    }
  }
  return res;
}
5、排序后去重，比较相邻位

2、数组扁平化

1、递归
function flatten(arr) {
  var res = [];
  arr.forEach((cur) => {
    if (Array.isArray(cur)) {
      res = res.concat(flatten(cur));
    } else {
      res.push(cur);
    }
  })
  return res;
}
2、reduce
function flatten(arr) {
  return arr.reduce((prev, cur) => {
    return Array.isArray(cur) ? prev.concat(flatten(cur)) : prev.concat(cur);
  }, [])
}
3、...扩展运算符，some()判断
function flatten(arr) {
  while(arr.some((cur) => {return Array.isArray(cur)})) {
    arr = [].concat(...arr)
  }
  return arr;
}

3、链表有环

// 快慢指针方法
function EntryNodeOfLoop(pHead)
{
    if (pHead == null || pHead.next == null) return null;
    let fast = pHead;
    let slow = pHead;
    let flag = false;
    while (fast) {
      fast = fast.next.next;
      slow = slow.next;
      if (fast == slow) {
        flag = true;
        break;
      }
    }
    if (flag) {
      fast = pHead;
      while (fast != slow) {
        fast = fast.next;
        slow = slow.next;
      }
      return fast;
    } else {
      return null;
    }
}

// 用Set解决
let node = pHead;
let arr = [];
while(node) {
  arr.push(node);
  if ([...new Set(arr)].length !== arr.length) {
    return node;
  }
  node = node.next;
}
return null

4、二分查找

// 非递归
function foo(arr, target) {
  let front = 0;
  let end = arr.length-1;
  while(front <= end) {
    let mid = Math.floor((end + front)/2);
    if (target > arr[mid]) {
      front = mid + 1;
    } else if (target < arr[mid]) {
      end = mid - 1;
    } else {
      return mid
    }
  }
  return -1;
}
// 递归
function binarySearch(data,item,start,end){
    var end=end || data.length-1;
    var start=start || 0;
    var m=Math.floor((start+end)/2);
    if(item==data[m]){
        return m;
    }else if(item

5、用apply实现bind

Function.prototype.bind = function(context) {
var self = this
args = Array.prototype.slice.call(arguments);
    return function() {
        return self.apply(context, args.slice(1));    
    }
};

6、树的遍历

// 深度优先递归
function DLR(tree){
    console.log(tree.value);
    if(tree.left){
        DLR(tree.left);
    }
    if(tree.right){
        DLR(tree.right);
    }
}
//深度优先非递归，栈先进后出
function DepthFirstSearch(biTree) {
    let stack = [];
    stack.push(biTree);
    while (stack.length != 0) {
        let node = stack.pop();
        console.log(node.data);
        if (node.rChild) {
            stack.push(node.rChild);
        }
        if (node.lChild) {
            stack.push(node.lChild);
        }
    }
}

//广度优先非递归，队列先进先出
function BreadthFirstSearch(biTree) {
    let queue = [];
    queue.push(biTree);
    while (queue.length != 0) {
        let node = queue.shift();
        console.log(node.data);
        if (node.lChild) {
            queue.push(node.lChild);
        }
        if (node.rChild) {
            queue.push(node.rChild);
        }
    }
}