少年づ＾

考过的前端题

考过的前端题------侯先生吃过的亏

对于MVVM的理解
请详细说下你对vue生命周期的理解
Vue组件间的数据传递方式有哪些
Vue的路由实现：hash模式和 history模式原理
vue路由的钩子函数有哪些
的作用是什么?
在Vue中使用插件的步骤
什么是Vue SSR
Proxy 相比于 defineProperty 的优势
vuex是什么？怎么使用？哪种功能场景使用它？
Vue3中自定义指令生命周期的变化及含义
Vue2.x 响应式原理
ES5、ES6和ES2015有什么区别?
在Vue中使用插件的步骤
babel是什么，有什么作用?
举一些ES6对String字符串类型做的常用升级优化?
举一些ES6对Array数组类型做的常用升级优化
说说你对ES6中Generator的理解
说说Promise和async/await 的区别？
说浏览器事件循环和nodeJs的事件循环的区别？
说说你对浏览器缓存机制的理解
说说你对浏览器内核的理解
说说你对nextTick的理解和作用
说说你对webpack的理解
new操作符具体干了什么？
说说你对闭包的理解？闭包使用场景？
说说webpack中常见的Plugin？解决了什么问题？
说说 React中的setState执行机制？
说说你对promise的了解？
网站性能优化的方案都有哪些？
说说浏览器的渐进增强和优雅降级的区别？
null，undefined 的区别
同步和异步的区别
说说你对BFC的理解，触发条件有哪些？
说说重排和重绘的区别？触发条件有哪些？
Vue的自定义指令钩子函数有哪些？你用自定义指令做过什么？
伪类和伪元素的区别有哪些？ Css3新增了哪些选择器
Javascript如何实现继承？
说说什么是严格模式，限制都有哪些？
如何快速的让一个打乱一个数组的顺序，比如 var arr = [1,2,3,4,5,6,7,8,9,10];
你对SPA单页面的理解，它的优缺点分别是什么？如何实现SPA应用呢
SPA首屏加载速度慢怎么解决
说说webpack中常见的Loader？解决了什么问题？
你了解vue的diff算法吗？说说看
简单说一下 Virtual Dom
说说你对Redux的理解？其工作原理？
如何封装组件在不同的项目之间使用如何实现？
说说箭头函数和普通函数的区别
什么是FOUC? 如何避免？
说说你对预编译器的理解？
概述下 React 中的事务处理逻辑
react组件的划分业务组件技术组件？
说说你对Fiber的理解和应用场景
说说html和css渲染的过程是什么
如何判断页面滚动到底部，如何判断页面中元素是否进入可视化区域？
说一下DOM0、DOM2、DOM3事件处理的区别是什么？
说说你对递归的理解？封装一个方法用递归实现树形结构封装
怎么判断一个变量arr的话是否为数组
JS 数据类型有哪些
说你对盒子模型的理解？
如何让一个盒子水平垂直居中,有哪些方法越多越好？
说说javascript都有哪些数据类型，如何存储的？
如何理解响应式，实现响应式的方法有哪些？有什么区别？
判断数据类型的方法有哪些？有什么区别？
说说你对事件循环的理解？
Css选择器有哪些？优先级是什么？哪些属性可以继承？
简单说一下什么是事件代理？
如何理解重回和回流？什么场景下才能
什么是防抖和节流，有什么区别？如何实现？
说说你对作用域链的理解？
说说你对原型和原型链的理解？
bind、call、apply 区别？如何实现一个bind？
如何优化webpack打包速度？
说说箭头函数和普通函数的区别？
说说对React Hooks的理解？解决了什么问题？
UseMemo和useCallback如何提升了性能，应用场景有哪些？
vue、react、angular 区别
如何封装组件在不同的项目之间使用如何实现？
说说你对Redux的理解？其工作原理？
对前端工程师这个职位是怎么样理解的？它的前景会怎么样
说说你都用过css3中的那些新特性？
说说你对BOM的理解，常见的BOM对象你了解哪些？

对于MVVM的理解

MVVM全名是Model-View-ViewModel，是一种通用的软件架构模式。它将应用程序分为三个部分：模型(Model)、视图(View)和视图模型(ViewModel)。

Model代表应用程序中的数据和业务逻辑，处理从后端服务获取或处理数据。模型对象只提供数据，不关心UI或前端界面；
View负责展示应用程序的用户界面(UI)，包括样式、布局、绑定数据等。视图根据需要从视图模型中获取并呈现数据；
ViewModel承担了将Model层和View层连接起来的角色，它充当UI逻辑和业务逻辑之间的桥梁，从Model层获取数据，并将数据封装到一个独立于View的状态中，然后通过双向数据绑定技术将状态绑定到View上。

相对于传统的MVC架构，MVVM模式具备许多优势，例如能实现代码重用、可测试性强、分离结构清晰等。在现今的前端开发领域得到广泛应用，特别是在响应式UI开发、跨平台开发、移动APP开发等方向有较好的效果。

请详细说下你对vue生命周期的理解

Vue.js 是一种流行的JavaScript框架，其设计了一些生命周期钩子函数，使开发者能够在关键阶段完善组件的状态或执行特定的功能。Vue的生命周期分为八个部分：

beforeCreate：组件实例被创建前调用，此时还没有初始化，data和methods等选项都未挂载；
created：组件实例已经创建完成，可访问到data和methods等选项，但DOM结构还未生成；
beforeMount：在DOM挂载之前被调用，此时组件不会渲染，常用于异步获取数据的场景；
mounted：组件渲染完成并已挂载到页面中后被调用，添加事件监听器或操作 DOM 和第三方库的入口通常放置在这里；
beforeUpdate：响应式数据发生修改，并且重新渲染之前被调用，该钩子函数中最好不要去修改组件中的 state；
updated：组件更新后调用，可以执行依赖于DOM操作的代码，但需要确保不会导致无限循环更新；
beforeDestroy：在实例销毁之前调用，在这里执行清理工作，如取消计时器或事件监听器等；
destroyed：组件实例从页面中销毁后被调用，一些插件和缓存需在该生命周期断开服务。

掌握Vue生命周期的钩子函数可以帮助我们更好地理解Vue组件的构造和工作方式，并且在开发中能更好地优化性能，避免内存泄漏等问题。

Vue组件间的数据传递方式有哪些

在 Vue 中，组件间数据传递方式主要包括以下几种：

父子组件之间的传递：父组件通过props属性向子组件传递数据，这种方式适用于父组件已知需要传递的数据信息，而子组件需要获取和使用该信息。
子父组件之间的传递：子组件通过 $emit 方法触发父组件自定义事件，向父组件传递数据。这种方式适用于子组件中发生了一些业务逻辑或者用户交互行为，需要通知到父组件去执行一些操作。
兄弟组件之间的传递：可以通过一个共享的Vue实例，作为中央事件总线（Event Bus），来进行兄弟组件之间的通信。中央事件总线就是将需要在组件间共享的数据、方法等放在同一个实例中，供各个组件引用访问的对象，其常用API为 $on $once $emit $off 。
Vuex 进行数据的全局管理：如果应用的状态管理较为复杂，那么可以使用 Vuex，对全部的state 进行集中式管理，不仅解决了组件间的数据共享问题，同时还能方便地对数据状态进行调试、预测和追踪。

以上几种方式都具有其独特的场景和优缺点，开发者需要按照具体的情况选择合适的方式进行数据传递处理。

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

vue路由的钩子函数有哪些

在 Vue Router 中，可以使用以下路由钩子函数（路由导航守卫）：

beforeEach(to, from, next) - 当每个路由进入之前调用，全局前置守卫。
beforeResolve(to, from, next) - 在所有绑定的组件被渲染之前调用，全局解析守卫。
afterEach(to, from) - 当每个路由完成后调用，全局后置钩子。
beforeEnter(to, from, next) - 路由独享的守卫。
enter(to, from, next) - 被渲染的组件内部，当组件激活时调用。
leave(to, from, next) - 被渲染的组件内部，当组件离开时调用。

需要注意的是，全局守卫可以作为插件使用，在任何地方调用，而组件内的守卫只能够在当前 vue-router 路由配置下进行访问。

以上这些路由钩子函数提供了开发者更加灵活的路径拦截和流程控制方式来实现一些特定的处理逻辑，如权限验证、页面访问限制等。如果需要深度学习，建议通过官方文档进行学习及了解，文档质量较高，且使用非常普及。

的作用是什么?

是 Vue 内置的一个组件，其作用可以实现缓存不活动的组件实例，而不是销毁和重新创建它们。这样在组件切换时，能够有效地提升页面性能。

具体来说，的作用包括：

缓存组件：当组件被包裹在中时，在组件的 activated 和 deactivated 生命周期中会触发相应的钩子函数，所以可以通过这两个函数对组件进行缓存和缓存回收处理，避免频繁地创建和销毁组件，提高了页面的性能和用户体验。
组件状态的保留：由于使用了缓存机制，因此使用包装的组件在切换时，能够保留其之前的状态、数据和DOM 结构，且当前的路由信息已经缓存，直接从 keep-alive 所缓存的队列中取出并进行相关操作，能够达到优化渲染速度的目的。

需要注意的是，如果要实现缓存效果，还需要给中的组件添加name属性，该属性的值用于标识这个组件缓存实例的唯一性，否则可能会产生bug。

综上所述，能够有效提升页面性能，尤其是在存在复杂组件切换、大数据量列表渲染等场景时，非常有用。

在Vue中使用插件的步骤

在Vue中使用插件的步骤可以概括为以下几个：

引入插件：通常情况下，我们需要在Vue应用创建之前引入需要使用的插件。这可以通过直接在 HTML 内部或外部引入插件脚本文件来实现，也可以通过在模块加载器（如webpack）中使用import语句来导入插件。
安装插件：引入插件文件后，我们需要在 Vue 应用中安装该插件。当使用 Vue.use() 方法安装插件时，会调用插件提供的 install 方法。此时，我们可以在 install 方法中执行一些初始化逻辑或添加全局组件、指令、mixins 等。需要注意的是，一个插件只能被安装一次，重复安装同一个插件将不会有效果。
使用插件：当插件安装完成后，就可以在 Vue 应用中使用插件提供的功能了。例如，如果我们安装了vue-router插件，则可以在项目中使用router-view和router-link等组件，实现页面路由和跳转。

总的来说，在 Vue 中使用插件是非常简单的。大多数插件已经实现了封装和打包，并且本身提供了完善的文档说明。我们只需要按照插件文档提供的方式进行引入和安装，就可以实现对项目的增强功能。

什么是Vue SSR

Vue SSR（Server-Side Rendering，服务器端渲染）是一种使得 Vue 应用在服务端也能够运行的方式。传统的 Vue 在浏览器环境下通过使用虚拟 DOM（Virtual DOM）将数据和 UI 同步更新，而 Vue SSR 在服务端使用模版引擎将组件渲染成 HTML 字符串，然后在客户端通过浏览器重新 hydrate（深度克隆）该页面以及注册事件。

Vue SSR 带来了以下好处：

更快的首屏渲染速度：对于传统单页面应用，往往需要等待所有 JavaScript 文件都加载完成之后才能进行首屏渲染，从而导致页面响应速度变慢。而采用 SSR 初次请求即可获得完全渲染好的HTML字符串，可以极大地提高首屏渲染速度，对于用户体验大有益处；
更适合 SEO：对于使用单页面应用技术框架（如 Vue、React 等）开发的网站，由于搜索引擎爬虫大多无法解析动态生成的内容，因此不利于 SEO。而采用 SSR 技术可以直接在服务端生成整个页面的完整 HTML 内容并返回给客户端，有助于提升搜索引擎的排名；
更灵活：采用 SSR 技术可以更灵活地调试和优化应用程序，可以提供更加友好和健壮的用户体验。

需要注意的是，Vue SSR 对服务器端的性能和稳定性要求比较高，因此开发过程中需要考虑到一些额外的问题，如服务端路由、数据预取等。但借助于 Vue-CLI 或 Nuxt.js 等支持 SSR 的框架，我们可以相对轻松地实现高性能和记录的服务器端渲染过程。

Proxy 相比于 defineProperty 的优势

相比于 Object.defineProperty()，Proxy 具有以下优势：

更加灵活的处理：Object.defineProperty() 只能针对某个对象的某个属性进行拦截和修改，无法对整个对象或数组进行劫持。而 Proxy 对象可以通过对 whole object 的 trap 及 Reflect API 来实现更加复杂数据结构的劫持，同时还可以拦截 delete 操作、defineProperty 动态添加属性、访问不可配置属性和 super 等。
更多的内置方法/操作的拦截支持：Object.defineProperty() 同样也无法拦截一些内置的 JavaScript 方法和操作，如Object.getOwnPropertyNames()、Object.assign()、Reflect 和代表数字下标的 Symbol.iterator 等。但是，Proxy 可以通过捕获这些命令的 trap 来实现更多的内置方法/操作。
性能更高：在大量修改数据时，使用 Object.defineProperty() 会导致执行效率降低。而 Proxy 的代理方式相较之而言，代理器只需拦截单次操作，不需要频繁地往 target 上挂载 getter/setter 并且其也允许批量读写数据能力更好，在性能上会比 defineProperty() 更优。

总的来说，虽然 Object.defineProperty() 由于 ES5 版本开始就被广泛使用，但 Proxy 作为一种新的代理机制，可以提供更加灵活的拦截和处理方式，同时还具有更好的性能表现，因此现在已经被越来越多的开发者所采用。

vuex是什么？怎么使用？哪种功能场景使用它？

Vue3中自定义指令生命周期的变化及含义

Vue3中自定义指令的生命周期发生了一些变化，大体上分为两类：钩子函数名称的变化和钩子函数参数的变化。

