写在前面

前端需要了解弄懂的知识可以说包罗万象。而想要对某一知识点深挖细究又是一番功夫。最近忙着面试的事，也看了不少面试指导下面记录我认为值得看的前端知识。

HTML和CSS部分

浏览器的内核：浏览器内核是浏览器的核心，也称“渲染引擎”，用来解释网页语法并渲染到网页上。浏览器内核决定了浏览器该如何显示网页内容以及页面的格式信息。浏览器内核又可以分成两部分：渲染引擎(layout engineer 或者 Rendering Engine)和 JS 引擎。

1、IE浏览器内核：Trident内核，也是俗称的IE内核；

2、Chrome浏览器内核：统称为Chromium内核或Chrome内核，以前是Webkit内核，现在是Blink内核；

3、Firefox浏览器内核：Gecko内核，俗称Firefox内核；

4、Safari浏览器内核：Webkit内核；

5、Opera浏览器内核：最初是自己的Presto内核，后来是Webkit，现在是Blink内核；

6、360浏览器、猎豹浏览器内核：IE+Chrome双内核；

7、搜狗、遨游、QQ浏览器内核：Trident（兼容模式）+Webkit（高速模式）；

8、百度浏览器、世界之窗内核：IE内核；

9、2345浏览器内核：以前是IE内核，现在也是IE+Chrome双内核；

盒模型:标准盒模型和IE盒模型区别，转换用boder-sizing。

flex布局画个九宫格

.wrap{	display:flex;	flex-direction:column;	height:300px	}.flex-box{	display:flex;	flex-direction:row;	flex:1}.flex-item{	flex:1;	}

说一说清除浮动:

1.给要清除浮动的元素添加overflow:auto;zoom:1;

2.加个<div class="clear"></div>.clear {clear:both;overflow:hidden}

这部分都比较基础没啥问题，接下来是JS部分

JavaScriptundefined 与 undeclared 的区别？

已在作用域中声明但还没有赋值的变量，是 undefined 的。相反，还没有在作用域中声明过的变量，是 undeclared 的。

对于 undeclared 变量的引用，浏览器会报引用错误，如 ReferenceError: b is not defined 。但是我们可以使用 typeof 的安全防范机制来避免报错，因为对于 undeclared（或者 not defined ）变量，typeof 会返回 “undefined”。

{} 和 [] 的 valueOf 和 toString 的结果是什么？

{} 的 valueOf 结果为 {} ，toString 的结果为 “[object Object]”

[] 的 valueOf 结果为 [] ，toString 的结果为 “”

说到这个我就应该扩展一下原型链：

当我们访问哪一个对象和属性时，如果这个对象内部不存在这个属性，那么它就会去它的原型对象里找这个属性，这个原型对象也会有自己的原型，于是一直找下去，源头就是：Object.prototype.

js获取原型的方法：p.proto,Object.getPrototypeOf§谈谈对this、call、apply和bind的理解

在浏览器里，在全局范围内this 指向window对象；

在函数中，this永远指向最后调用他的那个对象；

构造函数中，this指向new出来的那个新的对象；

call、apply、bind中的this被强绑定在指定的那个对象上；

箭头函数中this比较特殊,箭头函数this为父作用域的this，不是调用时的this.要知道前四种方式,都是调用时确定,也就是动态的,而箭头函数的this指向是静态的,声明的时候就确定了下来；

apply、call、bind都是js给函数内置的一些API，调用他们可以为函数指定this的执行,同时也可以传参。

怎么使用大家都懂但怎么理解需要注意。

关于闭包

关于闭包也是老生常谈，在《你不知道的JS》中是这样介绍的：==当函数可以记住并访问所在的词法作用域时，就产生了闭包，即使函数是在当前作用域之外执行。==我觉得有点功底的小伙伴恍然大悟。

