为了面试能通过，我要看完这75道面试题（上，响应式web开发项目教程

这可能是所有问题中最难的一个问题，因为闭包是一个有争议的话题，这里从个人角度来谈谈，如果不妥，多多海涵。

闭包就是一个函数在声明时能够记住当前作用域、父函数作用域、及父函数作用域上的变量和参数的引用，直至通过作用域链上全局作用域，基本上闭包是在声明函数时创建的作用域。

看看小例子：

// 全局作用域

var globalVar = “abc”;

function a(){

console.log(globalVar);

}

a(); // “abc”

在此示例中，当我们声明a函数时，全局作用域是a闭包的一部分。

变量globalVar在图中没有值的原因是该变量的值可以根据调用函数a的位置和时间而改变。但是在上面的示例中，globalVar变量的值为abc。

来看一个更复杂的例子：

var globalVar = “global”;

var outerVar = “outer”

function outerFunc(outerParam) {

function innerFunc(innerParam) {

console.log(globalVar, outerParam, innerParam);

}

return innerFunc;

}

const x = outerFunc(outerVar);

outerVar = “outer-2”;

globalVar = “guess”

x(“inner”);

上面打印结果是 guess outer inner。

当我们调用outerFunc函数并将返回值innerFunc函数分配给变量x时，即使我们为outerVar变量分配了新值outer-2，outerParam也继续保留outer值，因为重新分配是在调用outerFunc之后发生的，并且当我们调用outerFunc函数时，它会在作用域链中查找outerVar的值，此时的outerVar的值将为 "outer"。

现在，当我们调用引用了innerFunc的x变量时，innerParam将具有一个inner值，因为这是我们在调用中传递的值，而globalVar变量值为guess，因为在调用x变量之前，我们将一个新值分配给globalVar。

下面这个示例演示没有理解好闭包所犯的错误：

const arrFuncs = [];

for(var i = 0; i < 5; i++){

arrFuncs.push(function (){

return i;

});

}

console.log(i); // i is 5

for (let i = 0; i < arrFuncs.length; i++) {

console.log(arrFuncsi); // 都打印 5

}

由于闭包，此代码无法正常运行。var关键字创建一个全局变量，当我们 push 一个函数时，这里返回的全局变量i。 因此，当我们在循环后在该数组中调用其中一个函数时，它会打印5，因为我们得到i的当前值为5，我们可以访问它，因为它是全局变量。

因为闭包在创建变量时会保留该变量的引用而不是其值。 我们可以使用IIFES或使用 let 来代替 var 的声明。

const falsyValues = [‘’, 0, null, undefined, NaN, false];

简单的来说虚值就是是在转换为布尔值时变为 false 的值。

使用 Boolean 函数或者 !! 运算符。

"use strict" 是 ES5 特性，它使我们的代码在函数或整个脚本中处于严格模式。严格模式帮助我们在代码的早期避免 bug，并为其添加限制。

严格模式的一些限制：

1. 变量必须声明后再使用

2. 函数的参数不能有同名属性，否则报错

3. 不能使用with语句

4. 不能对只读属性赋值，否则报错

5. 不能使用前缀 0 表示八进制数，否则报错

6. 不能删除不可删除的属性，否则报错

7. 不能删除变量delete prop，会报错，只能删除属性delete global[prop]

8. eval不能在它的外层作用域引入变量

9. eval和arguments不能被重新赋值

10. arguments不会自动反映函数参数的变化

11. 不能使用arguments.callee

12. 不能使用arguments.caller

13. 禁止this指向全局对象

14. 不能使用fn.caller和fn.arguments获取函数调用的堆栈

15. 增加了保留字（比如protected、static和interface）

设立”严格模式”的目的，主要有以下几个：

1. 消除Javascript语法的一些不合理、不严谨之处，减少一些怪异行为;

2. 消除代码运行的一些不安全之处，保证代码运行的安全；

3. 提高编译器效率，增加运行速度；

4. 为未来新版本的Javascript做好铺垫。

基本上，this指的是当前正在执行或调用该函数的对象的值。this值的变化取决于我们使用它的上下文和我们在哪里使用它。

const carDetails = {

name: “Ford Mustang”,

yearBought: 2005,

getName(){

return this.name;

},

isRegistered: true

};

console.log(carDetails.getName()); // Ford Mustang