钩子函数名称的变化

Vue2中自定义指令有五个生命周期钩子函数：bind、inserted、update、componentUpdated、unbind。在Vue3中，这些钩子函数的名称发生了改变：

bind --> beforeMount
inserted --> mounted
update -->beforeUpdate
componentUpdated – updated
unbind -->unmounted

-钩子函数参数的变化
在Vue2中，自定义指令的生命周期钩子函数有两个参数：el和binding。在Vue3中，生命周期钩子函数的参数发生了一些变化：

beforeMount和mounted:只有一个参数VNode
beforeUpdate和updated：只有两个参数，VNode和prevNode
unmounted：只有一个参数 VNode
其中，vnode表示虚拟节点，prevVnode表示更新前的虚拟节点。在beforeUpdate和updated这两个钩子函数中，可以通过比较vnode和prevVnode来判断指令绑定的属性是否被更新。

Vue2.x 响应式原理

Vue2.x 的响应式原理基于 Object.defineProperty()方法，实现了数据双向绑定。

当 Vue 初始化时，会遍历 data 对象里的所有属性，并对每个属性使用 Object.defineProperty() 方法将其转化为 getter 和 setter。因此访问和修改 data 属性值时，都会触发相应的 getter 或 setter 方法，进行依赖收集和派发更新。

响应式原理的主要流程如下：

初始化：被监控的对象通过递归的方式重写对象属性的 getter 和 setter 方法，给属性添加Dep对象用于收集Watcher；
数据更新：当被监控的对象的属性被修改后，setter方法会发送消息通知Dep中记录的所有Watcher对象；
视图更新：Watcher对象接收到消息后执行组件的update视图函数，从而重新渲染视图；
依赖收集：在模板编译过程中，在模板中对属性的引用会创建一个对应的Watcher对象，并将这个Watcher对象添加到Dep对象中；

Vue2.x 的响应式原理具有以下特点：

只对指定对象上已有的属性进行劫持，无法检测到新属性的添加，需要使用 $set 方法手动添加监听；
每个属性都会关联一个 Dep 对象，每次修改属性都需要重新收集依赖；
Watcher 是连接数据和视图的桥梁，当依赖的数据变化时，Watcher 会通知视图重新渲染；
对象的每一级属性都会创建一个对应的 Dep 对象，它负责收集依赖并通知 Watcher。

总之，Vue2.x 的响应式原理通过监听对象属性的变化来实现数据和视图的双向绑定。这种机制非常聪明和高效，使得 Vue 应用可以自动、浅层次的追踪数据变更，并且在数据变化时立即派发更新通知模板重新渲染。

ES5、ES6和ES2015有什么区别?

ES5和ES6是JavaScript语言的两个版本，而ES2015是ES6的官方标准名称。因此，ES6和ES2015可以视为同一版本。

ES5作为第五版的ECMAScript标准于2009年发布，目前已经成为JavaScript的基础标准，同时也是浏览器支持最广泛的标准之一。ES6/ES2015作为ECMAScript第六版语言规范于2015年发布，包含了大量新增特性、更加严格的语法定义以及更好的性能和可读性。

ES5和ES6/ES2015之间的主要区别在于语言特性和语法的变化，具体包括：

新增的 let 和 const 关键字，用于声明块级作用域的变量；
强化的对象字面量表示法（{}）和数组解构，简化对象和数组操作；
模板字符串的引入（${}），可以方便地进行字符串拼接；
新增的箭头函数，可以使得函数体更加紧凑和可读性更高，同时避免了this指向的误差；
类的引入，实现了真正意义上的面向对象编程，并提供了更为直观的语法来处理原型继承，从而更易于代码重用；
Promise和Generator 函数，分别强化了异步编程和控制流的可读性和可维护性。

总之，ES6/ES2015作为JavaScript语言的重要升级版本，带来了很多新的语言特性和重大变化。这些变化不仅从整体上改善了代码的质量和可维护性，还对JavaScript开发人员提供了更加灵活和高效的编程手段。

在Vue中使用插件的步骤

babel是什么，有什么作用?

Babel是一个流行的JavaScript编译器，它能将最新版本的JavaScript语法转换为当前或更旧的浏览器和环境支持的格式。Babel允许开发者编写现代化的JavaScript代码并具有向后兼容性，从而实现跨平台开发的目的。

Babel主要有以下作用：

转译ES6+语法：Babel主要应用区域在于ECMAScript规范和 JavaScript语言特性转义，如箭头函数、模板字符串、解构赋值、let/const等，旧版浏览器或其他JavaScript环境可以通过Babel进行自动提升；
转译JSX语法：React组件中的JSX通常无法被一些浏览器理解和解析，Babel可以将JSX渲染函数转义成普通的JavaScript函数，使得React组件可以在多种环境中运行；
预设插件扩展：Babel提供了大量的预设插件,可以根据开发需要灵活配置；
优化打包体积：除了使用Polyfill对低版本不支持的语法进行兼容外，还有tree shaking、压缩等打包工具配合使用可有效减小文件体积；
满足开发需求：引入 Babel 可以在代码中使用诸如装饰器、提案的 class 属性、bind 操作符等相关语言特性，方便开发者实现需求。

总之，Babel作为一个通用的JavaScript编译器，可帮助开发者处理各种JavaScript语言的转义和兼容问题，同时可以辅助清理掉一些冗余代码和提升整个项目的性能。

举一些ES6对String字符串类型做的常用升级优化?

ES6主要提供了以下对字符串类型做的升级优化：

模板字符串 (Template Strings)：ES6中可以用反引号``来定义一个模板字符串，用 ${} 来嵌入变量或表达式，使得字符串拼接更加简洁明了；
新增 startsWith()和 endsWith() 方法：判断一个字符串是否以另一个给定的子字符串开头或结尾，简化以往复杂的字符串匹配处理；
新增repeat()方法: 可以重复字符串输出 N 次，方便实用;
使用 padStart()和 padEnd()方法：在字符串前面或后面填充一些字符，常用于格式化数字或字母；
新增 String.raw() 方法: 一种原始的操作，可以取消转义多余的元素，字面量的写法更加灵活。

这些升级优化带来了更便利的语法和更高效的字符串处理性能，方便了开发者在处理字符串数据结构过程中更好地优化代码。同时，这些新特性也有助于降低代码复杂度，提高代码可维护性和重用性。

举一些ES6对Array数组类型做的常用升级优化

ES6主要提供了以下对数组类型做的升级优化：

新增Array.from()方法：将类数组对象或具有迭代器接口的对象转换为数组，使得非数组类型的数据结构可以方便地使用数组的方法和属性；
新增Array.of()方法：用于创建一个具有可变数量参数的新数组实例，通常使用在需要快速初始化数组时；
使用find()、findIndex() 方法：分别返回数组中满足条件的元素，以及匹配元素的索引位置，找到后即停止遍历，减少了数组遍历中无效的轮训；
使用includes() 方法：判断数组是否包含某个指定元素，替代 indexOf() 从而减少代码并简化读写;
新增forEach()、map()、filter()、reduce() 等高阶函数：以函数式编程的思想改变传统开发方式，封装了常见操作，更便利且语法清晰易读。

这些升级优化带来了更便利的语法和更高效的计算性能，方便了开发者在处理数组数据结构的过程中更好地优化代码。同时，这些新特性也有助于降低代码复杂度，提高代码可维护性和重用性。

说说你对ES6中Generator的理解

ES6中的 Generator（生成器）是一个可以暂停和继续执行的函数，可以用于异步编程、迭代器的实现以及可以用来进行数据流处理等。

具体来说，Generator 的主要特点包括：

可以使用 yield 暂停和继续执行: 当 generator 函数被调用执行时，不会立即执行函数体，而是返回一个迭代器对象，通过该对象可以遍历依次获取函数中通过 yield 关键字返回的值，直到遇到 return 语句或者所有 yield 都执行完毕时，则迭代器结束。
状态保留: Generator 能够保存上一次迭代器执行的位置，从而可以在下次调用 next() 方法时从上次中断的地方继续执行。
异步编程的支持: 在 Generator 中使用 yield 语句来暂停函数执行，在需要等待异步操作完成后再恢复执行。
可以作为迭代器的实现: Generator 可以通过 yield 语句，依次将数据传递给迭代器，支持更加灵活的自定义迭代器实现。
可以用来进行数据流处理: 利用 Generator 的实现原理，可以非常方便地实现数据流的处理，如洋葱模型等。

需要注意的是，在使用 Generator 时，需要使用 * 声明函数为 generator 函数。在使用 next() 方法迭代时，每次调用 next() 会移动指针至下一个 yield 表达式，同时将 yield 的值作为下一个 yield() 函数的返回值。

综上所述，Generator 是 JS 中非常有用的一种函数模式，不仅可以实现同步流程控制，还能够支持异步、迭代器的实现以及数据流处理等功能。

说说Promise和async/await 的区别？

Promise 和 async/await 都是 JavaScript 中用于处理异步请求的方法。

Promise 是一种可以对异步操作进行链式调用的方式，其主要特点包括：

Promise 使用 then() 方法来注册回调函数，并返回一个新的 Promise 对象，从而可以实现对多个异步操作的串行或并行调用。
Promise 的优点是比较灵活，支持链式调用、层层嵌套等复杂的异步操作。
但 Promise 的缺点是在使用时需要不断地使用 then() 方法嵌套，代码可读性较差。

async/await 在 ES7 中添加了对异步编程的原生支持，其主要特点包括：

async/await 是基于 Promise 的，其中 async 函数会自动将其结果封装成一个 Promise 对象，而 await 则等待该 Promise 对象的解析返回结果。
async/await 的优点是使用起来更加简洁明了，在链式调用方面也比 Promise 更加直观。同时，也使得异步操作的异常处理更加简单和合理。
其缺点是可能出现阻塞状态，因为 await 命令会阻塞后面的代码执行，由此可能导致程序的效率降低。

综上所述，Promise 和 async/await 都是 JS 中用来处理异步操作的方法，它们都有自己的优点和缺点，开发者需要根据具体的情况和需求选择适合自己的方法。在使用时应注意代码的可读性，避免过度嵌套或阻塞等问题。

说浏览器事件循环和nodeJs的事件循环的区别？

浏览器事件循环和 Node.js 事件循环都是在 JavaScript 中实现异步编程的重要机制，但二者有一些差异。

在浏览器中，事件循环（Event Loop）的执行顺序如下：

执行完当前的同步任务，将所有到达时间阈值的定时器回调函数加入一个执行队列。
当执行队列不为空时，将队列中第一个时间队列的回调函数压入调用堆栈中执行。
不断重复步骤2，直到队列为空，再去执行微任务队列中的任务。
不断重复步骤3，直到微任务队列为空。
回到步骤1，继续执行新的同步任务。

Node.js 中的事件循环与浏览器有以下区别：

浏览器使用 Web APIs 来实现异步请求，而 Node.js 使用 libuv 等底层库来实现异步操作。
在 Node.js 中，微任务队列是通过 process.nextTick() 方法维护的，这使得其微任务的优先级比浏览器更高。
在 Node.js 中，如果 Event Loop 中的所有阶段都完成了且没有其他I/O活动，它会进入idle阶段并等待附加的I/O回调，这可以提供更好的性能和资源利用率。

综上所述，虽然二者都是基于事件循环机制实现的异步编程，但由于 Node.js 是基于独立进程架构运行的后端 JavaScript 程序，因此其事件循环与浏览器存在区别，Node.js 可以提供更好的性能和资源利用率，并且拥有更高的微任务队列优先级。

说说你对浏览器缓存机制的理解

浏览器缓存机制是浏览器在访问 Web 页面时，为了提高用户体验和降低网络带宽资源开销所采用的一种机制。其主要作用是将浏览器已经请求过的静态资源（如图片、脚本、样式文件等）缓存在本地，在下次访问页面时可以直接从缓存中读取而无需重新请求服务器。

常见的浏览器缓存机制有以下几种：

强缓存：浏览器在第一次请求资源时，通过设置响应头中的 Cache-Control 或 Expires 字段来指定该资源的缓存时间。当再次请求该资源时，浏览器会比较当前时间与过期时间，如果未过期则直接从本地缓存读取资源，不向服务器发送请求，否则则重新请求资源并更新缓存。
协商缓存：强缓存失效后，浏览器会向服务器发送 HTTP 请求，服务器会返回资源的最后修改时间或 ETag 标识符（即文件内容的唯一标识），浏览器再次请求资源时会带上 If-Modified-Since 或 If-None-Match 首部字段，表示资源的时间戳或 ETag 值，并由服务器进行校验，如果服务器认为客户端的缓存是最新的，则返回304状态码，告诉浏览器使用本地缓存数据。
Service Worker 缓存：使用 Service Worker 技术，可以将 Web 应用中的资源缓存到本地，并在网络不可用时直接读取缓存数据，从而实现离线访问和增强应用程序性能的效果。

需要注意的是，在实际的开发过程中，我们需要根据具体情况灵活掌握浏览器缓存机制的应用，结合 HTTP 协议和响应头字段的设置来优化图像、CSS、脚本等静态资源的加载速度，提升用户的使用体验。

说说你对浏览器内核的理解

浏览器内核指的是浏览器用于解析 HTML、CSS 和 JavaScript 代码，渲染和显示 Web 页面的核心引擎。目前主流的浏览器内核主要有两种：Trident（或称为 MSHTML）、Gecko、Blink/WebKit等。

