【前端高频面试题】 - JavaScript 篇
【前端高频面试题】 - JavaScript 篇
1. 请说明 JavaScript 中的变量类型,以及如何检测这些类型?
变量类型
- 基本数据类型(值类型):共 6 种,分别是
String(字符串)、Number(数字)、Boolean(布尔)、Undefined(未定义)、Null(空对象指针)、Symbol(唯一标识,ES6 新增),存储在栈内存中,值不可变。 - 引用数据类型:主要是
Object(对象),包括Array(数组)、Function(函数)、Date(日期)等,存储在堆内存中,栈内存仅保存堆内存的引用地址,值可修改。
类型检测方法
typeof运算符:- 适用场景:检测基本类型(除
Null外)和函数,返回字符串(如typeof 'abc' → 'string'、typeof function(){} → 'function')。 - 局限性:检测
Null会返回'object'(历史 bug),检测引用类型(如数组、对象)均返回'object'。
- 适用场景:检测基本类型(除
instanceof运算符:- 适用场景:检测引用类型的具体类型,基于原型链判断(如
[1,2] instanceof Array → true、new Date() instanceof Date → true)。 - 局限性:不能检测基本类型,且跨 iframe 时可能失效(原型链断裂)。
- 适用场景:检测引用类型的具体类型,基于原型链判断(如
Object.prototype.toString.call():- 适用场景:通用类型检测,返回格式为
'[object 类型]'的字符串(如Object.prototype.toString.call(null) → '[object Null]'、Object.prototype.toString.call([]) → '[object Array]')。 - 优势:无明显局限性,可准确区分所有内置类型。
- 适用场景:通用类型检测,返回格式为
2. 什么是变量提升?var、let、const 的变量提升有什么区别?
变量提升概念
变量提升是 JavaScript 引擎的预编译行为:在代码执行前,会将变量声明(var/let/const)和函数声明提升到当前作用域的顶部,但赋值不会提升。
三者变量提升的区别
var的变量提升:- 声明和赋值分离,提升时仅提升声明,默认赋值为
undefined。 - 示例:
console.log(a); // undefined(声明提升,赋值未提升) var a = 10; - 无块级作用域,提升到函数/全局作用域顶部。
- 声明和赋值分离,提升时仅提升声明,默认赋值为
let/const的变量提升:- 存在“暂时性死区(TDZ)”:声明会提升,但提升后到赋值前的区域不可访问,访问会报错。
- 示例:
console.log(b); // 报错(暂时性死区) let b = 20; - 有块级作用域(
{}包裹区域),提升到块级作用域顶部。
let与const的额外区别:let允许重复赋值,const声明的变量必须初始化,且赋值后不可修改(引用类型仅限制地址,内部属性可改)。
3. JavaScript 中 this 的指向的是如何确定的?请分场景说明。
this 的指向在函数调用时确定,而非定义时,不同调用场景指向不同:
- 全局环境下:
- 浏览器环境:
this指向window(非严格模式)或undefined(严格模式)。 - 示例:
console.log(this) → window(浏览器非严格模式)。
- 浏览器环境:
- 普通函数调用:
- 非严格模式:
this指向window;严格模式:this指向undefined。 - 示例:
function fn() { console.log(this); } fn(); // window(非严格模式)/ undefined(严格模式)
- 非严格模式:
- 对象方法调用:
this指向调用该方法的对象(即方法前面的“点”左边的对象)。- 示例:
const obj = { name: 'A', fn: function() { console.log(this.name); } }; obj.fn(); // 'A'(this 指向 obj)
- 构造函数调用(
new关键字):this指向新创建的实例对象。- 示例:
function Person(name) { this.name = name; } const p = new Person('B'); console.log(p.name); // 'B'(this 指向 p)
call/apply/bind调用:this指向这三个方法的第一个参数(手动指定的上下文)。- 示例:
function fn() { console.log(this.name); } const obj = { name: 'C' }; fn.call(obj); // 'C'(this 指向 obj)
- 箭头函数调用:
- 箭头函数无独立
this,其this继承自外层作用域的this(定义时确定,永不改变)。 - 示例:
const obj = { fn: () => { console.log(this); } }; obj.fn(); // window(继承全局 this,而非 obj)
- 箭头函数无独立
4. 什么是闭包?闭包的形成条件、作用及缺点是什么?
闭包概念
闭包是指有权访问另一个函数作用域中变量的函数,本质是函数嵌套时,内层函数保留了对外层函数作用域的引用。
形成条件
- 存在函数嵌套(内层函数 + 外层函数);
- 内层函数引用了外层函数的变量/参数;
- 内层函数被外层函数以外的地方调用(打破外层函数执行后作用域销毁的常规)。
闭包的作用
- 保存变量:延长外层函数变量的生命周期,避免被垃圾回收机制回收(如实现计数器)。
- 示例:
function createCounter() { let count = 0; // 外层函数变量,被内层函数引用 return function() { return ++count; }; // 内层函数被外部调用 } const counter = createCounter(); console.log(counter()); // 1 console.log(counter()); // 2(count 未被销毁)
- 示例:
- 模块化:实现私有变量和公有方法的封装(避免全局变量污染)。
闭包的缺点
- 内存泄漏风险:若闭包长期持有外层函数的变量且不释放,会导致内存无法回收,长期积累可能影响性能。
- 解决方式:不再使用闭包时,手动将引用设为
null(如counter = null)。
5. 请解释 JavaScript 中的原型(Prototype)和原型链(Prototype Chain)。
核心概念关系
JavaScript 中每个对象(除 null 外)都有 __proto__(隐式原型),每个函数都有 prototype(显式原型);对象的 __proto__ 指向其构造函数的 prototype。
-
原型(Prototype):
- 即函数的
prototype属性,是一个对象,称为“原型对象”。 - 作用:存储所有实例共享的属性和方法(如
Array.prototype.push是所有数组实例的共享方法)。 - 原型对象内置
constructor属性,指向其关联的构造函数(如Array.prototype.constructor === Array)。
- 即函数的
-
原型链(Prototype Chain):
- 当访问对象的某个属性/方法时,先在对象自身查找;若找不到,就通过
__proto__向上查找其构造函数的原型对象;若仍找不到,继续向上查找原型对象的__proto__,直到找到Object.prototype(原型链顶端,其__proto__为null);若最终未找到,返回undefined。 - 示例:
const arr = [1,2]; console.log(arr.push(3)); // 3(arr 自身无 push,通过 __proto__ 找到 Array.prototype.push) console.log(arr.toString()); // "1,2,3"(Array.prototype 无 toString,继续向上找到 Object.prototype.toString) - 作用:实现 JavaScript 的继承机制(实例继承构造函数原型的属性和方法)。
- 当访问对象的某个属性/方法时,先在对象自身查找;若找不到,就通过
6. JavaScript 中有哪些常见的继承方式?请说明各自的原理和优缺点。
1. 原型链继承
- 原理:让子类的原型对象指向父类的实例,子类实例通过原型链访问父类的属性和方法。
function Parent() { this.name = 'Parent'; } Parent.prototype.sayName = function() { console.log(this.name); }; function Child() {} Child.prototype = new Parent(); // 子类原型指向父类实例 const child = new Child(); child.sayName(); // "Parent" - 优点:实现简单,天然支持原型链的属性共享。
- 缺点:子类实例无法向父类构造函数传参;父类的引用类型属性会被所有子类实例共享(修改一个实例的属性会影响其他实例)。
2. 构造函数继承(借用构造函数)
- 原理:在子类构造函数中通过
call/apply调用父类构造函数,手动绑定this为子类实例。function Parent(name) { this.name = name; this.arr = [1,2]; } function Child(name) { Parent.call(this, name); } // 借用父类构造函数 const child1 = new Child('A'); const child2 = new Child('B'); child1.arr.push(3); console.log(child1.arr); // [1,2,3] console.log(child2.arr); // [1,2](引用类型属性不共享) - 优点:子类实例可向父类传参;父类引用类型属性不共享(每个实例独立)。
- 缺点:父类原型上的属性和方法无法继承(仅继承父类构造函数内的属性和方法);每个子类实例都会重复创建父类构造函数中的方法,浪费内存。
3. 组合继承(原型链 + 构造函数)
- 原理:结合原型链继承(继承原型方法)和构造函数继承(继承实例属性)。
function Parent(name) { this.name = name; this.arr = [1,2]; } Parent.prototype.sayName = function() { console.log(this.name); }; function Child(name) { Parent.call(this, name); } // 继承实例属性 Child.prototype = new Parent(); // 继承原型方法 Child.prototype.constructor = Child; // 修复 constructor 指向 - 优点:兼顾前两种方式的优点,可传参、引用类型不共享、能继承原型方法。
- 缺点:父类构造函数会被调用两次(一次
new Parent()赋值原型,一次Parent.call()借用),造成不必要的性能消耗。
4. 寄生组合继承(最优方案)
- 原理:用父类原型的浅拷贝对象作为子类原型,避免父类构造函数被重复调用。
function Parent(name) { this.name = name; this.arr = [1,2]; } Parent.prototype.sayName = function() { console.log(this.name); }; function Child(name) { Parent.call(this, name); } // 仅调用一次父类构造函数 // 用 Object.create 拷贝父类原型,作为子类原型 Child.prototype = Object.create(Parent.prototype); Child.prototype.constructor = Child; // 修复 constructor - 优点:解决组合继承的缺点,父类构造函数仅调用一次,是 ES6 之前的最优继承方案。
5. ES6 class 继承(语法糖)
- 原理:基于原型链实现,是寄生组合继承的语法简化,用
class和extends关键字声明。class Parent { constructor(name) { this.name = name; this.arr = [1,2]; } sayName() { console.log(this.name); } // 原型方法 } class Child extends Parent { constructor(name) { super(name); } // 调用父类构造函数(类似 Parent.call(this)) } - 优点:语法清晰、直观,符合传统面向对象编程习惯,本质仍是原型继承。
7. 请列举至少 5 个 ES6 及以后的新特性,并说明其作用。
1. let/const 声明
- 作用:替代
var,解决变量提升和全局污染问题;let:块级作用域,允许重复赋值;const:块级作用域,声明时必须初始化,赋值后不可修改(引用类型内部属性可改)。
2. 箭头函数(Arrow Function)
- 作用:简化函数语法,解决普通函数
this指向不明确的问题;- 特点:无独立
this(继承外层this)、无arguments对象、不能作为构造函数、语法简洁(单参数可省略括号,单语句可省略大括号和return)。 - 示例:
const add = (a, b) => a + b;
- 特点:无独立
3. 模板字符串(Template Literals)
- 作用:替代传统字符串拼接,支持多行字符串和变量插值;
- 语法:用反引号(
)包裹,变量用${}` 嵌入。 - 示例:
const name = 'A'; const str = `My name is ${name}, I'm 20.`; // "My name is A, I'm 20."
- 语法:用反引号(
4. 解构赋值(Destructuring Assignment)
- 作用:快速从数组或对象中提取数据,简化代码;
- 数组解构:
const [a, b] = [1, 2];(a=1,b=2); - 对象解构:
const { name, age } = { name: 'B', age: 20 };(name='B',age=20)。
- 数组解构:
5. 扩展运算符(Spread Operator)
- 作用:将数组/对象展开为单个元素/属性,用于数组拷贝、合并、函数参数传递;
- 数组扩展:
const arr2 = [...arr1];(浅拷贝数组)、const arr3 = [...arr1, 3, 4];(合并数组); - 对象扩展:
const obj2 = { ...obj1, age: 20 };(合并对象,覆盖同名属性)。
- 数组扩展:
6. Promise 对象
- 作用:解决“回调地狱”问题,优雅处理异步操作;
- 提供
pending(等待)、fulfilled(成功)、rejected(失败)三种状态,通过then/catch链式调用处理结果。
- 提供
7. 模块系统(ES Module)
- 作用:实现 JavaScript 模块化,支持文件间的导入(
import)和导出(export),避免全局变量污染;- 示例:
// 导出模块 export const add = (a, b) => a + b; // 导入模块 import { add } from './math.js';
- 示例:
8. 什么是 Promise?请说明其状态、常用方法及使用场景。
Promise 概念
Promise 是 ES6 引入的异步编程解决方案,用于表示一个异步操作的最终完成(或失败)及其结果值,本质是一个对象,封装了异步操作。
Promise 的三种状态
pending(等待态):初始状态,异步操作未完成,可转为fulfilled或rejected;fulfilled(成功态):异步操作完成,状态不可逆,会触发then方法的回调;rejected(失败态):异步操作失败,状态不可逆,会触发catch方法的回调。
常用方法
1. 实例方法(new Promise 生成的实例调用)
then(onFulfilled, onRejected):- 作用:处理成功/失败结果,
onFulfilled接收成功值,onRejected接收失败原因; - 返回值:新的
Promise对象,支持链式调用。
- 作用:处理成功/失败结果,
catch(onRejected):- 作用:简化
then的onRejected参数,专门处理失败结果(等同于then(null, onRejected)); - 特点:可捕获前面所有
then链中的错误。
- 作用:简化
finally(onFinally):- 作用:无论
Promise成功或失败,都会执行的回调(无参数); - 用途:清理操作(如关闭加载动画)。
- 作用:无论
2. 静态方法(Promise 构造函数调用)
Promise.resolve(value):快速创建一个成功态的Promise,value为成功值;Promise.reject(reason):快速创建一个失败态的Promise,reason为失败原因;Promise.all(iterable):- 作用:接收一个
Promise数组,等待所有Promise都成功后,返回成功结果数组;若有一个失败,立即返回该失败原因; - 场景:并行执行多个独立的异步操作(如同时请求多个接口)。
- 作用:接收一个
Promise.race(iterable):- 作用:接收一个
Promise数组,只要有一个Promise改变状态(成功/失败),就返回该结果; - 场景:设置异步操作超时(如请求接口超时后返回默认值)。
- 作用:接收一个
使用场景
- 处理单个异步操作(如接口请求、文件读取);
- 并行处理多个异步操作(如同时获取用户信息和商品列表);
- 解决回调地狱(如多层嵌套的异步操作,用
then链替代嵌套回调)。
9. 什么是 async/await?它和 Promise 是什么关系?如何处理 async/await 的错误?
async/await 概念
async/await 是 ES2017 引入的语法糖,基于 Promise 实现,用于进一步简化异步代码的写法,让异步代码看起来像同步代码。
和 Promise 的关系
- 依赖关系:
async/await不能脱离Promise单独使用,async函数的返回值本质是一个Promise对象;- 若
async函数内返回非Promise值,会自动用Promise.resolve()包装; - 若
async函数内抛出错误,会自动用Promise.reject()包装。 - 示例:
async function fn() { return 10; } fn().then(res => console.log(res)); // 10(返回值被包装为 Promise)
- 若
- 语法简化:
await关键字只能在async函数内使用,用于“等待”一个Promise完成,避免then链式调用的嵌套。
错误处理方式
async/await 本身不支持错误捕获,需通过 try/catch 语句处理,有两种常见方式:
-
全局
try/catch(处理所有错误):- 若多个
await操作的错误处理逻辑一致,可将所有await放在一个try块中,用一个catch捕获所有错误。 - 示例:
async function fetchData() { try { const res1 = await fetch('/api/user'); // 第一个异步操作 const res2 = await fetch('/api/goods'); // 第二个异步操作 } catch (err) { console.error('请求失败:', err); // 捕获 res1 或 res2 的错误 } }
- 若多个
-
单独
try/catch(处理特定错误):- 若不同
await操作的错误处理逻辑不同,可为每个await单独添加try/catch。 - 示例:
async function fetchData() { // 处理用户接口错误 let user; try { user = await fetch('/api/user'); } catch (err) { console.error('用户接口失败:', err); } // 处理商品接口错误 let goods; try { goods = await fetch('/api/goods'); } catch (err) { console.error('商品接口失败:', err); } }
- 若不同
10. 请解释浏览器环境下的事件循环(Event Loop)机制。
事件循环是浏览器处理同步代码和异步代码的核心机制,目的是避免单线程 JavaScript 因异步操作(如定时器、接口请求)阻塞执行。
核心前提
- JavaScript 是单线程语言,同一时间只能执行一段代码;
- 异步操作(如
setTimeout、Promise.then、DOM 事件)不会阻塞主线程,而是被放入“任务队列”,等待主线程空闲后执行。
任务队列分类
事件循环中的异步任务分为两类:
| 任务类型 | 包含的异步操作 | 执行优先级 |
|---|---|---|
| 宏任务(Macro Task) | setTimeout、setInterval、DOM 事件回调、fetch 接口请求、script 脚本执行 | 低 |
| 微任务(Micro Task) | Promise.then/catch/finally、async/await(本质是 Promise)、queueMicrotask | 高 |
事件循环执行流程
- 执行同步代码:主线程先执行当前
script中的所有同步代码,遇到异步操作时,将其对应的回调函数放入对应任务队列(宏任务/微任务); - 清空微任务队列:同步代码执行完毕后,主线程会优先清空所有微任务(按队列顺序执行);
- 执行一个宏任务:微任务队列清空后,主线程从宏任务队列中取出第一个宏任务执行;
- 重复循环:执行完一个宏任务后,再次清空所有微任务,然后再执行下一个宏任务,如此循环(即“事件循环”)。
示例验证
console.log('1'); // 同步代码,先执行
setTimeout(() => console.log('2'), 0); // 宏任务,放入宏任务队列
Promise.resolve().then(() => console.log('3')); // 微任务,放入微任务队列
console.log('4'); // 同步代码,继续执行
执行顺序:1 → 4(同步代码执行完)→ 3(清空微任务队列)→ 2(执行一个宏任务)。
11. 什么是防抖(Debounce)和节流(Throttle)?它们的区别、应用场景及实现方式是什么?
防抖和节流是两种常用的高频事件优化方案,用于减少不必要的函数调用,提升性能。
1. 防抖(Debounce)
概念
高频事件触发后,延迟 n 秒执行函数;若在 n 秒内事件再次触发,则重置延迟时间(重新计时),直到 n 秒内无新触发,才执行函数。
应用场景
- 搜索框输入联想(避免输入过程中频繁请求接口,仅在输入停止后请求);
- 窗口
resize事件(避免窗口拖动时频繁触发布局计算)。
实现方式(基础版)
function debounce(fn, delay) {
let timer = null; // 用闭包保存定时器
return function(...args) {
clearTimeout(timer); // 触发时重置定时器
timer = setTimeout(() => {
fn.apply(this, args); // 延迟后执行函数,绑定 this 和参数
}, delay);
};
}
// 使用:搜索框输入事件绑定防抖函数
const searchInput = document.querySelector('input');
searchInput.addEventListener('input', debounce(function(e) {
console.log('搜索请求:', e.target.value);
}, 500));
2. 节流(Throttle)
概念
高频事件触发时,每隔 n 秒只执行一次函数;无论事件在 n 秒内触发多少次,仅执行一次,避免函数频繁调用。
应用场景
- 滚动事件(如监听页面滚动加载更多,避免滚动过程中频繁触发加载);
- 按钮点击防重复提交(如表单提交按钮,限制 1 秒内只能点击一次)。
实现方式(时间戳版)
function throttle(fn, interval) {
let lastTime = 0; // 用闭包保存上次执行时间
return function(...args) {
const nowTime = Date.now(); // 当前时间戳
// 若当前时间 - 上次执行时间 >= 间隔,执行函数
if (nowTime - lastTime >= interval) {
fn.apply(this, args);
lastTime = nowTime; // 更新上次执行时间
}
};
}
// 使用:滚动事件绑定节流函数
window.addEventListener('scroll', throttle(function() {
console.log('滚动加载:', window.scrollY);
}, 1000));
防抖与节流的核心区别
| 维度 | 防抖(Debounce) | 节流(Throttle) |
|---|---|---|
| 执行时机 | 高频触发停止后延迟执行 | 高频触发过程中每隔固定时间执行 |
| 函数调用次数 | 高频触发后可能只执行 1 次 | 高频触发期间按间隔执行多次 |
| 核心目的 | 避免“最后一次”操作前的无效调用 | 避免“过程中”的频繁调用 |
12. 请列举 JavaScript 中数组的常用方法,并说明其作用、参数及返回值。
数组方法按“是否改变原数组”可分为两类,以下是实习面试高频考察的方法:
一、改变原数组的方法(7 个)
| 方法名 | 作用 | 参数 | 返回值 |
|---|---|---|---|
push() | 向数组末尾添加一个/多个元素 | 待添加的元素(可多个) | 新数组的长度 |
pop() | 删除数组末尾的一个元素 | 无 | 被删除的元素(若数组空则返回 undefined) |
unshift() | 向数组开头添加一个/多个元素 | 待添加的元素(可多个) | 新数组的长度 |
shift() | 删除数组开头的一个元素 | 无 | 被删除的元素(若数组空则返回 undefined) |
splice() | 插入、删除或替换数组元素(灵活) | 1. start:起始索引;2. deleteCount:删除元素个数;3. item1...:待插入元素 | 被删除元素组成的数组(若未删除则返回空数组) |
sort() | 对数组元素排序(默认按字符串 Unicode 排序) | 可选:比较函数 (a,b) => a - b(升序)/ b - a(降序) | 排序后的原数组 |
reverse() | 反转数组元素顺序 | 无 | 反转后的原数组 |
示例:
const arr = [1,2,3];
arr.push(4); // 返回 4,arr 变为 [1,2,3,4]
arr.splice(1, 1, 5); // 删除索引 1 的元素,插入 5,返回 [2],arr 变为 [1,5,3,4]
arr.sort((a,b) => a - b); // arr 变为 [1,3,4,5]
二、不改变原数组的方法(8 个)
| 方法名 | 作用 | 参数 | 返回值 |
|---|---|---|---|
concat() | 合并两个/多个数组,返回新数组 | 待合并的数组(可多个) | 合并后的新数组 |
slice() | 截取数组的一部分,返回新数组 | 1. start:起始索引(默认 0);2. end:结束索引(默认数组长度,不包含该索引) | 截取后的新数组 |
join() | 将数组元素拼接为字符串 | 可选:分隔符(默认用逗号 ,) | 拼接后的字符串 |
map() | 遍历数组,对每个元素执行回调,返回新数组 | 回调函数 (item, index, arr) => 新值 | 回调返回值组成的新数组 |
filter() | 遍历数组,筛选符合条件的元素,返回新数组 | 回调函数 (item) => 布尔值(true 保留元素) | 符合条件的元素组成的新数组 |
reduce() | 遍历数组,累积计算为单个值(灵活) | 1. 回调函数 (prev, curr, index) => 累积值;2. initialValue:初始累积值(可选) | 最终累积值 |
find() | 遍历数组,返回第一个符合条件的元素 | 回调函数 (item) => 布尔值 | 第一个符合条件的元素(无则返回 undefined) |
findIndex() | 遍历数组,返回第一个符合条件的元素索引 | 回调函数 (item) => 布尔值 | 第一个符合条件的索引(无则返回 -1) |
示例:
const arr = [1,2,3,4];
const mapRes = arr.map(item => item * 2); // [2,4,6,8](原数组不变)
const filterRes = arr.filter(item => item % 2 === 0); // [2,4]
const reduceRes = arr.reduce((prev, curr) => prev + curr, 0); // 10(求和)
const findRes = arr.find(item => item > 2); // 3
13. 如何实现数组去重?请列举至少 3 种方法,并说明优缺点。
数组去重是面试高频题,以下是 4 种常用方法,按实现简洁度和效率排序:
方法 1:利用 Set 数据结构(最简洁)
- 原理:
Set是 ES6 新增的数据结构,特性是“成员唯一,不重复”;通过[...new Set(arr)]或Array.from(new Set(arr))将Set转为数组。 - 代码实现:
const arr = [1,2,2,3,3,3]; const uniqueArr = [...new Set(arr)]; // [1,2,3] - 优点:代码极简,执行效率高(
Set基于哈希表实现,去重时间复杂度 O(n))。 - 缺点:
- 无法去重“复杂数据类型”(如
[{id:1}, {id:1}],Set会认为是两个不同对象); - 无法保留原数组的重复元素的“最后一次出现”或“第一次出现”的顺序(但 ES6 后
Set已保证插入顺序,实际使用无影响)。
- 无法去重“复杂数据类型”(如
方法 2:利用 indexOf/includes 遍历判断
- 原理:创建新数组,遍历原数组,若新数组中不存在当前元素(用
indexOf === -1或!includes判断),则加入新数组。 - 代码实现(
indexOf版):const arr = [1,2,2,3,3,3]; const uniqueArr = []; for (let i = 0; i < arr.length; i++) { if (uniqueArr.indexOf(arr[i]) === -1) { // 新数组无当前元素 uniqueArr.push(arr[i]); } } // 结果:[1,2,3] - 优点:兼容性好(支持 ES5 及以下环境),可手动控制去重逻辑(如保留最后一次出现的元素)。
- 缺点:
- 执行效率低(
indexOf每次遍历新数组,总时间复杂度 O(n²),大数据量下卡顿); - 同样无法去重复杂数据类型。
- 执行效率低(
方法 3:利用 reduce 累积去重
- 原理:用
reduce遍历原数组,累积器(prev)作为去重后的数组,判断当前元素(curr)是否在累积器中,不在则添加。 - 代码实现:
const arr = [1,2,2,3,3,3]; const uniqueArr = arr.reduce((prev, curr) => { return prev.includes(curr) ? prev : [...prev, curr]; // 或 prev.push(curr) 后返回 prev }, []); // 结果:[1,2,3] - 优点:代码简洁,符合函数式编程风格,可灵活扩展(如添加去重条件)。
- 缺点:效率与
indexOf方法类似(includes内部仍需遍历),时间复杂度 O(n²);无法去重复杂数据类型。
方法 4:利用对象键名唯一性(适合简单数据类型)
- 原理:对象的键名(
key)不可重复,遍历原数组,将元素作为对象键名,值设为true,最后提取对象的键名转为数组。 - 代码实现:
const arr = [1,2,2,3,3,3]; const obj = {}; const uniqueArr = []; for (let i = 0; i < arr.length; i++) { const key = arr[i]; if (!obj[key]) { // 键名不存在 obj[key] = true; uniqueArr.push(key); } } // 结果:[1,2,3] - 优点:执行效率高(对象键名查找是哈希表操作,时间复杂度 O(n))。
- 缺点:
- 会将元素转为字符串(如
1和'1'会被视为同一个键名,导致误去重); - 无法去重复杂数据类型。
- 会将元素转为字符串(如
14. 什么是深浅拷贝?请说明各自的实现方法及优缺点。
深浅拷贝仅针对引用类型(如对象、数组),核心区别是“是否复制引用类型的深层属性”:
- 浅拷贝:仅复制引用类型的“表层属性”(即栈内存中的引用地址),深层属性仍共享原对象的引用(修改深层属性会影响原对象);
- 深拷贝:复制引用类型的“所有层级属性”(包括深层的引用类型),新对象与原对象完全独立(修改任何属性都不影响原对象)。
一、浅拷贝实现方法
1. 数组浅拷贝
slice():const newArr = arr.slice()(无参数时复制整个数组);concat():const newArr = arr.concat()(无参数时复制整个数组);- 扩展运算符:
const newArr = [...arr]; Array.from():const newArr = Array.from(arr)。
2. 对象浅拷贝
Object.assign(target, source):const newObj = Object.assign({}, obj)(将obj拷贝到空对象);- 扩展运算符:
const newObj = { ...obj }; - 手动遍历:
for...in遍历原对象,将属性逐一赋值到新对象。
浅拷贝优点与缺点
- 优点:实现简单,执行效率高(仅复制表层)。
- 缺点:深层引用类型属性仍共享,修改新对象的深层属性会同步修改原对象。
- 示例:
const obj = { name: 'A', info: { age: 20 } }; const newObj = { ...obj }; // 浅拷贝 newObj.info.age = 21; // 修改深层属性 console.log(obj.info.age); // 21(原对象被修改)
二、深拷贝实现方法
1. JSON.parse(JSON.stringify())(简单场景首选)
- 原理:先将原对象转为 JSON 字符串(
JSON.stringify),再将字符串转回对象(JSON.parse),过程中会重新创建所有层级的属性。 - 代码实现:
const obj = { name: 'A', info: { age: 20 } }; const newObj = JSON.parse(JSON.stringify(obj)); newObj.info.age = 21; console.log(obj.info.age); // 20(原对象未被修改) - 优点:代码极简,无需手动实现复杂逻辑。
- 缺点:
- 无法拷贝
undefined、function、Symbol类型的属性(会被忽略); - 无法处理“循环引用”(如
obj.self = obj,会报错); - 无法拷贝对象的原型链属性(仅拷贝自身可枚举属性)。
- 无法拷贝
2. 递归实现深拷贝(通用方案)
- 原理:通过递归遍历对象的所有层级,遇到基本类型直接赋值,遇到引用类型(对象/数组)则创建新实例,再递归拷贝其属性。
- 代码实现(基础版):
function deepClone(target) { // 处理基本类型和 null if (typeof target !== 'object' || target === null) { return target; } // 处理数组和对象 const newObj = Array.isArray(target) ? [] : {}; // 遍历所有属性(包括非枚举属性,可选) for (const key in target) { // 只拷贝自身属性(排除原型链属性) if (target.hasOwnProperty(key)) { newObj[key] = deepClone(target[key]); // 递归拷贝深层属性 } } return newObj; } // 测试:处理循环引用(需额外逻辑,基础版暂不支持) const obj = { name: 'A', info: { age: 20 } }; const newObj = deepClone(obj); newObj.info.age = 21; console.log(obj.info.age); // 20(原对象未被修改) - 优点:
- 可拷贝
undefined、Symbol(需额外处理)、function(需判断并赋值); - 可手动处理循环引用(添加“已拷贝对象映射表”,如
WeakMap); - 灵活可控,可扩展支持更多类型(如
Date、RegExp)。
- 可拷贝
- 缺点:
- 实现逻辑较复杂(需处理多种数据类型和边界情况);
- 递归深度过大时可能导致“栈溢出”(可改用迭代实现优化)。
3. 第三方库(生产环境推荐)
- 如
lodash的_.cloneDeep()方法,已处理所有边界情况(循环引用、特殊类型),稳定性高,生产环境优先使用。 - 代码实现:
import _ from 'lodash'; const obj = { name: 'A', info: { age: 20 } }; const newObj = _.cloneDeep(obj);
15. 什么是函数柯里化(Currying)?它的作用和实现方式是什么?
柯里化概念
柯里化是函数式编程中的一种技术,指将接收多个参数的函数,转化为接收单个参数(第一个参数)的函数,并且返回接收剩余参数的新函数,最终通过链式调用实现原函数的功能。
- 示例:原函数
add(a, b, c) = a + b + c,柯里化后可调用add(1)(2)(3)或add(1,2)(3)得到结果 6。
柯里化的作用
- 参数复用:固定函数的部分参数,后续调用可直接使用固定参数,无需重复传入。
- 示例:实现“固定税率的计算函数”,税率固定为 0.1,后续只需传入金额即可。
function calculateTax(taxRate, amount) { return amount * taxRate; } const calculateTaxWith10Percent = calculateTax(0.1); // 固定税率 0.1 calculateTaxWith10Percent(100); // 10(100 * 0.1) calculateTaxWith10Percent(200); // 20(200 * 0.1)
- 示例:实现“固定税率的计算函数”,税率固定为 0.1,后续只需传入金额即可。
- 延迟执行:将函数的执行拆分为多次调用,直到传入所有参数后才执行最终逻辑。
- 示例:
add(1)(2)不会立即返回结果,需再传入(3)才返回 6。
- 示例:
- 函数组合:为后续函数组合(如
compose/pipe)提供基础,实现更复杂的函数逻辑。
柯里化的实现方式(递归版)
核心思路:通过闭包保存已传入的参数,若参数数量未达到原函数的参数个数,则返回新函数继续接收参数;若达到,则执行原函数并返回结果。
// 柯里化工具函数
function curry(fn) {
// fn.length 是原函数的形参个数
return function curried(...args) {
// 情况 1:已传入的参数个数 >= 原函数参数个数,执行原函数
if (args.length >= fn.length) {
return fn.apply(this, args); // 绑定 this 和参数
}
// 情况 2:未达到参数个数,返回新函数继续接收参数
return function(...nextArgs) {
// 递归调用 curried,合并已传入的 args 和新传入的 nextArgs
return curried.apply(this, [...args, ...nextArgs]);
};
};
}
// 测试:原函数 add(a, b, c)
function add(a, b, c) {
return a + b + c;
}
// 柯里化 add 函数
const curriedAdd = curry(add);
// 调用方式(支持多种传参形式)
console.log(curriedAdd(1)(2)(3)); // 6(每次传 1 个参数)
console.log(curriedAdd(1, 2)(3)); // 6(先传 2 个,再传 1 个)
console.log(curriedAdd(1, 2, 3)); // 6(一次性传完 3 个参数)
16. 箭头函数与普通函数有哪些区别?
箭头函数是 ES6 对普通函数的语法简化,但两者在 this 指向、作用域等核心特性上有本质区别:
| 区别维度 | 箭头函数(Arrow Function) | 普通函数(Normal Function) |
|---|---|---|
this 指向 | 无独立 this,继承外层作用域的 this(定义时确定,永不改变) | this 指向在调用时确定(如全局、对象、new 实例等,见问题 3) |
arguments 对象 | 无 arguments 对象(无法通过 arguments 获取参数列表) | 有 arguments 对象(类数组,存储实际传入的参数) |
| 构造函数能力 | 不能作为构造函数(无法用 new 关键字调用,会报错) | 可以作为构造函数(用 new 调用时,this 指向新实例) |
prototype 属性 | 无 prototype 属性(原型链中无该属性) | 有 prototype 属性(原型对象,用于继承) |
| 语法简洁性 | 语法简洁: - 单参数可省略括号( a => a+1);- 单语句可省略大括号和 return((a,b) => a+b) | 语法繁琐:必须有括号和大括号(除非函数体只有一句 return,可简写为 function(a){return a+1}) |
| yield 关键字 | 不能作为生成器函数(无法使用 yield 关键字) | 可以作为生成器函数(用 function* 声明,支持 yield) |
示例验证关键区别
1. this 指向区别
const obj = {
name: 'A',
// 普通函数:this 指向 obj(调用时确定)
normalFn: function() { console.log(this.name); },
// 箭头函数:this 继承外层全局作用域的 this(window)
arrowFn: () => { console.log(this.name); }
};
obj.normalFn(); // "A"(this 指向 obj)
obj.arrowFn(); // undefined(this 指向 window,window 无 name 属性)
2. arguments 对象区别
// 普通函数:有 arguments 对象
function normalFn() { console.log(arguments); }
normalFn(1,2,3); // Arguments(3) [1,2,3, callee: ƒ, Symbol(Symbol.iterator): ƒ]
// 箭头函数:无 arguments 对象,报错
const arrowFn = () => { console.log(arguments); };
arrowFn(1,2,3); // ReferenceError: arguments is not defined
// 替代方案:用剩余参数 ...args
const arrowFnWithArgs = (...args) => { console.log(args); };
arrowFnWithArgs(1,2,3); // [1,2,3]
3. 构造函数能力区别
// 普通函数:可作为构造函数
function Person(name) { this.name = name; }
const p = new Person('A'); // 正常创建实例
// 箭头函数:不能作为构造函数,报错
const PersonArrow = (name) => { this.name = name; };
const p2 = new PersonArrow('B'); // TypeError: PersonArrow is not a constructor
17. null 和 undefined 的区别是什么?它们的使用场景有哪些?
null 和 undefined 都是 JavaScript 中的“空值”,但语义和使用场景完全不同:
一、核心区别
| 区别维度 | undefined | null |
|---|---|---|
| 语义含义 | 表示“未定义”:变量已声明但未赋值,或属性不存在 | 表示“空值”:变量已赋值,但值为“空”(主动设置的空对象指针) |
类型检测(typeof) | typeof undefined → 'undefined'(准确) | typeof null → 'object'(历史 bug,不准确) |
| 默认赋值 | 变量声明未赋值时,默认值为 undefined | 需手动赋值为 null(不会默认出现) |
与 == 的关系 | undefined == null → true(隐式类型转换后相等) | undefined === null → false(严格相等不成立) |
二、使用场景
1. undefined 的使用场景
- 变量声明未赋值:
let a; console.log(a); // undefined - 函数参数未传入:
function fn(param) { console.log(param); } fn(); // undefined(未传参,param 为 undefined) - 对象属性不存在:
const obj = { name: 'A' }; console.log(obj.age); // undefined(obj 无 age 属性) - 函数无返回值:
function fn() { /* 无 return */ } console.log(fn()); // undefined(默认返回 undefined)
2. null 的使用场景
- 主动设置变量为空:表示变量“有值,但值是空的”,通常用于后续赋值为对象。
let user = null; // 先设为空,后续可能赋值为用户对象 user = { name: 'A' }; // 后续赋值 - 函数返回空对象:当函数需要返回对象,但当前无数据时,返回
null(而非undefined,语义更清晰)。function getUser() { // 无用户数据时,主动返回 null if (!hasData) return null; return { name: 'A' }; } - 清空对象引用:避免内存泄漏,当不再使用某个对象时,将其引用设为
null,方便垃圾回收。let obj = { name: 'A' }; obj = null; // 清空引用,原对象可被垃圾回收
三、开发中的最佳实践
- 不要手动给变量赋值
undefined(如let a = undefined),因为变量未赋值时默认就是undefined,手动赋值会冗余; - 当需要表示“空对象”或“主动清空值”时,用
null(语义更明确); - 判断变量是否为
null或undefined时,推荐用严格相等(===),避免隐式转换的坑(如if (a === undefined)或if (a === null)); - 若需同时判断“是
null或undefined”,可简写为if (a == null)(利用undefined == null → true的特性,且无其他值会满足该条件)。
18. == 和 === 的区别是什么?请列举常见的 == 隐式类型转换规则。
==(抽象相等)和 ===(严格相等)是 JavaScript 中用于比较值是否相等的两个运算符,核心区别是“是否进行隐式类型转换”。
一、核心区别
| 区别维度 | ==(抽象相等运算符) | ===(严格相等运算符) |
|---|---|---|
| 类型转换 | 若比较的两个值类型不同,会先进行隐式类型转换,再比较值 | 不进行类型转换,直接比较类型和值:类型不同则直接返回 false |
| 比较逻辑 | 先转类型,再比 value | 先比类型(类型不同则 false),再比 value |
| 推荐场景 | 仅在明确需要隐式转换的场景使用(如 null == undefined) | 绝大多数场景(尤其是业务代码),避免隐式转换的意外 bug |
二、== 的隐式类型转换规则
== 的转换规则复杂,需分场景记忆,以下是面试高频考察的场景:
1. 场景 1:一方是 undefined 或 null
- 规则:
undefined == null → true;undefined/null与其他任何类型比较都返回false。 - 示例:
undefined == null; // true undefined == 0; // false null == ''; // false
2. 场景 2:一方是 String,一方是 Number
- 规则:将
String转为Number,再比较数值。 - 转换逻辑:
Number(字符串)(如Number('123') → 123,Number('abc') → NaN,Number('') → 0)。 - 示例:
'123' == 123; // true('123' → 123) '' == 0; // true('' → 0) 'abc' == 1; // false('abc' → NaN,NaN 与任何值不相等)
3. 场景 3:一方是 Boolean,一方是其他类型(String/Number)
- 规则:将
Boolean转为Number(true → 1,false → 0),再按其他场景规则比较。 - 示例:
true == 1; // true(true → 1,1 == 1) false == 0; // true(false → 0,0 == 0) true == '1'; // true(true → 1,'1' → 1,1 == 1) false == ''; // true(false → 0,'' → 0,0 == 0)
4. 场景 4:一方是 Object,一方是基本类型(String/Number/Boolean)
- 规则:先将
Object转为基本类型(通过ToPrimitive抽象操作,优先调用valueOf(),再调用toString()),再按其他场景规则比较。 - 示例:
// 数组转基本类型:[1] → valueOf() 是 [1](对象),再调用 toString() → '1' [1] == 1; // true([1] → '1' → 1,1 == 1) // 空数组转基本类型:[] → toString() → '' [] == 0; // true([] → '' → 0,0 == 0) [] == false; // true([] → '' → 0,false → 0,0 == 0) // 对象转基本类型:{a:1} → toString() → '[object Object]' {a:1} == '[object Object]'; // true({a:1} → '[object Object]')
5. 特殊场景:NaN 参与比较
- 规则:
NaN与任何值(包括自身)比较,==和===都返回false。 - 示例:
NaN == NaN; // false NaN === NaN; // false // 判断是否为 NaN,需用 isNaN() 或 Number.isNaN() isNaN(NaN); // true
三、开发中的最佳实践
- 优先使用
===:避免隐式类型转换带来的意外 bug(如'' == 0 → true、[1] == 1 → true,业务中通常不希望这种“相等”); - 仅在明确场景用
==:如判断“值为null或undefined”,可简写为if (a == null)(等同于if (a === null || a === undefined)),代码更简洁; - 若需比较不同类型的值,手动进行显式类型转换(如
Number(str) === num),而非依赖==的隐式转换,可读性更高。
19. 函数的 call、apply、bind 方法有什么区别?它们的作用和使用场景是什么?
call、apply、bind 是函数原型上的三个方法,核心作用都是改变函数执行时的 this 指向,但在参数传递和执行时机上有区别。
一、核心区别(表格对比)
| 方法名 | 参数传递方式 | 函数执行时机 | 返回值 | 适用场景 |
|---|---|---|---|---|
call | 第一个参数是 this 指向,后续参数逐个传入(用逗号分隔) | 立即执行函数 | 函数执行后的返回值 | 已知参数个数,需立即执行函数 |
apply | 第一个参数是 this 指向,第二个参数是数组/类数组(包含所有参数) | 立即执行函数 | 函数执行后的返回值 | 参数个数不确定(如从数组中取参数),需立即执行函数 |
bind | 第一个参数是 this 指向,后续参数逐个传入(可分多次传) | 不立即执行,返回一个绑定了 this 的新函数 | 绑定后的新函数 | 需延迟执行函数(如事件回调、定时器),或固定部分参数 |
二、详细说明与示例
1. call 方法
- 语法:
function.call(thisArg, arg1, arg2, ...) - 作用:改变
function的this为thisArg,并立即执行function,传入arg1, arg2...作为参数。 - 示例:用
call实现数组最大值(Math.max不支持数组,需逐个传参)。const arr = [1, 3, 2]; // Math.max 正常调用:Math.max(1,3,2) → 3 // 用 call 改变 this 为 null(Math.max 不依赖 this),并逐个传入数组元素 const max = Math.max.call(null, ...arr); // 等同于 Math.max.call(null, 1,3,2) console.log(max); // 3
2. apply 方法
- 语法:
function.apply(thisArg, [argsArray]) - 作用:与
call类似,区别是参数通过数组传递(argsArray是数组或类数组)。 - 示例:同上,用
apply实现数组最大值(更简洁,无需展开数组)。const arr = [1, 3, 2]; // 用 apply 直接传入数组,内部会自动解析为逐个参数 const max = Math.max.apply(null, arr); console.log(max); // 3
3. bind 方法
- 语法:
function.bind(thisArg, arg1, arg2, ...) - 作用:改变
function的this为thisArg,但不立即执行,返回一个绑定了this的新函数;后续调用新函数时,可补充传入剩余参数。 - 示例 1:延迟执行(事件回调):避免事件回调中
this指向DOM元素,手动绑定this为组件实例。class Button { constructor() { this.text = '点击我'; this.btn = document.querySelector('button'); // 用 bind 绑定 this 为 Button 实例,返回新函数作为回调 this.btn.addEventListener('click', this.handleClick.bind(this)); } handleClick() { console.log(this.text); // "点击我"(this 指向 Button 实例,而非 btn 元素) } } new Button(); - 示例 2:固定部分参数(参数复用):固定函数的部分参数,后续调用只需传剩余参数。
function add(a, b, c) { return a + b + c; } // 用 bind 固定 a=1,返回新函数(接收 b 和 c) const add1 = add.bind(null, 1); add1(2, 3); // 6(1+2+3) add1(4, 5); // 10(1+4+5)
三、注意点
thisArg为null或undefined时,非严格模式下this会指向window,严格模式下指向undefined;apply的第二个参数必须是数组或类数组(如arguments),否则会报错;bind返回的新函数不能再次通过bind改变this指向(this已被固定)。
20. 请说明 ES Module(ESM)和 CommonJS 模块的区别。
ES Module(ESM,ES6 模块)和 CommonJS 是 JavaScript 中两种主流的模块化规范,分别用于浏览器和 Node.js 环境(目前 Node.js 也支持 ESM),核心区别体现在加载机制、语法等方面。
核心区别(表格对比)
| 区别维度 | ES Module(ESM) | CommonJS |
|---|---|---|
| 推出时间与环境 | ES2015 推出,原生支持浏览器;Node.js 14+ 支持 | Node.js 早期推出,默认用于 Node.js;浏览器需通过 Webpack 等工具打包 |
| 语法格式 | 导出:export(命名导出)、export default(默认导出);导入:import | 导出:module.exports、exports;导入:require() |
26. 什么是变量提升?JS 中变量提升有哪些特点?
- 概念:变量提升是 JS 引擎在代码执行前的“预编译”阶段,将使用
var声明的变量和函数声明提升到当前作用域顶部的行为(仅提升声明,不提升赋值/函数体)。 - 变量提升(
var):- 仅提升“变量声明”,变量的赋值语句仍留在原位置。
- 提升后变量默认值为
undefined。
- 函数提升:
- 函数声明(
function 函数名() {})会整体提升(包括函数名和函数体),可在声明前调用函数。 - 函数表达式(
var 函数名 = function() {})仅提升变量名(按var变量提升规则),声明前调用会报错(变量值为undefined,无法作为函数执行)。
- 函数声明(
- 示例:
console.log(a); // undefined(var 变量提升,未赋值) var a = 10; fn1(); // 输出 "fn1 执行"(函数声明整体提升) function fn1() { console.log("fn1 执行"); } fn2(); // 报错 "fn2 is not a function"(函数表达式仅提升变量名,值为 undefined) var fn2 = function() { console.log("fn2 执行"); }
27. let、const 与 var 的区别是什么?
从 变量提升、作用域、重复声明、值修改 四个核心维度对比:
- 变量提升:
var:存在变量提升,提升后默认值为undefined。let/const:存在“暂时性死区(TDZ)”,虽有预编译记录,但未到声明行前无法访问(避免了变量提升的不合理使用)。
- 作用域:
var:仅支持全局作用域和函数作用域,无块级作用域(if/for块内声明的变量会泄露到外部)。let/const:支持块级作用域(if/for/{}块内声明的变量仅在块内有效)。
- 重复声明:
var:允许在同一作用域内重复声明同一变量(后声明会覆盖前声明)。let/const:不允许在同一作用域内重复声明(包括与var声明的变量重名),否则报错。
- 值修改:
var/let:声明的变量值可修改。const:声明的是“常量”,必须初始化赋值,且基本类型值不可修改;若为引用类型(如对象/数组),仅保证引用地址不变,内部属性可修改。
28. 请解释 JS 中的原型(Prototype)和原型链(Prototype Chain)
- 原型(Prototype):
- 每个 JS 对象(除
null)都有一个内置属性__proto__(隐式原型),指向其“原型对象”;每个函数都有prototype属性(显式原型),其值就是该函数创建的实例的原型对象。 - 原型对象的核心作用是 实现继承:实例可共享原型对象上的属性和方法(避免重复定义,节省内存)。
- 原型对象中包含
constructor属性,指向创建该原型对象的构造函数。
- 每个 JS 对象(除
- 原型链(Prototype Chain):
- 当访问一个对象的属性/方法时,JS 会先在对象自身查找;若找不到,会通过
__proto__向上查找其原型对象;若仍找不到,继续向上查找原型对象的原型,直到找到Object.prototype(原型链的顶端);若最终仍找不到,返回undefined。 - 示例:
function Person(name) { this.name = name; } Person.prototype.sayHi = function() { console.log(`Hi, ${this.name}`); } const p = new Person("Tom"); p.sayHi(); // 输出 "Hi, Tom"(p 自身无 sayHi,通过 __proto__ 找到 Person.prototype 上的 sayHi) console.log(p.toString()); // 输出 "[object Object]"(p 及 Person.prototype 无 toString,通过原型链找到 Object.prototype 上的 toString)
- 当访问一个对象的属性/方法时,JS 会先在对象自身查找;若找不到,会通过
29. JS 中 this 的指向有哪些场景?如何确定 this 指向?
this 指向“当前执行上下文的所有者”,具体场景分 5 类:
- 全局作用域中的
this:- 浏览器环境:指向
window对象。 - Node.js 环境:指向
global对象。 - 示例:
console.log(this === window); // 浏览器中输出 true。
- 浏览器环境:指向
- 普通函数调用(无绑定):
this指向全局对象(浏览器window,Node.jsglobal);若在严格模式('use strict')下,this指向undefined。- 示例:
function fn() { console.log(this); } fn(); // 浏览器中输出 window(非严格模式)
- 对象方法调用:
this指向调用该方法的“对象”(即方法前的.左侧对象)。- 示例:
const obj = { name: "Tom", sayName: function() { console.log(this.name); } }; obj.sayName(); // 输出 "Tom"(this 指向 obj)
call/apply/bind绑定:- 三者均用于手动修改
this指向,区别在于参数传递和执行时机:call(obj, arg1, arg2, ...):立即执行函数,参数逐个传递。apply(obj, [arg1, arg2, ...]):立即执行函数,参数以数组传递。bind(obj, arg1, arg2, ...):返回新函数(不立即执行),this绑定为obj。
- 示例:
function fn(age) { console.log(`${this.name}, ${age}`); } const obj = { name: "Tom" }; fn.call(obj, 20); // 输出 "Tom, 20"
- 三者均用于手动修改
- 箭头函数中的
this:- 箭头函数 没有自己的
this,其this继承自“外层作用域的this”(定义时确定,而非执行时)。 - 示例:
const obj = { name: "Tom", fn: () => { console.log(this.name); } // this 继承外层(全局)的 this,而非 obj }; obj.fn(); // 浏览器中输出 undefined(全局 this 无 name 属性)
- 箭头函数 没有自己的
30. 什么是闭包?闭包的原理、用途及注意事项是什么?
- 概念:闭包是指“有权访问另一个函数作用域中变量的函数”,通常通过“函数嵌套 + 外部函数返回内部函数”实现。
- 原理:
- JS 函数执行时会创建“执行上下文”,执行完后若该函数的作用域仍被外部引用(如内部函数被返回并保存),则作用域不会被垃圾回收,内部函数可继续访问外部函数的变量。
- 核心用途:
- 实现 模块化:封装私有变量,仅暴露指定方法(避免全局变量污染)。
- 保存 函数作用域状态:如循环中保存每个迭代的变量值(避免因变量提升导致的问题)。
- 示例(模块化):
function createCounter() { let count = 0; // 私有变量,外部无法直接访问 return { increment: () => count++, // 暴露方法,可访问 count getCount: () => count }; } const counter = createCounter(); counter.increment(); console.log(counter.getCount()); // 输出 1
- 注意事项:
- 闭包会导致外部函数作用域无法被垃圾回收,若过度使用可能造成 内存泄漏(如闭包引用 DOM 元素且未及时释放)。
- 解决内存泄漏:不再使用闭包时,手动将闭包引用设为
null(如counter = null)。
31. JS 中的异步编程模式有哪些?分别有什么特点?
JS 是单线程语言,异步编程用于避免阻塞主线程,核心模式有 3 种:
- 回调函数(Callback):
- 特点:将异步操作的“后续逻辑”作为函数参数传入,异步完成后执行该函数。
- 优点:实现简单,早期常用(如
setTimeout、AJAX 回调)。 - 缺点:多层异步嵌套时会形成“回调地狱”(代码可读性差、难以维护)。
- 示例:
setTimeout(() => { console.log("第一步"); setTimeout(() => { console.log("第二步"); // 回调地狱,嵌套层级深 }, 1000); }, 1000);
- Promise:
- 特点:用“状态”管理异步操作(
pending等待、fulfilled成功、rejected失败),状态一旦改变不可逆;通过then/catch链式调用解决回调地狱。 - 优点:链式调用清晰,支持多个异步操作并行/串行;可捕获错误。
- 缺点:仍需通过
then链式调用,代码仍有一定冗余。 - 示例:
function delay() { return new Promise((resolve) => setTimeout(resolve, 1000)); } delay().then(() => { console.log("第一步"); return delay(); }).then(() => { console.log("第二步"); // 链式调用,无嵌套 });
- 特点:用“状态”管理异步操作(
async/await:- 特点:ES7 语法,基于 Promise 封装,用“同步代码的写法”实现异步逻辑;
async函数返回 Promise,await用于等待 Promise 完成。 - 优点:代码最简洁,可读性最高,错误处理可通过
try/catch实现(与同步代码一致)。 - 缺点:
await只能在async函数内使用;多个独立异步操作若用await串行,会浪费时间(需用Promise.all并行)。 - 示例:
async function fn() { await delay(); // 等待 1 秒 console.log("第一步"); await delay(); // 再等 1 秒 console.log("第二步"); } fn();
- 特点:ES7 语法,基于 Promise 封装,用“同步代码的写法”实现异步逻辑;
32. Promise 有哪些常用方法?分别有什么作用?
Promise 原型方法和静态方法核心有 6 种:
Promise.prototype.then(onFulfilled, onRejected):- 作用:指定 Promise 成功(
fulfilled)和失败(rejected)后的回调函数。 - 特点:返回新的 Promise,支持链式调用;若回调函数返回非 Promise 值,新 Promise 会 resolve 该值;若返回 Promise,新 Promise 会跟随其状态。
- 作用:指定 Promise 成功(
Promise.prototype.catch(onRejected):- 作用:专门捕获 Promise 的失败状态(等价于
then(null, onRejected))。 - 特点:可捕获链式调用中任意环节的错误(包括
then回调中的错误),建议放在链式调用末尾。
- 作用:专门捕获 Promise 的失败状态(等价于
Promise.prototype.finally(onFinally):- 作用:指定 Promise 无论成功或失败,最终都会执行的回调函数(如关闭加载动画)。
- 特点:回调函数无参数(不依赖 Promise 状态),返回的 Promise 状态与原 Promise 一致。
Promise.all(iterable):- 作用:接收一个可迭代对象(如数组),并行执行所有 Promise。
- 特点:
- 所有 Promise 都成功(
fulfilled):返回新 Promise,resolve 结果为“所有 Promise 结果组成的数组”(顺序与输入一致)。 - 只要有一个 Promise 失败(
rejected):立即返回新 Promise,reject 该失败原因(忽略其他未完成的 Promise)。
- 所有 Promise 都成功(
Promise.race(iterable):- 作用:并行执行所有 Promise,以第一个完成的 Promise 状态为准。
- 特点:无论第一个完成的是成功还是失败,新 Promise 都会跟随其状态(如设置请求超时:
Promise.race([ajaxRequest, timeoutPromise]))。
Promise.allSettled(iterable):- 作用:并行执行所有 Promise,等待所有 Promise 都完成(无论成功或失败)。
- 特点:返回的 Promise 始终 resolve,结果为“所有 Promise 状态对象组成的数组”,每个对象包含
status(fulfilled/rejected)和value(成功结果)或reason(失败原因)。
33. 如何使用 async/await?如何处理 async/await 中的错误?
- 基本使用步骤:
- 用
async关键字声明函数:async function 函数名() {},该函数返回值会自动包装为 Promise(若返回非 Promise 值,会 resolve 该值;若抛出错误,会 reject 该错误)。 - 用
await关键字等待 Promise 完成:await后必须跟 Promise 对象,执行时会“暂停”函数,直到 Promise 状态改变(成功则返回结果,失败则抛出错误)。 - 示例:
// 模拟异步请求 function fetchData() { return new Promise((resolve) => setTimeout(() => resolve("请求成功的数据"), 1000)); } // async 函数中使用 await async function getData() { console.log("开始请求"); const data = await fetchData(); // 等待 Promise 完成,获取结果 console.log("数据:", data); // 输出 "数据:请求成功的数据" return data; } getData();
- 用
- 错误处理方式:
await后的 Promise 若 reject,会抛出错误,需用try/catch捕获(与同步代码错误处理一致)。- 单个异步操作错误处理:
async function getData() { try { const data = await fetchData(); // 若 fetchData reject,会进入 catch console.log(data); } catch (error) { console.error("错误:", error); // 捕获并处理错误 } } - 多个异步操作错误处理(独立错误不影响其他):
async function getMultiData() { // 用 Promise.all 并行执行,整体捕获错误 try { const [data1, data2] = await Promise.all([fetchData1(), fetchData2()]); console.log(data1, data2); } catch (error) { console.error("某个请求错误:", error); } }
34. JS 数组有哪些常用方法?请分类说明(改变原数组/不改变原数组)
按“是否改变原数组”分为两类:
一、改变原数组的方法(7 种)
push(...items):在数组末尾添加元素,返回新长度。- 示例:
const arr = [1,2]; arr.push(3); // arr 变为 [1,2,3]。
- 示例:
pop():删除数组末尾元素,返回被删除的元素。- 示例:
arr.pop(); // arr 变为 [1,2],返回 3。
- 示例:
shift():删除数组第一个元素,返回被删除的元素。- 示例:
arr.shift(); // arr 变为 [2],返回 1。
- 示例:
unshift(...items):在数组开头添加元素,返回新长度。- 示例:
arr.unshift(0); // arr 变为 [0,2],返回 2。
- 示例:
sort((a,b) => a - b):对数组排序,默认按字符串 Unicode 排序(需传比较函数实现数字排序)。- 示例:
[3,1,2].sort((a,b) => a - b); // 变为 [1,2,3]。
- 示例:
reverse():反转数组元素顺序,返回原数组。- 示例:
[1,2,3].reverse(); // 变为 [3,2,1]。
- 示例:
splice(start, deleteCount, ...items):从start位置删除deleteCount个元素,插入新元素,返回被删除的元素数组。- 示例:
[1,2,3,4].splice(1,2,5); // arr 变为 [1,5,4],返回 [2,3]。
- 示例:
二、不改变原数组的方法(8 种)
map((item, index, arr) => {}):遍历数组,对每个元素执行回调,返回“新数组”(长度与原数组一致)。- 示例:
[1,2,3].map(item => item * 2); // 返回 [2,4,6]。
- 示例:
filter((item) => {}):遍历数组,筛选出“满足回调条件”的元素,返回新数组。- 示例:
[1,2,3,4].filter(item => item % 2 === 0); // 返回 [2,4]。
- 示例:
reduce((acc, item) => {}, initialValue):累加器,遍历数组将元素“累积”为一个值(如求和、求最大值、数组转对象)。- 示例:
[1,2,3].reduce((acc, item) => acc + item, 0); // 返回 6。
- 示例:
forEach((item) => {}):遍历数组,执行回调(无返回值,仅用于循环)。- 示例:
[1,2,3].forEach(item => console.log(item)); // 输出 1、2、3。
- 示例:
slice(start, end):从start位置截取到end位置(不包含end),返回新数组(start/end可传负数,代表从末尾开始)。- 示例:
[1,2,3,4].slice(1,3); // 返回 [2,3]。
- 示例:
concat(...arrays):合并多个数组,返回新数组(也可传非数组值)。- 示例:
[1,2].concat([3,4], 5); // 返回 [1,2,3,4,5]。
- 示例:
join(separator):将数组元素按separator拼接为字符串,默认用逗号拼接。- 示例:
[1,2,3].join("-"); // 返回 "1-2-3"。
- 示例:
includes(item, fromIndex):判断数组是否包含item,返回布尔值(fromIndex为起始查找位置)。- 示例:
[1,2,3].includes(2); // 返回 true。
- 示例:
35. JS 的基本数据类型和引用数据类型有哪些?两者的区别是什么?
- 数据类型分类:
- 基本数据类型(7 种):
null、undefined、boolean、number、string、symbol(ES6,唯一且不可变)、bigint(ES6,处理大整数)。 - 引用数据类型(1 类):
object,包括数组(Array)、函数(Function)、对象(Object)、日期(Date)等。
- 基本数据类型(7 种):
- 核心区别(3 点):
- 存储位置:
- 基本类型:存储在 栈内存 中,直接存储“值”。
- 引用类型:存储在 堆内存 中,栈内存仅存储“堆内存的引用地址”(即指针)。
- 赋值方式:
- 基本类型:赋值时复制“值”(新变量与原变量独立,修改新变量不影响原变量)。
- 引用类型:赋值时复制“引用地址”(新变量与原变量指向同一堆内存,修改新变量会影响原变量)。
- 判断方式:
- 基本类型:用
typeof判断(除null外,typeof null为object,需单独判断null === null)。 - 引用类型:用
instanceof判断(判断原型链关系),或Object.prototype.toString.call()精准判断。
- 基本类型:用
- 存储位置:
- 示例:
// 基本类型赋值 let a = 10; let b = a; b = 20; console.log(a); // 10(a 不受 b 修改影响) // 引用类型赋值 let obj1 = { name: "Tom" }; let obj2 = obj1; obj2.name = "Jerry"; console.log(obj1.name); // Jerry(obj1 与 obj2 指向同一对象,修改 obj2 影响 obj1)
36. typeof 和 instanceof 的区别是什么?
两者均用于判断数据类型,但适用场景和原理完全不同:
-
typeof:- 原理:检测变量的“类型标签”(JS 引擎为数据类型设置的内部标识)。
- 适用场景:判断 基本数据类型(除
null)和函数。 - 返回值:字符串,包括
'undefined'、'boolean'、'number'、'string'、'symbol'、'bigint'、'function'、'object'。 - 局限性:
- 无法区分
null和object(typeof null === 'object',历史遗留问题)。 - 无法区分具体的引用类型(如
array、date,typeof [] === 'object')。
- 无法区分
- 示例:
typeof 123; // 'number' typeof "abc"; // 'string' typeof []; // 'object'(无法判断是数组) typeof null; // 'object'(错误判断)
-
instanceof:- 原理:判断“左侧对象的原型链上是否存在右侧构造函数的
prototype属性”(即left.__proto__.__proto__... === right.prototype)。 - 适用场景:判断 引用数据类型(如数组、对象、函数)是否为某构造函数的实例。
- 返回值:布尔值(
true/false)。 - 局限性:
- 无法判断基本数据类型(基本类型不是任何构造函数的实例,除非用
new创建包装对象,如new Number(123))。 - 原型链可被修改,可能导致判断结果不准确。
- 无法判断基本数据类型(基本类型不是任何构造函数的实例,除非用
- 示例:
[] instanceof Array; // true(数组的原型链包含 Array.prototype) {} instanceof Object; // true(对象的原型链包含 Object.prototype) 123 instanceof Number; // false(基本类型不是实例) new Number(123) instanceof Number; // true(包装对象是实例)
- 原理:判断“左侧对象的原型链上是否存在右侧构造函数的
37. 什么是事件冒泡和事件捕获?如何阻止?
-
事件流:JS 中事件触发时会经历“捕获 → 目标 → 冒泡”三个阶段,合称事件流。
-
事件捕获(Event Capturing):
- 概念:事件从“顶层元素”(如
document)向下传播到“目标元素”的阶段(从外到内)。 - 触发时机:先于事件冒泡执行。
- 绑定方式:
addEventListener第三个参数设为true或{ capture: true }。 - 示例:
// 父元素捕获阶段绑定事件 parent.addEventListener("click", () => console.log("父元素捕获"), true); // 子元素绑定事件 child.addEventListener("click", () => console.log("子元素目标")); // 点击子元素,先输出 "父元素捕获",再输出 "子元素目标"
- 概念:事件从“顶层元素”(如
-
事件冒泡(Event Bubbling):
- 概念:事件从“目标元素”向上传播到“顶层元素”的阶段(从内到外)。
- 触发时机:在事件捕获和目标阶段之后执行。
- 绑定方式:
addEventListener第三个参数默认false或{ capture: false }(默认冒泡阶段触发)。 - 示例:
// 父元素冒泡阶段绑定事件 parent.addEventListener("click", () => console.log("父元素冒泡")); // 子元素绑定事件 child.addEventListener("click", () => console.log("子元素目标")); // 点击子元素,先输出 "子元素目标",再输出 "父元素冒泡"
-
阻止方式:
- 阻止事件冒泡:用
event.stopPropagation()(阻止事件向上传播,但不影响当前元素的其他事件)。child.addEventListener("click", (e) => { console.log("子元素"); e.stopPropagation(); // 阻止冒泡,父元素冒泡事件不会触发 }); - 阻止事件捕获:同阻止冒泡(
event.stopPropagation()可阻止捕获阶段的传播)。 - 阻止默认行为:用
event.preventDefault()(如阻止表单提交、链接跳转),不影响事件流(冒泡/捕获仍会执行)。
- 阻止事件冒泡:用
38. 什么是事件委托(事件代理)?原理和优势是什么?
- 概念:事件委托是利用“事件冒泡”机制,将“子元素的事件”统一绑定到“父元素”上,通过
event.target判断触发事件的子元素,从而执行对应逻辑。 - 核心原理:
- 子元素触发事件后,事件会冒泡到父元素;
- 父元素事件回调中,通过
event.target获取“实际触发事件的子元素”; - 判断
event.target是否为目标子元素,若符合则执行逻辑。
- 示例(点击列表项触发事件):
<ul id="list"> <li>项目1</li> <li>项目2</li> <li>项目3</li> </ul>const list = document.getElementById("list"); // 父元素 ul 绑定事件,委托子元素 li 的点击事件 list.addEventListener("click", (e) => { // 判断触发事件的是否是 li 元素 if (e.target.tagName === "LI") { console.log("点击了:", e.target.textContent); // 输出点击的 li 内容 } }); - 核心优势:
- 减少事件绑定数量:无需给每个子元素绑定事件,仅绑定父元素(尤其子元素数量多时,优化性能)。
- 支持动态子元素:新增的子元素(如通过 JS 动态添加的
li)无需重新绑定事件,父元素事件可自动生效。 - 简化代码维护:事件逻辑集中在父元素,无需分别维护每个子元素的事件。
39. JS 的垃圾回收机制是什么?常用的垃圾回收算法有哪些?
- 概念:JS 引擎自动管理内存,“垃圾回收机制(GC)”会定期找出“不再使用的内存”(即无引用的对象),并释放其占用的内存(避免内存泄漏)。
- 常用垃圾回收算法(2 种):
-
1. 标记清除(Mark-and-Sweep):
- 目前主流浏览器(Chrome、Firefox)采用的算法,分两步:
- 标记阶段:JS 引擎从“根对象”(如
window/global)出发,遍历所有可访问的对象,标记为“活跃对象”;未被标记的对象即为“垃圾对象”。 - 清除阶段:释放所有“垃圾对象”占用的内存,并将内存空间加入“空闲列表”,供后续使用。
- 标记阶段:JS 引擎从“根对象”(如
- 优点:解决了“引用计数”算法的循环引用问题。
- 缺点:清除后内存可能出现“碎片”(小块不连续的内存),但现代引擎会通过“内存整理”优化。
- 目前主流浏览器(Chrome、Firefox)采用的算法,分两步:
-
2. 引用计数(Reference Counting):
- 早期算法,原理是“统计对象被引用的次数”:
- 每个对象创建时,引用计数初始化为 1;
- 若对象被新变量引用,计数 +1;
- 若引用变量被赋值为其他值(或销毁),计数 -1;
- 当计数为 0 时,对象被判定为垃圾,释放内存。
- 优点:实现简单,回收及时。
- 缺点:无法解决“循环引用”问题(如 A 引用 B,B 引用 A,两者无其他引用,计数仍为 1,无法回收,导致内存泄漏)。
- 示例(循环引用):
function fn() { const a = {}; const b = {}; a.b = b; // a 引用 b,b 计数 +1 b.a = a; // b 引用 a,a 计数 +1 } fn(); // 函数执行完后,a 和 b 无外部引用,但循环引用导致计数不为 0,引用计数算法无法回收
- 早期算法,原理是“统计对象被引用的次数”:
-
- 开发者优化建议:
- 不再使用的对象,手动将其引用设为
null(如obj = null),帮助 GC 识别垃圾。 - 避免全局变量滥用(全局变量的引用一直存在,不会被 GC 回收)。
- 及时清除事件绑定、定时器(如
clearTimeout),避免闭包导致的内存泄漏。
- 不再使用的对象,手动将其引用设为
40. ES6 中的箭头函数与普通函数有哪些区别?
核心区别体现在 this 指向、构造函数、参数对象、原型、语法 5 个方面:
-
this指向不同:- 普通函数:
this指向“执行时的上下文所有者”(如全局调用指向window,对象方法调用指向对象)。 - 箭头函数:没有自己的
this,this继承自“定义时的外层作用域this”(一旦定义,this无法修改,call/apply/bind也无法改变)。 - 示例:
const obj = { name: "Tom", // 普通函数:this 指向 obj normalFn: function() { console.log(this.name); }, // 箭头函数:this 继承外层(全局)this,无 name 属性 arrowFn: () => { console.log(this.name); } }; obj.normalFn(); // 输出 "Tom" obj.arrowFn(); // 浏览器中输出 undefined
- 普通函数:
-
能否作为构造函数:
- 普通函数:可以作为构造函数,用
new关键字创建实例(new会绑定this为实例对象)。 - 箭头函数:不能作为构造函数,用
new调用会报错(箭头函数无prototype属性,也无this绑定)。 - 示例:
const Fn = () => {}; new Fn(); // 报错 "Fn is not a constructor"。
- 普通函数:可以作为构造函数,用
-
是否有
arguments对象:- 普通函数:内部有
arguments对象,是类数组,包含函数所有实参。 - 箭头函数:没有
arguments对象,若需获取实参,需用“剩余参数(...args)”代替。 - 示例:
// 普通函数:用 arguments function normalFn() { console.log(arguments[0]); } normalFn(10); // 输出 10 // 箭头函数:用剩余参数 const arrowFn = (...args) => { console.log(args[0]); }; arrowFn(20); // 输出 20
- 普通函数:内部有
-
是否有
prototype属性:- 普通函数:有
prototype属性,是其创建实例的原型对象。 - 箭头函数:没有
prototype属性(无法作为构造函数,无需原型对象)。 - 示例:
console.log(((a) => a).prototype); // undefined。
- 普通函数:有
-
语法简洁性:
- 普通函数:语法固定(
function 名() {}),即使只有一行代码也需写完整结构。 - 箭头函数:支持简写(如单个参数可省略括号,单行返回可省略大括号和
return)。 - 示例:
// 完整写法 const add1 = (a, b) => { return a + b; }; // 简写(单行返回省略 {} 和 return) const add2 = (a, b) => a + b; // 单个参数省略 () const double = a => a * 2;
- 普通函数:语法固定(
41. ES6 中的解构赋值是什么?如何使用?
-
概念:解构赋值是 ES6 新增的语法,允许从数组或对象中“提取数据”,并赋值给变量(简化代码,避免重复写
obj.key或arr[index])。 -
数组解构赋值:
- 规则:按“数组索引顺序”匹配变量和值,变量用
[]包裹。 - 常用场景:
- 基本解构:
let [a, b, c] = [1, 2, 3]; // a=1, b=2, c=3。 - 跳过元素:用空位置跳过不需要的元素,
let [a, , c] = [1, 2, 3]; // a=1, c=3。 - 设置默认值:当解构的值为
undefined时,使用默认值,let [a = 0, b] = [undefined, 2]; // a=0, b=2。 - 解构剩余元素:用
...接收剩余元素(必须放在最后),let [a, ...rest] = [1, 2, 3]; // a=1, rest=[2,3]。
- 基本解构:
- 规则:按“数组索引顺序”匹配变量和值,变量用
-
对象解构赋值:
- 规则:按“属性名”匹配变量和值,变量用
{}包裹(变量名需与属性名一致,若要改名需用: 新名)。 - 常用场景:
- 基本解构:
let { name, age } = { name: "Tom", age: 20 }; // name="Tom", age=20。 - 变量改名:
let { name: userName, age } = { name: "Tom", age: 20 }; // userName="Tom"。 - 设置默认值:
let { name, age = 18 } = { name: "Tom" }; // age=18。 - 解构剩余属性:
let { name, ...rest } = { name: "Tom", age:20, gender:"male" }; // rest={age:20, gender:"male"}。 - 嵌套解构:解构嵌套对象,
let { address: { city } } = { name: "Tom", address: { city: "Beijing" } }; // city="Beijing"。
- 基本解构:
- 规则:按“属性名”匹配变量和值,变量用
-
实际应用(函数参数解构):
- 函数参数可直接用解构赋值,简化参数获取(尤其参数是对象时)。
- 示例:
// 传统写法:需手动获取参数属性 function printUser(user) { console.log(user.name, user.age); } // 解构赋值写法:直接解构参数 function printUser({ name, age = 18 }) { console.log(name, age); } printUser({ name: "Tom" }); // 输出 "Tom 18"
42. ES6 中的扩展运算符(...)有哪些用法?
扩展运算符(...)可将“可迭代对象”(如数组、字符串、Set)展开为单个元素,或收集多个元素为数组,核心用法分 4 类:
-
数组扩展:
- 复制数组:避免引用类型赋值的问题(浅拷贝表层元素)。
- 示例:
const arr1 = [1,2,3]; const arr2 = [...arr1]; // arr2=[1,2,3],修改 arr2 不影响 arr1。
- 示例:
- 合并数组:替代
concat方法,语法更简洁。- 示例:
const arr3 = [...arr1, ...arr2, 4]; // arr3=[1,2,3,1,2,3,4]。
- 示例:
- 展开数组作为函数参数:替代
apply方法(apply需传数组,...直接展开)。- 示例:
function add(a,b,c) { return a+b+c; } add(...arr1); // 1+2+3=6。
- 示例:
- 复制数组:避免引用类型赋值的问题(浅拷贝表层元素)。
-
对象扩展(ES2018 支持):
- 复制对象:浅拷贝对象表层属性(替代
Object.assign部分场景)。- 示例:
const obj1 = { a:1, b:2 }; const obj2 = { ...obj1 }; // obj2={a:1,b:2}。
- 示例:
- 合并对象:后面对象的属性会覆盖前面对象的同名属性。
- 示例:
const obj3 = { ...obj1, b:3, c:4 }; // obj3={a:1, b:3, c:4}。
- 示例:
- 复制对象:浅拷贝对象表层属性(替代
-
字符串扩展:
- 将字符串展开为单个字符组成的数组。
- 示例:
const str = "abc"; const arr = [...str]; // arr=['a','b','c']。
-
函数参数(剩余参数):
- 与扩展运算符语法相同,但作用相反:将“多个函数实参”收集为“一个数组”(必须放在参数列表最后)。
- 示例:
function sum(...args) { return args.reduce((acc, item) => acc + item, 0); } sum(1,2,3,4); // 10(args=[1,2,3,4])
43. ES6 中的 Set 和 Map 是什么?有哪些常用方法?
Set 和 Map 是 ES6 新增的“数据结构”,用于解决传统对象/数组的局限性:
一、Set(无重复值的集合)
- 概念:Set 是“无序的、不包含重复值”的集合(值可以是任意类型,包括基本类型和引用类型)。
- 常用属性和方法:
size:返回 Set 中元素的个数(类似数组的length)。add(value):添加元素,返回 Set 本身(支持链式调用)。delete(value):删除指定元素,返回布尔值(true表示删除成功,false表示元素不存在)。has(value):判断 Set 中是否包含指定元素,返回布尔值。clear():清空 Set 中所有元素,无返回值。forEach((value, key, set) => {}):遍历 Set(value和key相同,因 Set 无键名)。
- 核心用途:数组去重(利用 Set 无重复值的特性)。
- 示例:
const set = new Set(); set.add(1).add(2).add(2); // 重复添加 2 无效,Set 中仅存 1、2 console.log(set.size); // 2 console.log(set.has(2)); // true // 数组去重 const arr = [1,2,2,3]; const uniqueArr = [...set]; // 或 Array.from(set),结果为 [1,2,3]
- 示例:
二、Map(键值对集合)
- 概念:Map 是“有序的键值对集合”,与传统对象的区别是:
- 传统对象的键只能是“字符串”或“Symbol”;
- Map 的键可以是“任意类型”(包括基本类型、对象、函数等)。
- 常用属性和方法:
size:返回 Map 中键值对的个数。set(key, value):添加键值对,返回 Map 本身(支持链式调用)。get(key):获取指定键对应的值,若键不存在返回undefined。delete(key):删除指定键值对,返回布尔值。has(key):判断 Map 中是否包含指定键,返回布尔值。clear():清空 Map 中所有键值对,无返回值。forEach((value, key, map) => {}):遍历 Map(回调参数为value、key、map本身)。
- 示例:
const map = new Map(); const objKey = { id: 1 }; // 添加键值对(键为对象) map.set(objKey, "value1").set("name", "Tom"); console.log(map.get(objKey)); // "value1"(通过对象键获取值) console.log(map.get("name")); // "Tom" console.log(map.size); // 2 // 遍历 Map map.forEach((value, key) => { console.log(key, value); // 输出 {id:1} "value1"、"name" "Tom" });
44. 函数的 call、apply、bind 方法有什么区别?如何使用?
三者的 共同点 是:均可手动修改函数的 this 指向;核心区别 是参数传递方式和函数执行时机。
-
call方法:- 语法:
function.call(thisArg, arg1, arg2, ...)。 - 参数说明:
thisArg:函数执行时this指向的对象(若为null/undefined,浏览器中this指向window)。arg1, arg2, ...:函数的实参,逐个传递。
- 执行时机:立即执行函数,返回函数执行结果。
- 示例:
function fn(a, b) { console.log(this.name, a + b); } const obj = { name: "Tom" }; fn.call(obj, 1, 2); // 立即执行,输出 "Tom 3"
- 语法:
-
apply方法:- 语法:
function.apply(thisArg, [arg1, arg2, ...])。 - 参数说明:
thisArg:同call,指定this指向。[arg1, arg2, ...]:函数的实参,以数组(或类数组)形式传递。
- 执行时机:立即执行函数,返回函数执行结果。
- 适用场景:当函数实参已存在于数组中时(如求数组最大值:
Math.max.apply(Math, [1,2,3]))。 - 示例:
fn.apply(obj, [1, 2]); // 立即执行,输出 "Tom 3"(与 call 结果一致,参数传递方式不同) console.log(Math.max.apply(Math, [1, 3, 2])); // 3(求数组最大值)
- 语法:
-
bind方法:- 语法:
function.bind(thisArg, arg1, arg2, ...)。 - 参数说明:同
call,thisArg指定this指向,后续参数逐个传递(可预传部分参数)。 - 执行时机:不立即执行函数,返回一个“
this已绑定、参数已预传”的新函数。 - 适用场景:需要“延迟执行函数”的场景(如事件回调、定时器回调),或“预传部分参数”(函数柯里化)。
- 示例:
// 绑定 this 和参数,返回新函数 const newFn = fn.bind(obj, 1, 2); newFn(); // 延迟执行,输出 "Tom 3" // 预传部分参数(柯里化) const add = (a, b) => a + b; const add1 = add.bind(null, 1); // 预传 a=1 console.log(add1(2)); // 3(b=2,1+2=3)
- 语法:
-
核心区别总结:
方法 参数传递方式 执行时机 返回值 call逐个传递实参 立即执行 函数执行结果 apply数组/类数组传递实参 立即执行 函数执行结果 bind逐个传递实参 延迟执行 绑定 this 的新函数
45. 如何实现数组去重?请列举至少 3 种方法并说明优缺点。
数组去重是面试高频题,核心思路是“筛选出不重复的元素”,常用方法有 4 种:
方法 1:利用 Set 数据结构(ES6 推荐)
- 原理:Set 特性是“不包含重复值”,将数组转为 Set 后,再转回数组。
- 实现代码:
function uniqueArr(arr) { // 方式 1:扩展运算符 + Set return [...new Set(arr)]; // 方式 2:Array.from + Set // return Array.from(new Set(arr)); } - 优点:语法最简洁,一行代码实现,性能高效(Set 底层用哈希表实现,查找速度快)。
- 缺点:
- 无法区分
NaN(Set 认为NaN === NaN,会去重;但 JS 中NaN !== NaN)。 - 无法处理引用类型(如
[{id:1}, {id:1}],Set 认为是不同对象,无法去重)。
- 无法区分
方法 2:利用 filter + indexOf
- 原理:
indexOf(item)返回数组中“第一个item的索引”;filter筛选出“索引等于indexOf(item)的元素”(即仅保留第一个出现的元素)。 - 实现代码:
function uniqueArr(arr) { return arr.filter((item, index) => { // 若当前元素的索引 === 第一个出现的索引,说明是第一次出现,保留 return arr.indexOf(item) === index; }); } - 优点:无需依赖 ES6 特性,兼容性好(支持 IE8+)。
- 缺点:
- 性能较差:
indexOf会遍历数组,filter也会遍历数组,时间复杂度为 O(n²)(n 为数组长度)。 - 无法区分
NaN:indexOf(NaN)始终返回 -1,会过滤掉所有NaN。
- 性能较差:
方法 3:利用 for 循环 + 对象哈希表
- 原理:用对象的“键名唯一性”存储元素(键名存元素值,键值存布尔值),遍历数组时判断元素是否已在对象中,若不存在则保留并添加到对象。
- 实现代码:
function uniqueArr(arr) { const obj = {}; const result = []; for (let i = 0; i < arr.length; i++) { const item = arr[i]; // 避免误判(如 1 和 "1" 视为不同元素,需加类型判断) const key = typeof item + item; if (!obj[key]) { obj[key] = true; result.push(item); } } return result; } - 优点:性能高效,仅遍历一次数组,时间复杂度为 O(n);可区分基本类型的类型差异(如 1 和 “1”)。
- 缺点:
- 需手动处理类型判断(否则 1 和 “1” 会被视为相同元素)。
- 无法处理引用类型(如
{id:1}作为键名会转为"[object Object]",导致误判)。
方法 4:利用 reduce + includes
- 原理:
reduce累加器遍历数组,includes判断当前元素是否已在累加结果中,若不存在则添加到结果。 - 实现代码:
function uniqueArr(arr) { return arr.reduce((result, item) => { // 若结果中没有当前元素,则添加 return result.includes(item) ? result : [...result, item]; }, []); } - 优点:代码简洁,逻辑清晰(利用
reduce实现累加,includes判断存在性)。 - 缺点:
- 性能较差:
includes会遍历结果数组,时间复杂度为 O(n²)。 - 无法区分
NaN:includes(NaN)可识别NaN(与indexOf不同),但仍无法处理引用类型。
- 性能较差:
46. 什么是深拷贝和浅拷贝?两者的区别是什么?如何实现深拷贝?
-
概念与区别:
- 浅拷贝(Shallow Copy):仅复制对象的“表层属性”,若属性值为引用类型(如对象/数组),则仅复制“引用地址”(新对象与原对象共享该引用类型属性,修改新对象的引用属性会影响原对象)。
- 深拷贝(Deep Copy):复制对象的“所有层级属性”,包括引用类型属性(会为引用类型属性重新创建新对象,新对象与原对象完全独立,修改新对象不会影响原对象)。
- 示例(浅拷贝 vs 深拷贝):
const obj = { a: 1, b: { c: 2 } }; // 浅拷贝(扩展运算符) const shallowCopy = { ...obj }; shallowCopy.b.c = 3; console.log(obj.b.c); // 3(修改浅拷贝的引用属性,影响原对象) // 深拷贝(假设已实现 deepCopy 函数) const deepCopy = deepCopy(obj); deepCopy.b.c = 4; console.log(obj.b.c); // 3(修改深拷贝的引用属性,不影响原对象)
-
浅拷贝实现方法(4 种):
- 数组:
[...arr]、arr.slice()、arr.concat()。 - 对象:
{...obj}、Object.assign({}, obj)。
- 数组:
-
深拷贝实现方法(3 种):
-
方法 1:
JSON.parse(JSON.stringify(obj))(简单场景推荐):- 原理:将对象转为 JSON 字符串(序列化),再将字符串转回对象(反序列化),过程中会重新创建所有引用类型属性。
- 实现代码:
const deepCopy = obj => JSON.parse(JSON.stringify(obj));。 - 优点:语法简洁,无需手动写递归。
- 缺点:
- 无法拷贝
function、undefined、Symbol类型(会被过滤)。 - 无法拷贝循环引用对象(如
obj.a = obj,会报错)。 - 无法拷贝
Date、RegExp类型(会转为普通对象,如Date转为字符串)。
- 无法拷贝
-
方法 2:递归实现深拷贝(通用场景):
- 原理:遍历对象所有属性,若属性为基本类型则直接复制;若为引用类型则递归调用深拷贝函数,创建新对象。
- 实现代码(基础版):
function deepCopy(obj) { // 处理 null 和基本类型 if (obj === null || typeof obj !== "object") { return obj; } // 处理 Date 类型 if (obj instanceof Date) { return new Date(obj); } // 处理 RegExp 类型 if (obj instanceof RegExp) { return new RegExp(obj.source, obj.flags); } // 处理数组和对象(创建新实例) const copy = Array.isArray(obj) ? [] : {}; // 遍历所有可枚举属性(包括原型链?用 hasOwnProperty 过滤原型链属性) for (const key in obj) { if (obj.hasOwnProperty(key)) { // 递归拷贝属性值 copy[key] = deepCopy(obj[key]); } } return copy; } - 优点:可处理
Date、RegExp类型,支持大部分场景;可避免循环引用(需额外处理,如用 WeakMap 存储已拷贝对象)。 - 缺点:需手动处理特殊类型(如
Map、Set),代码较复杂。
-
方法 3:使用第三方库(生产环境推荐):
- 如 Lodash 的
_.cloneDeep(obj)方法,已完善处理各种类型(包括循环引用、特殊对象),稳定性高。 - 示例:
const deepCopy = _.cloneDeep(obj);(需引入 Lodash 库)。
- 如 Lodash 的
-
47. 什么是 JS 的执行上下文和执行栈?请举例说明。
-
执行上下文(Execution Context):
- 概念:JS 代码执行时的“环境容器”,包含当前代码的变量、函数、
this等信息(JS 引擎通过执行上下文管理代码执行)。 - 分类(3 种):
- 全局执行上下文(Global Execution Context):
- 全局代码(不在任何函数内的代码)执行时创建,整个页面生命周期内仅存在一个。
- 浏览器环境中,全局执行上下文会创建
window对象,this指向window;同时将全局变量和函数作为window的属性和方法。
- 函数执行上下文(Function Execution Context):
- 函数被调用时创建(每次调用函数都会创建一个新的函数执行上下文,即使是同一函数)。
- 包含函数的参数、局部变量、
this指向等信息。
- eval 执行上下文(Eval Execution Context):
eval函数内的代码执行时创建,因eval安全性低、性能差,实际开发中极少使用。
- 全局执行上下文(Global Execution Context):
- 概念:JS 代码执行时的“环境容器”,包含当前代码的变量、函数、
-
执行栈(Execution Stack):
- 概念:又称“调用栈”,是 JS 引擎用于管理执行上下文的“栈结构”(遵循“先进后出”原则)。
- 工作流程:
- 代码开始执行时,先创建全局执行上下文,压入执行栈。
- 当调用函数时,创建该函数的执行上下文,压入执行栈顶部。
- 函数执行完成后,其执行上下文从执行栈顶部弹出,释放内存。
- 所有代码执行完成后,执行栈中仅剩余全局执行上下文,页面关闭时全局执行上下文弹出。
-
示例(执行栈流程):
// 全局代码 function a() { console.log("a 执行"); b(); // 调用函数 b,创建 b 的执行上下文并压栈 } function b() { console.log("b 执行"); c(); // 调用函数 c,创建 c 的执行上下文并压栈 } function c() { console.log("c 执行"); // c 执行完成,其执行上下文弹出 } a(); // 调用函数 a,创建 a 的执行上下文并压栈- 执行栈流程步骤:
- 全局代码执行,全局执行上下文压栈(栈:[全局])。
- 调用
a(),a 执行上下文压栈(栈:[全局, a]),执行a内部代码,输出 “a 执行”。 a内部调用b(),b 执行上下文压栈(栈:[全局, a, b]),执行b内部代码,输出 “b 执行”。b内部调用c(),c 执行上下文压栈(栈:[全局, a, b, c]),执行c内部代码,输出 “c 执行”。c执行完成,c 执行上下文弹出(栈:[全局, a, b])。b执行完成,b 执行上下文弹出(栈:[全局, a])。a执行完成,a 执行上下文弹出(栈:[全局])。- 所有代码执行完成,页面关闭时全局执行上下文弹出(栈:[])。
- 执行栈流程步骤:
48. 什么是防抖(Debounce)和节流(Throttle)?两者的区别是什么?如何实现?
防抖和节流是 JS 中用于“控制高频事件触发频率”的优化方案(如滚动、输入、点击等高频事件),避免函数频繁执行导致性能问题。
一、防抖(Debounce)
-
概念:高频事件触发后,延迟 n 秒再执行函数;若 n 秒内事件再次触发,则重新计时(仅执行最后一次触发后的函数)。
核心逻辑:“等待事件停止触发一段时间后,再执行一次”,适用于“需等待用户操作结束后再响应”的场景(如输入框搜索联想、窗口大小调整)。 -
实现思路:
- 用定时器(
setTimeout)延迟执行目标函数。 - 每次事件触发时,先清除之前的定时器(
clearTimeout),再重新设置新定时器。 - 可选“立即执行”版本(首次触发时立即执行,后续触发需等待延迟)。
- 用定时器(
-
基础实现代码(非立即执行版):
function debounce(fn, delay) { let timer = null; // 存储定时器ID,闭包保存状态 return function(...args) { // 每次触发事件,先清除之前的定时器(重新计时) clearTimeout(timer); // 重新设置定时器,延迟执行fn timer = setTimeout(() => { fn.apply(this, args); // 绑定this和参数(适应事件回调场景) }, delay); }; } // 使用示例:输入框搜索联想 const input = document.querySelector('input'); input.addEventListener('input', debounce((e) => { console.log('搜索关键词:', e.target.value); // 输入停止1秒后执行 }, 1000)); -
立即执行版(首次触发立即执行,后续需等待):
function debounce(fn, delay, immediate = false) { let timer = null; return function(...args) { clearTimeout(timer); // 立即执行逻辑:首次触发且timer为null时,直接执行fn if (immediate && !timer) { fn.apply(this, args); } // 延迟执行逻辑:无论是否立即执行,后续触发都需等待 timer = setTimeout(() => { timer = null; // 延迟后重置timer,允许下次立即执行 if (!immediate) { fn.apply(this, args); } }, delay); }; }
二、节流(Throttle)
-
概念:高频事件触发时,每隔 n 秒仅执行一次函数(无论事件触发多少次,n 秒内只执行一次)。
核心逻辑:“控制函数执行频率,固定时间间隔内必执行一次”,适用于“需持续响应但避免过度执行”的场景(如滚动加载数据、鼠标移动绘制)。 -
实现思路(两种常用方案):
- 时间戳方案:记录上次执行时间,每次事件触发时判断“当前时间 - 上次执行时间 ≥ 延迟”,若满足则执行函数并更新上次时间。
- 定时器方案:设置定时器,函数执行后清除定时器并重新设置,确保 n 秒内仅执行一次。
-
时间戳方案实现(立即执行):
function throttle(fn, interval) { let lastTime = 0; // 记录上次执行时间(初始为0,首次触发立即执行) return function(...args) { const nowTime = Date.now(); // 当前时间戳 // 若当前时间 - 上次执行时间 ≥ 间隔,执行函数 if (nowTime - lastTime >= interval) { fn.apply(this, args); lastTime = nowTime; // 更新上次执行时间 } }; } // 使用示例:滚动加载 window.addEventListener('scroll', throttle(() => { console.log('滚动位置:', window.scrollY); // 每2秒执行一次 }, 2000)); -
定时器方案实现(延迟执行):
function throttle(fn, interval) { let timer = null; return function(...args) { // 若定时器不存在,说明当前可执行函数 if (!timer) { timer = setTimeout(() => { fn.apply(this, args); timer = null; // 执行后清除定时器,允许下次触发 }, interval); } }; }
三、防抖与节流的核心区别
| 特性 | 防抖(Debounce) | 节流(Throttle) |
|---|---|---|
| 执行时机 | 事件停止触发后延迟执行(仅最后一次) | 固定时间间隔内必执行一次(多次触发也只一次) |
| 核心逻辑 | “等待结束后执行” | “控制频率,定期执行” |
| 适用场景 | 输入搜索、窗口 resize、按钮防重复点击 | 滚动加载、鼠标移动、高频点击统计 |
| 函数执行次数 | 高频触发后可能仅执行 1 次 | 高频触发后按间隔执行多次(如每秒 1 次) |
49. 什么是跨域?跨域的原因是什么?如何解决跨域问题?
一、概念与跨域原因
-
跨域:指浏览器中“当前页面的域名”与“请求目标资源的域名”不一致(包括协议、域名、端口任一不同),导致请求被浏览器拦截的现象。
例如:http://localhost:3000(前端页面)请求https://api.example.com(后端接口),因协议(http/https)和域名(localhost/example.com)不同,属于跨域。 -
跨域的本质:浏览器的“同源策略(Same-Origin Policy)”限制。
同源策略是浏览器的安全机制,规定“非同源的页面不能访问对方的资源”,目的是防止恶意网站窃取用户数据(如 Cookie、LocalStorage)。
同源定义:协议(http/https)、域名(example.com)、端口(80/443)三者完全相同。
二、常见跨域场景
| 前端页面 URL | 请求目标 URL | 跨域原因 |
|---|---|---|
http://a.com | https://a.com | 协议不同(http/https) |
http://a.com | http://b.com | 域名不同(a.com/b.com) |
http://a.com:80 | http://a.com:3000 | 端口不同(80/3000) |
http://a.com | http://sub.a.com | 主域名相同,子域名不同 |
三、跨域解决方案(6 种常用方案)
1. CORS(跨域资源共享,推荐后端配置)
- 原理:后端在响应头中添加
Access-Control-*相关字段,告知浏览器“允许该前端域名访问资源”,浏览器验证通过后放行请求。 - 核心响应头:
Access-Control-Allow-Origin: http://localhost:3000:允许的前端域名(* 表示允许所有域名,不推荐生产环境)。Access-Control-Allow-Methods: GET, POST, PUT:允许的请求方法。Access-Control-Allow-Credentials: true:允许携带 Cookie(此时Allow-Origin不能为 *)。
- 优点:标准方案,支持所有 HTTP 方法,无需前端额外处理。
- 缺点:需后端配合配置,老浏览器(如 IE8-)不支持。
2. 代理服务器(前端本地开发常用)
- 原理:利用“服务器端请求无跨域限制”的特性,前端先将请求发送到“本地代理服务器”,再由代理服务器转发到目标接口,最后将响应返回给前端。
- 常见配置(Vue CLI 示例):在
vue.config.js中配置代理:module.exports = { devServer: { proxy: { '/api': { // 匹配以 /api 开头的请求 target: 'https://api.example.com', // 目标接口域名 changeOrigin: true, // 开启代理,模拟目标域名(解决跨域) pathRewrite: { '^/api': '' } // 去除请求路径中的 /api(若目标接口无 /api 前缀) } } } }; - 优点:前端无需修改代码,仅需配置代理,适合开发环境。
- 缺点:仅用于开发环境,生产环境需后端部署代理服务。
3. JSONP(仅支持 GET 方法,兼容性好)
- 原理:利用
<script>标签无跨域限制的特性,通过动态创建<script>标签,将目标接口 URL 作为src,并指定回调函数,后端返回“回调函数包裹的 JSON 数据”,浏览器执行回调函数获取数据。 - 实现示例:
// 前端:定义回调函数 function handleData(data) { console.log('JSONP 响应数据:', data); } // 动态创建 <script> 标签,发送请求 const script = document.createElement('script'); script.src = 'https://api.example.com/data?callback=handleData'; // 传入回调函数名 document.body.appendChild(script); // 后端:返回格式(回调函数包裹数据) // handleData({"name":"Tom","age":20}) - 优点:兼容性好(支持 IE 等老浏览器),实现简单。
- 缺点:仅支持 GET 方法,无错误处理机制,存在 XSS 安全风险。
4. 文档域(Document Domain,仅适合同主域名的子域名)
- 原理:当两个页面的“主域名相同、子域名不同”时(如
a.example.com和b.example.com),可通过设置document.domain = "example.com",将两者的文档域统一为“主域名”,从而实现跨域访问。 - 实现示例:
// 页面 a.example.com document.domain = "example.com"; const iframe = document.createElement('iframe'); iframe.src = "http://b.example.com"; iframe.onload = function() { const iframeWindow = iframe.contentWindow; console.log(iframeWindow.data); // 访问 b.example.com 中的数据 }; document.body.appendChild(iframe); // 页面 b.example.com document.domain = "example.com"; window.data = "来自 b 页面的数据"; - 优点:仅需前端配置,适合子域名跨域场景。
- 缺点:仅限主域名相同的子域名,无法跨主域名,且需双方页面配合设置。
5. postMessage(跨窗口/iframe 通信)
- 原理:HTML5 新增的
postMessage方法,允许不同域名的窗口/iframe 之间安全通信,通过发送消息和监听消息事件实现数据传递。 - 实现示例(父窗口 → 子 iframe):
// 父窗口(http://a.com) const iframe = document.querySelector('iframe'); // 向子 iframe 发送消息(目标域名、消息内容) iframe.contentWindow.postMessage({ name: "Tom" }, "http://b.com"); // 子 iframe(http://b.com) window.addEventListener('message', (e) => { // 验证发送方域名,防止恶意消息 if (e.origin === "http://a.com") { console.log('收到父窗口消息:', e.data); // e.data 为消息内容 // 可选:向父窗口回复消息 e.source.postMessage("已收到消息", e.origin); } }); - 优点:支持任意域名跨域,可传递任意数据(字符串、对象),安全可控。
- 缺点:需双方页面配合监听消息,仅支持现代浏览器(IE8+ 部分支持)。
6. WebSocket(全双工通信,适用于实时场景)
- 原理:WebSocket 是 HTML5 新增的协议,建立连接后客户端与服务器可“全双工通信”(双向实时发送数据),且 WebSocket 协议本身无跨域限制(请求头中会携带
Origin,后端可配置允许的域名)。 - 实现示例:
// 前端:建立 WebSocket 连接(协议为 ws/wss,对应 http/https) const ws = new WebSocket('ws://api.example.com/chat'); // 连接成功 ws.onopen = function() { ws.send('前端发送的消息'); // 发送数据 }; // 接收服务器消息 ws.onmessage = function(e) { console.log('收到服务器消息:', e.data); }; // 连接关闭 ws.onclose = function() { console.log('连接关闭'); }; - 优点:实时性高,支持双向通信,无跨域限制。
- 缺点:需后端支持 WebSocket 协议,适用于实时场景(如聊天、直播),非普通接口请求。
50. 请解释 JS 中的模块化(CommonJS、ES6 Module),两者的区别是什么?
一、模块化的概念
模块化是将 JS 代码“按功能拆分为独立文件”的规范,每个文件是一个“模块”,模块内的变量/函数默认私有,通过 导出(export) 和 导入(import) 实现模块间通信,解决“全局变量污染”和“代码依赖混乱”问题。
二、CommonJS 模块(Node.js 默认规范)
-
核心语法:
- 导出模块:用
module.exports或exports导出模块内容(exports是module.exports的引用,不能直接赋值为新对象)。// 模块 a.js const name = "Tom"; function sayHi() { console.log(`Hi, ${name}`); } // 导出方式 1:module.exports(推荐,可导出任意类型) module.exports = { name, sayHi }; // 导出方式 2:exports(仅能添加属性,不能直接赋值 exports = {}) // exports.name = name; // exports.sayHi = sayHi; - 导入模块:用
require()导入模块,返回模块导出的内容(同步导入)。// 模块 b.js const { name, sayHi } = require('./a.js'); // 解构导入 // 或 const moduleA = require('./a.js'); // 整体导入 console.log(name); // "Tom" sayHi(); // "Hi, Tom"
- 导出模块:用
-
核心特性:
- 同步加载:
require()执行时会“阻塞代码”,直到模块加载完成(适合 Node.js 服务器端,文件加载速度快;不适合浏览器端,会阻塞页面渲染)。 - 运行时加载:模块加载发生在代码执行阶段,
require()可动态指定模块路径(如require('./' + path))。 - 值拷贝:导入的是模块导出值的“拷贝”,若模块内值后续修改,导入方不会同步更新(除非导出的是引用类型,修改内部属性会同步)。
// a.js let count = 0; module.exports = { count, increment: () => count++ }; // b.js const { count, increment } = require('./a.js'); increment(); console.log(count); // 0(count 是值拷贝,不会更新)
- 同步加载:
三、ES6 Module(ES6 官方规范,浏览器/Node.js 均支持)
- 核心语法:
- 导出模块:分
具名导出(export)和默认导出(export default),一个模块可多个具名导出,仅一个默认导出。// 模块 a.js const name = "Tom"; function sayHi() { console.log(`Hi, ${name}`); } // 具名导出(可多个) export { name, sayHi }; // 或单个具名导出:export const age = 20; // 默认导出(仅一个,可导出任意类型) export default function() { console.log("默认导出的函数"); } - 导入模块:用
import导入,具名导出需用{}匹配,默认导出可自定义名称(静态导入,需在代码顶部)。// 模块 b.js // 导入具名导出 + 默认导出 import defaultFn, { name, sayHi } from './a.js'; // 或整体导入:import * as moduleA from './a.js'; console.log(name); // "Tom" sayHi(); // "Hi, Tom" defaultFn(); // "默认导出的函数"
- 导出模块:分
更多推荐


所有评论(0)