这通常是我们期望结果的，因为在getName方法中我们返回this.name，在此上下文中，this指向的是carDetails对象，该对象当前是执行函数的“所有者”对象。

接下我们做些奇怪的事情：

var name = “Ford Ranger”;

var getCarName = carDetails.getName;

console.log(getCarName()); // Ford Ranger

上面打印Ford Ranger，这很奇怪，因为在第一个console.log语句中打印的是Ford Mustang。这样做的原因是getCarName方法有一个不同的“所有者”对象，即window对象。在全局作用域中使用var关键字声明变量会在window对象中附加与变量名称相同的属性。请记住，当没有使用“use strict”时，在全局作用域中this指的是window对象。

console.log(getCarName === window.getCarName); // true

console.log(getCarName === this.getCarName); // true

本例中的this和window引用同一个对象。

解决这个问题的一种方法是在函数中使用apply和call方法。

console.log(getCarName.apply(carDetails)); // Ford Mustang

console.log(getCarName.call(carDetails)); // Ford Mustang

apply和call方法期望第一个参数是一个对象，该对象是函数内部this的值。

IIFE或立即执行的函数表达式，在全局作用域内声明的函数，对象内部方法中的匿名函数和内部函数的this具有默认值，该值指向window对象。

(function (){

console.log(this);

})(); // 打印 “window” 对象

function iHateThis(){

console.log(this);

}

iHateThis(); // 打印 “window” 对象

const myFavoriteObj = {

guessThis(){

function getName(){

console.log(this.name);

}

getName();

},

name: ‘Marko Polo’,

thisIsAnnoying(callback){

callback();

}

};

myFavoriteObj.guessThis(); // 打印 “window” 对象

myFavoriteObj.thisIsAnnoying(function (){

console.log(this); // 打印 “window” 对象

});

如果我们要获取myFavoriteObj对象中的name属性（即Marko Polo）的值，则有两种方法可以解决此问题。

一种是将 this 值保存在变量中。

const myFavoriteObj = {

guessThis(){

const self = this; // 把 this 值保存在 self 变量中

function getName(){

console.log(self.name);

}

getName();

},

name: ‘Marko Polo’,

thisIsAnnoying(callback){

callback();

}

};

第二种方式是使用箭头函数

const myFavoriteObj = {

guessThis(){

const getName = () => {

console.log(this.name);

}

getName();

},

name: ‘Marko Polo’,

thisIsAnnoying(callback){

callback();

}

};

箭头函数没有自己的 this。它复制了这个封闭的词法作用域中this值，在这个例子中，this值在getName内部函数之外，也就是myFavoriteObj对象。

简单地说，原型就是对象的蓝图。如果它存在当前对象中，则将其用作属性和方法的回退。它是在对象之间共享属性和功能的方法，这也是JavaScript实现继承的核心。

const o = {};

console.log(o.toString()); // logs [object Object]

即使o对象中不存在o.toString方法，它也不会引发错误，而是返回字符串[object Object]。 当对象中不存在属性时，它将查看其原型，如果仍然不存在，则将其查找到原型的原型，依此类推，直到在原型链中找到具有相同属性的属性为止。 原型链的末尾是Object.prototype。

console.log(o.toString === Object.prototype.toString); // logs true

IIFE或立即调用的函数表达式是在创建或声明后将被调用或执行的函数。 创建IIFE的语法是，将function (){}包裹在在括号()内，然后再用另一个括号()调用它，如：(function(){})()

(function(){

…

} ());

(function () {

…

})();

(function named(params) {

…

})();

(() => {

});

(function (global) {

…

})(window);

const utility = (function () {

return {

…

}

})

这些示例都是有效的IIFE。 倒数第二个救命表明我们可以将参数传递给IIFE函数。 最后一个示例表明，我们可以将IIFE的结果保存到变量中，以便稍后使用。

IIFE的一个主要作用是避免与全局作用域内的其他变量命名冲突或污染全局命名空间，来个例子。

假设我们引入了一个omelibr.js的链接，它提供了一些我们在代码中使用的全局函数，但是这个库有两个方法我们没有使用：createGraph和drawGraph，因为这些方法都有bug。我们想实现自己的createGraph和drawGraph方法。

解决此问题的一种方法是直接覆盖：

当我们使用这个解决方案时，我们覆盖了库提供给我们的那两个方法。