Trident 内核：是微软开发的一款浏览器内核，最早是在 Internet Explorer 4.0 中使用，现在仍广泛应用于 Internet Explorer 浏览器中。其特点是安全性较低，兼容性好，但对 HTML5 和 CSS3 的支持比较差。
Gecko 内核：是 Mozilla 公司开发的一款浏览器内核，现在被 Firefox 等浏览器采用。它具有强大的 JavaScript 引擎，能够实现高效的渲染和动态效果，但相对来说资源占用较多。
WebKit/Blink 内核：原本是 KDE 开发的一款浏览器引擎，后来由苹果公司改写为 WebKit，并被 Safari 等众多浏览器采用。Blink 是由谷歌公司基于 WebKit 改造而来，现在被 Chrome 等浏览器采用。Webkit/Blink 内核支持 HTML5 和 CSS3 规范，且速度快、稳定性强。

总的来说，不同的浏览器内核对 Web 页面的解析和呈现方式有着各自的特点和优劣，前端开发者需要了解并掌握不同浏览器内核的相关知识，以便在开发过程中针对性地优化和调整页面结构和样式。

说说你对nextTick的理解和作用

nextTick 是 Node.js 中的一个 API，用于将回调函数推迟到事件循环的下一轮执行。具体来说，当在当前事件循环（Event Loop）中调用 nextTick() 时，它所接收的回调函数会被添加到微任务队列尾部，在本次事件循环结束后立即执行，优先于 I/O 操作、计时器等其他异步事件。

由于 nextTick() 执行的优先级很高且不可被打断，因此我们可以利用它在避免竞争条件和实现异步递归（递归函数一般会阻塞事件循环）等方面发挥作用。例如，我们可以对一个数组进行大规模遍历操作，每次遍历一定数量的元素就将余下的元素交给 nextTick() 延后执行，从而避免了大量计算造成的长时间阻塞。

需要注意的是，nextTick() 不适用于大规模或密集的计算操作，否则会占据 Node.js 主线程资源，导致程序失去响应，影响系统性能和用户体验。因此，在使用 nextTick() 时应该根据情况为其设置合理的时间间隔，控制回调函数的执行频率。

说说你对webpack的理解

Webpack 是一个现代化的 JavaScript 应用程序静态模块打包器（module bundler）。它可以分析代码，将多个模块打包成一系列文件，在浏览器中以最优方式加载。简单来说，Webpack 主要负责解析应用程序依赖树，将多个模块打包合并为一个或多个 bundle 文件，并提供 loader 和 plugin 机制处理应用程序中的各种格式的文件。

Webpack 支持 CommonJS 和 AMD 模块规范，同时也支持 ES6 Module。通过借助于 Loader，Webpack 可以对指定类型的静态资源如 CSS、图片等生成同样 Webpack 能够识别的模块，从而能够使这些在编译之后能够像 JavaScript 模块一样使用。另外，Webpack 还提供了大量的插件，如 hot module replacement、source map 等，来满足各种开发需要。

通过使用 Webpack，我们可以实现代码拆分和按需加载，减小初始化加载资源的大小，防止过多不必要的网络请求，提高应用程序的性能和用户体验。同时，Webpack 也支持丰富的扩展，使得开发者可以自由发挥创造力去完成更多自己的想法。

new操作符具体干了什么？

new 操作符用于创建一个对象实例，其干的具体事情如下：

创建一个新对象。该对象是由构造函数的原型（即 __proto__ 属性）派生而来。
将新对象作为 this 对象传递给构造函数。这样，构造函数内部的代码就可以通过 this 引用新对象，并对其进行操作。
如果构造函数返回值是一个对象，则 new 表达式返回该对象。否则，返回刚刚创建的新对象。

以下是一个简单的构造函数例子：

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.greet = function() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  };
}

const person1 = new Person("Amy", 22);
person1.greet(); // 输出：Hello, my name is Amy and I am 22 years old.

在上面的例子中使用了 new 操作符来创建一个 Person 类型的对象实例 person1。new Person("Amy", 22) 执行过程中会将 Person 函数的执行上下文变为 person1 对象，并将 name 和 age 属性赋值给 person1 对象，最后执行 greet 方法。

说说你对闭包的理解？闭包使用场景？

闭包是指一个函数能够继续访问它定义时所在的词法作用域中的变量。简单来说，就是内部函数可以访问到外部函数作用域的变量，而这些变量称为闭包。

闭包的一个重要特点是，即使外部函数执行完毕后，依然可以访问外部函数定义时所在的作用域。闭包可以帮助我们隐藏私有变量、模拟块级作用域等。

闭包的使用场景如下：

执行一次性初始化操作：在初始化时，利用闭包将一些变量保留下来，供以后的调用使用，从而避免了重复初始化的消耗。
私有变量共享：Javascript 缺少对私有变量的支持，但是闭包却可以实现私有变量的共享。
模块化开发：利用闭包的私有变量机制，可以封装一些只提供 API 接口而不提供实现细节的代码块，从而实现模块化开发的效果。
防止变量污染：在局部作用域内定义一个闭包，可以避免全局变量的被篡改，这对于开发大型应用程序时非常有用。

以下是一个闭包的示例：

function counter() {
  let count = 0;
  return function() {
    return ++count;
  };
}

const increment = counter();
console.log(increment()); // 输出：1
console.log(increment()); // 输出：2
console.log(increment()); // 输出：3

在上面的例子中，counter 函数返回了一个函数，该函数可以访问到 counter 函数内部的变量 count。每次调用 increment() 函数时，都会执行返回的匿名函数，并将 count 的值自增。由于闭包的存在，count 变量的值被一直保留着。

说说webpack中常见的Plugin？解决了什么问题？

Webpack 是一个现代化的 JavaScript 打包工具，可以将各种 Web 资源进行打包、压缩、转换等处理。在 Webpack 中，Plugin 是用于扩展其功能的关键模块之一。Plugin 可以帮助我们解决各种 Web 开发中的问题，比如引入第三方库、代码分割、自动生成 HTML 文件、压缩代码等。

以下是常见的几种 Webpack Plugin：

HtmlWebpackPlugin：可以根据模板生成 HTML 文件，并自动添加打包后产生的 JS 和 CSS 等文件的引用。
terser-webpack-plugin：可以对 JS 代码进行压缩和混淆，从而减小打包后文件的体积。
MiniCssExtractPlugin：将样式文件从 JS 中抽离出来，使得样式文件可以进行单独的压缩和加载，并提高页面的渲染性能。
CopyWebpackPlugin：可以将指定的文件或目录复制到输出目录下，常用于拷贝图片、字体等静态资源。
DefinePlugin：可以定义全局常量，在代码中使用这些常量时，Webpack 会将其替换成相应的值。常用于区分开发环境和生产环境。
ProvidePlugin：可以在模块中自动加载指定的模块，无需通过 import/require 引入。常用于加载第三方库或框架。

以上这些 Plugin，都能够帮助我们减少手动操作、提升开发效率、优化代码质量和性能，从而更好地完成 Web 应用程序的开发。

说说 React中的setState执行机制？

在 React 中，组件的状态是通过使用 state 对象来管理的。当组件的状态发生改变时，我们通常会使用 setState 方法来更新状态，并通知 React 重新渲染该组件。

setState 是异步执行的，它会将状态的更新放入一个队列中，并告诉 React 需要重新渲染该组件。然而，React 并不会立即对组件进行重新渲染，而是先使用事务机制将多个更新操作打包成一个操作，最终只对组件进行一次重新渲染。

更具体来说，setState 执行的过程如下：

当调用 setState 的时候，React 将更改前和更改后的状态对象合并起来，得到最新的状态对象。
React 判断当前是否处于批量更新模式，如果是，则将这个更新操作加入到更新队列中，等待之后进行批量更新。
如果当前不处于批量更新模式，React 会开启新的批量更新，并将这个更新操作加入到批量更新队列中。同时，React 设置一个标记位，表示当前处于批量更新模式。
React 在合适的时机，结束批量更新，并开始遍历批量更新队列，计算出最终的状态值并触发组件的更新。
一旦所有的组件都完成了更新，React 会清空更新队列，标记位恢复为非批量更新模式。

需要注意的是，由于 setState 是异步执行的，因此如果有多个连续的 setState 调用，可能会遇到没有得到最新状态的问题。如果需要得到最新状态执行一些操作，可以在 setState 的回调函数中进行相关操作。例如：

this.setState({ count: this.state.count + 1 }, () => {
  console.log(this.state.count); // 在回调函数中得到最新状态
});

需要注意的是，在回调函数中访问状态时一定要使用回调函数中的参数，而不是 this.state。因为 React 并不保证回调函数中的 this.state 是最新的状态值，而参数中传入的状态则确保是最新的。

说说你对promise的了解？

Promise 是一种用于异步编程的 JavaScript 对象，它在 ES6 中被引入，并得到了广泛的应用。 Promise 可以帮助我们处理各种异步操作，比如文件读写、AJAX 请求、定时器等，在编写异步代码时非常实用。

Promise 有三种状态：

Pending（进行中）：初始状态，表示 Promise 的状态还没有确定；
Fulfilled（已成功）：表示 Promise 的异步操作执行成功并返回了一个结果，此时 Promise 将会返回这个结果；
Rejected（已失败）：表示 Promise 执行过程中发生错误，无法完成异步操作。

当 Promise 进入 Fulfilled 或者 Rejected 状态之后，就不能再改变其状态。同时，可以通过 .then() 来注册 Promise 对象在 Fulfilled 状态下的回调函数，或者使用 .catch() 来捕获 Promise 对象在 Rejected 状态下的错误信息。

例如，我们可以结合 AJAX 请求来实现 Promise：

function ajax(url) {
  return new Promise((resolve, reject) => {
    const xhr = new XMLHttpRequest();
    xhr.open('GET', url);
    xhr.onreadystatechange = function() {
      if (xhr.readyState === 4) {
        if (xhr.status === 200) {
          resolve(xhr.response);
        } else {
          reject(new Error(xhr.statusText));
        }
      }
    };
    xhr.onerror = function() {
      reject(new Error('Network error'));
    };
    xhr.send();
  });
}

ajax('/data.json')
  .then(response => console.log(response))
  .catch(error => console.error(error));

在上述代码中，我们通过 new Promise() 创建了一个新的 Promise 对象，并在其中进行了 AJAX 请求。如果请求成功，则用 resolve() 方法将得到的响应赋给回调函数；如果请求失败，则用 reject() 方法将错误信息赋给回调函数。随后，我们结合 then() 和 catch() 来处理 Promise 返回的结果。

需要注意的是，在 Promise 中有一个重要的概念——“链式调用”。这意味着，每个 .then() 或 .catch() 都会返回一个新的 Promise 对象，可以继续在其上进行操作。例如：

fetch(url)
  .then(response => response.text())
  .then(text => console.log(text))
  .catch(error => console.error(error));

在这个例子中，首先使用 fetch() 发送 AJAX 请求，通过 .then() 将

网站性能优化的方案都有哪些？

以下是几种常见的网站性能优化方案：

压缩和缩小文件大小：通过压缩CSS、JavaScript和HTML等静态文件，减少请求大小，并使用图像优化技术来优化图像大小。
简化页面设计：去除不必要的元素，减少HTTP请求数量，提高页面加载速度。合并多个CSS或JS文件、精简代码等也是可以考虑的手段。
网络传输加速：使用CDN分发网络访问量大的静态资源；配置HTTP缓存和GZip压缩；使用百度MIP、谷歌AMP等移动端框架，以及将关键路径上的渲染块或样式尽可能向前移动等。
服务器端压力减轻：使用负载均衡技术、适当调整Web容器或代理服务器的参数，周期性地清理服务器数据，优化数据库查询等操作。
异步加载内容：对于长一点的或者容易展开的内容，可以使用AJAX异步刷新，避免每次刷新页面时重复加载数据，减少页面加载时间。
懒加载技术：对于图片等资源可以根据用户滚动行为异步加载，提高页面展示速度。
移动端适配：优化网站在不同分辨率设备上的显示效果，并对不同分辨率设备做清晰度处理，提高用户体验。

总之，网站性能优化需要综合考虑多个方面的因素。一旦改进策略被确定了，实施和不断调整操作方法以持续优化是十分必要的。

说说浏览器的渐进增强和优雅降级的区别？

浏览器的渐进增强（progressive enhancement）和优雅降级（graceful degradation）都是Web开发的两种策略，目的都是实现跨浏览器兼容性。

渐进增强是从一个基础功能开始，逐步向更高级的功能进行增加。这个基础功能要对所有浏览器都能正常地工作。当使用一些先进的技术或者某些浏览器不支持的特性时，它们也不会影响到网站的基本功能。比如说，在较新的浏览器上，我们可以使用HTML5的语义化标签、CSS3的阴影、圆角等美化页面；但在老版本浏览器中（如IE6），这些特性并不被支持，所以我们需要采用其他的方法以保证页面正常显示。

优雅降级是从一个复杂的功能开始，逐步向简单的功能倒退。在设计网站时，通过考虑老浏览器的兼容性，首先实现所有浏览器可支持的完整功能。肯定有浏览器无法支持某个高级的特性，此时我们可以让这些浏览器看到一个相对简单但仍然有效的实现，而不能直接让它们看到错误。如采用JS制作的模糊效果，在IE浏览器上无法生效，我们可以通过兼容写法在IE浏览器上实现简单的不透明度控制来优雅降级。

总之，渐进增强是从简单开始，向复杂逐步加强；优雅降级则是从复杂开始，向简单倒退。无论哪种策略，都是为了能够在所有浏览器上提供最好的用户体验。

null，undefined 的区别

null和undefined都是JavaScript中表示“无”的值，但它们的用途略有不同：

