单向链表反转（单向链表反转代码）

大家好，我是讯享网，很高兴认识大家。

diff算法

React用三大策略将O(n^3)复杂度转化为 O(n)复杂度

策略一（tree diff）：
Web UI中DOM节点跨层级的移动操作特别少，可以忽略不计。

策略二（component diff）：
拥有相同类的两个组件生成相似的树形结构，
拥有不同类的两个组件生成不同的树形结构。

策略三（element diff）：
对于同一层级的一组子节点，通过唯一id区分

虚拟DOM

虚拟 dom 相当于在 js 和真实 dom 中间加了一个缓存，利用 dom diff 算法避免了没有必要的 dom 操作，从而提高性能。

用 JavaScript 对象结构表示 DOM 树的结构；然后用这个树构建一个真正的 DOM 树，插到文档当中当状态变更的时候，重新构造一棵新的对象树。然后用新的树和旧的树进行比较，记录两棵树差异把 2 所记录的差异应用到步骤 1 所构建的真正的 DOM 树上，视图就更新了。

状态管理

redux

是什么：是一个应用数据流框架，集中式管理

怎么用：view 调用 store 的 dispatch 接收 action 传入 store，reducer 进行 state 操作，view 通过 store 提供的 getState 获取最新的数据

缺点： state必须由父组件传过来，子组件相关数据更新，父组件会强渲

flux

单向数据流

用户访问 View
View 发出用户的 Action
Dispatcher 收到 Action，要求 Store 进行相应的更新
Store 更新后，发出一个”change”事件
View 收到”change”事件后，更新页面

vuex

：vuex 仅仅是作为 vue 的一个插件而存在，不像 Redux,MobX 等库可以应用于所有框架，vuex 只能使用在 vue 上，很大的程度是因为其高度依赖于 vue 的 computed 依赖检测系统以及其插件系统，

vuex 整体思想诞生于 flux,可其的实现方式完完全全的使用了 vue 自身的响应式设计，依赖监听、依赖收集都属于 vue 对对象 Property set get 方法的代理劫持。最后一句话结束 vuex 工作，vuex 中的 store 本质就是没有 template 的隐藏着的 vue 组件；

使用：在 main.js 引入 store，注入。新建了一个目录 store，…… export

场景：单页应用中，组件之间的状态。音乐播放、登录状态、加入购物车

MVVM

MVVM 是 Model-View-ViewModel 的缩写。mvvm 是一种设计思想。Model 层代表数据模型，也可以在 Model 中定义数据修改和操作的业务逻辑；View 代表 UI 组件，它负责将数据模型转化成 UI 展现出来，ViewModel 是一个同步 View 和 Model 的对象。

在 MVVM 架构下，View 和 Model 之间并没有直接的联系，而是通过 ViewModel 进行交互，Model 和 ViewModel 之间的交互是双向的，因此 View 数据的变化会同步到 Model 中，而 Model 数据的变化也会立即反应到 View 上。

ViewModel 通过双向数据绑定把 View 层和 Model 层连接了起来，而 View 和 Model 之间的同步工作完全是自动的，无需人为干涉，因此开发者只需关注业务逻辑，不需要手动操作 DOM, 不需要关注数据状态的同步问题，复杂的数据状态维护完全由 MVVM 来统一管理

mvc

mvc 和 mvvm 其实区别并不大。都是一种设计思想。主要就是 mvc 中 Controller 演变成 mvvm 中的 viewModel。mvvm 主要解决了 mvc 中大量的 DOM 操作使页面渲染性能降低，加载速度变慢，影响用户体验。和当 Model 频繁发生变化，开发者需要主动更新到 View

双向绑定

vue.js 是采用数据劫持结合发布者-订阅者模式的方式，通过 Object.defineProperty()来劫持各个属性的 setter，getter，在数据变动时发布消息给订阅者，触发相应的监听回调。

第一步：需要 observe 的数据对象进行递归遍历，包括子属性对象的属性，都加上 setter 和 getter 这样的话，给这个对象的某个值赋值，就会触发 setter，那么就能监听到了数据变化

第二步：compile 解析模板指令，将模板中的变量替换成数据，然后初始化渲染页面视图，并将每个指令对应的节点绑定更新函数，添加监听数据的订阅者，一旦数据有变动，收到通知，更新视图

第三步：Watcher 订阅者是 Observer 和 Compile 之间通信的桥梁，主要做的事情是:

在自身实例化时往属性订阅器(dep)里面添加自己
自身必须有一个 update()方法
待属性变动 dep.notice()通知时，能调用自身的 update() 方法，并触发 Compile 中绑定的回调，则功成身退。

第四步：MVVM 作为数据绑定的入口，整合 Observer、Compile 和 Watcher 三者，通过 Observer 来监听自己的 model 数据变化，通过 Compile 来解析编译模板指令，最终利用 Watcher 搭起 Observer 和 Compile 之间的通信桥梁，达到数据变化 -> 视图更新；视图交互变化(input) -> 数据 model 变更的双向绑定效果

路由

hash模式：在浏览器中符号“#”，用window.location.hash读取

特点：hash虽然在URL中，但不被包括在HTTP请求中；用来指导浏览器动作，对服务端安全无用，hash不会重加载页面。仅 hash 符号之前的内容会被包含在请求中，如 http://www.xxx.com，因此对于后端来说，即使没有做到对路由的全覆盖，也不会返回 404 错误。

history模式：history采用HTML5的新特性；且提供了两个新方法：pushState（），replaceState（）可以对浏览器历史记录栈进行修改，以及popState事件的监听到状态变更。

特点：前端的 URL 必须和实际向后端发起请求的 URL 一致，如 http://www.xxx.com/items/id。后端如果缺少对 /items/id 的路由处理，将返回 404 错误。你要在服务端增加一个覆盖所有情况的候选资源：如果 URL 匹配不到任何静态资源，则应该返回同一个 index.html 页面，这个页面就是你 app 依赖的页面。

框架处理事件

React 的事件是合成事件，React 在组件加载(mount)和更新(update)时，将事件通过 addEventListener 统一注册到 document 上，然后会有一个事件池存储了所有的事件，当事件触发的时候，通过 dispatchEvent 进行事件分发

高阶组件(higher order component)

高阶组件是一个以组件为参数并返回一个新组件的函数。HOC 运行你重用代码、逻辑和引导抽象。最常见的可能是 Redux 的 connect 函数。除了简单分享工具库和简单的组合，HOC 最好的方式是共享 React 组件之间的行为。如果你发现你在不同的地方写了大量代码来做同一件事时，就应该考虑将代码重构为可重用的 HOC。

axios

axios其实就是在ajax的基础上加了promise，具体如下：

304的缓存

浏览器渲染

babel

代码输入 -> 进行解析 -> 得到（抽象语法树）-> 用b对树进行遍历转译 ->得到新的树->用通过树生成代码

SSR

作为客户端与服务端的公用入口，导出根实例，供客户端与服务端使用。客户端主要作用挂载到上，服务端除了创建和返回实例，还进行路由匹配与数据预获取。
为客服端打包一个，为服务端打包一个。
服务器接收请求时，会根据，加载相应组件，获取和解析异步数据，创建一个读取的，然后生成发送给客户端。
客户端混合，客户端收到从服务端传来的与自己的生成的 DOM 进行对比，把不相同的激活，使其可以能够响应后续变化，这个过程称为客户端激活。为确保混合成功，客户端与服务器端需要共享同一套数据。在服务端，可以在渲染之前获取数据，填充到里，这样，在客户端挂载到之前，可以直接从里取数据。首屏的动态数据通过发送到客户端

的实现，主要就是把的组件输出成一个完整 , 就是干这事的

需要做的事多点（输出完整 HTML），除了，还需如数据获取填充至、客户端混合（）、缓存等等。相比于其他模板引擎（, 等），最终要实现的目的是一样的，性能上可能要差点

Vue computed

建立与其他属性（如：、）的联系；
属性改变后，通知计算属性重新计算

实现时，主要如下

初始化，使用把这些属性全部转为。
初始化 , 遍历里的每个属性，每个属性都是一个实例。每个属性提供的函数作为属性的，使用转化。
依赖收集。用于依赖发生变化时，触发属性重新计算。
若出现当前计算属性嵌套其他计算属性时，先进行其他的依赖收集

Vue complier

模板解析这种事，本质是将数据转化为一段，最开始出现在后端，经过各种处理吐给前端。随着各种的兴起，模板解析交由前端处理。
总的来说，是将转化成一个字符串。

可以简单理解成以下步骤：

过程，将利用正则转化成抽象语法树。
过程，标记静态节点，后过程跳过静态节点，提升性能。
过程，生成字符串

离线储存

在线的情况下，浏览器发现头部有属性，它会请求文件，如果是第一次访问，那么浏览器就会根据manifest文件的内容下载相应的资源并且进行离线存储。如果已经访问过并且资源已经离线存储了，那么浏览器就会使用离线的资源加载页面，然后浏览器会对比新的文件与旧的文件，如果文件没有发生改变，就不做任何操作，如果文件改变了，那么就会重新下载文件中的资源并进行离线存储。
离线的情况下，浏览器就直接使用离线存储的资源。

聊聊对vue的理解

vue是一个渐进式的JS框架。他易用，灵活，高效；可以把一个页面分隔成多个组件；当其他页面有类似功能时，直接让封装的组件进行复用；他是构建用户界面的声明式框架，只关心图层；不关心具体是如何实现的

V-model的是什么？

Vue的双向数据绑定是由数据劫持结合发布者订阅者实现的。数据劫持是通过Object.defineProperty()来劫持对象数据的setter和getter操作。在数据变动时作你想做的事

通过Observer来监听自己的model数据变化，通过Compile来解析编译模板指令，最终利用Watcher搭起Observer和Compile之间的通信桥梁，达到数据变化->视图更新在初始化vue实例时，遍历data这个对象，给每一个键值对利用Object.definedProperty对data的键值对新增get和set方法，利用了事件监听DOM的机制，让视图去改变数据

谈谈对生命周期的理解