另一种方式是我们自己改名称：

当我们使用这个解决方案时，我们把那些函数调用更改为新的函数名。

还有一种方法就是使用IIFE：

在此解决方案中，我们要声明了graphUtility 变量，用来保存IIFE执行的结果，该函数返回一个包含两个方法createGraph和drawGraph的对象。

IIFE 还可以用来解决一个常见的面试题：

var li = document.querySelectorAll(‘.list-group > li’);

for (var i = 0, len = li.length; i < len; i++) {

li[i].addEventListener(‘click’, function (e) {

console.log(i);

})

假设我们有一个带有list-group类的ul元素，它有5个li子元素。 当我们单击单个li元素时，打印对应的下标值。但在此外上述代码不起作用，这里每次点击 li 打印 i 的值都是5，这是由于闭包的原因。

闭包只是函数记住其当前作用域，父函数作用域和全局作用域的变量引用的能力。 当我们在全局作用域内使用var关键字声明变量时，就创建全局变量i。 因此，当我们单击li元素时，它将打印5，因为这是稍后在回调函数中引用它时i的值。

使用 IIFE 可以解决此问题：

var li = document.querySelectorAll(‘.list-group > li’);

for (var i = 0, len = li.length; i < len; i++) {

(function (currentIndex) {

li[currentIndex].addEventListener(‘click’, function (e) {

console.log(currentIndex);

})

})(i);

}

该解决方案之所以行的通，是因为IIFE会为每次迭代创建一个新的作用域，我们捕获i的值并将其传递给currentIndex参数，因此调用IIFE时，每次迭代的currentIndex值都是不同的。

apply() 方法调用一个具有给定this值的函数，以及作为一个数组（或类似数组对象）提供的参数。

const details = {

message: ‘Hello World!’

};

function getMessage(){

return this.message;

}

getMessage.apply(details); // ‘Hello World!’

call()方法的作用和 apply() 方法类似，区别就是call()方法接受的是参数列表，而apply()方法接受的是一个参数数组。

const person = {

name: “Marko Polo”

};

function greeting(greetingMessage) {

return ${greetingMessage} ${this.name};

}

greeting.apply(person, [‘Hello’]); // “Hello Marko Polo!”

call() 方法使用一个指定的 this 值和单独给出的一个或多个参数来调用一个函数。

const details = {

message: ‘Hello World!’

};

function getMessage(){

return this.message;

}

getMessage.call(details); // ‘Hello World!’

注意：该方法的语法和作用与 apply() 方法类似，只有一个区别，就是 call() 方法接受的是一个参数列表，而 apply() 方法接受的是一个包含多个参数的数组。

const person = {

name: “Marko Polo”

};

function greeting(greetingMessage) {

return ${greetingMessage} ${this.name};

}

greeting.call(person, ‘Hello’); // “Hello Marko Polo!”

apply()方法可以在使用一个指定的 this 值和一个参数数组（或类数组对象）的前提下调用某个函数或方法。call()方法类似于apply()，不同之处仅仅是call()接受的参数是参数列表。

const obj1 = {

result:0

};

const obj2 = {

result:0

};

function reduceAdd(){

let result = 0;

for(let i = 0, len = arguments.length; i < len; i++){

result += arguments[i];

}

this.result = result;

}

reduceAdd.apply(obj1, [1, 2, 3, 4, 5]); // 15

reduceAdd.call(obj2, 1, 2, 3, 4, 5); // 15

bind() 方法创建一个新的函数，在 bind() 被调用时，这个新函数的 this 被指定为 bind() 的第一个参数，而其余参数将作为新函数的参数，供调用时使用。

import React from ‘react’;

class MyComponent extends React.Component {

constructor(props){

super(props);

this.state = {

value : “”

}

this.handleChange = this.handleChange.bind(this);

// 将 “handleChange” 方法绑定到 “MyComponent” 组件

}

handleChange(e){

//do something amazing here

}

render(){

return (

<>

<input type={this.props.type}

value={this.state.value}

onChange={this.handleChange}

/>

</>

)

}

}

函数式编程（通常缩写为FP）是通过编写纯函数，避免共享状态、可变数据、副作用 来构建软件的过程。数式编程是声明式 的而不是命令式 的，应用程序的状态是通过纯函数流动的。与面向对象编程形成对比，面向对象中应用程序的状态通常与对象中的方法共享和共处。

函数式编程是一种编程范式 ，这意味着它是一种基于一些基本的定义原则（如上所列）思考软件构建的方式。当然，编程范示的其他示例也包括面向对象编程和过程编程。

函数式的代码往往比命令式或面向对象的代码更简洁，更可预测，更容易测试 - 但如果不熟悉它以及与之相关的常见模式，函数式的代码也可能看起来更密集杂乱，并且 相关文献对新人来说是不好理解的。

JavaScript支持闭包和高阶函数是函数式编程语言的特点。

高阶函数只是将函数作为参数或返回值的函数。

function higherOrderFunction(param,callback){

return callback(param);

}

在JavaScript中，函数不仅拥有一切传统函数的使用方式（声明和调用），而且可以做到像简单值一样赋值（var func = function(){}）、传参(function func(x,callback){callback();})、返回(function(){return function(){}})，这样的函数也称之为第一级函数（First-class Function）。不仅如此，JavaScript中的函数还充当了类的构造函数的作用，同时又是一个Function类的实例(instance)。这样的多重身份让JavaScript的函数变得非常重要。

map() 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

function map(arr, mapCallback) {

// 首先，检查传递的参数是否正确。

if (!Array.isArray(arr) || !arr.length || typeof mapCallback !== ‘function’) {

return [];

} else {

let result = [];

// 每次调用此函数时，我们都会创建一个 result 数组

// 因为我们不想改变原始数组。

for (let i = 0, len = arr.length; i < len; i++) {

result.push(mapCallback(arr[i], i, arr));

// 将 mapCallback 返回的结果 push 到 result 数组中

}

return result;

}

}

filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

function filter(arr, filterCallback) {

// 首先，检查传递的参数是否正确。

if (!Array.isArray(arr) || !arr.length || typeof filterCallback !== ‘function’)

{

return [];

} else {

let result = [];

// 每次调用此函数时，我们都会创建一个 result 数组

// 因为我们不想改变原始数组。

for (let i = 0, len = arr.length; i < len; i++) {

// 检查 filterCallback 的返回值是否是真值

if (filterCallback(arr[i], i, arr)) {

// 如果条件为真，则将数组元素 push 到 result 中

result.push(arr[i]);

}

}

return result; // return the result array

}

}

reduce() 方法对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

function reduce(arr, reduceCallback, initialValue) {

// 首先，检查传递的参数是否正确。

if (!Array.isArray(arr) || !arr.length || typeof reduceCallback !== ‘function’)

{

return [];

} else {

// 如果没有将initialValue传递给该函数，我们将使用第一个数组项作为initialValue

let hasInitialValue = initialValue !== undefined;

let value = hasInitialValue ? initialValue : arr[0];

、

// 如果有传递 initialValue，则索引从 1 开始，否则从 0 开始

for (let i = hasInitialValue ? 0 : 1, len = arr.length; i < len; i++) {

value = reduceCallback(value, arr[i], i, arr);

}

return value;

}

}

arguments对象是函数中传递的参数值的集合。它是一个类似数组的对象，因为它有一个length属性，我们可以使用数组索引表示法arguments[1]来访问单个值，但它没有数组中的内置方法，如：forEach、reduce、filter和map。

我们可以使用Array.prototype.slice将arguments对象转换成一个数组。

function one() {

return Array.prototype.slice.call(arguments);

}

注意:箭头函数中没有arguments对象。

function one() {

return arguments;

}

const two = function () {

return arguments;

}

const three = function three() {

return arguments;

}

const four = () => arguments;

four(); // Throws an error - arguments is not defined

当我们调用函数four时，它会抛出一个ReferenceError: arguments is not defined error。使用rest语法，可以解决这个问题。

const four = (…args) => args;

这会自动将所有参数值放入数组中。

我们可以使用Object.create方法创建没有原型的对象。

const o1 = {};

console.log(o1.toString()); // [object Object]

const o2 = Object.create(null);

console.log(o2.toString());

// throws an error o2.toString is not a function

function myFunc() {

let a = b = 0;

}

myFunc();

原因是赋值运算符是从右到左的求值的。这意味着当多个赋值运算符出现在一个表达式中时，它们是从右向左求值的。所以上面代码变成了这样：

function myFunc() {

let a = (b = 0);

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数前端工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024c （备注前端）