undefined 表示声明了一个变量但是未对其进行初始化赋值；或者是引用一个不存在的属性时返回的默认值，也就是说，undefined表示并没有给该变量或属性指定具体的值。
null则表示该变量或属性存在，但是没有具体的值，或者暂时还不可用（即表示一个空对象指针）。

可以看到二者的区别在于undefined表示的是缺失了一个本应该存在的值，而null表示的是一个已经被定义过但是空缺的对象值，另外undefined属于基本数据类型，而null属于对象类型。

在编写代码时，可以利用这些差异来辨别变量或属性的状态，在某些情况下可以更好地控制程序流程。例如，当需要判断调用函数时是否传入参数时，可以用“参数 === undefined”来判断参数是否为未定义，而如果某个对象存在但没有定义特定的属性，则相关判断场景最好使用 “属性名 === null”。

同步和异步的区别

同步和异步是指在程序执行过程中处理任务的两种不同方式。

同步指的是代码按顺序执行，每条语句需要等待上一条语句执行完成后才能依次执行。当一个任务启动时，会一直等待该任务执行完毕后，才会开始下一个任务。这样做有利于代码软件流程控制及信息处理的可预测性和安全性，但也很容易因为某个阻塞操作耗费时间过长而导致主线程被阻塞，从而导致程序崩溃或出现其他异常状况。

异步则非常灵活，常用于I/O、GUI交互、文件读写等场景。异步任务的启动并不会等待前面的任务执行完毕，而是立即返回，当前上下文的太阳（比如主线程）可以继续处理其它任务，异步任务状态会变成“挂起” 或者 “等待” 状态，并在将来某个时候再次通知上下文继续执行，这种通知机制可以是回调函数，Promise对象, async/await 等。在等待异步任务结果期间，本地线程可以同时继续执行其它任务，从而避免了耗费大量时间停滞不前的尴尬境地，提高了程序流畅性以及对外反应快速的特性。

异步操作还可以实现高效的并行处理，例如通过WebWorker将计算密集型任务从主线程中移出，由另一个线程独立执行，从而增加程序可用性和执行效率。

简言之，同步是指前一个任务完成后再执行下一个任务，而异步则是启动后不会等待结果而直接去执行后面的代码，通常可以更快地完成任务并且能够提升代码效率。

说说你对BFC的理解，触发条件有哪些？

BFC（Block Formatting Context）是指块级格式化上下文，是Web页面中一个重要的渲染概念。BFC在浏览器渲染Web页面过程中起到了非常重要的作用，它是Web页面布局的核心基础之一，可以解决各种问题。

BFC的主要作用和特点有：

阻止外部元素的浮动影响
清除自身内部的浮动
避免margin重叠
自适应高度

触发BFC的条件有：

浮动：如果一个元素被设置为浮动，那么它会触发BFC。
绝对定位：如果一个元素被设置为绝对定位，那么它会触发BFC。
父元素设置display:flex或者display:inline-flex属性
overflow属性不为visible：如果一个元素的overflow属性为auto、scroll或hidden，那么它也会触发BFC。

BFC是一种独立的渲染区域，所以其中的元素不会影响到外部元素，同时内部元素也互相隔离，从而有效避免了一些常见的布局问题，例如清除浮动、防止 margin 重叠等。因此，在Web页面开发中，建议尽量多应用BFC来进行布局和解决问题。

说说重排和重绘的区别？触发条件有哪些？

重排（Layout）和重绘（Painting）都是Web页面渲染过程中的概念，其区别如下：

重排：当DOM结构中的元素发生变化，或者某个元素的位置、尺寸、边距等属性发生变化时，浏览器会重新计算元素在页面上的位置和大小，并重新绘制到页面上。这个过程称为重排。
重绘：当元素的外观样式（例如颜色、字体等）变化但不影响它在页面上的布局时，浏览器会重新绘制修改了的部分到页面上，这个过程称为重绘。

可以看出，重排比重绘更加昂贵，因为重排需要执行一系列复杂的计算来更新布局树和渲染树，会使页面的渲染性能迅速下降。而重绘只需要重新绘制页面的某些部分，不涉及到元素的位置和布局信息，开销要小得多。

触发重排和重绘的条件有：

对DOM节点进行操作（增删改查）
修改了CSS样式或者伪类
窗口大小发生改变
浏览器滚动条发生滚动
获取offsetWidth、offsetHeight、scrollTop等几个属性
使用了js调整元素位置、大小等

为了避免造成过多的重排和重绘，开发者可以考虑对操作进行批量更新，或者使用CSS3动画代替JavaScript控制样式（如transform和opacity等），提高页面渲染性能。同时，也要尽量减少强制同步布局的代码和操作，尽可能地解耦DOM节点以及Page Rendering Tree，让其全面利用浏览器的优化机制达到最佳性能表现。

Vue的自定义指令钩子函数有哪些？你用自定义指令做过什么？

Vue的自定义指令提供了一种便捷的方法，允许我们在元素渲染到页面之前和之后进行一些特殊处理。自定义指令钩子函数包括以下几种：

bind：只调用一次，指令绑定到元素时触发。
inserted：被绑定元素插入到父节点时触发。注意，父节点存在即可触发，不必存在于document中。
update：被绑定元素所在的模板更新时触发，而无论绑定值是否变化，通过比较更新前后的绑定值，可以忽略不必要的模板更新。
componentUpdated：被绑定元素所在的模板完成更新时触发。
unbind：只调用一次，指令与元素解绑时触发。

使用自定义指令可以方便地扩展 Vue 的功能。举一个实际的例子，在开发过程中我们可能需要限制用户输入某些非法字符，这时候可以结合正则表达式，编写一个自定义指令来过滤。

例如：

// 一个 Vue 自定义指令，用于只允许输入数字和小数点
Vue.directive('number-only', {
  bind: function(el) {
    el.handler = function(e) {
      let input = e.target
      let val = input.value
      let reg = /^(\d+)?([.]?\d{0,2})?$/
      if (!reg.test(val)) {
        input.value = val.substring(0, val.length - 1)
      }
    }
    el.addEventListener('input', el.handler)
  },
  unbind: function(el) {
    el.removeEventListener('input', el.handler)
  }
})

以上代码创建了一个自定义指令，名为“number-only”，它会绑定到指定的元素上，并在用户输入时检查其值是否符合指定的正则表达式，如果非法，则进行过滤处理。这样的自定义指令可以在很多场景中使用，比如输入金额、电话号码、邮箱等等。

伪类和伪元素的区别有哪些？ Css3新增了哪些选择器

伪类和伪元素是 CSS 中常用的概念，它们都是用于为 HTML 元素添加特殊样式的方式。但是它们有一些不同之处，具体区别如下：

伪类（Pseudo-classes）：在选择器后面使用一个冒号（:），用于对元素的某种状态进行样式设置。例如，:hover 表示鼠标悬停在元素上方时的样式，:first-child 表示第一个子元素的样式。
伪元素（Pseudo-elements）：在选择器后面使用两个冒号（::），用于向元素的某个部分添加样式。例如，::before 表示在元素内容前插入的虚拟元素，可以用来添加一些装饰性的内容。

CSS3 新增了很多选择器，下面列出比较常用的一些：

属性选择器（Attribute selectors）：根据元素的属性值来选择元素，例如 [class=""] 表示选择 class 属性值为空的元素。
通用选择器（Universal selectors）：选择所有元素，例如 * 表示选择所有元素。
相邻兄弟选择器（Adjacent sibling selectors）：选择紧接在另一个元素后面的元素，例如 h2 + p 表示选择紧接在 h2 元素后面的 p 元素。
伪类选择器（Pseudo-class selectors）：选择元素的某种状态，例如 :hover 表示鼠标悬停时的状态。
伪元素选择器（Pseudo-element selectors）：向元素的某个部分添加样式，例如 ::before 表示在元素内容前插入的虚拟元素。

Javascript如何实现继承？

在 JavaScript 中，可以使用原型链来实现继承。原型链是通过每个对象都有一个指向父对象的内部链接 proto 来实现的。

具体步骤如下：

定义父类（或基类）：

function Animal(name) {
  this.name = name;
}

Animal.prototype.sayName = function() {
  console.log('My name is ' + this.name);
};

定义子类（或派生类）：

function Dog(name, breed) {
  Animal.call(this, name);   // call 方法用于调用父类构造函数并传入当前对象
  this.breed = breed;
}

Dog.prototype = Object.create(Animal.prototype);   // 将子类的原型对象指向父类的原型对象

Dog.prototype.constructor = Dog;   // 手动设置子类的构造函数指向自己
Dog.prototype.bark = function() {   // 在子类上添加子类特有的方法和属性
  console.log(this.name + ' barks!');
};

创建子类对象并使用其继承的方法：

var dog = new Dog('Lucky', 'beagle');
dog.sayName();   // 输出 "My name is Lucky"
dog.bark();      // 输出 "Lucky barks!"

以上代码创建了一个 Animal 类作为父类，其中定义了 name 属性和 sayName() 方法。然后定义了一个 Dog 类，它从 Animal 类继承了所有属性和方法，并添加了一个 breed 属性和 bark() 方法。最后创建了一个名为 Lucky 的小狗，并使用 sayName() 和 bark() 方法。

需要注意的是，在给子类的原型对象设置父类的原型对象时，不能直接将子类的原型对象指向父类的原型对象，而应该创建一个中介对象来实现继承。以上代码中使用了 Object.create() 方法来创建一个空对象并将其原型对象指向父类的原型对象，然后再将这个空对象赋值给子类的原型对象。

说说什么是严格模式，限制都有哪些？

严格模式（Strict Mode）是 JavaScript 的一种执行模式，它提供了更严格的语法规则和错误检测机制，使代码执行更加安全和可靠。

严格模式可以通过在代码开头使用字符串 'use strict' 来启用，也可以在函数内部使用，以实现代码局部的限制。以下是严格模式对 JavaScript 执行的限制：

变量必须先声明再使用：

在严格模式下，变量必须先通过 var、let 或 const 关键字声明后才能使用，否则会抛出 ReferenceError 异常。

禁止删除不可删除的属性：

在严格模式下，无法删除一个对象的不可配置（configurable:false）的属性，否则会抛出 TypeError 异常。

函数的参数名不能重复：

在严格模式下，函数的参数名不能重复，否则会抛出 SyntaxError 异常。

禁止使用八进制数字：

在严格模式下，禁止在数字前面添加 “0” 来表示八进制数字，否则会被解释为十进制数字。

eval 函数具有独立作用域：

在非严格模式下，eval() 函数中的变量会污染外部作用域，而在严格模式下，eval() 会创建一个新的作用域，变量不会污染外部作用域。

禁止使用未声明的变量：

在严格模式下，禁止使用未声明的变量，否则会抛出 ReferenceError 异常。

函数必须声明在顶层：

在严格模式下，函数必须被声明在顶层或者是通过立即执行函数表达式（IIFE）方式创建，否则会抛出 SyntaxError 异常。

this 关键字的使用限制：

在严格模式下，全局上下文的 this 默认为 undefined，而不是指向全局对象；同时，在调用函数时如果未明确指定 this，其值将是 undefined，而不是指向全局对象。

总之，严格模式在 JavaScript 代码规范和安全方面提供了更多的保障与规范，有利于避免

如何快速的让一个打乱一个数组的顺序，比如 var arr = [1,2,3,4,5,6,7,8,9,10];

可以使用 JavaScript 数组的 sort() 方法结合 Math.random() 函数来实现打乱数组的顺序。具体步骤如下：

var arr = [1,2,3,4,5,6,7,8,9,10];
arr.sort(function() {
  return Math.random() - 0.5;
});

以上代码将数组 arr 中的元素随机排序，实现了数组顺序的打乱。其原理是每次调用 sort() 方法时都会比较两个元素，如果返回值小于 0，则表示 a 应该排在 b 前面；如果返回值大于 0，则表示 a 应该排在 b 后面；如果返回值等于 0，则表示 a 和 b 的顺序不变。利用 Math.random() 函数生成一个 0 ~ 1 之间的随机数，使得每次比较两个元素时的返回值随机性更高。

你对SPA单页面的理解，它的优缺点分别是什么？如何实现SPA应用呢

SPA 单页面指的是构建一个单一 HTML 页面应用程序，该应用程序在加载后动态更新其内容，而不是通过多页应用来实现。

其优点主要有：

用户体验好。由于 SPA 只加载一次 HTML、CSS、JS 文件，实现了无刷新网页，页面的响应更加迅速，交互性更好。
减轻服务器压力。相比多页应用每次请求均需重新加载整个页面，SPA 与服务器的通信一般通过 AJAX/RESTful API 实现数据传输，减小了服务端负担。
关注点分离。前端和后端可以进行相对独立的开发工作，提高了团队协作效率。
更好的可维护性。采用组件化开发方式，修改或调试某一个组件只需要关注组件自身的代码而不影响其他组件。

缺点主要有：

首次渲染时间较长。SPA 在首次加载时需要下载大量的 JavaScript 和 CSS 代码，因此首屏渲染时间会比多页应用更长。
SEO 不佳。由于 SPA 的内容只有一个 HTML，且页面根据路由动态渲染，而本身没有以标签为基础的视图结构，所以不利于搜索引擎的爬取。
浏览器兼容问题。一些旧的浏览器可能不支持 HTML5 History API，这样 SPA 将无法实现前进后退等基本浏览器功能。

如何实现 SPA 应用：

采用现代化 JavaScript 框架库，例如 React、Vue、Angular 等。
利用 HTML5 History API 实现页面路由控制。
使用 AJAX/RESTful API 技术实现前后端数据交互。
对多个组件进行异步加载优化，减轻单次请求的负担。
对代码进行缓存，提高响应速度。