beforeCreate阶段：vue实例的挂载元素el和数据对象data都是undefined，还没有初始化。
created阶段：vue实例的数据对象data有了，可以访问里面的数据和方法，未挂载到DOM，el还没有
beforeMount阶段：vue实例的el和data都初始化了，但是挂载之前为虚拟的dom节点
mounted阶段：vue实例挂载到真实DOM上，就可以通过DOM获取DOM节点
beforeUpdate阶段：响应式数据更新时调用，发生在虚拟DOM打补丁之前，适合在更新之前访问现有的DOM，比如手动移除已添加的事件监听器
updated阶段：虚拟DOM重新渲染和打补丁之后调用，组成新的DOM已经更新，避免在这个钩子函数中操作数据，防止死循环
beforeDestroy阶段：实例销毁前调用，实例还可以用，this能获取到实例，常用于销毁定时器，解绑事件
destroyed阶段：实例销毁后调用，调用后所有事件监听器会被移除，所有的子实例都会被销毁

VUE和REACT有什么区别？

react整体是函数式的思想，把组件设计成纯组件，状态和逻辑通过参数传入，所以在react中，是单向数据流；

vue的思想是响应式的，也就是基于是数据可变的，通过对每一个属性建立Watcher来监听，当属性变化的时候，响应式的更新对应的虚拟dom。

vuex的流程

vuex有哪几种状态和属性

state中保存着共有数据，数据是响应式的

getter可以对state进行计算操作，主要用来过滤一些数据，可以在多组件之间复用

mutations定义的方法动态修改state中的数据，通过commit提交方法，方法必须是同步的

actions将mutations里面处理数据的方法变成异步的，就是异步操作数据，通store.dispatch来分发actions，把异步的方法写在actions中，通过commit提交mutations，进行修改数据。

modules：模块化vuex

vue路由的两种模式

hash ——即地址栏URL中的#符号（此hsah 不是密码学里的散列运算） hash 虽然出现URL中，但不会被包含在HTTP请求中，对后端完全没有影响，因此改变hash不会重新加载页面。

history ——利用了HTML5 History Interface 中新增的pushState() 和replaceState() 方法

这两个方法应用于浏览器的历史记录站，在当前已有的back、forward、go 的基础之上，它们提供了对历史记录进行修改的功能。只是当它们执行修改是，虽然改变了当前的URL，但你浏览器不会立即向后端发送请求。

vue中 key 值的作用

当 Vue.js 用v-for正在更新已渲染过的元素列表时，它默认用“就地复用”策略。如果数据项的顺序被改变，Vue 将不会移动 DOM 元素来匹配数据项的顺序，而是简单复用此处每个元素，并且确保它在特定索引下显示已被渲染过的每个元素。

key的作用主要是为了高效的更新虚拟DOM。

和的区别

\(route是“路由信息对象”，包括path，params，hash，query，fullPath，matched，name等路由信息参数。</li><li>\)router是“路由实例”对象包括了路由的跳转方法，钩子函数等。

vue-router守卫

导航守卫 router.beforeEach 全局前置守卫

to: Route: 即将要进入的目标（路由对象）
from: Route: 当前导航正要离开的路由
next: Function: 一定要调用该方法来 resolve 这个钩子。（一定要用这个函数才能去到下一个路由，如果不用就拦截）执行效果依赖 next 方法的调用参数。
next(): 进行管道中的下一个钩子。如果全部钩子执行完了，则导航的状态就是 confirmed (确认的)。
next(false): 取消进入路由，url地址重置为from路由地址(也就是将要离开的路由地址)。

路由独享的守卫你可以在路由配置上直接定义 beforeEnter 守卫

组件内的守卫你可以在路由组件内直接定义以下路由导航守卫

axios是什么？怎么使用？描述使用它实现登录功能的流程？

请求后台资源的模块。

然后发送的是跨域，需在配置文件中config/index.js进行设置。后台如果是Tp5则定义一个资源路由。 js中使用import进来，然后.get或.post。返回在.then函数中如果成功，失败则是在.catch函数中

vue修饰符

stop：阻止事件的冒泡
prevent：阻止事件的默认行为
once：只触发一次
self：只触发自己的事件行为时，才会执行

vue项目中的性能优化

1.不要在模板里面写过多表达式

2.循环调用子组件时添加key

3.频繁切换的使用v-show，不频繁切换的使用v-if

4.尽量少用float，可以用flex

5.按需加载，可以用require或者import()按需加载需要的组件

6.路由懒加载

vue.extend和vue.component

extend 是构造一个组件的语法器。然后这个组件你可以作用到Vue.component这个全局注册方法里还可以在任意vue模板里使用组件。也可以作用到vue实例或者某个组件中的components属性中并在内部使用apple组件。

Vue.component 你可以创建，也可以取组件。

Vue组件间的参数传递

父组件与子组件传值

父组件传给子组件：子组件通过方法接受数据；

子组件传给父组件：方法传递参数

非父子组件间的数据传递，兄弟组件传值

，就是创建一个事件中心，相当于中转站，可以用它来传递事件和接收事件。项目比较小时，用这个比较合适（虽然也有不少人推荐直接用，具体来说看需求）

Vue的路由实现：hash模式和 history模式

模式：在浏览器中符号，#以及#后面的字符称之为，用读取。特点：虽然在中，但不被包括在请求中；用来指导浏览器动作，对服务端安全无用，不会重加载页面。
模式：h采用的新特性；且提供了两个新方法：，可以对浏览器历史记录栈进行修改，以及事件的监听到状态变更

v-if 和 v-show 区别

按照条件是否渲染，是的或

的作用是什么

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

