前端面试题手册

当我们在JavaScript中使用new操作符创建一个新对象时，实际上会发生以下几个步骤：创建一个新对象。 使用new操作符时，JavaScript会自动为我们创建一个新的空对象。设置原型链。 新对象内部的[[Prototype]]（或者__proto__）属性会被赋值为构造函数的prototype属性，这样新对象就可以访问到构造函数原型上的属性和方法。绑定this并执行构造函数。 构造函数内部的this将会被绑定到新创建的对象上，然后执行构造函数中的代码，这样新对象就可以具有构造函数中定义的属性和方法。返回新对象。 如果构造函数返回的是一个对象，则返回该对象；如果没有返回对象或者返回的不是一个对象，那么将返回步骤1创建的新对象。如果我们要手写一个new的实现，可以定义一个函数来模拟这个过程。以下是一个例子：function myNew(constructor, ...args) { // 步骤1：创建一个空对象，并设置原型链 const obj = Object.create(constructor.prototype); // 步骤2：将构造函数的this绑定到新对象上，并执行构造函数 const result = constructor.apply(obj, args); // 步骤3：根据返回值判断 return result instanceof Object ? result : obj;}// 测试用例function Person(name, age) { this.name = name; this.age = age; this.sayHello = function() { console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`); };}// 使用自定义的myNew来替代new操作符const person = myNew(Person, 'Alice', 30);person.sayHello(); // 输出: Hello, my name is Alice and I am 30 years old.以上代码中，myNew函数模拟了new操作符的所有关键步骤，能够模拟出通过new操作符创建对象的效果。

在Redux中，中间件是一种强大的机制，允许开发者在action被发送到reducer之前插入自己的逻辑。创建自定义的Redux中间件涉及到编写一个函数，该函数按照Redux中间件API的规格返回一个满足特定签名的函数。我将向您展示如何自定义实现一个简单的日志中间件，该中间件的作用是在action被派发时在控制台输出日志信息。以下是自定义Redux中间件的基本步骤：编写一个函数，该函数接收store的dispatch和getState方法。该函数返回一个接收下一个中间件的next函数的函数。返回的函数再返回一个接收action的函数。在最内层的函数体内，可以执行自定义的逻辑，然后调用next(action)将action传递给链中的下一个中间件或reducer。下面是一个自定义日志中间件的例子：// 自定义日志中间件const loggerMiddleware = store => next => action => { // 自定义的逻辑：在当前action被处理之前输出日志 console.log('dispatching', action); // 调用链中的下一个中间件或reducer let result = next(action); // 自定义的逻辑：在action被处理后输出新的状态 console.log('next state', store.getState()); // 返回result，因为middleware的链需要从next(action)获取返回值 return result;};export default loggerMiddleware;在上述的中间件代码中：store: Redux store实例，它包含了dispatch和getState方法。next: 是一个将action传递给链中下一个处理者（中间件或reducer）的函数。action: 是当前正在处理的action对象。使用这个中间件的典型方式是在创建Redux store时应用它：import { createStore, applyMiddleware } from 'redux';import rootReducer from './reducers';import loggerMiddleware from './middleware/loggerMiddleware';// 使用applyMiddleware来增强store，添加自定义的loggerMiddlewareconst store = createStore( rootReducer, applyMiddleware(loggerMiddleware));export default store;在这个例子中，任何派发到store的action都会先经过loggerMiddleware这个中间件，在控制台输出action信息，然后继续沿中间件链传递，直到最终被reducer处理。这只是自定义中间件的一个简单例子，但您可以根据需要在中间件中实现更复杂的逻辑，例如异步操作、路由导航或其他您想要的任何自定义行为。

CSS中清除浮动（Float）的几种常见方法如下：1. 使用clear属性在浮动元素之后添加一个空的元素，并为其设置clear属性。<div class="float-element"></div><div class="clear"></div>.float-element { float: left;}.clear { clear: both;}优点:简单易懂。兼容性好，适用于所有浏览器。缺点:需要额外的标记（markup），可能导致HTML结构变得臃肿。与内容分离度不高，不符合现代Web开发的最佳实践。2. 使用overflow属性为父元素设置overflow: auto或overflow: hidden可以清除子元素的浮动。.parent { overflow: auto;}优点:不需要添加额外的HTML元素。代码简洁。缺点:在某些情况下可能会导致不期望的滚动条出现。如果子元素需要超出父容器边界显示，此方法可能会剪切子元素的部分内容。3. 使用伪元素清除浮动（clearfix hack）通过在父元素上添加一个伪元素来清除浮动。.clearfix::after { content: ""; display: block; clear: both;}优点:不需要在HTML中添加额外的元素。代码整洁且符合无障碍标准。被广泛采纳，成为一种标准做法。缺点:在旧版IE浏览器中可能需要额外的兼容性处理。4. 使用Flexbox将父元素设为Flex容器。.parent { display: flex;}优点:为现代网站提供了更强大的布局选项。自动处理了元素的浮动问题，不需要显式清除。缺点:在不支持Flexbox的老旧浏览器中不可用。涉及到布局方式的更改，可能需要重新考虑整个布局结构。5. 使用Grid布局将父元素设为Grid容器。.parent { display: grid;}优点:更先进的布局系统，提供了更多布局选项。同样自动处理元素的浮动问题。缺点:兼容性不如Flexbox，特别是在老旧浏览器上。总的来说，选择哪种方法取决于具体项目的要求、浏览器兼容性，以及开发者对于CSS规范的熟悉程度。清除浮动是一个常见的问题，现代前端开发倾向于使用clearfix技术或更现代的布局方法（如Flexbox或Grid）来避免这个问题。

React 的异步组件（通常被称为懒加载组件）主要是通过动态 import() 语法和 React 的 React.lazy 函数来实现的。它们用于在需要时才加载组件，可以显著提高应用程序的性能，尤其是当应用程序很大并且有许多不同的页面和组件时。接下来，我会详细介绍如何使用异步组件以及它们的使用场景。 如何使用异步组件使用 React 异步组件的基本步骤如下：使用 React.lazy 函数分别导入组件。这个函数允许你定义一个动态导入的组件。该函数接受一个函数，这个函数必须调用一个 import()，它返回一个 Promise，该 Promise 解析为一个有 default 导出的模块。 const AsyncComponent = React.lazy(() => import('./AsyncComponent'));将 React.lazy 返回的组件与 React.Suspense 组件结合使用。Suspense 组件允许你指定加载指示器（例如：加载中的旋转器），在等待异步组件加载时显示给用户。 import React, { Suspense } from 'react'; // 异步导入组件 const AsyncComponent = React.lazy(() => import('./AsyncComponent')); function App() { return ( <div> <Suspense fallback={<div>Loading...</div>}> <AsyncComponent /> </Suspense> </div> ); }使用场景性能优化： 对于大型应用程序，将不同的页面或功能分割成独立的代码块，然后只在用户需要时才加载，可以减少应用程序的初始负载时间。条件渲染组件： 当一个组件只在某些条件下才需要时，例如特定的用户角色或权限，可以使用异步组件按需加载，从而节省资源。路由懒加载： 在使用如 React Router 这样的库进行路由管理时，可以结合 React.lazy 和 Suspense 来实现路由级别的懒加载。 import { BrowserRouter as Router, Route, Switch } from 'react-router-dom'; import React, { Suspense } from 'react'; const Home = React.lazy(() => import('./Home')); const About = React.lazy(() => import('./About')); const App = () => ( <Router> <Suspense fallback={<div>Loading...</div>}> <Switch> <Route exact path="/" component={Home} /> <Route path="/about" component={About} /> </Switch> </Suspense> </Router> );组件库懒加载： 如果你的应用程序使用了庞大的第三方组件库，而只有少数组件被频繁使用，可以选择仅懒加载那些较少使用的组件，以减少初始包的大小。使用异步组件的主要目标是提升用户体验，减少页面加载时间，并且按需加载资源，避免浪费客户端的计算和带宽资源。React 的懒加载功能是实现上述目标的重要手段之一。

React Router 可以通过配合 React 的 React.lazy() 和 Suspense 组件来配置组件的懒加载。以下是使用 React Router 实现懒加载的基本步骤：使用 React.lazy 实现动态导入: React.lazy() 是一个允许你动态加载组件的函数。它可以让你定义一个动态导入的组件，并且这个组件会在首次渲染时自动加载。 const LazyComponent = React.lazy(() => import('./LazyComponent'));使用 Suspense 组件包裹路由: 在你的应用中，你需要使用 Suspense 组件来包裹懒加载的路由。Suspense 可以指定一个加载指示器（比如一个 spinner），它会在懒加载组件加载完成之前显示。 import { BrowserRouter as Router, Route, Switch } from 'react-router-dom'; import React, { Suspense } from 'react'; const LazyComponent = React.lazy(() => import('./LazyComponent')); function App() { return ( <Router> <Suspense fallback={<div>Loading...</div>}> <Switch> <Route path="/lazy" component={LazyComponent} /> {/* 其他路由 */} </Switch> </Suspense> </Router> ); }为懒加载组件创建独立的 chunk: 当你使用 create-react-app 或其他构建工具时，它会为每个用 React.lazy() 引入的组件自动创建一个独立的 JavaScript chunk 文件。这意味着这些代码只会在用户需要时才会被加载。举个例子，假设你有一个很大的组件 BigComponent，你不希望它在应用首次加载时就加载进来，而是希望当用户真正访问到该组件对应的路由时再加载，你可以这样设置：import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';import React, { Suspense } from 'react';const BigComponent = React.lazy(() => import('./BigComponent'));function App() { return ( <Router> <Suspense fallback={<div>Loading Big Component...</div>}> <Switch> <Route path="/big-component" component={BigComponent} /> {/* 其他路由 */} </Switch> </Suspense> </Router> );}在上述例子中，当用户访问 /big-component 路径时，BigComponent 会被动态加载。用户会看到 "Loading Big Component…" 的文本，直到 BigComponent 加载完成并准备好渲染。这样可以减少应用的初始加载时间，并且按需加载资源，提高性能。

React 函数组件和类组件是 React 中创建组件的两种不同方式。它们有几个主要区别：语法：函数组件：使用 JavaScript 函数（或箭头函数）定义，它接收一个 props 参数并返回 JSX。函数组件通常更简洁。 jsx function Welcome(props) { return <h1>Hello, {props.name}</h1>; }类组件：使用 ES6 类来定义，它扩展自 React.Component，必须包含一个 render() 方法，该方法返回 JSX。 jsx class Welcome extends React.Component { render() { return <h1>Hello, {this.props.name}</h1>; } }状态管理：函数组件：在 React 16.8 之前，函数组件不具备状态（state）和生命周期方法。但随着 React Hooks 的引入，函数组件可以使用 useState 和其他 Hooks 来管理状态和生命周期。类组件：具有内置的状态和生命周期方法。它们使用 this.state 和 this.setState 来管理组件的状态，以及一系列的生命周期函数（如 componentDidMount，componentShouldUpdate 等）来执行副作用操作。生命周期方法：函数组件：通过使用 React Hooks（如 useEffect），函数组件可以执行与类组件生命周期方法相似的操作，但它们不直接拥有生命周期方法。类组件：具有完整的生命周期方法，可以在组件的不同阶段执行代码。this 关键字：函数组件：不使用 this 关键字。所有的数据（包括 props 和 state）都通过函数参数或 Hooks 访问。类组件：需要使用 this 关键字来访问 props、state 和类方法。优化性能：函数组件：因为它们没有类实例，理论上可以更轻量。并且可以通过使用 React.memo 进行性能优化。类组件：可以使用 shouldComponentUpdate 或 PureComponent 来优化性能，但这些通常比函数组件中的优化方法更复杂。钩子(Hooks)：函数组件：可以使用 Hooks，如 useState、useEffect 等，使得在不使用类的情况下也能拥有类似的功能。类组件：无法使用 Hooks，必须依靠类本身的特性和生命周期。部署和维护：函数组件：通常来说，由于它们更加简洁，函数组件更容易编写和维护。它们也更容易分割成更小的函数。类组件：可能会更加冗长，特别是当涉及到多个生命周期方法和状态管理时，这可能使得维护和重构变得更加困难。代码复用：函数组件：可以通过自定义 Hooks 实现逻辑的复用。类组件：通常通过高阶组件（HOCs）或渲染道具（Render Props）来实现逻辑的复用。

React 的合成事件（SyntheticEvent）是 React 为了跨浏览器兼容性而实现的一个事件封装。合成事件的原理可以总结为以下几个关键点：1. 事件封装React 为了解决原生事件在不同浏览器中的兼容问题，实现了一套自己的事件系统。这个系统模拟原生事件系统，但是提供了一致的接口和行为。当事件发生时（如用户点击一个按钮），React 会创建一个合成事件的实例，这个实例包含了所有事件的信息，无论在哪个浏览器上。2. 事件冒泡在 React 中，所有的事件都会自动应用事件冒泡（bubbling），即事件会从触发它的最深的节点开始，逐层向上传播到最外层的节点。合成事件同样遵循这个机制，这意味着您只需要在一个高层节点上监听事件，就能处理下层节点的相应事件。3. 事件委托React 并不会将事件处理器直接绑定到真实的 DOM 元素上，而是使用了一种叫做事件委托的技术。React 在最顶层的文档节点上（通常是document）添加了一个单一的事件监听器，用来监听所有支持的事件类型。当一个事件发生时，React 会根据这个事件的目标和冒泡路径，来决定哪些注册的事件处理器需要被调用。4. 合成事件对象池出于性能考虑，React 实现了一个合成事件的对象池。每当一个事件发生并且事件处理器被调用时，React 从池中分配一个合成事件对象，并填充事件的相关信息。一旦事件处理器被调用，这个对象会被清空，并回收到池中以供后续的事件重复使用。这个过程减少了垃圾回收的压力和合成事件对象的创建成本。5. 与原生事件的关系尽管 React 使用了合成事件，但它仍然是基于原生事件的。当原生事件被触发时，React 的事件委托机制会处理这个事件，并创建一个合成事件传递给相应的事件处理器。开发者在编写事件处理函数时，操作的是由 React 提供的合成事件，而不是直接操作原生 DOM 事件。实例假设我们有一个按钮的点击事件，我们希望在点击时打印出事件对象：class MyComponent extends React.Component { handleClick = (event) => { console.log(event); // 这里的 event 是一个 SyntheticEvent 的实例 console.log(event.nativeEvent); // 这里可以访问原生的 DOM 事件对象 }; render() { return <button onClick={this.handleClick}>Click me</button>; }}这段代码中，handleClick 方法接收一个合成事件的实例。我们可以访问此对象的所有属性和方法，如同处理一个原生事件一样。但由于它是合成的，它在所有浏览器中的行为都是一致的。综上所述，React 的合成事件系统提供了一种高效且一致的方式来处理浏览器间的事件差异，并优化了性能，同时简化了事件处理的复杂性。

在JavaScript中实现高效的字符串前缀匹配通常可以通过以下几种方式：1. 原生字符串方法使用字符串的startsWith()方法，这是最简单直接的方法，性能也相当好。function isPrefix(str, prefix) { return str.startsWith(prefix);}// 使用示例console.log(isPrefix('javascript', 'java')); // 输出: trueconsole.log(isPrefix('javascript', 'script')); // 输出: false2. 正则表达式利用正则表达式的^锚点来匹配字符串的开头。function isPrefix(str, prefix) { let regex = new RegExp('^' + escapeRegExp(prefix)); return regex.test(str);}// 为了安全性，对特殊字符进行转义，防止注入攻击function escapeRegExp(string) { return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');}// 使用示例console.log(isPrefix('javascript', 'java')); // 输出: trueconsole.log(isPrefix('javascript', 'script')); // 输出: false3. 字符串切片比较通过截取原字符串前N个字符，然后与前缀进行比较。function isPrefix(str, prefix) { return str.slice(0, prefix.length) === prefix;}// 使用示例console.log(isPrefix('javascript', 'java')); // 输出: trueconsole.log(isPrefix('javascript', 'script')); // 输出: false4. 循环比较逐个字符比较，这通常不是最高效的方法，但在某些特定情况下可能是必要的。function isPrefix(str, prefix) { if (str.length < prefix.length) return false; for (let i = 0; i < prefix.length; i++) { if (str[i] !== prefix[i]) { return false; } } return true;}// 使用示例console.log(isPrefix('javascript', 'java')); // 输出: trueconsole.log(isPrefix('javascript', 'script')); // 输出: false5. 使用内置方法 indexOf检查前缀是否在字符串的开头位置。function isPrefix(str, prefix) { return str.indexOf(prefix) === 0;}// 使用示例console.log(isPrefix('javascript', 'java')); // 输出: trueconsole.log(isPrefix('javascript', 'script')); // 输出: false每种方法都有其适用场景，一般而言，如果只需要简单的前缀匹配，推荐使用startsWith()方法，因为它简单且意图明确。如果需要对匹配进行更复杂的控制，可能会选择正则表达式。在处理大量数据或性能至关重要的情况下，可以进行基准测试以确定哪种方法最有效。

JavaScript 是一种动态类型语言，这意味着在声明变量时不需要指定数据类型，数据类型会在脚本执行时自动确定。JavaScript 的数据类型主要分为两大类：原始数据类型和对象类型。原始数据类型undefined：表示变量未定义，即声明了变量但未初始化。null：表示一个空值。boolean：布尔类型，有两个值：true 和 false。string：表示文本数据，例如 "Hello, World!"。number：可以是整数或浮点数，例如 42 或 3.14159。bigint：表示大于2^53 - 1的整数。symbol：表示唯一的、不可变的数据值。对象类型Object：JavaScript 中的对象是键值对的集合，几乎所有的 JavaScript 值都是对象类型的，包括数组、函数以及其他内置对象。类型检测的方法在 JavaScript 中，检测变量的类型常用的有几种方法：typeof 运算符：用来检测一个变量的类型，对于原始数据类型非常有效，但对于对象类型和 null，会有一些局限性。let num = 42;console.log(typeof num); // "number"let str = "Hello";console.log(typeof str); // "string"let flag = true;console.log(typeof flag); // "boolean"let bigIntNumber = 1234567890123456789012345678901234567890n;console.log(typeof bigIntNumber); // "bigint"let sym = Symbol('foo');console.log(typeof sym); // "symbol"let und;console.log(typeof und); // "undefined"let obj = { key: 'value' };console.log(typeof obj); // "object"let arr = [1, 2, 3];console.log(typeof arr); // "object", 尽管它是数组let func = function() {};console.log(typeof func); // "function", 函数是对象的一种特殊类型let nul = null;console.log(typeof nul); // "object", 这是一个历史上的错误instanceof 运算符：用来检测一个对象是否是另一个对象的实例。let arr = [1, 2, 3];console.log(arr instanceof Array); // trueconsole.log(arr instanceof Object); // truelet d = new Date();console.log(d instanceof Date); // true// 注意，instanceof 无法检测原始数据类型Array.isArray()：用来确定一个值是否是数组。let arr = [1, 2, 3];console.log(Array.isArray(arr)); // true对象的 constructor 属性：可以用来判断对象的构造函数。let arr = [1, 2, 3];console.log(arr.constructor === Array); // truelet obj = {};console.log(obj.constructor === Object); // trueObject.prototype.toString.call()：这是一个通用的类型检测方法，可以准确判断各种类型的值。let d = new Date();console.log(Object.prototype.toString.call(d)); // "[object Date]"let num = 42;console.log(Object.prototype.toString.call(num)); // "[object Number]"let str = "Hello";console.log(Object.prototype.toString.call(str)); // "[object String]"注意，当使用类型检测方法时，应当根据具体情况选择最适合的方法，因为每种方法都有其适用场景和限制。

React 的虚拟DOM（VDOM）是React用于提升应用性能的核心概念之一。它是对真实DOM的一个轻量级抽象。虚拟DOM本质上是一个JavaScript对象，它是真实DOM结构的一个简化版本。React使用虚拟DOM来模拟真实DOM的更新，这样就可以最小化对真实DOM的操作，因为真实DOM操作的开销通常比较大。当组件的状态变化时，React会创建一个新的虚拟DOM树并将其与上一次的虚拟DOM树进行比较。这个过程被称为Diff算法。通过Diff算法，React可以确定实际DOM需要进行的最小更新。以下是Diff算法的简要步骤：树的比较：React首先比较两棵树的根节点，如果根节点的类型不同（例如从<div>变到<span>），React会销毁旧树并建立一棵新树。如果类型相同，则保留根节点，并继续进行递归比较。组件的比较：如果是React组件节点，React会检查组件的类型是否相同。如果相同，组件将接收新的props并重新渲染。然后，React会比较返回的虚拟DOM。子元素的比较：当比较两个相同类型的元素时，React会继续比较它们的子元素。React有两种不同的策略来比较子元素：同层比较：React只比较同一层级的子元素。如果在不同层级有相同的元素，React不会尝试复用这些元素。key属性：当开发者提供了key属性时，React会使用这个key来匹配旧的虚拟DOM树中的元素和新的虚拟DOM树中的元素。这有助于保持状态和提高性能，特别是在处理列表时。更新DOM：一旦Diff算法确定了需要变更的最小部分，React会批量执行这些更新，尽量减少对真实DOM的操作，从而提高性能。例子：假设有一个列表，列表项组件<ListItem />有一个唯一的key属性，并且列表的状态更新导致列表项的顺序颠倒。由于每个<ListItem />都有唯一的key，React能够识别出这些组件只是顺序改变了，而不是完全不同的组件。因此，React仅会改变DOM中这些列表项的顺序，而不是销毁整个列表并重新创建，这大大提高了性能。总结：React的虚拟DOM和Diff算法共同工作，以提供高效的更新机制。虚拟DOM使得React可以在内存中进行计算，而Diff算法确保只对真实DOM做必要的、最小的修改。这种机制使得React在处理大型、动态的应用时能够保持良好的性能。