总之，SPA 单页面相较于传统多页应用有着许多明显的优点和一些缺点，具体使用需根据项目特点和技术场景决定。

SPA首屏加载速度慢怎么解决

SPAs（单页应用程序）的一个常见问题是首屏加载速度慢，这主要是因为 SPA 单独请求一个 JavaScript 文件，通常包含整个应用程序及其依赖项。

以下是几种解决 SPA 首屏加载速度慢的常见方法：

代码分割：将应用程序代码分割为多个较小的 JS 文件，以逐步加载应用程序。可以使用工具如 webpack 进行代码分割和自动化打包。
按需加载：只在需要时才加载某些组件、库或模块，而不是每次加载完整的应用程序。这可以通过惰性加载实现，即在用户浏览到该组件或功能之前，不会加载它。
服务端渲染：使用服务端生成 HTML 内容，使首屏可以快速呈现。在首次加载应用程序时利用预渲染技术生成静态 HTML 页面，并在后续与 SPA 交互时更新内容。
压缩资源文件：压缩 JS 和 CSS 文件可以减少网络传输数据量。
缓存：利用浏览器本地缓存或内容分发网络 (CDN) 缓存可以减少HTTP 请求，从而提高网站性能。

此外，还可通过优化图片大小、减少 HTTP 请求等来加速SPA的首屏加载速度。

说说webpack中常见的Loader？解决了什么问题？

Webpack是一个模块打包工具，它依靠不同的插件和Loader来处理应用程序中的各种资源文件。在Webpack的生态系统中，Loader 负责将文件从源代码转换成Web浏览器可以理解并加载的格式，因此Loader也被视为是对资源（除了JS以外）进行处理的“翻译员”。

以下是一些Webpack中常见的Loader：

Babel Loader：一个解析ES6+语法并将其转换为兼容的JavaScript语法的转码Loader。
CSS/SASS/LESS Loader：负责将不同类型的 CSS 文件转换为 JavaScript 模块，实现样式表与其他 JavaScript 模块之间的 require/import/require.context 接口调用。
File Loader：用于处理一些静态资源文件（如图片、字体），自动输出正确的文件路径。
html-loader：从 HTML 文件中提取嵌入式的img标签等资源文件，并把他们作为文件来处理输出。
url-loader：与 file-loader 类似，但专门处理较小文件，可将他们转换为 DataURL 的形式，减少HTTP网络请求。

这些Loader解决了各种不同的问题，例如：Babel Loader解决了浏览器不支持最新JavaScript语法的问题；CSS Loader解决了CSS引入不能模块化，无法控制顺序，导致样式覆盖的问题；FileLoader解决了加载静态资源（如图片、字体等）的问题等。这些Loader不仅使得我们开发工具链的编写变得简单，同时也提高了生产环境的应用程序的效率和性能。

你了解vue的diff算法吗？说说看

Vue中的Diff算法是用于处理Virtual DOM比较的算法。Virtual DOM是一种内存中的表现形式，可以在DOM操作时降低性能损失。当状态发生改变时，Vue框架首先会生成新的Virtual DOM，然后再与旧的Virtual DOM进行比较，找出两者之间的区别，最后只更新需要更改的部分，从而减少了对真实DOM的操作。

Vue中的Diff算法具体流程如下：

首先比较新旧节点的标签类型是否相同。如果不相同，则直接替换整个节点。
如果标签相同，则继续比较子节点。如果存在父子节点，那么逐层进行比较。
对于没有key值的节点，只进行同级节点比较；如果有key值，则根据key值进行比较，以减少操作数量。
如果都没有匹配到，则表示需要替换该节点。
通过以上步骤，完成新旧虚拟节点的差异化比较，并记录更改。最后将更改应用于真正的DOM树上，完成更新。

通过Vue的Diff算法，我们可以有效地减少DOM操作次数，提高页面渲染效率和性能，实现高效的前端开发。

简单说一下 Virtual Dom

Virtual DOM（虚拟DOM）是一种内存中的表现形式，它是一个JavaScript对象，类似于真实的DOM结构，但是不会直接操作页面上的DOM，而是在内存中进行操作。Virtual DOM具有树形结构，由节点和属性组成，与真实的DOM结构类似。

在前端开发中，当数据发生变化时，更新真实DOM会对性能造成很大的影响。因此，React、Vue、Angular等流行的前端框架都使用了Virtual DOM技术来优化渲染性能。

对于Virtual DOM，我们可以采用以下流程：

首先，框架将程序当前状态映射为Virtual DOM结构。
当应用程序的状态改变时，框架会比较新旧Virtual DOM之间的不同。
根据比较结果，框架会选择最小代价地修改Virtual DOM，并更新渲染结果到真实DOM上。

使用Virtual DOM技术可以有效减少无用的DOM操作，提高性能，同时也方便了前端开发人员的工作，使得代码更加清晰可维护。

说说你对Redux的理解？其工作原理？

Redux是一个状态管理库，常见于React应用程序中。它通过提供可预测的状态容器来简化复杂的JavaScript应用程序，同时也可以与任何框架或库结合使用。

Redux的工作原理类似于如下流程：

应用程序中的所有state（状态）都被存储在单一的store对象中。
当组件需要更改状态时，它会派发一个action（行动），描述所需的行动。
所有的actions会被传递到reducer中，在这里它们会根据不同的操作类型来更新store中的状态。
当store中的状态更改时，会通过React-redux机制自动触发组件的重新渲染以反映最新的状态变化。

可以看出，Redux通过约束应用程序的状态更改流程来保证应用程序状态的可控性和一致性。这种架构模式非常适合在大型应用程序中管理大量数据。同时，Redux还具有便于开发、易于测试和方便调试等优点。

在使用Redux时，我们需要编写reducer函数来处理对state的更新，actionCreator函数来创建相应的action，以及使用connect()函数来连接store和组件。熟练掌握Redux的使用可以帮助我们快速开发高质量的应用程序。

如何封装组件在不同的项目之间使用如何实现？

要封装组件以便在不同项目之间使用，一般可以按照以下步骤进行：

创建组件：组件需要遵循正常的React组件编写规则，并且需要将组件本身与组件所需的所有依赖项区分开来。这意味着组件应该只包含业务逻辑和UI代码，而不包括外部组件库、图片等资源或其他非业务代码。
导出组件：为确保组件可用于其他项目，必须将其导出。通常情况下，推荐使用ES6的export语法进行导出，在导出组件的同时也可以选择导出相关依赖项。
使用方式：当需要在其他项目中使用该组件时，可以引入它并调用它。由于组件依赖的资源可能会发生变化，因此最好尽量保持资源路径相对稳定，或者通过传递props参数的方式来解耦组件与资源的依赖关系。
发布到npm：为了方便其他开发者使用，可以将该组件发布到npm上。这样，其他项目就可以通过npm获取更新后的版本，而无需手动更新组件。

总结来说，要封装React组件以便在不同的项目中使用，我们首先创建组件，然后导出它，再通过npm发布组件给其他开发者使用。对于不同的项目需求，我们可以通过灵活的使用props来自定义样式与行为，以满足不同的应用场景。

说说箭头函数和普通函数的区别

箭头函数和普通函数的主要区别在于语法和this的指向。

语法：箭头函数的语法比普通函数更加简洁，可以省略function关键字、参数括号以及return关键字（如果只有一条语句），例如：

// 普通函数的写法
function sum(a, b) {
 return a + b;
}

// 箭头函数的写法
const sum = (a, b) => a + b;

this指向：箭头函数中的this始终指向它声明时所处的上下文环境，而不是使用时的上下文环境。这意味着，在箭头函数中无法通过this来访问调用者对象或全局对象。

// 使用普通函数来定义对象方法时，方法内部this指向调用者obj
const obj = {
  name: 'Alice',
  sayHi: function() {
    console.log('Hi, ' + this.name);
  }
};
obj.sayHi(); // 输出"Hi, Alice"

// 使用箭头函数来定义对象方法时，方法内部this指向外部作用域的this
const obj = {
  name: 'Alice',
  sayHi: () => {
    console.log('Hi, ' + this.name); // 输出"Hi, undefined"
  }
};
obj.sayHi();

因此，根据实际需求选择使用普通函数还是箭头函数。如果需要访问调用者对象或全局对象，应该使用普通函数；如果需要保持this指向在不同地方（如嵌套函数内）一致，或者只是单纯的返回一个值，则可以使用箭头函数来实现简洁代码。

什么是FOUC? 如何避免？

FOUC全称为Flash of Unstyled Content，意为“无样式内容闪烁”。发生在页面初次加载时，用户会看到短暂的无样式内容闪烁，之后才慢慢呈现出完整的样式。

造成FOUC的原因是样式表被放在文档底部或使用了@import的方式引入外部样式表，在样式表加载完成之前，浏览器就已经开始渲染了HTML，导致了这种不期望的视觉效果。

避免FOUC的方法有以下几种：

将样式表放在文档头部：这样样式表能够尽早地加载渲染，减少FOUC发生的可能性。
使用link标签而不是@import：link方式可以使多个样式表并行下载和并行解析，而@import则需要等待之前的样式表加载完成才能继续下载后面的样式表。
在内部样式中定义Critical CSS： Critical CSS 是指包含与“above the fold”部分有关的关键样式的最小CSS集。将Critical CSS 到内联样式表中，在样式表加载完成之前让浏览器先达到一个合理的渲染状态，以减轻 FOUC 的挥之。
使用缓存：让样式表缓存在本地，可以大幅度减少首次加载需要的时间，进而减少了FOUC的可能性。

总之，通过使用以上方法，可以有效避免 FOUC 的发生。

说说你对预编译器的理解？

预编译器（Preprocessor）是指一种能够扩展原生语言的程序，能够在代码被编译成可执行代码之前先根据源码中的特定指令进行处理，以生成目标代码。预编译器通常用于提供比基础语言更高级、更强大的功能和语法糖。

常见的预编译器有 Sass、Less、Stylus 等针对 CSS 的预编译器，以及 Pug、Markdown 等针对 HTML 的预编译器。在 JavaScript 中，也有类似的预编译器，如 TypeScript、CoffeeScript、Babel 等。

预编译器可以帮助我们简化代码书写，减少重复性操作，增加可读性、可维护性，并且能够弥补原生语言的不足，提供更多的功能和工具。例如，Sass 提供了变量、嵌套、混合等语法，使得 CSS 更易于组织和维护；TypeScript 则提供了类型定义和 ES6+ 语法支持，使得 JavaScript 更加强健和可靠等。

总之，使用预编译器可以使开发效率更高，代码质量更好，为开发者提供更好的开发体验，并且还可以通过编译过程的优化提高应用程序性能。

概述下 React 中的事务处理逻辑

React 中的事务是指多个组件更新被捆绑在一起的单个操作单元，使用了类似于数据库中事务的概念。

React 通过创建一个全局唯一的 Transaction（事务）对象来实现这种机制。在一次事务中，如果某个组件通过 setState() 方法进行了状态更新，React 不会立刻触发重新渲染（即执行 render() 方法）。相反，对该组件及其子组件的所有状态更改都会被收集并缓存到当前事务的队列中，最后一起批量处理。这就是 React 批量更新的核心原理。

React 通过将组件内部的各个生命周期函数包裹在事务处理的过程之中，使得我们能够在组件更新之前或之后执行一些特定的操作。例如，使用 componentDidMount() 生命周期钩子，可以确保 DOM 元素已被渲染并挂接到真正的 DOM 树中后才进行初始化操作。

React 还提供了一个叫做 Transaction Mixin 的特性来自定义事务。它可以让我们在组件的生命周期几个阶段（componentWillMount、componentDidMount、componentWillUpdate、componentDidUpdate 等）之间插入自己的回调函数。

需要注意的是，React 提供的事务处理机制只适用于同步代码，也就是说事件监听器等异步代码并不会被包含在事务处理过程中。如果我们需要播放动画等操作同时更新样式和状态，那么最好使用 requestAnimationFrame（RAF）或类似库来确保异步代码能够被正确地同步执行。

总之，React 中的事务机制是一种性能优化手段，通过批量更新组件状态来减少渲染次数，提高应用程序的性能，并且提供了一些钩子 API 可以让开发者控制组件更新前后的行为，扩展 React 库的功能特性。

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

在 React 开发中，根据组件的职责和功能，常规情况下可以将组件划分为业务组件和技术组件。

业务组件通常是指与具体业务相关的组件，它们通常由一些特定的功能模块组成，并且可能需要访问应用程序的状态或后端数据。这些组件主要负责展示、响应用户操作或其他与业务逻辑相关的任务。例如，在一个电商网站中，购物车、商品列表、收货地址等组件都可以被视为业务组件。

技术组件通常是指实现某些技术或功能的组件，比如说路由、表单验证、UI 组件库等等。这些组件通常是可复用的，独立于特定业务之外，且有着清晰的输入输出边界（接口）。这样的设计可以使得我们更容易对代码进行维护和测试。例如， react-router 库提供了路由解决方案；AntD 提供了丰富的 UI 组件库，等等。

划分业务组件和技术组件可以使得代码更加结构化和灵活，同时还能够使得开发者更好地理解应用程序的体系结构和运作原理。在实际开发过程中，我们通常先从页面抽象出一些比较通用的组件（例如顶部导航栏、登录框等），再从这些组件中抽象出更具体的业务或技术特定组件。

总之，将 React 组件划分为业务组件和技术组件是一种优秀的代码架构和设计思路，并且能够提高应用程序的可维护性和可重用性。

说说你对Fiber的理解和应用场景

React Fiber 是 React v16 中一个全新的协调引擎，它是对 React 渲染机制的重大更新，旨在提高渲染性能、优化复杂度极高的场景和支持基于时间分片的渲染。