比如有一个列表和一个详情，那么用户就会经常执行打开详情=>返回列表=>打开详情…这样的话列表和详情都是一个频率很高的页面，那么就可以对列表组件使用进行缓存，这样用户每次返回列表的时候，都能从缓存中快速渲染，而不是重新渲染</p></blockquote><h4 id="h37">指令v-el的作用是什么</h4><blockquote style="margin-top: 5px; margin-bottom: 5px; padding-left: 1em; margin-left: 0px; border-left: 3px solid rgb(238, 238, 238); opacity: 0.6;"><p>提供一个在页面上已存在的元素作为实例的挂载目标.可以是 CSS 选择器，也可以是一个实例,</p></blockquote><h4 id="h38">在Vue中使用插件的步骤</h4><ul><li>采用的语法或的方法引入插件</li><li>使用全局方法使用插件,可以传入一个选项对象 </li></ul><h4 id="h39">vue的优点是什么？</h4><ul><li>低耦合。视图（）可以独立于变化和修改，一个可以绑定到不同的上，当View变化的时候Model可以不变，当变化的时候也可以不变</li><li>可重用性。你可以把一些视图逻辑放在一个里面，让很多重用这段视图逻辑</li><li>可测试。界面素来是比较难于测试的，而现在测试可以针对来写</li></ul><h4 id="h40">路由之间跳转？</h4><p><strong>声明式（标签跳转）</strong></p><div></div><p><strong>编程式（ js跳转）</strong></p><div></div><p> <br></p><p><br></p><h4 id="h41">Vue 组件 data 为什么必须是函数</h4><ul><li>每个组件都是的实例。</li><li>组件共享属性，当的值是同一个引用类型的值时，改变其中一个会影响其他</li><li><br></li></ul><h4 id="h42">怎么快速定位哪个组件出现性能问题</h4><blockquote style="margin-top: 5px; margin-bottom: 5px; padding-left: 1em; margin-left: 0px; border-left: 3px solid rgb(238, 238, 238); opacity: 0.6;"><p>用工具。大意是通过来查看每个函数的调用时常，定位出哪个函数的问题，从而能判断哪个组件出了问题</p></blockquote><h4 id="h43">extend 能做什么</h4><blockquote style="margin-top: 5px; margin-bottom: 5px; padding-left: 1em; margin-left: 0px; border-left: 3px solid rgb(238, 238, 238); opacity: 0.6;"><p>这个很少用到，作用是扩展组件生成一个构造器，通常会与一起使用。</p></blockquote><div></div><h4 id="h44">mixin 和 mixins 区别</h4><blockquote style="margin-top: 5px; margin-bottom: 5px; padding-left: 1em; margin-left: 0px; border-left: 3px solid rgb(238, 238, 238); opacity: 0.6;"><p> 用于全局混入，会影响到每个组件实例，通常插件都是这样做初始化的</p></blockquote><div></div><ul><li>虽然文档不建议我们在应用中直接使用，但是如果不滥用的话也是很有帮助的，比如可以全局混入封装好的或者一些工具函数等等。</li><li> 应该是我们最常使用的扩展组件的方式了。如果多个组件中有相同的业务逻辑，就可以将这些逻辑剥离出来，通过混入代码，比如上拉下拉加载数据这种逻辑等等。</li><li>另外需要注意的是混入的钩子函数会先于组件内的钩子函数执行，并且在遇到同名选项的时候也会有选择性的进行合并，具体可以阅读文档。</li></ul><h4 id="h45">computed 和 watch 区别</h4><ul><li> 是计算属性，依赖其他属性计算值，并且的值有缓存，只有当计算值变化才会返回内容。</li><li> 监听到值的变化就会执行回调，在回调中可以进行一些逻辑操作。</li><li>所以一般来说需要依赖别的属性来动态获得值的时候可以使用，对于监听到值的变化需要做一些复杂业务逻辑的情况可以使用。</li><li>另外和还都支持对象的写法，这种方式知道的人并不多。</li></ul><div></div><h4 id="h46">Proxy 相比于 defineProperty 的优势</h4><ul><li>数组变化也能监听到</li><li>不需要深度遍历监听</li></ul><div></div><hr style="background-color: rgb(232, 232, 232); border: 1px solid transparent; margin: 18px 0px;"><h4 id="h48">给我介绍一下react</h4><ol><li>以前我们没有jquery的时候，我们大概的流程是从后端通过ajax获取到数据然后使用jquery生成dom结果然后更新到页面当中，但是随着业务发展，我们的项目可能会越来越复杂，我们每次请求到数据，或则数据有更改的时候，我们又需要重新组装一次dom结构，然后更新页面，这样我们手动同步dom和数据的成本就越来越高，而且频繁的操作dom，也使我我们页面的性能慢慢的降低。</li><li>这个时候mvvm出现了，mvvm的双向数据绑定可以让我们在数据修改的同时同步dom的更新，dom的更新也可以直接同步我们数据的更改，这个特定可以大大降低我们手动去维护dom更新的成本，mvvm为react的特性之一，虽然react属于单项数据流，需要我们手动实现双向数据绑定。</li><li>有了mvvm还不够，因为如果每次有数据做了更改，然后我们都全量更新dom结构的话，也没办法解决我们频繁操作dom结构(降低了页面性能)的问题，为了解决这个问题，react内部实现了一套虚拟dom结构，也就是用js实现的一套dom结构，他的作用是讲真实dom在js中做一套缓存，每次有数据更改的时候，react内部先使用算法，也就是鼎鼎有名的diff算法对dom结构进行对比，找到那些我们需要新增、更新、删除的dom节点，然后一次性对真实DOM进行更新，这样就大大降低了操作dom的次数。那么diff算法是怎么运作的呢，首先，diff针对类型不同的节点，会直接判定原来节点需要卸载并且用新的节点来装载卸载的节点的位置；针对于节点类型相同的节点，会对比这个节点的所有属性，如果节点的所有属性相同，那么判定这个节点不需要更新，如果节点属性不相同，那么会判定这个节点需要更新，react会更新并重渲染这个节点。</li><li>react设计之初是主要负责UI层的渲染，虽然每个组件有自己的state，state表示组件的状态，当状态需要变化的时候，需要使用setState更新我们的组件，但是，我们想通过一个组件重渲染它的兄弟组件，我们就需要将组件的状态提升到父组件当中，让父组件的状态来控制这两个组件的重渲染，当我们组件的层次越来越深的时候，状态需要一直往下传，无疑加大了我们代码的复杂度，我们需要一个状态管理中心，来帮我们管理我们状态state。</li><li>这个时候，redux出现了，我们可以将所有的state交给redux去管理，当我们的某一个state有变化的时候，依赖到这个state的组件就会进行一次重渲染，这样就解决了我们的我们需要一直把state往下传的问题。redux有action、reducer的概念，action为唯一修改state的来源，reducer为唯一确定state如何变化的入口，这使得redux的数据流非常规范，同时也暴露出了redux代码的复杂，本来那么简单的功能，却需要完成那么多的代码。</li><li>后来，社区就出现了另外一套解决方案，也就是mobx，它推崇代码简约易懂，只需要定义一个可观测的对象，然后哪个组价使用到这个可观测的对象，并且这个对象的数据有更改，那么这个组件就会重渲染，而且mobx内部也做好了是否重渲染组件的生命周期shouldUpdateComponent，不建议开发者进行更改，这使得我们使用mobx开发项目的时候可以简单快速的完成很多功能，连redux的作者也推荐使用mobx进行项目开发。但是，随着项目的不断变大，mobx也不断暴露出了它的缺点，就是数据流太随意，出了bug之后不好追溯数据的流向，这个缺点正好体现出了redux的优点所在，所以针对于小项目来说，社区推荐使用mobx，对大项目推荐使用redux</li></ol><h4 id="h49">react和vue的区别</h4><div></div><h4 id="h50">纯函数</h4><div></div><h4 id="h51">react的refs</h4><div></div><h4 id="h52">react中的keys</h4><div></div><h4 id="h53">React的生命周期</h4><div></div><h4 id="h54">React子组件向父组件传值</h4><div></div><h4 id="h55">为什么虚拟DOM会提高性能</h4><div></div><h4 id="h56">reac性能优化是哪个周期函</h4><div></div><h4 id="h57">怎么划分业务组件和技术组件</h4><div></div><h4 id="h58">setState</h4><div></div><h4 id="h59">shouldComponentUpdate</h4><p>shouldComponentUpdate 这个方法用来判断是否需要调用 render 方法重新描绘 dom。因为 dom 的描绘非常消耗性能，如果我们能在 shouldComponentUpdate 方法中能够写出更优化的 dom diff 算法，可以极大的提高性能。</p><h4 id="h60">展示组件(Presentational component)和容器组件(Container component)之间有何不同</h4><ul><li>展示组件关心组件看起来是什么。展示专门通过 props 接受数据和回调，并且几乎不会有自身的状态，但当展示组件拥有自身的状态时，通常也只关心 UI 状态而不是数据的状态。</li><li>容器组件则更关心组件是如何运作的。容器组件会为展示组件或者其它容器组件提供数据和行为(behavior)，它们会调用 Flux actions，并将其作为回调提供给展示组件。容器组件经常是有状态的，因为它们是(其它组件的)数据源。</li></ul><h4 id="h61">类组件(Class component)和函数式组件(Functional component)之间有何不同</h4><ul><li>类组件不仅允许你使用更多额外的功能，如组件自身的状态和生命周期钩子，也能使组件直接访问 store 并维持状态</li><li>当组件仅是接收 props，并将组件自身渲染到页面时，该组件就是一个 ‘无状态组件(stateless component)’，可以使用一个纯函数来创建这样的组件。这种组件也被称为哑组件(dumb components)或展示组件</li></ul><h4 id="h62">状态(state)和属性(props)之间有何不同</h4><ul><li>State 是一种数据结构，用于组件挂载时所需数据的默认值。State 可能会随着时间的推移而发生突变，但多数时候是作为用户事件行为的结果。</li><li>Props(properties 的简写)则是组件的配置。props 由父组件传递给子组件，并且就子组件而言，props 是不可变的(immutable)。组件不能改变自身的 props，但是可以把其子组件的 props 放在一起(统一管理)。Props 也不仅仅是数据–回调函数也可以通过 props 传递。</li></ul><h4 id="h63">何为受控组件(controlled component)</h4><p>在 HTML 中，类似和这样的表单元素会维护自身的状态，并基于用户的输入来更新。当用户提交表单时，前面提到的元素的值将随表单一起被发送。但在 React 中会有些不同，包含表单元素的组件将会在 state 中追踪输入的值，并且每次调用回调函数时，如 onChange 会更新 state，重新渲染组件。一个输入表单元素，它的值通过 React 的这种方式来控制，这样的元素就被称为”受控元素”。

何为高阶组件(higher order component)

高阶组件是一个以组件为参数并返回一个新组件的函数。HOC 运行你重用代码、逻辑和引导抽象。最常见的可能是 Redux 的 connect 函数。除了简单分享工具库和简单的组合，HOC 最好的方式是共享 React 组件之间的行为。如果你发现你在不同的地方写了大量代码来做同一件事时，就应该考虑将代码重构为可重用的 HOC。

为什么建议传递给 setState 的参数是一个 callback 而不是一个对象

因为 this.props 和 this.state 的更新可能是异步的，不能依赖它们的值去计算下一个 state。

除了在构造函数中绑定 this，还有其它方式吗

你可以使用属性初始值设定项(property initializers)来正确绑定回调，create-react-app 也是默认支持的。在回调中你可以使用箭头函数，但问题是每次组件渲染时都会创建一个新的回调。

(在构造函数中)调用 super(props) 的目的是什么

在 super() 被调用之前，子类是不能使用 this 的，在 ES2015 中，子类必须在 constructor 中调用 super()。传递 props 给 super() 的原因则是便于(在子类中)能在 constructor 访问 this.props。

应该在 React 组件的何处发起 Ajax 请求

在 React 组件中，应该在 componentDidMount 中发起网络请求。这个方法会在组件第一次“挂载”(被添加到 DOM)时执行，在组件的生命周期中仅会执行一次。更重要的是，你不能保证在组件挂载之前 Ajax 请求已经完成，如果是这样，也就意味着你将尝试在一个未挂载的组件上调用 setState，这将不起作用。在 componentDidMount 中发起网络请求将保证这有一个组件可以更新了。

事件在 React 中的处理方式

为了解决跨浏览器兼容性问题，您的 React 中的事件处理程序将传递 SyntheticEvent 的实例，它是 React 的浏览器本机事件的跨浏览器包装器。

这些 SyntheticEvent 与您习惯的原生事件具有相同的接口，除了它们在所有浏览器中都兼容。有趣的是，React 实际上并没有将事件附加到子节点本身。React 将使用单个事件监听器监听顶层的所有事件。这对于性能是有好处的，这也意味着在更新 DOM 时，React 不需要担心跟踪事件监听器。

createElement 和 cloneElement 有什么区别

React.createElement():JSX 语法就是用 React.createElement()来构建 React 元素的。它接受三个参数，第一个参数可以是一个标签名。如 div、span，或者 React 组件。第二个参数为传入的属性。第三个以及之后的参数，皆作为组件的子组件。

React.cloneElement()与 React.createElement()相似，不同的是它传入的第一个参数是一个 React 元素，而不是标签名或组件。新添加的属性会并入原有的属性，传入到返回的新元素中，而就的子元素奖杯替换。

React 中有三种构建组件的方式

React.createClass()、ES6 class 和无状态函数。

react 组件的划分业务组件技术组件

根据组件的职责通常把组件分为 UI 组件和容器组件。

UI 组件负责 UI 的呈现，容器组件负责管理数据和逻辑。

两者通过 React-Redux 提供 connect 方法联系起来。

微信小程序有几个文件

是一套样式语言，用于描述的组件样式，逻辑处理，网络请求小程序设置，如页面注册，页面标题及。

必须要有这个文件，如果没有这个文件，项目无法运行，因为微信框架把这个作为配置文件入口，整个小程序的全局配置。包括页面注册，网络设置，以及小程序的背景色，配置导航条样式，配置默认标题。

必须要有这个文件，没有也是会报错！但是这个文件创建一下就行什么都不需要写以后我们可以在这个文件中监听并处理小程序的生命周期函数、声明全局变量。

配置全局

微信小程序怎样跟事件传值

给元素添加属性来传递我们需要的值，然后通过或的参数获取。但名称不能有大写字母和不可以存放对象

小程序的 wxss 和 css 有哪些不一样的

的图片引入需使用外链地址

没有；样式可直接使用导入

关联微信公众号如何确定用户的唯一性

使用方法为时可获取，里面有。后端需要进行对称解密

微信小程序与vue区别

生命周期不一样，微信小程序生命周期比较简单

数据绑定也不同，微信小程序数据绑定需要使用，直接就可以

显示与隐藏元素，中，使用和控制元素的显示和隐藏，小程序中，使用和控制元素的显示和隐藏

事件处理不同，小程序中，全用，或者绑定事件,使用绑定事件，或者使用绑定事件