用通俗的话讲：闭包是指有权访问另一个函数作用域内变量的函数，创建闭包的最常见的方式就是在一个函数内创建另一个函数，创建的函数可以访问到当前函数的局部变量。

function a(){    var n = 0;    function add(){       n++;       console.log(n);    }    return add;}var a1 = a(); //注意，函数名只是一个标识（指向函数的指针），而（）才是执行函数；a1();    //1a1();    //2  第二次调用n变量还在内存中

事件 是用户操作网页时发生的交互动作或者网页本身的一些操作，现代浏览器一共有三种事件模型。

1.DOM0级模型：这种模型不会传播，所以没有事件流的概念，但是现在有的浏览器支持以冒泡的方式实现，它可以在网页中直接定义监听函数，也可以通过 js属性来指定监听函数。这种方式是所有浏览器都兼容的。

2.IE 事件模型： 在该事件模型中，一次事件共有两个过程，事件处理阶段，和事件冒泡阶段。事件处理阶段会首先执行目标元素绑定的监听事件。然后是事件冒泡阶段，冒泡指的是事件从目标元素冒泡到 document，依次检查经过的节点是否绑定了事件监听函数，如果有则执行。这种模型通过 attachEvent 来添加监听函数，可以添加多个监听函数，会按顺序依次执行。

3.DOM2事件模型: 在该事件模型中，一次事件共有三个过程，第一个过程是事件捕获阶段。捕获指的是事件从 document 一直向下传播到目标元素，依次检查经过的节点是否绑定了事件监听函数，如果有则执行。后面两个阶段和 IE 事件模型的两个阶段相同。这种事件模型，事件绑定的函数是 addEventListener，其中第三个参数可以指定事件是否在捕获阶段执行。

DOM 操作——怎样添加、移除、移动、复制、创建和查找节点？

（1）创建新节点

createDocumentFragment()    //创建一个DOM片段createElement()   //创建一个具体的元素createTextNode()   //创建一个文本节点`

（2）添加、移除、替换、插入

appendChild(node)removeChild(node)replaceChild(new,old)insertBefore(new,old)

（3）查找

getElementById();getElementsByName();getElementsByTagName();getElementsByClassName();querySelector();querySelectorAll();

（4）属性操作

getAttribute(key);setAttribute(key, value);hasAttribute(key);removeAttribute(key);

原生：

//1：创建XMLHttpRequest对象var xhr = window.XMLHttpRequest?new XMLHttpRequest():new ActiveXObject('Microsoft.XMLHTTP');// 兼容IE6及以下版本//2：配置 Ajax请求地址xhr.open('get','index.xml',true);//3：发送请求xhr.send(null); // 严谨写法//4:监听请求，接受响应xhr.onreadysatechange=function(){     if(xhr.readySates==4&&xhr.status==200 || xhr.status==304 )          console.log(xhr.responsetXML)}