React Fiber 在之前的 React Stack Reconciliation 算法的基础上做了很多创新。首先，它将之前的递归算法改成了迭代算法，并且使用 requestIdleCallback 基于时间分片的机制，可以让渲染任务和其他任务一起进行，不会阻塞页面其它异步操作。其次，在 Fiber 中，React 将所有组件依据优先级进行切片，可中止当前调和过程，转而处理其他更高优先级的任务，实现了先更新紧急的部分，避免造成界面的卡顿或者长时间卡死等问题。最后，在 Fiber 引入了 Diff 策略，将组件的本身与其子组件的生命周期阶段分开考虑，将不同类别的 Component 间的比较操作隔离开来，从而对每个变更单元赋予独立的更新周期。这样就实现了节点无法直接跳过 diff 的“缓存”效果。

相比之前的版本，React Fiber 可以显著地提高应用程序的渲染性能、可调度性和卡顿优化，使得应用程序更加流畅。此外，React Fiber 还为某些渲染场景带来了新的可能。例如，在大型列表渲染、动画和交互式操作等领域，可以使用 React Fiber 提供的 Suspense 和 Concurrent 模式，实现更高效的渲染和控制策略。

总之, Fiber 引擎在React架构中的重要地位体现了React框架在前端设计模式中所处的引领位置，它对于提升React应用程序性能有着较大的作用。应用场景包括但不限于大型项目复杂渲染场景，动态图表与游戏，延迟加载中间件逻辑

说说html和css渲染的过程是什么

HTML 和 CSS 是网页的两个基本组成部分，HTML 描述了网页的结构和内容，CSS 则决定了网页的样式和布局。当浏览器收到 HTML 和 CSS 文件时，它们就开始了渲染过程。

具体来说，HTML 和 CSS 渲染的过程如下：

解析 HTML 文件。浏览器会根据 HTML 文档中的标签解析出 DOM 树（文档对象模型），即将 HTML 文档转换为一个由节点与属性组成的树形结构。这个过程中还会处理一些特殊的标记，例如图片、脚本等。
解析 CSS 文件。在建立好 DOM 树的基础上，浏览器会加载并解析 CSS 文件，产生样式规则，并将其应用到 DOM 树上的各个元素。可以通过选择器的匹配，优先级的计算等方式来确定每个元素的最终样式。
构建渲染树。在产生了带样式的 DOM 树之后，浏览器会根据渲染引擎的特定规则，对这些节点进行计算和合并，从而生成另一个树形结构——渲染树，其中只包括需要显示的节点和其对应的样式信息。
布局和绘制。在完成渲染树的构建之后，浏览器会进行布局和绘制。布局流程中计算出元素在屏幕上的确切位置和尺寸，而绘制过程则将这些元素渲染为像素级别的位图。
优化和重排：由于 HTML 和 CSS 可以通过 JavaScript 和用户交互事件（如窗口大小变化）动态修改，所以为了保证页面的响应性能，浏览器通常会进行一些优化，使得不必要的重排（计算布局信息后暴力重绘所有元素）和重绘操作最小化。

总之，HTML 和 CSS 渲染是一个相互协作、非常复杂且涉及多个阶段的过程，如果我们对其有深入的认识，就可以更好地理解网页的工作原理，并且优化页面性能，开发可维护的代码。

如何判断页面滚动到底部，如何判断页面中元素是否进入可视化区域？

判断页面滚动到底部的方法：

可以通过比较滚动条的位置和整个页面的高度来确定当前是否滚动到了页面的底部。具体而言，可以使用以下两种方式实现：

判断当前滚动条的位置是否达到了整个页面的高度减去浏览器视口的高度：

if (window.pageYOffset + window.innerHeight === document.body.scrollHeight) {
  // 到达底部
}

计算页面底部距离窗口顶部的距离，并判断滚动条距离窗口顶部的距离是否大于或等于这个值：

const bottomDistance = document.documentElement.scrollHeight - window.innerHeight;
if (window.scrollY >= bottomDistance) {
  // 到达底部
}

判断元素进入可视化区域的方法：

可以通过元素相对于窗口的位置来判断其是否进入了可视化区域。具体而言，可以使用以下两种方式实现：

使用 getBoundingClientRect() 方法获取元素的位置信息，并计算元素顶部和底部相对于窗口顶部的位置，判断是否在窗口内：

const elTop = element.getBoundingClientRect().top;
const elBottom = element.getBoundingClientRect().bottom;
const windowHeight = window.innerHeight;
if ((elTop > 0 && elTop < windowHeight) || (elBottom > 0 && elBottom < windowHeight)) {
  // 元素进入了可视化区域
}

使用 Intersection Observer API：这是一种通用的方法，可以同时监听多个元素是否进入或离开可视化区域，并支持配置一些额外的选项。比如可以设置元素进入可视化区域多少像素后触发回调函数等。
```
const options = {
  threshold: 1
};
const observer = new IntersectionObserver((entries, observer) => {
  if (entries[0].isIntersecting) {
    // 监听的元素进入了可视化区域
  }
}, options);
observer.observe(element);
```

说一下DOM0、DOM2、DOM3事件处理的区别是什么？

DOM0、DOM2 和 DOM3 事件处理是 JavaScript 中用于监听和处理 HTML 元素上事件的三种常见方式。

DOM0 事件处理：通过给元素对象的属性赋值的方式来绑定事件处理函数，事件回调函数作为属性值传入。例如，“onclick”、“onmousedown”等。

例如：
```
<button id="btn">Click mebutton>
```
```
const btn = document.getElementById('btn');
btn.onclick = function() {
  console.log('clicked!');
}
```
这种方式相对简单，但是只能同时为一个事件设置一个处理函数。当我们需要为多个事件添加多个不同的处理函数时，就会非常麻烦。
DOM2 事件处理：通过 addEventListener() 方法来为元素添加事件处理函数。此方法可以为同一事件名添加多个处理函数。

例如：
```
<button id="btn">Click mebutton>
```
```
const btn = document.getElementById('btn');
btn.addEventListener('click', function() {
  console.log('clicked!');
});
```
这种方式可以为一个元素添加多个事件监听函数，并且可以动态添加和删除事件监听函数。
DOM3 事件处理：与 DOM2 事件处理模型类似，主要区别在于支持更多的事件类型（如 UI 事件、键盘事件等）和更多的事件流模型（如捕获和冒泡）。我们可以使用 removeEventListener() 方法来移除注册的事件监听函数。

例如：
```
<button id="btn">Click mebutton>
```
```
const btn = document.getElementById('btn');
btn.addEventListener('click', function() {
  console.log('clicked!');
}, false);
```
这种方式可以为元素添加多个事件监听函数，并支持更多的事件类型和事件流模型。

总之，相较于 DOM0，DOM2 和 DOM3 更加灵活、高效且易于管理，是 Web 开发中常见的事件处理方式。

说说你对递归的理解？封装一个方法用递归实现树形结构封装

递归是一种程序设计或算法设计方法，它通过调用自身来解决问题，将一个大规模的问题拆分成多个相同或类似的子问题来解决。递归具有简洁明了、可读性高、解决简单问题效率高等优点，但也容易造成堆栈溢出等问题。

对于树形结构，可以使用递归实现遍历和封装。以先序遍历为例，在遍历根节点之后，依次遍历左子树和右子树，即先处理当前节点，再处理左子树和右子树。

下面是一个使用递归实现先序遍历的示例：

function traverseTree(tree, callback) {
  if (!tree) return; // 基线条件
  callback(tree.value); // 处理当前节点
  traverseTree(tree.left, callback); // 遍历左子树
  traverseTree(tree.right, callback); // 遍历右子树
}

// 示例数据
const tree = {
  value: 'A',
  left: {
    value: 'B',
    left: {
      value: 'D'
    },
    right: {
      value: 'E'
    }
  },
  right: {
    value: 'C',
    right: {
      value: 'F'
    }
  }
};

// 调用示例
traverseTree(tree, console.log);

这个示例中，traverseTree 方法接收两个参数：要遍历的树和一个回调函数，回调函数用于处理节点的值。在遍历过程中，先判断当前节点是否存在（基线条件），如果不存在则直接返回；否则处理该节点的值（处理当前节点），并递归遍历左子树和右子树（遍历左子树和遍历右子树）。代码执行结束后，将按照先序遍历的顺序打印出每个节点的值。

怎么判断一个变量arr的话是否为数组

可以使用 Array.isArray() 方法来判断一个变量是否为数组，该方法返回一个布尔值，表示该变量是否为数组类型。

如果变量 arr 是数组，则返回 true，否则返回 false。例如：

const arr1 = [1, 2, 3];
const arr2 = {a: 1, b: 2};
console.log(Array.isArray(arr1)); // true
console.log(Array.isArray(arr2)); // false

在上面的示例中，arr1 是数组类型，Array.isArray(arr1) 返回值为 true；而 arr2 不是数组类型，Array.isArray(arr2) 返回值为 false。

JS 数据类型有哪些

JavaScript 中有六种原始数据类型，分别是：

number（数字）：整数或浮点数。
string（字符串）: 字符串是字符序列，用单引号 ' 或双引号 " 表示。
boolean（布尔值）：只有两个值，即 true 和 false。
undefined（未定义）：表示声明了变量但没有赋值或未定义的值，其对应的数据类型为 undefined。
null（空值）：表示一个空对象指针。
symbol（符号）：表示独一无二的值，用于解决属性名冲突等问题。

在 ECMAScript 6（ES6）中，还新加入了一种原始数据类型 BigInt （大整数），可以表示任意大的整数。同时，JavaScript 还提供了一种其他类型转换为数字类型的方法，即将字符串、布尔值和 null 转换成数字类型。

除了原始数据类型以外，JavaScript 还有一种复合数据类型 Object 类型，它可以存储不同类型的键值对，并支持将函数作为对象的属性值，以及添加/删除属性、修改属性值、按照特定顺序遍历对象属性等操作。此外，ECMAScript 6 新增了 Map、Set、Array 等高级数据结构，提供了更多的数据处理和操作方式。

说你对盒子模型的理解？

盒子模型是css中的一种思维模型，即把网页内容看成一个盒子，这个盒子由外到内包括margin、border、padding、content。根据浏览器计算方式不同分为两种模型：标准模型（w3c模型）和怪异模型（又称IE模型）。

他们的主要区别是：标准模型的宽度不包含padding和border，怪异模型的宽度包含padding和border(个人认为主要表现在内容区域的大小变化)。

默认情况下，box-sizing为content-box，也就是标准模型。可通过设置box-sizing的值为border-box准换为怪异模型。

如何让一个盒子水平垂直居中,有哪些方法越多越好？

有很多种方法可以实现一个盒子水平垂直居中，以下是其中几种常见的方法：

使用 Flexbox 布局：

.parent {
  display: flex;
  justify-content: center; /* 水平居中 */
  align-items: center; /* 垂直居中 */
}

使用 Grid 布局：

.parent {
  display: grid;
  place-items: center; /* 居中 */
}

使用绝对定位：

.parent {
  position: relative;
}

.child {
  position: absolute;
  top: 50%; /* 向下偏移一半高度 */
  left: 50%; /* 向右偏移一半宽度 */
  transform: translate(-50%, -50%); /* 往左和往上各移动一半自身尺寸 */
}

使用 table 和 table-cell：

.parent {
  display: table;
  width: 100%;
  height: 100%;
  text-align: center;
}

.child {
  display: table-cell;
  vertical-align: middle;
}

使用 calc 函数：

.parent {
  position: relative;
}

.child {
  position: absolute;
  top: calc(50% - [height]/2);
  left: calc(50% - [width]/2);
}

其中 [height] 和 [width] 分别为子元素的高度和宽度。

需要注意的是，每种方法都有其优缺点，具体的选择要根据实际情况进行权衡。另外，在实际使用时还应该注意父元素的尺寸、盒模型，以及子元素的尺寸和定位方式等因素的影响。

说说javascript都有哪些数据类型，如何存储的？

js中的数据类型分类
JavaScript一共有8种数据类型，有7种基本数据类型（原始数据类型、简单数据类型）和1种引用数据类型（复杂数据类型）

基本数据类型：Undefined、Null、Boolean、Number、String、Symbol（es6新增，表示独一无二的值）和BigInt（es10新增）；
引用数据类型：Object（Object本质上是由一组无序的名值对组成的），里面包含 function、Array、Date等。注意：JavaScript不支持任何创建自定义类型的机制，而所有值最终都将是上述 8 种数据类型之一。

基本数据类型：直接存储在栈（stack）中，占据空间小、大小固定，属于被频繁使用数据，所以放入栈中存储。
引用数据类型：同时存储在栈（stack）和堆（heap）中，占据空间大、大小不固定。引用数据类型在栈中存储了指针，该指针指向堆中该实体的起始地址。当解释器寻找引用值时，会首先检索其在栈中的地址，取得地址后从堆中获得实体。

两种数据类型赋值方式的区别
1.基本类型赋值时，拷贝的是数据

2.应用类型赋值时，拷贝的是地址

如何理解响应式，实现响应式的方法有哪些？有什么区别？

响应式（Responsive）指的是网页能够根据设备屏幕尺寸、浏览器窗口大小等因素自动调整布局和样式，让用户可以在不同尺寸的设备上获得更好的浏览体验。实现响应式的方法主要有以下三种：

CSS 媒体查询：通过在 CSS 中使用媒体查询（@media），可以根据设备像素比、显示屏宽度等条件为不同的设备提供不同的样式。
Flexbox 和 Grid 布局：Flexbox 和 Grid 布局是 CSS3 新增的两种弹性盒子布局方式，它们可以通过 CSS 属性来控制元素在容器中的位置和尺寸，从而实现响应式布局。
JavaScript 操作 DOM：通过 JavaScript 获取文档对象模型（DOM）并对其进行操作，可以根据窗口大小或其他条件来改变 DOM 元素的布局和样式。