数据双向绑定也不也不一样在中,只需要再表单元素上加上 ,然后再绑定中对应的一个值，当表单元素内容发生变化时，中对应的值也会相应改变，这是非常 nice 的一点。微信小程序必须获取到表单元素，改变的值，然后再把值赋给一个中声明的变量。

登录

unionid和openid

了解小程序登陆之前，我们写了解下小程序/公众号登录涉及到两个最关键的用户标识：

是一个用户对于一个小程序／公众号的标识，开发者可以通过这个标识识别出用户。

是一个用户对于同主体微信小程序／公众号／的标识，开发者需要在微信开放平台下绑定相同账号的主体。开发者可通过，实现多个小程序、公众号、甚至APP 之间的数据互通了。

关键Api

官方提供的登录能力

校验用户当前的是否有效

提前向用户发起授权请求

获取用户基本信息

登录流程设计

利用现有登录体系

直接复用现有系统的登录体系，只需要在小程序端设计用户名，密码/验证码输入页面，便可以简便的实现登录，只需要保持良好的用户体验即可

利用 创建用户体系

是一个小程序对于一个用户的标识，利用这一点我们可以轻松的实现一套基于小程序的用户体系，值得一提的是这种用户体系对用户的打扰最低，可以实现静默登录。具体步骤如下

小程序客户端通过获取

传递向服务端，服务端拿到 code 调用微信登录凭证校验接口，微信服务器返回和会话密钥，此时开发者服务端便可以利用生成用户入库，再向小程序客户端返回自定义登录态

小程序客户端缓存（通过）自定义登录态（），后续调用接口时携带该登录态作为用户身份标识即可

利用 Unionid 创建用户体系

如果想实现多个小程序，公众号，已有登录系统的数据互通，可以通过获取到用户的方式建立用户体系。因为在同一开放平台下的所所有应用都是相同的，通过建立的用户体系即可实现全平台数据的互通，更方便的接入原有的功能，那如何获取呢，有以下两种方式

如果户关注了某个相同主体公众号，或曾经在某个相同主体、公众号上进行过微信登录授权，通过可以直接获取到

结合

和

这两种方式引导用户主动授权，主动授权后通过返回的信息和服务端交互 (这里有一步需要服务端解密数据的过程，很简单，微信提供了示例代码) 即可拿到

建立用户体系，然后由服务端返回登录态，本地记录即可实现登录，附上微信提供的**实践

调用获取，然后从微信后端换取到，用于解密返回的敏感数据

使用

获取用户的授权情况

如果用户已经授权，直接调用获取用户最新的信息；

用户未授权，在界面中显示一个按钮提示用户登入，当用户点击并授权后就获取到用户的最新信息

获取到用户数据后可以进行展示或者发送给自己的后端。

注意事项

需要获取形式的登录体系，在以前（18年4月之前）是通过以下这种方式来实现，但后续微信做了调整（因为一进入小程序，主动弹起各种授权弹窗的这种形式，比较容易导致用户流失），调整为必须使用按钮引导用户主动授权的方式，这次调整对开发者影响较大，开发者需要注意遵守微信的规则，并及时和业务方沟通业务形式，不要存在侥幸心理，以防造成小程序不过审等情况

因为小程序不存在的概念，登录态必须缓存在本地，因此强烈建议为登录态设置过期时间

值得一提的是如果需要支持风控安全校验，多平台登录等功能，可能需要加入一些公共参数，例如，，等参数。在和服务端确定方案时，作为前端同学应该及时提出这些合理的建议，设计合理的系统。

，不要在接口中明文传输，这是一种危险的行为，同时也很不专业

图片导出

这是一种常见的引流方式，一般同时会在图片中附加一个小程序二维码。

基本

借助元素，将需要导出的样式首先在画布上绘制出来（基本和保持一致，但有轻微差异，使用时注意即可

借助微信提供的导出图片，最后再使用（需要授权）保存图片到本地

如何优雅实现

绘制出需要的样式这一步是省略不掉的。但是我们可以封装一个绘制库，包含常见图形的绘制，例如矩形，圆角矩形，圆，扇形，三角形，文字，图片减少绘制代码，只需要提炼出样式信息，便可以轻松的绘制，最后导出图片存入相册。笔者觉得以下这种方式绘制更为优雅清晰一些，其实也可以使用加入一个type参数来指定绘制类型，传入的一个是样式数组，实现绘制。

结合上一步的实现，如果对于同一类型的卡片有多次导出需求的场景，也可以使用自定义组件的方式，封装同一类型的卡片为一个通用组件，在需要导出图片功能的地方，引入该组件即可。

注意事项

小程序中无法绘制网络图片到上，需要通过先下载图片到本地临时文件才可以绘制

通常需要绘制二维码到导出的图片上，有一种方式导出二维码时，需要携带的参数必须做编码，而且有具体的长度（可见字符）限制，可以借助服务端生成短链接的方式来解决

数据统计

数据统计作为目前一种常用的分析用户行为的方式，小程序端也是必不可少的。小程序采取的曝光，点击数据埋点其实和h5是一样的。但是埋点作为一个和业务逻辑不相关的需求，我们如果在每一个点击事件，每一个生命周期加入各种埋点代码，则会干扰正常的业务逻辑，和使代码变的臃肿，笔者提供以下几种思路来解决数据埋点

设计一个埋点sdk

小程序的代码结构是，每一个中都有一个方法，接受一个包含生命周期函数，数据的业务逻辑对象包装这层数据，借助小程序的底层逻辑实现页面的业务逻辑。通过这个我们可以想到思路，对进行一次包装，篡改它的生命周期和点击事件，混入埋点代码，不干扰业务逻辑，只要做一些简单的配置即可埋点，简单的代码实现如下

这种思路不光适用于埋点，也可以用来作全局异常处理，请求的统一处理等场景。

分析接口

对于特殊的一些业务，我们可以采取接口埋点，什么叫接口埋点呢？很多情况下，我们有的并不是多处调用的，只会在某一个特定的页面调用，通过这个思路我们可以分析出，该接口被请求，则这个行为被触发了，则完全可以通过服务端日志得出埋点数据，但是这种方式局限性较大，而且属于分析结果得出过程，可能存在误差，但可以作为一种思路了解一下。

微信自定义数据分析

微信本身提供的数据分析能力，微信本身提供了常规分析和自定义分析两种数据分析方式，在小程序后台配置即可。借助小程序数据助手这款小程序可以很方便的查看

工程化

工程化做什么

目前的前端开发过程，工程化是必不可少的一环，那小程序工程化都需要做些什么呢，先看下目前小程序开发当中存在哪些问题需要解决：

不支持预编译器,作为一种主流的解决方案，不论是 ,, 都可以提升效率

不支持引入npm包（这一条，从微信公开课中听闻，微信准备支持）

不支持等后续的特性，好用的等特性都无法使用

不支持引入外部字体文件，只支持

没有等代码检查工具

方案选型

对于目前常用的工程化方案，，，等来看，都常用与单页应用的打包和处理，而小程序天生是 “多页应用” 并且存在一些特定的配置。根据要解决的问题来看，无非是文件的编译，修改，拷贝这些处理，对于这些需求，我们想到基于流的非常的适合处理，并且相对于配置多页应用更加简单。所以小程序工程化方案推荐使用

具体开发思路

通过的实现：

实时编译文件至相应目录

引入支持，的运行时文件

编译字体文件为并生成相应文件，方便使用

依赖分析哪些地方引用了包，将包打成一个文件，拷贝至相应目录

检查代码规范

小程序架构

讯享网

微信小程序的框架包含两部分视图层、逻辑层。层用来渲染页面结构，层用来逻辑处理、数据请求、接口调用。

它们在两个线程里运行。

视图层和逻辑层通过系统层的进行通信，逻辑层把数据变化通知到视图层，触发视图层页面更新，视图层把触发的事件通知到逻辑层进行业务处理

视图层使用渲染，中使用自带，在使用腾讯的内核（基于）运行。

逻辑层使用在中使用自带的运行，在中使用腾讯的内核（基于）运行。

开发工具使用同时提供了视图层和逻辑层的运行环境。

WXML && WXSS

WXML

支持数据绑定

支持逻辑算术、运算

支持模板、引用

支持添加事件（）

编译器：把文件转为

执行方式：

使用，进行局部更新

WXSS

wxss编译器：把文件转化为

执行方式：

尺寸单位 rpx

）: 可以根据屏幕宽度进行自适应。规定屏幕宽为。公式：

样式导入

使用语句可以导入外联样式表，后跟需要导入的外联样式表的相对路径，用表示语句结束

内联样式

静态的样式统一写到中。接收动态的样式，在运行时会进行解析，请尽量避免将静态的样式写进中，以免影响渲染速度

全局样式与局部样式

定义在中的样式为全局样式，作用于每一个页面。在的文件中定义的样式为局部样式，只作用在对应的页面，并会覆盖中相同的选择器

小程序有什么问题

小程序仍然使用渲染，并非原生渲染。（部分原生）

服务端接口返回的头无法执行，比如：。

依赖浏览器环境的库不能使用。

不能使用，但是可以自搭构建工具或者使用。（未来官方有计划支持）

不能使用，可以自己用自搭或者使用。

不支持使用自己的字体（未来官方计划支持）。

可以用的方式来使用。

小程序不能发朋友圈（可以通过保存图片到本地，发图片到朋友前。二维码可以使用B接口）。

获取二维码/小程序接口的限制

程序推送只能使用“服务通知” 而且需要用户主动触发提交，只有7天有效期。（现在的做法是在每个页面都放入并且隐藏以此获取更多的。后端使用原则为：优先使用有效期最短的）

小程序大小限制 2M，分包总计不超过 8M

转发（分享）小程序不能拿到成功结果，原来可以。链接（小游戏造的孽）

授权获取用户信息流程

有有效期，有效期并没有被告知开发者，只知道用户越频繁使用小程序，有效期越长

在调用时会直接更新，导致旧失效

小程序内先调用检查登录态，并保证没有过期的不会被更新，再调用获取。接着用户授权小程序获取用户信息，小程序拿到加密后的用户数据，把加密数据和传给后端服务。后端通过拿到并解密数据，将解密后的用户信息返回给小程序

先授权获取用户信息再 login 会发生什么