jquery:

 $.ajax({          type:'post',          url:'',          async:ture,//async 异步  sync  同步          data:data,//针对post请求          dataType:'jsonp',          success:function (msg) {          },          error:function (error) {          }        })

结合自己的项目说，搬运一位前辈的介绍：

我对模块的理解是，一个模块是实现一个特定功能的一组方法。在最开始的时候，js 只实现一些简单的功能，所以并没有模块的概念，但随着程序越来越复杂，代码的模块化开发变得越来越重要。

由于函数具有独立作用域的特点，最原始的写法是使用函数来作为模块，几个函数作为一个模块，但是这种方式容易造成全局变量的污

染，并且模块间没有联系。

后面提出了对象写法，通过将函数作为一个对象的方法来实现，这样解决了直接使用函数作为模块的一些缺点，但是这种办法会暴露所

有的所有的模块成员，外部代码可以修改内部属性的值。

现在最常用的是立即执行函数的写法，通过利用闭包来实现模块私有作用域的建立，同时不会对全局作用域造成污染。

js的模块规范

CommonJS：modlue.exports.x抛出（定义模块的输出接口），require来引用。这种模块加载方案是服务器端（nodejs）的解决方案，它是以同步的方式来引入模块的，因为在服务端文件都存储在本地磁盘，所以读取非常快，所以以同步的方式加载没有问题。但如果是在浏览器端，由于模块的加载是使用网络请求，因此使用异步加载的方式更加合适。

AMD:这种方案采用异步加载的方式来加载模块，模块的加载不影响后面语句的执行，所有依赖这个模块的语句都定义在一个回调函数里，等到加载完成后再执行回调函数。**require.js **实现了 AMD 规范。

CMD:这种方案和 AMD 方案都是为了解决异步模块加载的问题，sea.js 实现了 CMD 规范。它和require.js的区别在于模块定义时对依赖的处理不同和对依赖模块的执行时机的处理不同。

ES6提出的:参考上上一篇博客

(重要)js运行机制

setTimeout(function() {  console.log(1)}, 0);new Promise(function(resolve, reject) {  console.log(2);  resolve()}).then(function() {  console.log(3)});process.nextTick(function () {  console.log(4)})console.log(5)

结果是什么先思考。先介绍一下运行机制

js单线程：

JavaScript语言的一大特点就是单线程，即同一时间只能做一件事情。

JavaScript的单线程，与它的用途有关。作为浏览器脚本语言，JavaScript的主要用途是与用户互动，以及操作DOM。这决定了它只能是单线程，否则会带来很复杂的同步问题。比如，假定JavaScript同时有两个线程，一个线程在某个DOM节点上添加内容，另一个线程删除了这个节点，这时浏览器应该以哪个线程为准？

所以，为了避免复杂性，从一诞生，JavaScript就是单线程，这已经成了这门语言的核心特征，将来也不会改变。

js事件循环

js代码执行过程中会有很多任务，这些任务总的分成两类：1.同步任务2.异步任务

当我们打开网站时，网页的渲染过程就是一大堆同步任务，比如页面骨架和页面元素的渲染。而像加载图片音乐之类占用资源大耗时久的任务，就是异步任务.

同步任务进主线程，异步任务进Event Table注册报道。

当指定的事情完成时，Event Table会将这个函数移入Event Queue。

主线程内的任务执行完毕为空，会去Event Queue读取对应的函数，进入主线程执行。

上述过程会不断重复，也就是常说的Event Loop(事件循环)。

异步任务又可以分为：

microtask(微任务)：

当执行栈中的代码执行完毕，会在执行宏任务队列之前先看看微任务队列中有没有任务，如果有会先将微任务队列中的任务清空才会去执行宏任务队列

包括：Promise，nextTick，callback，Object.observe，MutationObserver

macrotask(宏任务)：

等待执行栈和微任务队列都执行完毕才会执行，并且在执行完每一个宏任务之后，会去看看微任务队列有没有新添加的任务，如果有，会先将微任务队列中的任务清空，才会继续执行下一个宏任务

包括：script代码块，setTimeout，setInterval，I/O

面试推荐回答：

首先js 是单线程运行的，在代码执行的时候，通过将不同函数的执行上下文压入执行栈中来保证代码的有序执行。

在执行同步代码的时候，如果遇到了异步事件，js 引擎并不会一直等待其返回结果，而是会将这个事件挂起，继续执行执行栈中的其他任务

当同步事件执行完毕后，再将异步事件对应的回调加入到与当前执行栈中不同的另一个任务队列中等待执行。

任务队列可以分为宏任务对列和微任务对列，当当前执行栈中的事件执行完毕后，js 引擎首先会判断微任务对列中是否有任务可以执行，如果有就将微任务队首的事件压入栈中执行。

当微任务对列中的任务都执行完成后再去判断宏任务对列中的任务。

那么对刚开始的题目应该一目了然了吧：25431

var,let和const的区别是什么？

var声明存在变量提升，let，const不会

console.log(a); // undefined  ===>  a已声明还没赋值，默认得到undefined值var a = 100;console.log(b); // 报错：b is not defined  ===> 找不到b这个变量let b = 10;console.log(c); // 报错：c is not defined  ===> 找不到c这个变量const c = 10;

let和const声明形成块作用域

if(1){  var a = 100;  let b = 10;}console.log(a); // 100console.log(b)  // 报错：b is not defined  ===> 找不到b这个变量-------------------------------------------------------------if(1){  var a = 100;  const c = 1;}console.log(a); // 100console.log(c)  // 报错：c is not defined  ===> 找不到c这个变量

同一作用域下let和const不能声明同名变量，而var可以

var声明的变量会挂载在window上，而let和const声明的变量不会

var a ="lly" console.log(window.a)//lly

创建一个空的简单JavaScript对象（即{}）；

链接该对象（即设置该对象的构造函数）到另一个对象 ；

将步骤1新创建的对象作为this的上下文 ；

如果该函数没有返回对象，则返回this。

如果你熟悉原型链：

优雅的处理Promise回调（async，await）

async/await是一种建立在Promise之上的编写异步或非阻塞代码的新方法，被普遍认为是 JS异步操作的最终且最优雅的解决方案。相对于 Promise 和回调，它的可读性和简洁度都更高。毕竟一直then()也很烦。

async 是异步的意思，而 await 是 async wait的简写，即异步等待。

所以从语义上就很好理解 async 用于声明一个 function 是异步的，而await 用于等待一个异步方法执行完成。

一个函数如果加上 async ，那么该函数就会返回一个 Promise

async function test() {  return "lly"}console.log(test()) // -> Promise {<resolved>: "lly"}

可以看到输出的是一个Promise对象。所以，async 函数返回的是一个 Promise 对象，如果在 async 函数中直接 return 一个直接量，async 会把这个直接量通过 PromIse.resolve()封装成Promise对象返回。

做个比较

function takeLongTime(n) {    return new Promise(resolve => {        setTimeout(() => resolve(n + 200), n);    });}function step1(n) {    console.log(`step1 with ${n}`);    return takeLongTime(n);}function step2(n) {    console.log(`step2 with ${n}`);    return takeLongTime(n);}function step3(n) {    console.log(`step3 with ${n}`);    return takeLongTime(n);}

Proime处理：

function doIt() {    console.time("doIt");    const time1 = 300;    step1(time1)        .then(time2 => step2(time2))        .then(time3 => step3(time3))        .then(result => {            console.log(`result is ${result}`);        });}doIt();

async/await处理

async function doIt() {    console.time("doIt");    const time1 = 300;    const time2 = await step1(time1);    const time3 = await step2(time2);    const result = await step3(time3);    console.log(`result is ${result}`);}doIt();

async/await的优势在于处理 then 的调用链，能够更清晰准确的写出代码，并且也能优雅地解决回调地狱问题。

JS继承

原型链，apply或call

VueMVVM框架

最好也结合项目介绍，举个例子。在我的项目中，我通过vue.js代码（axios或者ajax通信）向后端接口（Model）请求了用户的个人信息，请求成功获得响应的数据后。VM把数据再给View（页面），页面就会发生相应的变化。

因为VUE是以数据为驱动的，Vue自身将DOM和数据进行了绑定，一旦创建绑定，数据变化，DOM也变化，那么核心就是VM(ViewModel)

vuex

mutations是唯一能够改变状态的

通过Vue组件中的dispath来出发actions，actions再调用Commit来对mutations重新分发，提交mutations来改变数据并改变视图。

结合自己的项目说就简单了。

生命周期vue computed原理、computed和watch的区别；vue组件通信vue-router

包裹动态组件（路由）时，会缓存下不活动的组件实例，主要用于保留组件状态，避免重新渲染

先整理到这里