这三种方法的区别在于实现方式不同，但本质都是为了让网页能够适配各种设备，提高用户的体验。

其中，CSS 媒体查询是最常用和最推荐的实现响应式的方法之一，因为它能够直接作用于 CSS 样式，极大地提高了代码的可读性和可维护性；Flexbox 和 Grid 布局也逐渐成为响应式布局的主流，通过设置容器和元素的属性可以在不同设备上动态适配视图；JavaScript 操作 DOM 要相对复杂一些，并且可能会影响性能，但它具有更大的灵活性和可扩展性，在某些特殊情况下也会被使用。

判断数据类型的方法有哪些？有什么区别？

1.typeof
这个方法很常见，一般用来判断基本数据类型，如：string，number，boolean，symbol，bigint（es10新增一种基本数据类型bigint），undefined等。
typeof 目前能返回string，number，boolean，symbol，bigint，unfined，object，function这八种判断类型
2.instanceof
一般用来判断引用数据类型的判断，如：Object，Function，Array，Date，RegExp等
instanceof 主要的作用就是判断一个实例是否属于某种类型

3、Object.prototype.toString（这个是判断类型最准的方法）
toString是Object原型对象上的一个方法，该方法默认返回其调用者的具体类型，更严格的讲，是 toString运行时this指向的对象类型, 返回的类型格式为[object,xxx]，xxx是具体的数据类型，其中包括：String,Number,Boolean,Undefined,Null,Function,Date,Array,RegExp,Error,HTMLDocument,… 基本上所有对象的类型都可以通过这个方法获取到。

4.constructor
当一个函数F被定义时，JS引擎会为F添加prototype原型，然后再在prototype上添加一个constructor属性，并让其指向F的引用。如下所示：

说说你对事件循环的理解？

事件循环（Event Loop）是 JavaScript 实现异步编程的一种机制。JavaScript 的单线程模型意味着在同一时刻只能执行代码中的一个任务，而需要等待 I/O 操作、定时器等操作完成后才能继续执行下一个任务，如果直接阻塞线程等待它们完成会影响程序的响应速度和用户体验。JavaScript 通过事件循环机制解决了这个问题。

事件循环的大致流程是：

执行同步任务，将任务加入调用栈（Call Stack）中按顺序执行；
当遇到异步任务（如设置 setTimeout 定时器等）时，会把这些任务挂起，不会立即执行，并交给相应的执行环境处理以后的回调；
然后 JavaScript 引擎会继续执行同步任务，直至调用栈被清空；
随后，JavaScript 引擎会检查是否存在异步任务的完成回调，如果有就将其放入任务队列（Message Queue）中；
接着开始从任务队列中取出回调函数并压入调用栈来执行，重复上述过程。

在事件循环中，任务队列分为两种类型：宏任务（MacroTask）和微任务（MicroTask）。

常见的宏任务包括：script（整体代码）、setTimeout、setInterval、setImmediate、I/O 操作等；

常见的微任务包括：Promise、MutationObserver、process.nextTick 等。

事件循环会先按照任务类型顺序处理完所有的微任务，再在下一次循环中依次处理当前待执行的宏任务。每次只执行一个宏任务，并且执行完一个宏任务时，又重新回到处理微任务的阶段。

在实际应用中，开发者通过设计异步调用方式和控制任务队列的处理顺序，可以利用事件循环实现各种高效、复杂的编程逻辑。理解事件循环机制有助于深入了解 JavaScript 单线程模型，提高编程效率和代码质量。

Css选择器有哪些？优先级是什么？哪些属性可以继承？

CSS 选择器可以分为五种类型：

元素选择器：通过元素名来选择元素，如 div、p 等；
类选择器：通过类名来选择元素，用 . 符号开头，如 .class；
ID 选择器：通过元素的 id 属性来选择元素，用 # 符号开头，如 #id；
属性选择器：根据元素属性来选择元素，如 [type="text"]；
伪类选择器：通过元素的状态或位置等特征来选择元素，如 :hover。

在样式规则中，不同的选择器拥有不同的优先级。从最高到最低，它们的优先级依次为：

!important；
行内样式（即在 HTML 元素上直接添加的 style 属性）；
ID 选择器；
类选择器、属性选择器和伪类选择器；
元素选择器和伪元素选择器。

当多个选择器的优先级相同时，按照其出现的顺序来决定应用哪一个样式。

CSS 中的继承属性主要包括字体相关、文本相关和少数布局属性。具体来说，以下是常见的可继承属性列表：

字体相关：font-family、font-size、font-weight、font-style、font-variant、line-height；
文本相关：color、text-align、text-indent、text-transform、letter-spacing、word-spacing、white-space、text-decoration等；
少数布局属性：visibility、opacity。

其他大多数 CSS 属性默认情况下是不可继承的，即子元素并不会从其父元素继承这些属性的值。但我们可以利用 inherit 关键字来将某个属性的值强制传递给它的子元素，使其具备相同的属性值。

简单说一下什么是事件代理？

事件代理（Event Delegation）是一种常用的 JavaScript 事件处理方式，它将事件处理器添加到一个父元素上，从而减少了事件处理器的数量，提高了性能。

具体实现方式是将事件委托给一个父元素，然后在父元素上绑定事件，当子元素触发该事件时，事件会一直冒泡到父元素，并被父元素处理。由于事件会冒泡到父元素，因此父元素可以通过判断事件来源来执行不同的操作。

使用事件代理的好处是：

减少事件处理器的数量，节省内存资源。
避免了对动态创建或删除的元素重复绑定和解绑事件的麻烦。
简化代码结构，提高可维护性和可读性。

例如，我们可以为 ul 元素添加一个 click 事件监听器，并通过 event.target 判断点击的是哪个子元素：

var ul = document.querySelector('ul');
ul.addEventListener('click', function (event) {
  if (event.target.tagName === 'LI') {
    console.log(event.target.innerHTML);
  }
});

上述示例中，我们为 ul 元素添加了一个 click 事件监听器，并通过判断 event.target 的标签名是否为 li，来确定点击的是哪个子元素。这样，我们无需为每个子元素单独添加事件监听器，代码量更少，性能更好。

如何理解重回和回流？什么场景下才能

回流：布局引擎会根据各种样式计算每个盒子在页面上的大小与位置。

重绘：当计算好盒模型的位置、大小及其他属性后，浏览器根据每个盒子特性进行绘制。

回流触发时机

添加或删除可见的DOM元素。

元素的位置发生变化。

元素的尺寸发生变化（包括外边距、内边框、边框大小、高度和宽度等）。

内容发生变化，比如文本变化或图片被另一个不同尺寸的图片所替代。

页面一开始渲染的时候（这避免不了）。

浏览器的窗口尺寸变化（因为回流是根据视口的大小来计算元素的位置和大小的）。

还有一些容易被忽略的操作：获取一些特定属性的值

offsetTop、offsetLeft、 offsetWidth、offsetHeight、scrollTop、scrollLeft、scrollWidth、scrollHeight、clientTop、clientLeft、clientWidth、clientHeight

这些属性有一个共性，就是需要通过即时计算得到。因此浏览器为了获取这些值，也会进行回流。

除此还包括 getComputedStyle 方法，原理是一样的。

重绘触发时机

颜色的修改

文本方向的修改

阴影的修改

避免回流、重绘的经验

如果想设定元素的样式，通过改变元素的 class 类名 (尽可能在 DOM 树的最里层)。

避免设置多项内联样式。

应用元素的动画，使用 position 属性的 fixed 值或 absolute 值(如前文示例所提)。

避免使用 table 布局，table 中每个元素的大小以及内容的改动，都会导致整个 table 的重新计算。

对于那些复杂的动画，对其设置 position: fixed/absolute，尽可能地使元素脱离文档流，从而减少对其他元素的影响。

使用css3硬件加速，可以让transform、opacity、filters这些动画不会引起回流重绘。

什么是防抖和节流，有什么区别？如何实现？

防抖和节流都是前端开发中用于优化页面性能的常见技术，它们可以控制事件触发频率，避免一些过度频繁地运算。

防抖（Debouncing）的原理是在一定时间延迟后执行最后一次操作，如果在等待期间再次触发，则会取消上一次操作并重新等待，这样可以确保只有等待期结束才会执行最终操作。比如搜索框输入联想提示、按钮 debounce 防止多次重复点击等场景都可以使用防抖。

例如，以下代码为具有防抖效果的搜索框：

function debounce(func, wait) {
  let timer = null;
  return function() {
    if (timer !== null) clearTimeout(timer);
    timer = setTimeout(func, wait);
  }
}

const searchInput = document.getElementById('search-input');
searchInput.addEventListener('input', debounce(() => {
  // 执行搜索操作
}, 500));

节流（Throttling）的原理是在一定时间内只执行一次操作，相对于防抖，在某些场景下更加适合。例如，当用户在滚动页面，或者在 resize 窗口大小时，需要做出响应处理，但又不想让这些操作触发太多次调用，此时就可以使用节流来限制函数的调用频率，以达到提升页面性能表现。

例如，以下代码为具有节流效果的滚动事件响应：

function throttle(func, interval) {
  let lastTime = null;
  return function() {
    const nowTime = Date.now();
    if (nowTime - lastTime > interval || !lastTime) {
      func();
      lastTime = nowTime;
    }
  }
}

window.addEventListener('scroll', throttle(() => {
  // 执行滚动操作
}, 100));

防抖与节流的区别在于，防抖会执行一次并取消之前所有等待的计时器；而节流仅仅是限制操作被触发的频率为 n 秒执行一次, 计时器按照相同间隔时间循环执行。

需要注意，在实际开发中，根据不同的使用场景和要求，选择应用防抖或者节流都是需要仔细思考和分析的。

说说你对作用域链的理解？

当在Javascript中使用一个变量的时候，首先Javascript引擎会尝试在当前作用域下去寻找该变量，如果没找到，再到它的上层作用域寻找，以此类推直到找到该变量或是已经到了全局作用域

如果在全局作用域里仍然找不到该变量，它就会在全局范围内隐式声明该变量(非严格模式下)或是直接报错
变量的引用会顺着当前楼层进行查找，如果找不到，则会往上一层找，一旦到达顶层，查找的过程都会停止

说说你对原型和原型链的理解？

一、原型
原型是一个对象，是函数的一个属性prototype；

  通过该函数实例化出来的对象都可以继承得到原型上的所有属性和方法

  原型对象默认有一个属性constructor ，值为对应的构造函数；另外，有一个属性__proto__，值为Object.prototype

后文还有相关介绍！！！

二、原型链
概念：（1）对象的创建（2）对象的组织结构（3）对象访问成员的规定

在JavaScript中万物都是对象，对象和对象之间并不是独立存在的，对象和对象之间有一定关系。

    通过对象__proto__属性指向函数的原型对象(函数.prototype)一层一层往上找，直到找到Object的原型对象(Object.prototype)为止，层层继承的链接结构叫做原型链（通过proto属性形成原型的链式结构,专业术语叫做原型链）

bind、call、apply 区别？如何实现一个bind？

bind、call 和 apply 都是 JavaScript 函数提供的方法，用于改变函数的作用域（即 this 指向）和传递参数。

它们的区别如下：

call 和 apply 可以直接调用函数并且立即执行，而 bind 则是返回一个新函数，需要再次调用才能执行。
call 和 apply 的区别在于参数的传递方式不同：call 是将每个参数依次列出来，而 apply 则是通过数组或类数组对象的形式传入参数。
bind 方法不仅可以改变函数的作用域和参数，还可以返回一个新函数，在后续使用中可以保留原函数的一些特性。

以下是实现一个简单的 bind 方法的示例：

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

上述代码给 Function.prototype 添加了一个新的方法 bind2，该方法的作用类似于原生的 bind 方法。主要思路是保存原函数，然后返回一个新函数，在新函数内部使用 apply 方法改变原函数的作用域和参数，并将其返回。其中，利用 Array.prototype.slice 方法把 Arguments 对象转化为真正的数组。

如何优化webpack打包速度？

Webpack 作为前端工程化中最重要的构建工具之一，能够对项目进行模块管理和打包构建。在大型项目中，Webpack 打包速度可能会变得非常慢，这时候我们需要采取一些优化策略来加快打包速度。下面是一些常见的优化方法：

缩小查找范围：

减少入口 entry（只打包必要的代码）。
使用 resolve 来缩小模块搜索规则，在 resolve.modules 中只保留真正需要检索解析的文件目录。
缩小文件处理范围：设置 include 和 exclude 属性用来指定 loader 处理的文件路径范围。

使用 DLLPlugin 和 DllReferencePlugin 预编译公共依赖：

将公共依赖库抽离出来预先进行单独的编译，并且在主编译过程中不再对公共模块进行打包，而是通过引用动态链接库的方式利用本地缓存提高于用户交互时加载过程中的速度。

多线程/并发编译：

Webpack4 版本内置了一个 optimization.concatenateModules 插件可以使模块合并为一个闭包。除此之外还有一些实现多线程/并发编译webpack插件：

HappyPack
thread-loader
parallel-webpack
cache-loader

Tree Shaking：

利用 ES6 模块的静态结构，把没有被引用到的代码从打包构建结果中完全排除。

优化 loader 和 plugin：

使用 HappyPack 加快处理速度
配置 babel-loader 缓存来提供性能（在 module.rules 中配置 cacheDirectory:true）
使用 terser-webpack-plugin 压缩 js 代码
使用 HtmlWebpackPlugin 和 ScriptExtHtmlWebpackPlugin 管理 html 文件