用户授权时，开放平台使用旧的对用户信息进行加密。调用重新登录，会刷新，这时后端服务从开放平台获取到新，但是无法对老加密过的数据解密，用户信息获取失败

在用户信息授权之前先调用呢？检查登录态，并且保证 wx.login 不会刷新，从而让后端服务正确解密数据。但是这里存在一个问题，如果小程序较长时间不用导致过期，则必定会重新生成，从而再一次导致用户信息解密失败

webpack打包文件体积过大

如何优化webpack构建的性能

移动端的性能优化

优化打包速度

减少文件搜索范围

比如通过别名

的，

默认压缩并行

并发调用

也可以缓存编译

Babel

本质就是编译器，当代码转为字符串生成，对进行转变最后再生成新的代码

分为三步：词法分析生成，语法分析生成，遍历，根据插件变换相应的节点，最后把转换为代码

如何实现一个插件

调用插件函数传入对象

通过对象监听事件

比如你想实现一个编译结束退出命令的插件

打包效率

开发环境采用增量构建，启用热更新

开发环境不做无意义的工作如提取计算文件hash等

配置

选择合适的

个别开启如

第三方库采用引入方式

提取公共代码

优化构建时的搜索路径指明需要构建目录及不需要构建目录

模块化引入需要的部分

Loader

编写一个loader

loader就是一个node模块，它输出了一个函数。当某种资源需要用这个loader转换时，这个函数会被调用。并且，这个函数可以通过提供给它的this上下文访问Loader API。reverse-txt-loader

plugin优化

构建优化

减少编译体积、、、

并行编译、、开启并行

缓存、、开启缓存、开启缓存

预编译、

性能优化

减少编译体积、

缓存

拆包、、

状态码

get/post的区别

http协议的理解

http和https

http1.0 1.1 2.0的区别

web缓存

web安全及防护

CDN

TCP三次握手

TCP四次挥手

客户端 – FIN –> 服务端， FIN—WAIT

服务端 – ACK –> 客户端， CLOSE-WAIT

服务端 – ACK,FIN –> 客户端， LAST-ACK

客户端 – ACK –> 服务端，CLOSED

从输入url到获取页面过程

为什么css放在顶部而js写在后面

存储方式与传输方式

cookie，sessionStorage，localStorage

1、cookie，sessionStorage，localStorage是存放在客户端，session对象数据是存放在服务器上实际上浏览器和服务器之间仅需传递session id即可，服务器根据session-id找到对应的用户session对象 session存储数据更安全一些，一般存放用户信息，浏览器只适合存储一般的数据 2、cookie数据始终在同源的http请求中携带，在浏览器和服务器来回传递，里面存放着session-id sessionStorage，localStorage仅在本地保存 3、大小限制区别，cookie数据不超过4kb，localStorage在谷歌浏览中2.6MB 4、数据有效期不同，cookie在设置的（服务器设置）有效期内有效，不管窗口和浏览器关闭 sessionStorage仅在当前浏览器窗口关闭前有效，关闭即销毁（临时存储） localStorage始终有效

SessionStorage和localStorage区别： 1.sessionStorage用于本地存储一个会话（session）中的数据，这些数据只有在用一个会话的页面中才能被访问（也就是说在第一次通信过程中）并且在会话结束后数据也随之销毁，不是一个持久的本地存储，会话级别的储存 2.localStorage用于持久化的本地存储，除非主动删除数据，否则不会过期

token、cookie、session

基于Token的身份验证

cookie与session区别

session与token区别

Cookie的弊端有哪些

怎么判断页面是否加载完成

事件触发代表页面中的，，，图片已经全部加载完毕。

事件触发代表初始的被完全加载和解析，不需要等待，，图片加载

Service worker

service worker

本质上充当Web应用程序与浏览器之间的代理服务器，也可以在网络可用时作为浏览器和网络间的代理。它们旨在（除其他之外）使得能够创建有效的离线体验，拦截网络请求并基于网络是否可用以及更新的资源是否驻留在服务器上来采取适当的动作。他们还允许访问推送通知和后台同步API

目前该技术通常用来做缓存文件，提高首屏速度，可以试着来实现这个功能

浏览器缓存

缓存对于前端性能优化来说是个很重要的点，良好的缓存策略可以降低资源的重复加载提高网页的整体加载速度。

通常浏览器缓存策略分为两种：强缓存和协商缓存。

强缓存

实现强缓存可以通过两种响应头实现：和。强缓存表示在缓存期间不需要请求，为

是的产物，表示资源会在, 后过期，需要再次请求。并且受限于本地时间，如果修改了本地时间，可能会造成缓存失效。

出现于，优先级高于。该属性表示资源会在秒后过期，需要再次请求。

协商缓存

如果缓存过期了，我们就可以使用协商缓存来解决问题。协商缓存需要请求，如果缓存有效会返回。

协商缓存需要客户端和服务端共同实现，和强缓存一样，也有两种实现方式

Last-Modified 和 If-Modified-Since

表示本地文件最后修改日期，会将的值发送给服务器，询问服务器在该日期后资源是否有更新，有更新的话就会将新的资源发送回来。

但是如果在本地打开缓存文件，就会造成被修改，所以在出现了

ETag 和 If-None-Match

类似于文件指纹，会将当前发送给服务器，询问该资源是否变动，有变动的话就将新的资源发送回来。并且优先级比高

选择合适的缓存策略

对于大部分的场景都可以使用强缓存配合协商缓存解决，但是在一些特殊的地方可能需要选择特殊的缓存策略

对于某些不需要缓存的资源，可以使用，表示该资源不需要缓存

对于频繁变动的资源，可以使用并配合使用，表示该资源已被缓存，但是每次都会发送请求询问资源是否更新。

对于代码文件来说，通常使用并配合策略缓存使用，然后对文件进行指纹处理，一旦文件名变动就会立刻下载新的文件

浏览器性能问题

重绘（Repaint）和回流（Reflow）

重绘和回流是渲染步骤中的一小节，但是这两个步骤对于性能影响很大。

重绘是当节点需要更改外观而不会影响布局的，比如改变就叫称为重绘

回流是布局或者几何属性需要改变就称为回流。

回流必定会发生重绘，重绘不一定会引发回流。回流所需的成本比重绘高的多，改变深层次的节点很可能导致父节点的一系列回流。

所以以下几个动作可能会导致性能问题：

改变大小

改变字体

添加或删除样式

文字改变

定位或者浮动

盒模型

很多人不知道的是，重绘和回流其实和 Event loop 有关。

当执行完后，会判断是否需要更新。- 因为浏览器是的刷新率，每才会更新一次。

然后判断是否有或者，有的话会去触发事件，所以和事件也是至少 16ms 才会触发一次，并且自带节流功能。

判断是否触发了

更新动画并且发送事件

判断是否有全屏操作事件

执行回调

执行回调，该方法用于判断元素是否可见，可以用于懒加载上，但是兼容性不好

更新界面

以上就是一帧中可能会做的事情。如果在一帧中有空闲时间，就会去执行回调。

减少重绘和回流

使用替代

使用替换，因为前者只会引起重绘，后者会引发回流（改变了布局）

把离线后修改，比如：先把给 (有一次 )，然后你修改次，然后再把它显示出来

不要把结点的属性值放在一个循环里当成循环里的变量

不要使用布局，可能很小的一个小改动会造成整个的重新布局动画实现的速度的选择，动画速度越快，回流次数越多，也可以选择使用

选择符从右往左匹配查找，避免深度过深

将频繁运行的动画变为图层，图层能够阻止该节点回流影响别的元素。比如对于标签，浏览器会自动将该节点变为图层。

负载均衡

多台服务器共同协作，不让其中某一台或几台超额工作，发挥服务器的最大作用

重定向负载均衡：调度者根据策略选择服务器以302响应请求，缺点只有第一次有效果，后续操作维持在该服务器 dns负载均衡：解析域名时，访问多个服务器中的一个（可监控性较弱）

反向代理负载均衡：访问统一的服务器，由服务器进行调度访问实际的某个服务器，对统一的服务器要求大，性能受到服务器群的数量

浏览器 Eventloop 和 Node 中的有什么区别

众所周知 JS 是门非阻塞单线程语言，因为在最初 JS 就是为了和浏览器交互而诞生的。如果 JS 是门多线程的语言话，我们在多个线程中处理 DOM 就可能会发生问题（一个线程中新加节点，另一个线程中删除节点），当然可以引入读写锁解决这个问题。

在执行的过程中会产生执行环境，这些执行环境会被顺序的加入到执行栈中。如果遇到异步的代码，会被挂起并加入到（有多种）队列中。一旦执行栈为空，就会从队列中拿出需要执行的代码并放入执行栈中执行，所以本质上来说中的异步还是同步行为

以上代码虽然延时为，其实还是异步。这是因为标准规定这个函数第二个参数不得小于毫秒，不足会自动增加。所以还是会在之后打印。

不同的任务源会被分配到不同的队列中，任务源可以分为微任务（）和宏任务（）。在 ES6 规范中，称为 jobs，称为。

以上代码虽然写在之前，但是因为属于微任务而属于宏任务，所以会有以上的打印。

微任务包括 ，，，

宏任务包括 ，，，，，

很多人有个误区，认为微任务快于宏任务，其实是错误的。因为宏任务中包括了，浏览器会先执行一个宏任务，接下来有异步代码的话就先执行微任务

所以正确的一次 Event loop 顺序是这样的

执行同步代码，这属于宏任务

执行栈为空，查询是否有微任务需要执行

执行所有微任务

必要的话渲染

然后开始下一轮，执行宏任务中的异步代码

通过上述的顺序可知，如果宏任务中的异步代码有大量的计算并且需要操作的话，为了更快的界面响应，我们可以把操作放入微任务中

重绘与回流

当元素的样式发生变化时，浏览器需要触发更新，重新绘制元素。这个过程中，有两种类型的操作，即重绘与回流。

重绘(repaint): 当元素样式的改变不影响布局时，浏览器将使用重绘对元素进行更新，此时由于只需要UI层面的重新像素绘制，因此损耗较少

回流(reflow): 当元素的尺寸、结构或触发某些属性时，浏览器会重新渲染页面，称为回流。此时，浏览器需要重新经过计算，计算后还需要重新页面布局，因此是较重的操作。会触发回流的操作:

页面初次渲染

浏览器窗口大小改变

元素尺寸、位置、内容发生改变

元素字体大小变化

添加或者删除可见的元素

激活伪类（例如：）

查询某些属性或调用某些方法

回流必定触发重绘，重绘不一定触发回流。重绘的开销较小，回流的代价较高。

**实践:

css

避免使用布局

将动画效果应用到属性为或的元素上

javascript

避免频繁操作样式，可汇总后统一一次修改

尽量使用进行样式修改

减少的增删次数，可使用字符串或者一次性插入

极限优化时，修改样式可将其后修改

避免多次触发上面提到的那些会触发回流的方法，可以的话尽量用变量存住

XSS

跨网站指令码（英语：，通常简称为：）是一种网站应用程式的安全漏洞攻击，是代码注入的一种。它允许恶意使用者将程式码注入到网页上，其他使用者在观看网页时就会受到影响。这类攻击通常包含了以及使用者端脚本语言

XSS分为三种：反射型，存储型和DOM-based

如何攻击

通过修改节点或者执行代码来攻击网站。

例如通过获取某些参数

上述输入可能会将改为，这样页面中就凭空多了一段可执行脚本。这种攻击类型是反射型攻击，也可以说是攻击

如何防御

最普遍的做法是转义输入输出的内容，对于引号，尖括号，斜杠进行转义

通过转义可以将攻击代码变成

对于显示富文本来说，不能通过上面的办法来转义所有字符，因为这样会把需要的格式也过滤掉。这种情况通常采用白名单过滤的办法，当然也可以通过黑名单过滤，但是考虑到需要过滤的标签和标签属性实在太多，更加推荐使用白名单的方式

以上示例使用了来实现。可以看到在输出中保留了标签且过滤了标签

CSRF

跨站请求伪造（英语：），也被称为或者，通常缩写为或者，是一种挟制用户在当前已登录的应用程序上执行非本意的操作的攻击方法

就是利用用户的登录态发起恶意请求

如何攻击

假设网站中有一个通过 Get 请求提交用户评论的接口，那么攻击者就可以在钓鱼网站中加入一个图片，图片的地址就是评论接口

如何防御

请求不对数据进行修改

不让第三方网站访问到用户

阻止第三方网站请求接口

请求时附带验证信息，比如验证码或者

密码安全

加盐

对于密码存储来说，必然是不能明文存储在数据库中的，否则一旦数据库泄露，会对用户造成很大的损失。并且不建议只对密码单纯通过加密算法加密，因为存在彩虹表的关系

通常需要对密码加盐，然后进行几次不同加密算法的加密

但是加盐并不能阻止别人盗取账号，只能确保即使数据库泄露，也不会暴露用户的真实密码。一旦攻击者得到了用户的账号，可以通过暴力。对于这种情况，通常使用验证码增加延时或者限制尝试次数的方式。并且一旦用户输入了错误的密码，也不能直接提示用户输错密码，而应该提示账号或密码错误

前端加密

虽然前端加密对于安全防护来说意义不大，但是在遇到中间人攻击的情况下，可以避免明文密码被第三方获取

点击劫持

涉及面试题：什么是点击劫持？如何防范点击劫持？

点击劫持是一种视觉欺骗的攻击手段。攻击者将需要攻击的网站通过嵌套的方式嵌入自己的网页中，并将设置为透明，在页面中透出一个按钮诱导用户点击

对于这种攻击方式，推荐防御的方法有两种

1. X-FRAME-OPTIONS

是一个响应头，在现代浏览器有一个很好的支持。这个 HTTP 响应头就是为了防御用嵌套的点击劫持攻击。

该响应头有三个值可选，分别是

，表示页面不允许通过的方式展示

，表示页面可以在相同域名下通过的方式展示

，表示页面可以在指定来源的中展示

2. JS 防御

对于某些远古浏览器来说，并不能支持上面的这种方式，那我们只有通过 JS 的方式来防御点击劫持了。

以上代码的作用就是当通过的方式加载页面时，攻击者的网页直接不显示所有内容了

栈

概念

栈是一个线性结构，在计算机中是一个相当常见的数据结构。

栈的特点是只能在某一端添加或删除数据，遵循先进后出的原则

实现

每种数据结构都可以用很多种方式来实现，其实可以把栈看成是数组的一个子集，所以这里使用数组来实现

应用

匹配括号，可以通过栈的特性来完成

队列

概念

队列一个线性结构，特点是在某一端添加数据，在另一端删除数据，遵循先进先出的原则

实现

这里会讲解两种实现队列的方式，分别是单链队列和循环队列

单链队列

因为单链队列在出队操作的时候需要的时间复杂度，所以引入了循环队列。循环队列的出队操作平均是的时间复杂度

循环队列

链表

概念

链表是一个线性结构，同时也是一个天然的递归结构。链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大

实现

单向链表

树

二叉树

树拥有很多种结构，二叉树是树中最常用的结构，同时也是一个天然的递归结构。

二叉树拥有一个根节点，每个节点至多拥有两个子节点，分别为：左节点和右节点。树的最底部节点称之为叶节点，当一颗树的叶数量数量为满时，该树可以称之为满二叉树

二分搜索树

二分搜索树也是二叉树，拥有二叉树的特性。但是区别在于二分搜索树每个节点的值都比他的左子树的值大，比右子树的值小

这种存储方式很适合于数据搜索。如下图所示，当需要查找 6 的时候，因为需要查找的值比根节点的值大，所以只需要在根节点的右子树上寻找，大大提高了搜索效率

实现

以上是最基本的二分搜索树实现，接下来实现树的遍历。

对于树的遍历来说，有三种遍历方法，分别是先序遍历、中序遍历、后序遍历。三种遍历的区别在于何时访问节点。在遍历树的过程中，每个节点都会遍历三次，分别是遍历到自己，遍历左子树和遍历右子树。如果需要实现先序遍历，那么只需要第一次遍历到节点时进行操作即可

以上的这几种遍历都可以称之为深度遍历，对应的还有种遍历叫做广度遍历，也就是一层层地遍历树。对于广度遍历来说，我们需要利用之前讲过的队列结构来完成

接下来先介绍如何在树中寻找最小值或最大数。因为二分搜索树的特性，所以最小值一定在根节点的最左边，最大值相反

向上取整和向下取整，这两个操作是相反的，所以代码也是类似的，这里只介绍如何向下取整。既然是向下取整，那么根据二分搜索树的特性，值一定在根节点的左侧。只需要一直遍历左子树直到当前节点的值不再大于等于需要的值，然后判断节点是否还拥有右子树。如果有的话，继续上面的递归判断

排名，这是用于获取给定值的排名或者排名第几的节点的值，这两个操作也是相反的，所以这个只介绍如何获取排名第几的节点的值。对于这个操作而言，我们需要略微的改造点代码，让每个节点拥有一个 size 属性。该属性表示该节点下有多少子节点（包含自身）

接下来讲解的是二分搜索树中最难实现的部分：删除节点。因为对于删除节点来说，会存在以下几种情况

需要删除的节点没有子树

需要删除的节点只有一条子树

需要删除的节点有左右两条树

对于前两种情况很好解决，但是第三种情况就有难度了，所以先来实现相对简单的操作：删除最小节点，对于删除最小节点来说，是不存在第三种情况的，删除最大节点操作是和删除最小节点相反的，所以这里也就不再赘述

最后讲解的就是如何删除任意节点了。对于这个操作，在年提出了解决这个难题的办法，也就是如何解决第三种情况。

当遇到这种情况时，需要取出当前节点的后继节点（也就是当前节点右子树的最小节点）来替换需要删除的节点。然后将需要删除节点的左子树赋值给后继结点，右子树删除后继结点后赋值给他。

你如果对于这个解决办法有疑问的话，可以这样考虑。因为二分搜索树的特性，父节点一定比所有左子节点大，比所有右子节点小。那么当需要删除父节点时，势必需要拿出一个比父节点大的节点来替换父节点。这个节点肯定不存在于左子树，必然存在于右子树。然后又需要保持父节点都是比右子节点小的，那么就可以取出右子树中最小的那个节点来替换父节点

堆

概念

堆通常是一个可以被看做一棵树的数组对象。

堆的实现通过构造二叉堆，实为二叉树的一种。这种数据结构具有以下性质。

任意节点小于（或大于）它的所有子节点堆总是一棵完全树。即除了最底层，其他层的节点都被元素填满，且最底层从左到右填入。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

优先队列也完全可以用堆来实现，操作是一模一样的。

实现大根堆

堆的每个节点的左边子节点索引是，右边是，父节点是。

堆有两个核心的操作，分别是和。前者用于添加元素，后者用于删除根节点。

的核心思路是一路将节点与父节点对比大小，如果比父节点大，就和父节点交换位置。

的核心思路是先将根节点和末尾交换位置，然后移除末尾元素。接下来循环判断父节点和两个子节点的大小，如果子节点大，就把最大的子节点和父节点交换

时间复杂度

通常使用最差的时间复杂度来衡量一个算法的好坏。

常数时间代表这个操作和数据量没关系，是一个固定时间的操作，比如说四则运算。

对于一个算法来说，可能会计算出如下操作次数 1，代表数据量。那么该算法的时间复杂度就是。因为我们在计算时间复杂度的时候，数据量通常是非常大的，这时候低阶项和常数项可以忽略不计。

当然可能会出现两个算法都是的时间复杂度，那么对比两个算法的好坏就要通过对比低阶项和常数项了

位运算

位运算在算法中很有用，速度可以比四则运算快很多。

在学习位运算之前应该知道十进制如何转二进制，二进制如何转十进制。这里说明下简单的计算方式

十进制可以看成是，并且应该是六位二进制的（因为近似，而是的五次方，所以是六位），那么十进制就是，只要是 2 的次方，那么就是否则都为那么二进制同理，首位是，末位是，相加得出

左移 <<

左移就是将二进制全部往左移动，在二进制中表示为，左移一位后变成，转换为十进制也就是，所以基本可以把左移看成以下公式

算数右移 >>

算数右移就是将二进制全部往右移动并去除多余的右边，10 在二进制中表示为，右移一位后变成，转换为十进制也就是，所以基本可以把右移看成以下公式

右移很好用，比如可以用在二分算法中取中间值

按位操作

按位与

每一位都为 1，结果才为 1

按位或

其中一位为 1，结果就是 1

按位异或

每一位都不同，结果才为 1

两个数不使用四则运算得出和

这道题中可以按位异或，因为按位异或就是不进位加法，如果进位了，就是了，所以我们只需要将两个数进行异或操作，然后进位。那么也就是说两个二进制都是 1 的位置，左边应该有一个进位，所以可以得出以下公式，然后通过迭代的方式模拟加法

排序

冒泡排序

冒泡排序的如下，从第一个元素开始，把当前元素和下一个索引元素进行比较。如果当前元素大，那么就交换位置，重复操作直到比较到最后一个元素，那么此时最后一个元素就是该数组中最大的数。下一轮重复以上操作，但是此时最后一个元素已经是最大数了，所以不需要再比较最后一个元素，只需要比较到的位置

以下是实现该算法的代码

该算法的操作次数是一个等差数列，去掉常数项以后得出时间复杂度是

插入排序

入排序的如下。第一个元素默认是已排序元素，取出下一个元素和当前元素比较，如果当前元素大就交换位置。那么此时第一个元素就是当前的最小数，所以下次取出操作从第三个元素开始，向前对比，重复之前的操作

以下是实现该算法的代码

该算法的操作次数是一个等差数列，去掉常数项以后得出时间复杂度是

选择排序

选择排序的如下。遍历数组，设置最小值的索引为 0，如果取出的值比当前最小值小，就替换最小值索引，遍历完成后，将第一个元素和最小值索引上的值交换。如上操作后，第一个元素就是数组中的最小值，下次遍历就可以从索引 1 开始重复上述操作

以下是实现该算法的代码

该算法的操作次数是一个等差数列，去掉常数项以后得出时间复杂度是

归并排序

归并排序的如下。递归的将数组两两分开直到最多包含两个元素，然后将数组排序合并，最终合并为排序好的数组。假设我有一组数组，中间数索引是 3，先排序数组。在这个左边数组上，继续拆分直到变成数组包含两个元素（如果数组长度是奇数的话，会有一个拆分数组只包含一个元素）。然后排序数组和，然后再排序数组，这样左边数组就排序完成，然后按照以上思路排序右边数组，最后将数组和排序

以下是实现该算法的代码

以上算法使用了递归的思想。递归的本质就是压栈，每递归执行一次函数，就将该函数的信息（比如参数，内部的变量，执行到的行数）压栈，直到遇到终止条件，然后出栈并继续执行函数。对于以上递归函数的调用轨迹如下

该算法的操作次数是可以这样计算：递归了两次，每次数据量是数组的一半，并且最后把整个数组迭代了一次，所以得出表达式（代表时间，代表数据量）。根据该表达式可以套用该公式得出时间复杂度为

快排

快排的如下。随机选取一个数组中的值作为基准值，从左至右取值与基准值对比大小。比基准值小的放数组左边，大的放右边，对比完成后将基准值和第一个比基准值大的值交换位置。然后将数组以基准值的位置分为两部分，继续递归以上操作。

以下是实现该算法的代码

该算法的复杂度和归并排序是相同的，但是额外空间复杂度比归并排序少，只需，并且相比归并排序来说，所需的常数时间也更少

面试题

Sort Colors：该题目来自 LeetCode，题目需要我们将排序成，这个问题就可以使用三路快排的思想

链表

反转单向链表

该题目来自 LeetCode，题目需要将一个单向链表反转。思路很简单，使用三个变量分别表示当前节点和当前节点的前后节点，虽然这题很简单，但是却是一道面试常考题

树

二叉树的先序，中序，后序遍历

先序遍历表示先访问根节点，然后访问左节点，最后访问右节点。

中序遍历表示先访问左节点，然后访问根节点，最后访问右节点。

后序遍历表示先访问左节点，然后访问右节点，最后访问根节点

递归实现

递归实现相当简单，代码如下

对于递归的实现来说，只需要理解每个节点都会被访问三次就明白为什么这样实现了

非递归实现

非递归实现使用了栈的结构，通过栈的先进后出模拟递归实现。

以下是先序遍历代码实现

以下是中序遍历代码实现

以下是后序遍历代码实现，该代码使用了两个栈来实现遍历，相比一个栈的遍历来说要容易理解很多

中序遍历的前驱后继节点

实现这个算法的前提是节点有一个的指针指向父节点，根节点指向

如图所示，该树的中序遍历结果是

前驱节点

对于节点 2 来说，他的前驱节点就是 4 ，按照中序遍历原则，可以得出以下结论

如果选取的节点的左节点不为空，就找该左节点最右的节点。对于节点 1 来说，他有左节点 2 ，那么节点 2 的最右节点就是 5

如果左节点为空，且目标节点是父节点的右节点，那么前驱节点为父节点。对于节点 5 来说，没有左节点，且是节点 2 的右节点，所以节点 2 是前驱节点

如果左节点为空，且目标节点是父节点的左节点，向上寻找到第一个是父节点的右节点的节点。对于节点 6 来说，没有左节点，且是节点 3 的左节点，所以向上寻找到节点 1 ，发现节点 3 是节点 1 的右节点，所以节点 1 是节点 6 的前驱节点

以下是算法实现

后继节点

对于节点 2 来说，他的后继节点就是 5 ，按照中序遍历原则，可以得出以下结论

如果有右节点，就找到该右节点的最左节点。对于节点 1 来说，他有右节点 3 ，那么节点 3 的最左节点就是 6

如果没有右节点，就向上遍历直到找到一个节点是父节点的左节点。对于节点 5 来说，没有右节点，就向上寻找到节点 2 ，该节点是父节点 1 的左节点，所以节点 1 是后继节点以下是算法实现

树的深度

树的最大深度：该题目来自 Leetcode，题目需要求出一颗二叉树的最大深度

以下是算法实现

对于该递归函数可以这样理解：一旦没有找到节点就会返回 0，每弹出一次递归函数就会加一，树有三层就会得到3

变量提升

当执行代码时，会生成执行环境，只要代码不是写在函数中的，就是在全局执行环境中，函数中的代码会产生函数执行环境，只此两种执行环境。

想必以上的输出大家肯定都已经明白了，这是因为函数和变量提升的原因。通常提升的解释是说将声明的代码移动到了顶部，这其实没有什么错误，便于大家理解。但是更准确的解释应该是：在生成执行环境时，会有两个阶段。第一个阶段是创建的阶段，解释器会找出需要提升的变量和函数，并且给他们提前在内存中开辟好空间，函数的话会将整个函数存入内存中，变量只声明并且赋值为，所以在第二个阶段，也就是代码执行阶段，我们可以直接提前使用

在提升的过程中，相同的函数会覆盖上一个函数，并且函数优先于变量提升

会产生很多错误，所以在 ES6中引入了。不能在声明前使用，但是这并不是常说的不会提升，提升了，在第一阶段内存也已经为他开辟好了空间，但是因为这个声明的特性导致了并不能在声明前使用

bind、call、apply 区别

和都是为了解决改变的指向。作用都是相同的，只是传参的方式不同。

除了第一个参数外，可以接收一个参数列表，只接受一个参数数组

和其他两个方法作用也是一致的，只是该方法会返回一个函数。并且我们可以通过实现柯里化

实现一个 bind 函数

对于实现以下几个函数，可以从几个方面思考

不传入第一个参数，那么默认为

改变了指向，让新的对象可以执行该函数。那么思路是否可以变成给新的对象添加一个函数，然后在执行完以后删除？

实现一个 call 函数

实现一个 apply 函数

简单说下原型链？

每个函数都有属性，除了，该属性指向原型。

每个对象都有属性，指向了创建该对象的构造函数的原型。其实这个属性指向了，但是是内部属性，我们并不能访问到，所以使用来访问。

对象可以通过来寻找不属于该对象的属性，将对象连接起来组成了原型链。

怎么判断对象类型

可以通过。这样我们就可以获得类似的字符串。

可以正确的判断对象的类型，因为内部机制是通过判断对象的原型链中是不是能找到类型的

箭头函数的特点

箭头函数其实是没有的，这个函数中的只取决于他外面的第一个不是箭头函数的函数的。在这个例子中，因为调用符合前面代码中的第一个情况，所以是。并且一旦绑定了上下文，就不会被任何代码改变

This

async、await 优缺点

和相比直接使用来说，优势在于处理 then 的调用链，能够更清晰准确的写出代码。缺点在于滥用可能会导致性能问题，因为会阻塞代码，也许之后的异步代码并不依赖于前者，但仍然需要等待前者完成，导致代码失去了并发性

下面来看一个使用的代码。

首先函数先执行，在执行到之前变量还是，因为在内部实现了，会保留堆栈中东西，所以这时候被保存了下来

因为是异步操作，遇到就会立即返回一个状态的对象，暂时返回执行代码的控制权，使得函数外的代码得以继续执行，所以会先执行

这时候同步代码执行完毕，开始执行异步代码，将保存下来的值拿出来使用，这时候

然后后面就是常规执行代码了

generator 原理

是中新增的语法，和一样，都可以用来异步编程

从以上代码可以发现，加上的函数执行后拥有了函数，也就是说函数执行后返回了一个对象。每次调用函数可以继续执行被暂停的代码。以下是函数的简单实现

Promise

是新增的语法，解决了回调地狱的问题。

可以把看成一个状态机。初始是状态，可以通过函数和，将状态转变为或者状态，状态一旦改变就不能再次变化。

函数会返回一个实例，并且该返回值是一个新的实例而不是之前的实例。因为规范规定除了状态，其他状态是不可以改变的，如果返回的是一个相同实例的话，多个调用就失去意义了。对于来说，本质上可以把它看成是

实现一个 Promise