总之，在实际开发过程中可以多使用 Webpack 提供的插件和 loader 进行优化，并针对不同的项目特点进行适量的调整。

说说箭头函数和普通函数的区别？

箭头函数和普通函数是 JavaScript 中的两种定义函数的方式。它们有以下几个不同点：

箭头函数没有自己的 this、arguments、super 和 new.target 绑定，它们会捕获其所在上下文的相应词法作用域的绑定。
箭头函数不能被用作构造函数，也就是说不能使用 new 关键字实例化一个箭头函数。如果使用了 new 来调用一个箭头函数会抛出 TypeError 错误。
箭头函数没有 prototype 属性，所以无法通过箭头函数来创建实例。
箭头函数语法更加简洁和易懂。当要求函数体只包含一个 return 语句时，箭头函数可以省略掉{}与return关键字，让代码更加简洁。
箭头函数不绑定自己的this，而是通过外部作用域来提供this值；普通函数的this指向谁调用了该函数，由运行时决定。

总之，箭头函数和普通函数在使用场景、语法及编写风格方面有所不同，选择哪种函数需要根据具体情况来定取决于不同的业务需求和程序设计风格。

说说对React Hooks的理解？解决了什么问题？

React Hooks 是 React16.8 引入的一个新特性，用于在函数组件中使用状态（state）和其他 React 特性（如生命周期方法、context 等），并且不需要编写 class 组件。

React Hooks 主要解决了以下一些问题：

使用 Class 组件时存在代码复杂度较高以及难以维护等问题。通过使用 Hooks 可以使得代码更加简单易懂、结构更加清晰明了。
函数式组件无法使用 State 和生命周期等功能，而 Hooks 能够在不影响原来组件形式的情况下引入这些特性。
增强了代码的可复用性。在类组件中，复用逻辑必须使用高阶组件或 render Props 等方式实现；而在函数组件中使用 Hooks 及自定义 Hooks 更易于复用逻辑。

React Hooks 主要包括以下几种：

useState：用于在函数式组件中声明和使用 state。
useEffect：在函数式组件中执行副作用，替代组件生命周期方法。
useContext：在函数式组件中使用 React Context API 来实现全局状态管理。
useRef：获取 DOM 元素的引用或保持其引用不变。
useCallback 和 useMemo：用于缓存和优化函数的创建和计算。
useReducer：在函数式组件中使用 reducer 来管理复杂的 state 状态。

总之，React Hooks 在函数式组件中深度解耦了代码复杂度，提升了性能、可读性和复用性。随着 Hooks 的不断发展和完善，React 的开发模式正在逐渐从 Class 组件向函数组件的模式转变。

UseMemo和useCallback如何提升了性能，应用场景有哪些？

useMemo 和 useCallback 都是 React Hooks 提供的便捷函数，主要用于优化 React 应用程序的性能。

首先，useMemo 用于缓存计算结果，当某个值需要重新计算时，它会尝试重复使用之前返回的值。如果前后两次计算所依赖的依赖不变，则直接返回缓存结果；否则重新计算并更新缓存。通过使用 useMemo 可以减少组件渲染次数，从而提高应用性能。

其语法格式为：const memoizedValue = useMemo(() => computeExpensiveValue(a, b), [a, b]);

其中第一个参数是用来进行计算的函数，第二个参数是一个数组，只有与这些变量相关的值发生变化时才会重新计算 memoizedValue 的值。

与此相似，useCallback 也是用于性能优化的钩子函数，其作用是记忆一个函数，待依赖项 change 改变时改回新的函数。在遇到函数作为 props 传递给子组件时，可以使用 useMemo 包含该函数定义，而使用 useCallback 来包裹该函数并返回一个 memoized 版本。

其语法格式为：const memoizedCallback = useCallback(() => callback(a, b), [a, b]);

其中第一个参数是被 Memoize 的函数，第二个参数是作为依赖项最好是不固定的值或者函数的列表。

应用场景：

使用 useMemo 和 useCallback 可以在如下场景中提高应用程序性能：

重复计算问题：当遇到多次运行相同的代码时，缓存计算结果，避免无谓的 DOM 更新。
父子组件函数传递问题：当函数作为 props 传递给子组件时，通过使用 useMemo 和 useCallback 可以保证仅在依赖项发生改变时实际渲染重新创建该函数并避免不必要的渲染。
大量数据的处理问题：应用程序需要大量数据

vue、react、angular 区别

Vue、React 和 Angular 是当前最流行的前端框架之一，它们的区别主要体现在以下几个方面：

技术栈和语言：Vue 使用了类似 HTML 的模板语法以及基于 JavaScript 的组件化开发；React 使用了 JSX 语法，基于组件的开发方式；Angular 则使用了模板语法和 TypeScript 进行开发。
数据流管理：Vue 和 React 都采用单向数据流，即从父组件向子组件传递数据，而子组件并不能直接修改父组件传递的数据；Angular 则使用了双向数据绑定，可以实现自动更新视图。
性能：Vue 和 React 通过虚拟 DOM 技术优化渲染性能，相对来说比 Angular 更快。
学习曲线：Vue 拥有很好的文档和易于理解的 API，因此学习起来比较简单；React 对于熟悉函数式编程的开发者而言非常友好；而 Angular 基于 TypeScript 的开发可能会导致一些入门难度。

总之，三者各有千秋，在选择时需要根据项目需求和团队技术水平综合考虑。

如何封装组件在不同的项目之间使用如何实现？

封装组件是前端开发中重要的一个环节，它可以提高代码的可重用性和维护性，同时也便于不同项目之间的共享。下面介绍一些实现方法：

使用第三方库或框架：比较常见的做法是使用流行的前端框架（如 React、Vue 等）来创建并打包组件，然后上传到 npm 或类似平台上供其他项目直接安装和使用。
手动打包：如果你并不需要用到第三方库或框架，也可以使用 webpack 等自动化构建工具手动将对应的组件文件进行打包，并在项目中引用。这样做的好处是可以更加灵活地控制打包细节和输出格式。
统一管理：无论是使用第三方库还是手动打包，都应该尽可能地遵循统一的命名、文档、代码规范和版本管理，以确保组件的易用性和稳定性。
注重文档和测试：在编写组件时，应该编写清晰明了的文档，包含组件的功能、API 结构、示例代码等。除此之外，也需要编写相应的单元测试或集成测试，保证组件的正确性和可靠性。

总之，组件的封装与使用需要注意事项较多，这需要开发人员具备较强的技术能力、良好的编程习惯和规范意识，以及积极的沟通合作精神。

说说你对Redux的理解？其工作原理？

Redux是一个状态管理工具，它将应用的所有状态存储在一个中央存储器(即Store)中，并通过Action（描述状态变化的事件）和Reducer（处理Action并更新State）来管理状态。Redux的工作原理可以概括为以下三个步骤：

Action：通过定义Action来描述状态变化的事件。
Action是一个带有type属性的对象，它描述了发生的事件类型以及相关的数据。
Reducer：通过定义Reducer函数来处理Action并更新State。
Reducer接收Action和当前的State作为输入，根据Action的类型执行相应的操作并返回一个新的State。
Store：通过将所有State存储在中央存储库中来管理应用程序的状态。
Store负责保存应用程序的状态，并暴露一些API，允许应用程序与其进行交互。

Redux的核心思想是单向数据流，即数据从Store中流向View，用户事件触发Action，然后更新State，最终重新渲染View。这种方式使得状态变化非常可控和可预测，方便进行调试和测试。但是使用Redux也需要开发者花费大量精力来编写Action和Reducer函数以及与React框架进行集成。

对前端工程师这个职位是怎么样理解的？它的前景会怎么样

前端工程师是负责设计和开发网站或应用程序前端界面的专业人员。他们主要使用HTML、CSS和JavaScript编写代码，并通过各种前端框架和工具来构建互联网应用程序。通常，前端工程师需要与UI/UX设计师密切合作，以实现用户友好和响应性的用户界面。

前端开发领域的需求一直都很高，未来几年也不会改变。随着移动设备的普及，越来越多的公司和组织需要拥有一个优秀的网站或者应用程序，以提供更好的用户体验和服务。因此，前端工程师的工作前景十分广阔。同时，前端技术也在不断更新和进化，新的技术和框架层出不穷，对于不断学习和追求技术创新的前端工程师而言，未来的职业发展也非常有希望。

说说你都用过css3中的那些新特性？

Flexbox布局 - 更加灵活的布局方式。
Grid布局 - 可以在二维网格中进行布局与对齐。
动画特效 - 可以使用关键帧（@keyframes）定义动画，并且可以通过transition、transform等属性控制元素在不同状态下的样式变化。
文字特效 - 可以使用text-shadow、word-wrap、word-break等属性进行文字特效设置。
响应式设计 - 可以通过@media查询设置不同屏幕大小或设备类型下的样式。
渐变 - 可以使用linear-gradient和radial-gradient等属性创建渐变色彩效果。
边框特效 - 可以使用border-radius、box-shadow、border-image等属性实现各种边框样式效果。

说说你对BOM的理解，常见的BOM对象你了解哪些？

BOM（浏览器对象模型）是JavaScript中用于操作浏览器窗口和页面的API集合。BOM并不是W3C制定的标准，而是由浏览器厂商提供的一系列特有的API。

常见的BOM对象包括：

Window对象：代表浏览器打开的窗口或选项卡，在JavaScript中默认的全局对象是Window对象。
Location对象：代表当前页面的URL地址，并且可以用于重定向到其他URL地址。
Navigator对象：包含有关浏览器的信息，例如浏览器名称、版本和用户代理字符串。
History对象：允许以编程方式与浏览器历史记录进行交互，可以控制网页后退和前进时的行为。
Screen对象：代表用户屏幕的相关信息，例如宽度、高度、像素深度等。

除了这些常见的BOM对象，还有一些比较特殊的对象，例如XMLHttpRequest对象、setTimeout和setInterval函数等，它们虽然不是BOM对象，但也是常用于操作浏览器窗口和页面的API。

考过的前端题

考过的前端题------*侯先生吃过的亏*

对于MVVM的理解

请详细说下你对vue生命周期的理解

Vue组件间的数据传递方式有哪些

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

vue路由的钩子函数有哪些

的作用是什么?

在Vue中使用插件的步骤

什么是Vue SSR

Proxy 相比于 defineProperty 的优势

vuex是什么？怎么使用？哪种功能场景使用它？

Vue3中自定义指令生命周期的变化及含义

Vue2.x 响应式原理

ES5、ES6和ES2015有什么区别?

在Vue中使用插件的步骤

babel是什么，有什么作用?

举一些ES6对String字符串类型做的常用升级优化?

举一些ES6对Array数组类型做的常用升级优化

说说你对ES6中Generator的理解

说说Promise和async/await 的区别？

说浏览器事件循环和nodeJs的事件循环的区别？

说说你对浏览器缓存机制的理解

说说你对浏览器内核的理解

说说你对nextTick的理解和作用

说说你对webpack的理解

new操作符具体干了什么？

说说你对闭包的理解？闭包使用场景？

说说webpack中常见的Plugin？解决了什么问题？

说说 React中的setState执行机制？

说说你对promise的了解？

网站性能优化的方案都有哪些？

说说浏览器的渐进增强和优雅降级的区别？

null，undefined 的区别

同步和异步的区别

说说你对BFC的理解，触发条件有哪些？

说说重排和重绘的区别？触发条件有哪些？

Vue的自定义指令钩子函数有哪些？你用自定义指令做过什么？

伪类和伪元素的区别有哪些？ Css3新增了哪些选择器

Javascript如何实现继承？

说说什么是严格模式，限制都有哪些？

如何快速的让一个打乱一个数组的顺序，比如 var arr = [1,2,3,4,5,6,7,8,9,10];

你对SPA单页面的理解，它的优缺点分别是什么？如何实现SPA应用呢

SPA首屏加载速度慢怎么解决

说说webpack中常见的Loader？解决了什么问题？

你了解vue的diff算法吗？说说看

简单说一下 Virtual Dom

说说你对Redux的理解？其工作原理？

如何封装组件在不同的项目之间使用如何实现？

说说箭头函数和普通函数的区别

什么是FOUC? 如何避免？

说说你对预编译器的理解？

概述下 React 中的事务处理逻辑

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

说说你对Fiber的理解和应用场景

说说html和css渲染的过程是什么

如何判断页面滚动到底部，如何判断页面中元素是否进入可视化区域？

说一下DOM0、DOM2、DOM3事件处理的区别是什么？

说说你对递归的理解？封装一个方法用递归实现树形结构封装

怎么判断一个变量arr的话是否为数组

JS 数据类型有哪些

说你对盒子模型的理解？

如何让一个盒子水平垂直居中,有哪些方法越多越好？

说说javascript都有哪些数据类型，如何存储的？

如何理解响应式，实现响应式的方法有哪些？有什么区别？

判断数据类型的方法有哪些？有什么区别？

说说你对事件循环的理解？

Css选择器有哪些？优先级是什么？哪些属性可以继承？

简单说一下什么是事件代理？

如何理解重回和回流？什么场景下才能

什么是防抖和节流，有什么区别？如何实现？

说说你对作用域链的理解？

说说你对原型和原型链的理解？

bind、call、apply 区别？如何实现一个bind？

如何优化webpack打包速度？

说说箭头函数和普通函数的区别？

说说对React Hooks的理解？解决了什么问题？

UseMemo和useCallback如何提升了性能，应用场景有哪些？

vue、react、angular 区别

如何封装组件在不同的项目之间使用如何实现？

考过的前端题------侯先生吃过的亏

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