== 和 ===区别，什么情况用 ==

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkCVHEBr-17)(https://user-gold-cdn.xitu.io/2018/3/30/16275f89ebf931e9?imageView2/0/w/1280/h/960/format/webp/ignore-error/1)]

这里来解析一道题目，下面是这个表达式为何为的步骤

用于判断两者类型和值是否相同。在开发中，对于后端返回的，可以通过去判断

基本数据类型和引⽤类型在存储上的差别

前者存储在栈上，后者存储在堆上

setTimeout 倒计时误差

是单线程的，所以的误差其实是无法被完全解决的，原因有很多，可能是回调中的，有可能是浏览器中的各种事件导致。这也是为什么页面开久了，定时器会不准的原因，当然我们可以通过一定的办法去减少这个误差。

数组降维

如果想将一个多维数组彻底的降维，可以这样实现

深拷贝

这个问题通常可以通过来解决

但是该方法也是有局限性的：

会忽略

会忽略

不能序列化函数

不能解决循环引用的对象

在遇到函数、或者的时候，该对象也不能正常的序列化

但是在通常情况下，复杂数据都是可以序列化的，所以这个函数可以解决大部分问题，并且该函数是内置函数中处理深拷贝性能最快的。当然如果你的数据中含有以上三种情况下，可以使用的深拷贝函数

typeof 于 instanceof 区别

对于基本类型，除了都可以显示正确的类型

typeof对于对象，除了函数都会显示object

对于来说，虽然它是基本类型，但是会显示，这是一个存在很久了的

instanceof可以正确的判断对象的类型，因为内部机制是通过判断对象的原型链中是不是能找到类型的prototype

AMD，CMD，CommonJs，ES6 Module

AMD：在推广过程中对模块定义的规范化产出，提前执行，推崇依赖前置

CMD：在推广过程中对模块定义的规范化产出，延迟执行，推崇依赖就近

CommonJs：模块输出的是一个值的，运行时加载，加载的是一个对象（属性），该对象只有在脚本运行完才会生成

ES6 Module：模块输出的是一个值的引用，编译时输出接口，模块不是对象，它对外接口只是一种静态定义，在代码静态解析阶段就会生成。

防抖

你是否在日常开发中遇到一个问题，在滚动事件中需要做个复杂计算或者实现一个按钮的防二次点击操作。

这些需求都可以通过函数防抖动来实现。尤其是第一个需求，如果在频繁的事件回调中做复杂计算，很有可能导致页面卡顿，不如将多次计算合并为一次计算，只在一个精确点做操作

PS：防抖和节流的作用都是防止函数多次调用。区别在于，假设一个用户一直触发这个函数，且每次触发函数的间隔小于，防抖的情况下只会调用一次，而节流的情况会每隔一定时间（参数）调用函数

对于按钮防点击来说的实现：如果函数是立即执行的，就立即调用，如果函数是延迟执行的，就缓存上下文和参数，放到延迟函数中去执行。一旦我开始一个定时器，只要我定时器还在，你每次点击我都重新计时。一旦你点累了，定时器时间到，定时器重置为，就可以再次点击了。

对于延时执行函数来说的实现：清除定时器，如果是延迟调用就调用函数

节流

防抖动和节流本质是不一样的。防抖动是将多次执行变为最后一次执行，节流是将多次执行变成每隔一段时间执行

继承

在 ES5 中，我们可以使用如下方式解决继承的问题

以上继承实现思路就是将子类的原型设置为父类的原型

在中，我们可以通过语法轻松解决这个问题

但是不是所有浏览器都兼容，所以我们需要使用来编译这段代码。

如果你使用编译过得代码调用你会惊奇地发现出现了报错

因为在底层有限制，如果不是由构造出来的实例的话，是不能调用里的函数的。所以这也侧面的说明了：中的继承与中的一般继承写法是不同的。

既然底层限制了实例必须由构造出来，那么我们可以改变下思路实现继承

以上继承实现思路：先创建父类实例 => 改变实例原先的转而连接到子类的 => 子类的的改为父类的。

通过以上方法实现的继承就可以完美解决底层的这个限制

实现一个Generator

是中新增的语法，和一样，都可以用来异步编程

从以上代码可以发现，加上的函数执行后拥有了函数，也就是说函数执行后返回了一个对象。每次调用函数可以继续执行被暂停的代码。以下是函数的简单实现

Proxy

是中新增的功能，可以用来自定义对象中的操作

跨域

涉及面试题：什么是跨域？为什么浏览器要使用同源策略？你有几种方式可以解决跨域问题？了解预检请求嘛？

因为浏览器出于安全考虑，有同源策略。也就是说，如果协议、域名或者端口有一个不同就是跨域，请求会失败。

那么是出于什么安全考虑才会引入这种机制呢？其实主要是用来防止攻击的。简单点说，攻击是利用用户的登录态发起恶意请求。

也就是说，没有同源策略的情况下，网站可以被任意其他来源的访问到内容。如果你当前网站还存在登录态，那么对方就可以通过获得你的任何信息。当然跨域并不能完全阻止。

然后我们来考虑一个问题，请求跨域了，那么请求到底发出去没有？请求必然是发出去了，但是浏览器拦截了响应。你可能会疑问明明通过表单的方式可以发起跨域请求，为什么就不会。因为归根结底，跨域是为了阻止用户读取到另一个域名下的内容，可以获取响应，浏览器认为这不安全，所以拦截了响应。但是表单并不会获取新的内容，所以可以发起跨域请求。同时也说明了跨域并不能完全阻止，因为请求毕竟是发出去了。

接下来我们将来学习几种常见的方式来解决跨域的问题

JSONP

的原理很简单，就是利用标签指向一个需要访问的地址并提供一个回调函数来接收数据当需要通讯时

使用简单且兼容性不错，但是只限于请求。

在开发中可能会遇到多个请求的回调函数名是相同的，这时候就需要自己封装一个，以下是简单实现

CORS

需要浏览器和后端同时支持。和需要通过来实现。

浏览器会自动进行通信，实现通信的关键是后端。只要后端实现了，就实现了跨域。

服务端设置就可以开启。该属性表示哪些域名可以访问资源，如果设置通配符则表示所有网站都可以访问资源。虽然设置和前端没什么关系，但是通过这种方式解决跨域问题的话，会在发送请求时出现两种情况，分别为简单请求和复杂请求。

简单请求

以为例，当满足以下条件时，会触发简单请求

使用下列方法之一：

的值仅限于下列三者之一：

text/plain

请求中的任意对象均没有注册任何事件监听器；对象可以使用属性访问

复杂请求

对于复杂请求来说，首先会发起一个预检请求，该请求是方法的，通过该请求来知道服务端是否允许跨域请求。

对于预检请求来说，如果你使用过来设置的话，可能会遇到过这么一个坑。

以下以框架举例

该请求会验证你的字段，没有的话就会报错。

当前端发起了复杂请求后，你会发现就算你代码是正确的，返回结果也永远是报错的。因为预检请求也会进入回调中，也会触发方法，因为预检请求并不包含字段，所以服务端会报错。

想解决这个问题很简单，只需要在回调中过滤方法即可

document.domain

该方式只能用于主域名相同的情况下，比如和适用于该方式。

只需要给页面添加表示主域名都相同就可以实现跨域

postMessage

这种方式通常用于获取嵌入页面中的第三方页面数据。一个页面发送消息，另一个页面判断来源并接收消息

函数柯里化

在一个函数中，首先填充几个参数，然后再返回一个新的函数的技术，称为函数的柯里化。通常可用于在不侵入函数的前提下，为函数预置通用参数，供多次重复调用。

跨域

涉及面试题：什么是跨域？为什么浏览器要使用同源策略？你有几种方式可以解决跨域问题？了解预检请求嘛？

因为浏览器出于安全考虑，有同源策略。也就是说，如果协议、域名或者端口有一个不同就是跨域，请求会失败。

那么是出于什么安全考虑才会引入这种机制呢？其实主要是用来防止攻击的。简单点说，攻击是利用用户的登录态发起恶意请求。

也就是说，没有同源策略的情况下，网站可以被任意其他来源的访问到内容。如果你当前网站还存在登录态，那么对方就可以通过获得你的任何信息。当然跨域并不能完全阻止。

然后我们来考虑一个问题，请求跨域了，那么请求到底发出去没有？请求必然是发出去了，但是浏览器拦截了响应。你可能会疑问明明通过表单的方式可以发起跨域请求，为什么就不会。因为归根结底，跨域是为了阻止用户读取到另一个域名下的内容，可以获取响应，浏览器认为这不安全，所以拦截了响应。但是表单并不会获取新的内容，所以可以发起跨域请求。同时也说明了跨域并不能完全阻止，因为请求毕竟是发出去了。

接下来我们将来学习几种常见的方式来解决跨域的问题

JSONP

的原理很简单，就是利用标签指向一个需要访问的地址并提供一个回调函数来接收数据当需要通讯时

使用简单且兼容性不错，但是只限于请求。

在开发中可能会遇到多个请求的回调函数名是相同的，这时候就需要自己封装一个，以下是简单实现

CORS

需要浏览器和后端同时支持。和需要通过来实现。

浏览器会自动进行通信，实现通信的关键是后端。只要后端实现了，就实现了跨域。

服务端设置就可以开启。该属性表示哪些域名可以访问资源，如果设置通配符则表示所有网站都可以访问资源。虽然设置和前端没什么关系，但是通过这种方式解决跨域问题的话，会在发送请求时出现两种情况，分别为简单请求和复杂请求。

简单请求

以为例，当满足以下条件时，会触发简单请求

使用下列方法之一：

的值仅限于下列三者之一：

text/plain

请求中的任意对象均没有注册任何事件监听器；对象可以使用属性访问

复杂请求

对于复杂请求来说，首先会发起一个预检请求，该请求是方法的，通过该请求来知道服务端是否允许跨域请求。

对于预检请求来说，如果你使用过来设置的话，可能会遇到过这么一个坑。

以下以框架举例

该请求会验证你的字段，没有的话就会报错。

当前端发起了复杂请求后，你会发现就算你代码是正确的，返回结果也永远是报错的。因为预检请求也会进入回调中，也会触发方法，因为预检请求并不包含字段，所以服务端会报错。

想解决这个问题很简单，只需要在回调中过滤方法即可

document.domain

该方式只能用于主域名相同的情况下，比如和适用于该方式。

只需要给页面添加表示主域名都相同就可以实现跨域

postMessage

这种方式通常用于获取嵌入页面中的第三方页面数据。一个页面发送消息，另一个页面判断来源并接收消息

函数柯里化

在一个函数中，首先填充几个参数，然后再返回一个新的函数的技术，称为函数的柯里化。通常可用于在不侵入函数的前提下，为函数预置通用参数，供多次重复调用。