【前端高频面试题】 - JavaScript 篇

1. 请说明 JavaScript 中的变量类型,以及如何检测这些类型?

变量类型

  • 基本数据类型(值类型):共 6 种,分别是 String(字符串)、Number(数字)、Boolean(布尔)、Undefined(未定义)、Null(空对象指针)、Symbol(唯一标识,ES6 新增),存储在栈内存中,值不可变。
  • 引用数据类型:主要是 Object(对象),包括 Array(数组)、Function(函数)、Date(日期)等,存储在堆内存中,栈内存仅保存堆内存的引用地址,值可修改。

类型检测方法

  1. typeof 运算符:
    • 适用场景:检测基本类型(除 Null 外)和函数,返回字符串(如 typeof 'abc' → 'string'、typeof function(){} → 'function')。
    • 局限性:检测 Null 会返回 'object'(历史 bug),检测引用类型(如数组、对象)均返回 'object'。
  2. instanceof 运算符:
    • 适用场景:检测引用类型的具体类型,基于原型链判断(如 [1,2] instanceof Array → true、new Date() instanceof Date → true)。
    • 局限性:不能检测基本类型,且跨 iframe 时可能失效(原型链断裂)。
  3. 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)和函数声明提升到当前作用域的顶部,但赋值不会提升。

三者变量提升的区别

  1. var 的变量提升:
    • 声明和赋值分离,提升时仅提升声明,默认赋值为 undefined。
    • 示例:
      console.log(a); // undefined(声明提升,赋值未提升)
      var a = 10;
      
    • 无块级作用域,提升到函数/全局作用域顶部。
  2. let/const 的变量提升:
    • 存在“暂时性死区(TDZ)”:声明会提升,但提升后到赋值前的区域不可访问,访问会报错。
    • 示例:
      console.log(b); // 报错(暂时性死区)
      let b = 20;
      
    • 有块级作用域({} 包裹区域),提升到块级作用域顶部。
  3. let 与 const 的额外区别:
    • let 允许重复赋值,const 声明的变量必须初始化,且赋值后不可修改(引用类型仅限制地址,内部属性可改)。

3. JavaScript 中 this 的指向的是如何确定的?请分场景说明。

this 的指向在函数调用时确定,而非定义时,不同调用场景指向不同:

  1. 全局环境下:
    • 浏览器环境:this 指向 window(非严格模式)或 undefined(严格模式)。
    • 示例:console.log(this) → window(浏览器非严格模式)。
  2. 普通函数调用:
    • 非严格模式:this 指向 window;严格模式:this 指向 undefined。
    • 示例:
      function fn() { console.log(this); }
      fn(); // window(非严格模式)/ undefined(严格模式)
      
  3. 对象方法调用:
    • this 指向调用该方法的对象(即方法前面的“点”左边的对象)。
    • 示例:
      const obj = { name: 'A', fn: function() { console.log(this.name); } };
      obj.fn(); // 'A'(this 指向 obj)
      
  4. 构造函数调用(new 关键字):
    • this 指向新创建的实例对象。
    • 示例:
      function Person(name) { this.name = name; }
      const p = new Person('B');
      console.log(p.name); // 'B'(this 指向 p)
      
  5. call/apply/bind 调用:
    • this 指向这三个方法的第一个参数(手动指定的上下文)。
    • 示例:
      function fn() { console.log(this.name); }
      const obj = { name: 'C' };
      fn.call(obj); // 'C'(this 指向 obj)
      
  6. 箭头函数调用:
    • 箭头函数无独立 this,其 this 继承自外层作用域的 this(定义时确定,永不改变)。
    • 示例:
      const obj = { fn: () => { console.log(this); } };
      obj.fn(); // window(继承全局 this,而非 obj)
      

4. 什么是闭包?闭包的形成条件、作用及缺点是什么?

闭包概念

闭包是指有权访问另一个函数作用域中变量的函数,本质是函数嵌套时,内层函数保留了对外层函数作用域的引用。

形成条件

  1. 存在函数嵌套(内层函数 + 外层函数);
  2. 内层函数引用了外层函数的变量/参数;
  3. 内层函数被外层函数以外的地方调用(打破外层函数执行后作用域销毁的常规)。

闭包的作用

  1. 保存变量:延长外层函数变量的生命周期,避免被垃圾回收机制回收(如实现计数器)。
    • 示例:
      function createCounter() {
        let count = 0; // 外层函数变量,被内层函数引用
        return function() { return ++count; }; // 内层函数被外部调用
      }
      const counter = createCounter();
      console.log(counter()); // 1
      console.log(counter()); // 2(count 未被销毁)
      
  2. 模块化:实现私有变量和公有方法的封装(避免全局变量污染)。

闭包的缺点

  • 内存泄漏风险:若闭包长期持有外层函数的变量且不释放,会导致内存无法回收,长期积累可能影响性能。
  • 解决方式:不再使用闭包时,手动将引用设为 null(如 counter = null)。

5. 请解释 JavaScript 中的原型(Prototype)和原型链(Prototype Chain)。

核心概念关系

JavaScript 中每个对象(除 null 外)都有 __proto__(隐式原型),每个函数都有 prototype(显式原型);对象的 __proto__ 指向其构造函数的 prototype。

  1. 原型(Prototype):

    • 即函数的 prototype 属性,是一个对象,称为“原型对象”。
    • 作用:存储所有实例共享的属性和方法(如 Array.prototype.push 是所有数组实例的共享方法)。
    • 原型对象内置 constructor 属性,指向其关联的构造函数(如 Array.prototype.constructor === Array)。
  2. 原型链(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 的关系

  1. 依赖关系: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)
      
  2. 语法简化:await 关键字只能在 async 函数内使用,用于“等待”一个 Promise 完成,避免 then 链式调用的嵌套。

错误处理方式

async/await 本身不支持错误捕获,需通过 try/catch 语句处理,有两种常见方式:

  1. 全局 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 的错误
        }
      }
      
  2. 单独 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高

事件循环执行流程

  1. 执行同步代码:主线程先执行当前 script 中的所有同步代码,遇到异步操作时,将其对应的回调函数放入对应任务队列(宏任务/微任务);
  2. 清空微任务队列:同步代码执行完毕后,主线程会优先清空所有微任务(按队列顺序执行);
  3. 执行一个宏任务:微任务队列清空后,主线程从宏任务队列中取出第一个宏任务执行;
  4. 重复循环:执行完一个宏任务后,再次清空所有微任务,然后再执行下一个宏任务,如此循环(即“事件循环”)。

示例验证

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。

柯里化的作用

  1. 参数复用:固定函数的部分参数,后续调用可直接使用固定参数,无需重复传入。
    • 示例:实现“固定税率的计算函数”,税率固定为 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)
      
  2. 延迟执行:将函数的执行拆分为多次调用,直到传入所有参数后才执行最终逻辑。
    • 示例:add(1)(2) 不会立即返回结果,需再传入 (3) 才返回 6。
  3. 函数组合:为后续函数组合(如 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 中的“空值”,但语义和使用场景完全不同:

一、核心区别

区别维度undefinednull
语义含义表示“未定义”:变量已声明但未赋值,或属性不存在表示“空值”:变量已赋值,但值为“空”(主动设置的空对象指针)
类型检测(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 中变量提升有哪些特点?

  1. 概念:变量提升是 JS 引擎在代码执行前的“预编译”阶段,将使用 var 声明的变量和函数声明提升到当前作用域顶部的行为(仅提升声明,不提升赋值/函数体)。
  2. 变量提升(var):
    • 仅提升“变量声明”,变量的赋值语句仍留在原位置。
    • 提升后变量默认值为 undefined。
  3. 函数提升:
    • 函数声明(function 函数名() {})会整体提升(包括函数名和函数体),可在声明前调用函数。
    • 函数表达式(var 函数名 = function() {})仅提升变量名(按 var 变量提升规则),声明前调用会报错(变量值为 undefined,无法作为函数执行)。
  4. 示例:
    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 的区别是什么?

从 变量提升、作用域、重复声明、值修改 四个核心维度对比:

  1. 变量提升:
    • var:存在变量提升,提升后默认值为 undefined。
    • let/const:存在“暂时性死区(TDZ)”,虽有预编译记录,但未到声明行前无法访问(避免了变量提升的不合理使用)。
  2. 作用域:
    • var:仅支持全局作用域和函数作用域,无块级作用域(if/for 块内声明的变量会泄露到外部)。
    • let/const:支持块级作用域(if/for/{} 块内声明的变量仅在块内有效)。
  3. 重复声明:
    • var:允许在同一作用域内重复声明同一变量(后声明会覆盖前声明)。
    • let/const:不允许在同一作用域内重复声明(包括与 var 声明的变量重名),否则报错。
  4. 值修改:
    • var/let:声明的变量值可修改。
    • const:声明的是“常量”,必须初始化赋值,且基本类型值不可修改;若为引用类型(如对象/数组),仅保证引用地址不变,内部属性可修改。

28. 请解释 JS 中的原型(Prototype)和原型链(Prototype Chain)

  1. 原型(Prototype):
    • 每个 JS 对象(除 null)都有一个内置属性 __proto__(隐式原型),指向其“原型对象”;每个函数都有 prototype 属性(显式原型),其值就是该函数创建的实例的原型对象。
    • 原型对象的核心作用是 实现继承:实例可共享原型对象上的属性和方法(避免重复定义,节省内存)。
    • 原型对象中包含 constructor 属性,指向创建该原型对象的构造函数。
  2. 原型链(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)
      

29. JS 中 this 的指向有哪些场景?如何确定 this 指向?

this 指向“当前执行上下文的所有者”,具体场景分 5 类:

  1. 全局作用域中的 this:
    • 浏览器环境:指向 window 对象。
    • Node.js 环境:指向 global 对象。
    • 示例:console.log(this === window); // 浏览器中输出 true。
  2. 普通函数调用(无绑定):
    • this 指向全局对象(浏览器 window,Node.js global);若在严格模式('use strict')下,this 指向 undefined。
    • 示例:
      function fn() { console.log(this); }
      fn(); // 浏览器中输出 window(非严格模式)
      
  3. 对象方法调用:
    • this 指向调用该方法的“对象”(即方法前的.左侧对象)。
    • 示例:
      const obj = { name: "Tom", sayName: function() { console.log(this.name); } };
      obj.sayName(); // 输出 "Tom"(this 指向 obj)
      
  4. 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"
      
  5. 箭头函数中的 this:
    • 箭头函数 没有自己的 this,其 this 继承自“外层作用域的 this”(定义时确定,而非执行时)。
    • 示例:
      const obj = {
        name: "Tom",
        fn: () => { console.log(this.name); } // this 继承外层(全局)的 this,而非 obj
      };
      obj.fn(); // 浏览器中输出 undefined(全局 this 无 name 属性)
      

30. 什么是闭包?闭包的原理、用途及注意事项是什么?

  1. 概念:闭包是指“有权访问另一个函数作用域中变量的函数”,通常通过“函数嵌套 + 外部函数返回内部函数”实现。
  2. 原理:
    • JS 函数执行时会创建“执行上下文”,执行完后若该函数的作用域仍被外部引用(如内部函数被返回并保存),则作用域不会被垃圾回收,内部函数可继续访问外部函数的变量。
  3. 核心用途:
    • 实现 模块化:封装私有变量,仅暴露指定方法(避免全局变量污染)。
    • 保存 函数作用域状态:如循环中保存每个迭代的变量值(避免因变量提升导致的问题)。
    • 示例(模块化):
      function createCounter() {
        let count = 0; // 私有变量,外部无法直接访问
        return {
          increment: () => count++, // 暴露方法,可访问 count
          getCount: () => count
        };
      }
      const counter = createCounter();
      counter.increment();
      console.log(counter.getCount()); // 输出 1
      
  4. 注意事项:
    • 闭包会导致外部函数作用域无法被垃圾回收,若过度使用可能造成 内存泄漏(如闭包引用 DOM 元素且未及时释放)。
    • 解决内存泄漏:不再使用闭包时,手动将闭包引用设为 null(如 counter = null)。

31. JS 中的异步编程模式有哪些?分别有什么特点?

JS 是单线程语言,异步编程用于避免阻塞主线程,核心模式有 3 种:

  1. 回调函数(Callback):
    • 特点:将异步操作的“后续逻辑”作为函数参数传入,异步完成后执行该函数。
    • 优点:实现简单,早期常用(如 setTimeout、AJAX 回调)。
    • 缺点:多层异步嵌套时会形成“回调地狱”(代码可读性差、难以维护)。
    • 示例:
      setTimeout(() => {
        console.log("第一步");
        setTimeout(() => {
          console.log("第二步"); // 回调地狱,嵌套层级深
        }, 1000);
      }, 1000);
      
  2. 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("第二步"); // 链式调用,无嵌套
      });
      
  3. 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();
      

32. Promise 有哪些常用方法?分别有什么作用?

Promise 原型方法和静态方法核心有 6 种:

  1. Promise.prototype.then(onFulfilled, onRejected):
    • 作用:指定 Promise 成功(fulfilled)和失败(rejected)后的回调函数。
    • 特点:返回新的 Promise,支持链式调用;若回调函数返回非 Promise 值,新 Promise 会 resolve 该值;若返回 Promise,新 Promise 会跟随其状态。
  2. Promise.prototype.catch(onRejected):
    • 作用:专门捕获 Promise 的失败状态(等价于 then(null, onRejected))。
    • 特点:可捕获链式调用中任意环节的错误(包括 then 回调中的错误),建议放在链式调用末尾。
  3. Promise.prototype.finally(onFinally):
    • 作用:指定 Promise 无论成功或失败,最终都会执行的回调函数(如关闭加载动画)。
    • 特点:回调函数无参数(不依赖 Promise 状态),返回的 Promise 状态与原 Promise 一致。
  4. Promise.all(iterable):
    • 作用:接收一个可迭代对象(如数组),并行执行所有 Promise。
    • 特点:
      • 所有 Promise 都成功(fulfilled):返回新 Promise,resolve 结果为“所有 Promise 结果组成的数组”(顺序与输入一致)。
      • 只要有一个 Promise 失败(rejected):立即返回新 Promise,reject 该失败原因(忽略其他未完成的 Promise)。
  5. Promise.race(iterable):
    • 作用:并行执行所有 Promise,以第一个完成的 Promise 状态为准。
    • 特点:无论第一个完成的是成功还是失败,新 Promise 都会跟随其状态(如设置请求超时:Promise.race([ajaxRequest, timeoutPromise]))。
  6. Promise.allSettled(iterable):
    • 作用:并行执行所有 Promise,等待所有 Promise 都完成(无论成功或失败)。
    • 特点:返回的 Promise 始终 resolve,结果为“所有 Promise 状态对象组成的数组”,每个对象包含 status(fulfilled/rejected)和 value(成功结果)或 reason(失败原因)。

33. 如何使用 async/await?如何处理 async/await 中的错误?

  1. 基本使用步骤:
    • 用 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();
      
  2. 错误处理方式:
    • 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 种)

  1. push(...items):在数组末尾添加元素,返回新长度。
    • 示例:const arr = [1,2]; arr.push(3); // arr 变为 [1,2,3]。
  2. pop():删除数组末尾元素,返回被删除的元素。
    • 示例:arr.pop(); // arr 变为 [1,2],返回 3。
  3. shift():删除数组第一个元素,返回被删除的元素。
    • 示例:arr.shift(); // arr 变为 [2],返回 1。
  4. unshift(...items):在数组开头添加元素,返回新长度。
    • 示例:arr.unshift(0); // arr 变为 [0,2],返回 2。
  5. sort((a,b) => a - b):对数组排序,默认按字符串 Unicode 排序(需传比较函数实现数字排序)。
    • 示例:[3,1,2].sort((a,b) => a - b); // 变为 [1,2,3]。
  6. reverse():反转数组元素顺序,返回原数组。
    • 示例:[1,2,3].reverse(); // 变为 [3,2,1]。
  7. splice(start, deleteCount, ...items):从 start 位置删除 deleteCount 个元素,插入新元素,返回被删除的元素数组。
    • 示例:[1,2,3,4].splice(1,2,5); // arr 变为 [1,5,4],返回 [2,3]。

二、不改变原数组的方法(8 种)

  1. map((item, index, arr) => {}):遍历数组,对每个元素执行回调,返回“新数组”(长度与原数组一致)。
    • 示例:[1,2,3].map(item => item * 2); // 返回 [2,4,6]。
  2. filter((item) => {}):遍历数组,筛选出“满足回调条件”的元素,返回新数组。
    • 示例:[1,2,3,4].filter(item => item % 2 === 0); // 返回 [2,4]。
  3. reduce((acc, item) => {}, initialValue):累加器,遍历数组将元素“累积”为一个值(如求和、求最大值、数组转对象)。
    • 示例:[1,2,3].reduce((acc, item) => acc + item, 0); // 返回 6。
  4. forEach((item) => {}):遍历数组,执行回调(无返回值,仅用于循环)。
    • 示例:[1,2,3].forEach(item => console.log(item)); // 输出 1、2、3。
  5. slice(start, end):从 start 位置截取到 end 位置(不包含 end),返回新数组(start/end 可传负数,代表从末尾开始)。
    • 示例:[1,2,3,4].slice(1,3); // 返回 [2,3]。
  6. concat(...arrays):合并多个数组,返回新数组(也可传非数组值)。
    • 示例:[1,2].concat([3,4], 5); // 返回 [1,2,3,4,5]。
  7. join(separator):将数组元素按 separator 拼接为字符串,默认用逗号拼接。
    • 示例:[1,2,3].join("-"); // 返回 "1-2-3"。
  8. includes(item, fromIndex):判断数组是否包含 item,返回布尔值(fromIndex 为起始查找位置)。
    • 示例:[1,2,3].includes(2); // 返回 true。

35. JS 的基本数据类型和引用数据类型有哪些?两者的区别是什么?

  1. 数据类型分类:
    • 基本数据类型(7 种):null、undefined、boolean、number、string、symbol(ES6,唯一且不可变)、bigint(ES6,处理大整数)。
    • 引用数据类型(1 类):object,包括数组(Array)、函数(Function)、对象(Object)、日期(Date)等。
  2. 核心区别(3 点):
    • 存储位置:
      • 基本类型:存储在 栈内存 中,直接存储“值”。
      • 引用类型:存储在 堆内存 中,栈内存仅存储“堆内存的引用地址”(即指针)。
    • 赋值方式:
      • 基本类型:赋值时复制“值”(新变量与原变量独立,修改新变量不影响原变量)。
      • 引用类型:赋值时复制“引用地址”(新变量与原变量指向同一堆内存,修改新变量会影响原变量)。
    • 判断方式:
      • 基本类型:用 typeof 判断(除 null 外,typeof null 为 object,需单独判断 null === null)。
      • 引用类型:用 instanceof 判断(判断原型链关系),或 Object.prototype.toString.call() 精准判断。
  3. 示例:
    // 基本类型赋值
    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 的区别是什么?

两者均用于判断数据类型,但适用场景和原理完全不同:

  1. 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'(错误判断)
      
  2. 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. 什么是事件冒泡和事件捕获?如何阻止?

  1. 事件流:JS 中事件触发时会经历“捕获 → 目标 → 冒泡”三个阶段,合称事件流。

  2. 事件捕获(Event Capturing):

    • 概念:事件从“顶层元素”(如 document)向下传播到“目标元素”的阶段(从外到内)。
    • 触发时机:先于事件冒泡执行。
    • 绑定方式:addEventListener 第三个参数设为 true 或 { capture: true }。
    • 示例:
      // 父元素捕获阶段绑定事件
      parent.addEventListener("click", () => console.log("父元素捕获"), true);
      // 子元素绑定事件
      child.addEventListener("click", () => console.log("子元素目标"));
      // 点击子元素,先输出 "父元素捕获",再输出 "子元素目标"
      
  3. 事件冒泡(Event Bubbling):

    • 概念:事件从“目标元素”向上传播到“顶层元素”的阶段(从内到外)。
    • 触发时机:在事件捕获和目标阶段之后执行。
    • 绑定方式:addEventListener 第三个参数默认 false 或 { capture: false }(默认冒泡阶段触发)。
    • 示例:
      // 父元素冒泡阶段绑定事件
      parent.addEventListener("click", () => console.log("父元素冒泡"));
      // 子元素绑定事件
      child.addEventListener("click", () => console.log("子元素目标"));
      // 点击子元素,先输出 "子元素目标",再输出 "父元素冒泡"
      
  4. 阻止方式:

    • 阻止事件冒泡:用 event.stopPropagation()(阻止事件向上传播,但不影响当前元素的其他事件)。
      child.addEventListener("click", (e) => {
        console.log("子元素");
        e.stopPropagation(); // 阻止冒泡,父元素冒泡事件不会触发
      });
      
    • 阻止事件捕获:同阻止冒泡(event.stopPropagation() 可阻止捕获阶段的传播)。
    • 阻止默认行为:用 event.preventDefault()(如阻止表单提交、链接跳转),不影响事件流(冒泡/捕获仍会执行)。

38. 什么是事件委托(事件代理)?原理和优势是什么?

  1. 概念:事件委托是利用“事件冒泡”机制,将“子元素的事件”统一绑定到“父元素”上,通过 event.target 判断触发事件的子元素,从而执行对应逻辑。
  2. 核心原理:
    • 子元素触发事件后,事件会冒泡到父元素;
    • 父元素事件回调中,通过 event.target 获取“实际触发事件的子元素”;
    • 判断 event.target 是否为目标子元素,若符合则执行逻辑。
  3. 示例(点击列表项触发事件):
    <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 内容
      }
    });
    
  4. 核心优势:
    • 减少事件绑定数量:无需给每个子元素绑定事件,仅绑定父元素(尤其子元素数量多时,优化性能)。
    • 支持动态子元素:新增的子元素(如通过 JS 动态添加的 li)无需重新绑定事件,父元素事件可自动生效。
    • 简化代码维护:事件逻辑集中在父元素,无需分别维护每个子元素的事件。

39. JS 的垃圾回收机制是什么?常用的垃圾回收算法有哪些?

  1. 概念:JS 引擎自动管理内存,“垃圾回收机制(GC)”会定期找出“不再使用的内存”(即无引用的对象),并释放其占用的内存(避免内存泄漏)。
  2. 常用垃圾回收算法(2 种):
    • 1. 标记清除(Mark-and-Sweep):

      • 目前主流浏览器(Chrome、Firefox)采用的算法,分两步:
        1. 标记阶段:JS 引擎从“根对象”(如 window/global)出发,遍历所有可访问的对象,标记为“活跃对象”;未被标记的对象即为“垃圾对象”。
        2. 清除阶段:释放所有“垃圾对象”占用的内存,并将内存空间加入“空闲列表”,供后续使用。
      • 优点:解决了“引用计数”算法的循环引用问题。
      • 缺点:清除后内存可能出现“碎片”(小块不连续的内存),但现代引擎会通过“内存整理”优化。
    • 2. 引用计数(Reference Counting):

      • 早期算法,原理是“统计对象被引用的次数”:
        1. 每个对象创建时,引用计数初始化为 1;
        2. 若对象被新变量引用,计数 +1;
        3. 若引用变量被赋值为其他值(或销毁),计数 -1;
        4. 当计数为 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,引用计数算法无法回收
        
  3. 开发者优化建议:
    • 不再使用的对象,手动将其引用设为 null(如 obj = null),帮助 GC 识别垃圾。
    • 避免全局变量滥用(全局变量的引用一直存在,不会被 GC 回收)。
    • 及时清除事件绑定、定时器(如 clearTimeout),避免闭包导致的内存泄漏。

40. ES6 中的箭头函数与普通函数有哪些区别?

核心区别体现在 this 指向、构造函数、参数对象、原型、语法 5 个方面:

  1. 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
      
  2. 能否作为构造函数:

    • 普通函数:可以作为构造函数,用 new 关键字创建实例(new 会绑定 this 为实例对象)。
    • 箭头函数:不能作为构造函数,用 new 调用会报错(箭头函数无 prototype 属性,也无 this 绑定)。
    • 示例:const Fn = () => {}; new Fn(); // 报错 "Fn is not a constructor"。
  3. 是否有 arguments 对象:

    • 普通函数:内部有 arguments 对象,是类数组,包含函数所有实参。
    • 箭头函数:没有 arguments 对象,若需获取实参,需用“剩余参数(...args)”代替。
    • 示例:
      // 普通函数:用 arguments
      function normalFn() { console.log(arguments[0]); }
      normalFn(10); // 输出 10
      
      // 箭头函数:用剩余参数
      const arrowFn = (...args) => { console.log(args[0]); };
      arrowFn(20); // 输出 20
      
  4. 是否有 prototype 属性:

    • 普通函数:有 prototype 属性,是其创建实例的原型对象。
    • 箭头函数:没有 prototype 属性(无法作为构造函数,无需原型对象)。
    • 示例:console.log(((a) => a).prototype); // undefined。
  5. 语法简洁性:

    • 普通函数:语法固定(function 名() {}),即使只有一行代码也需写完整结构。
    • 箭头函数:支持简写(如单个参数可省略括号,单行返回可省略大括号和 return)。
    • 示例:
      // 完整写法
      const add1 = (a, b) => { return a + b; };
      // 简写(单行返回省略 {} 和 return)
      const add2 = (a, b) => a + b;
      // 单个参数省略 ()
      const double = a => a * 2;
      

41. ES6 中的解构赋值是什么?如何使用?

  1. 概念:解构赋值是 ES6 新增的语法,允许从数组或对象中“提取数据”,并赋值给变量(简化代码,避免重复写 obj.key 或 arr[index])。

  2. 数组解构赋值:

    • 规则:按“数组索引顺序”匹配变量和值,变量用 [] 包裹。
    • 常用场景:
      1. 基本解构:let [a, b, c] = [1, 2, 3]; // a=1, b=2, c=3。
      2. 跳过元素:用空位置跳过不需要的元素,let [a, , c] = [1, 2, 3]; // a=1, c=3。
      3. 设置默认值:当解构的值为 undefined 时,使用默认值,let [a = 0, b] = [undefined, 2]; // a=0, b=2。
      4. 解构剩余元素:用 ... 接收剩余元素(必须放在最后),let [a, ...rest] = [1, 2, 3]; // a=1, rest=[2,3]。
  3. 对象解构赋值:

    • 规则:按“属性名”匹配变量和值,变量用 {} 包裹(变量名需与属性名一致,若要改名需用 : 新名)。
    • 常用场景:
      1. 基本解构:let { name, age } = { name: "Tom", age: 20 }; // name="Tom", age=20。
      2. 变量改名:let { name: userName, age } = { name: "Tom", age: 20 }; // userName="Tom"。
      3. 设置默认值:let { name, age = 18 } = { name: "Tom" }; // age=18。
      4. 解构剩余属性:let { name, ...rest } = { name: "Tom", age:20, gender:"male" }; // rest={age:20, gender:"male"}。
      5. 嵌套解构:解构嵌套对象,let { address: { city } } = { name: "Tom", address: { city: "Beijing" } }; // city="Beijing"。
  4. 实际应用(函数参数解构):

    • 函数参数可直接用解构赋值,简化参数获取(尤其参数是对象时)。
    • 示例:
      // 传统写法:需手动获取参数属性
      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 类:

  1. 数组扩展:

    • 复制数组:避免引用类型赋值的问题(浅拷贝表层元素)。
      • 示例: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。
  2. 对象扩展(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}。
  3. 字符串扩展:

    • 将字符串展开为单个字符组成的数组。
    • 示例:const str = "abc"; const arr = [...str]; // arr=['a','b','c']。
  4. 函数参数(剩余参数):

    • 与扩展运算符语法相同,但作用相反:将“多个函数实参”收集为“一个数组”(必须放在参数列表最后)。
    • 示例:
      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(无重复值的集合)

  1. 概念:Set 是“无序的、不包含重复值”的集合(值可以是任意类型,包括基本类型和引用类型)。
  2. 常用属性和方法:
    • size:返回 Set 中元素的个数(类似数组的 length)。
    • add(value):添加元素,返回 Set 本身(支持链式调用)。
    • delete(value):删除指定元素,返回布尔值(true 表示删除成功,false 表示元素不存在)。
    • has(value):判断 Set 中是否包含指定元素,返回布尔值。
    • clear():清空 Set 中所有元素,无返回值。
    • forEach((value, key, set) => {}):遍历 Set(value 和 key 相同,因 Set 无键名)。
  3. 核心用途:数组去重(利用 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(键值对集合)

  1. 概念:Map 是“有序的键值对集合”,与传统对象的区别是:
    • 传统对象的键只能是“字符串”或“Symbol”;
    • Map 的键可以是“任意类型”(包括基本类型、对象、函数等)。
  2. 常用属性和方法:
    • size:返回 Map 中键值对的个数。
    • set(key, value):添加键值对,返回 Map 本身(支持链式调用)。
    • get(key):获取指定键对应的值,若键不存在返回 undefined。
    • delete(key):删除指定键值对,返回布尔值。
    • has(key):判断 Map 中是否包含指定键,返回布尔值。
    • clear():清空 Map 中所有键值对,无返回值。
    • forEach((value, key, map) => {}):遍历 Map(回调参数为 value、key、map 本身)。
  3. 示例:
    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 指向;核心区别 是参数传递方式和函数执行时机。

  1. 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"
      
  2. 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(求数组最大值)
      
  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)
      
  4. 核心区别总结:

    方法参数传递方式执行时机返回值
    call逐个传递实参立即执行函数执行结果
    apply数组/类数组传递实参立即执行函数执行结果
    bind逐个传递实参延迟执行绑定 this 的新函数

45. 如何实现数组去重?请列举至少 3 种方法并说明优缺点。

数组去重是面试高频题,核心思路是“筛选出不重复的元素”,常用方法有 4 种:

方法 1:利用 Set 数据结构(ES6 推荐)

  1. 原理:Set 特性是“不包含重复值”,将数组转为 Set 后,再转回数组。
  2. 实现代码:
    function uniqueArr(arr) {
      // 方式 1:扩展运算符 + Set
      return [...new Set(arr)];
      // 方式 2:Array.from + Set
      // return Array.from(new Set(arr));
    }
    
  3. 优点:语法最简洁,一行代码实现,性能高效(Set 底层用哈希表实现,查找速度快)。
  4. 缺点:
    • 无法区分 NaN(Set 认为 NaN === NaN,会去重;但 JS 中 NaN !== NaN)。
    • 无法处理引用类型(如 [{id:1}, {id:1}],Set 认为是不同对象,无法去重)。

方法 2:利用 filter + indexOf

  1. 原理:indexOf(item) 返回数组中“第一个 item 的索引”;filter 筛选出“索引等于 indexOf(item) 的元素”(即仅保留第一个出现的元素)。
  2. 实现代码:
    function uniqueArr(arr) {
      return arr.filter((item, index) => {
        // 若当前元素的索引 === 第一个出现的索引,说明是第一次出现,保留
        return arr.indexOf(item) === index;
      });
    }
    
  3. 优点:无需依赖 ES6 特性,兼容性好(支持 IE8+)。
  4. 缺点:
    • 性能较差:indexOf 会遍历数组,filter 也会遍历数组,时间复杂度为 O(n²)(n 为数组长度)。
    • 无法区分 NaN:indexOf(NaN) 始终返回 -1,会过滤掉所有 NaN。

方法 3:利用 for 循环 + 对象哈希表

  1. 原理:用对象的“键名唯一性”存储元素(键名存元素值,键值存布尔值),遍历数组时判断元素是否已在对象中,若不存在则保留并添加到对象。
  2. 实现代码:
    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;
    }
    
  3. 优点:性能高效,仅遍历一次数组,时间复杂度为 O(n);可区分基本类型的类型差异(如 1 和 “1”)。
  4. 缺点:
    • 需手动处理类型判断(否则 1 和 “1” 会被视为相同元素)。
    • 无法处理引用类型(如 {id:1} 作为键名会转为 "[object Object]",导致误判)。

方法 4:利用 reduce + includes

  1. 原理:reduce 累加器遍历数组,includes 判断当前元素是否已在累加结果中,若不存在则添加到结果。
  2. 实现代码:
    function uniqueArr(arr) {
      return arr.reduce((result, item) => {
        // 若结果中没有当前元素,则添加
        return result.includes(item) ? result : [...result, item];
      }, []);
    }
    
  3. 优点:代码简洁,逻辑清晰(利用 reduce 实现累加,includes 判断存在性)。
  4. 缺点:
    • 性能较差:includes 会遍历结果数组,时间复杂度为 O(n²)。
    • 无法区分 NaN:includes(NaN) 可识别 NaN(与 indexOf 不同),但仍无法处理引用类型。

46. 什么是深拷贝和浅拷贝?两者的区别是什么?如何实现深拷贝?

  1. 概念与区别:

    • 浅拷贝(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(修改深拷贝的引用属性,不影响原对象)
      
  2. 浅拷贝实现方法(4 种):

    • 数组:[...arr]、arr.slice()、arr.concat()。
    • 对象:{...obj}、Object.assign({}, obj)。
  3. 深拷贝实现方法(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 库)。

47. 什么是 JS 的执行上下文和执行栈?请举例说明。

  1. 执行上下文(Execution Context):

    • 概念:JS 代码执行时的“环境容器”,包含当前代码的变量、函数、this 等信息(JS 引擎通过执行上下文管理代码执行)。
    • 分类(3 种):
      1. 全局执行上下文(Global Execution Context):
        • 全局代码(不在任何函数内的代码)执行时创建,整个页面生命周期内仅存在一个。
        • 浏览器环境中,全局执行上下文会创建 window 对象,this 指向 window;同时将全局变量和函数作为 window 的属性和方法。
      2. 函数执行上下文(Function Execution Context):
        • 函数被调用时创建(每次调用函数都会创建一个新的函数执行上下文,即使是同一函数)。
        • 包含函数的参数、局部变量、this 指向等信息。
      3. eval 执行上下文(Eval Execution Context):
        • eval 函数内的代码执行时创建,因 eval 安全性低、性能差,实际开发中极少使用。
  2. 执行栈(Execution Stack):

    • 概念:又称“调用栈”,是 JS 引擎用于管理执行上下文的“栈结构”(遵循“先进后出”原则)。
    • 工作流程:
      1. 代码开始执行时,先创建全局执行上下文,压入执行栈。
      2. 当调用函数时,创建该函数的执行上下文,压入执行栈顶部。
      3. 函数执行完成后,其执行上下文从执行栈顶部弹出,释放内存。
      4. 所有代码执行完成后,执行栈中仅剩余全局执行上下文,页面关闭时全局执行上下文弹出。
  3. 示例(执行栈流程):

    // 全局代码
    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 的执行上下文并压栈
    
    • 执行栈流程步骤:
      1. 全局代码执行,全局执行上下文压栈(栈:[全局])。
      2. 调用 a(),a 执行上下文压栈(栈:[全局, a]),执行 a 内部代码,输出 “a 执行”。
      3. a 内部调用 b(),b 执行上下文压栈(栈:[全局, a, b]),执行 b 内部代码,输出 “b 执行”。
      4. b 内部调用 c(),c 执行上下文压栈(栈:[全局, a, b, c]),执行 c 内部代码,输出 “c 执行”。
      5. c 执行完成,c 执行上下文弹出(栈:[全局, a, b])。
      6. b 执行完成,b 执行上下文弹出(栈:[全局, a])。
      7. a 执行完成,a 执行上下文弹出(栈:[全局])。
      8. 所有代码执行完成,页面关闭时全局执行上下文弹出(栈:[])。

48. 什么是防抖(Debounce)和节流(Throttle)?两者的区别是什么?如何实现?

防抖和节流是 JS 中用于“控制高频事件触发频率”的优化方案(如滚动、输入、点击等高频事件),避免函数频繁执行导致性能问题。

一、防抖(Debounce)

  1. 概念:高频事件触发后,延迟 n 秒再执行函数;若 n 秒内事件再次触发,则重新计时(仅执行最后一次触发后的函数)。
    核心逻辑:“等待事件停止触发一段时间后,再执行一次”,适用于“需等待用户操作结束后再响应”的场景(如输入框搜索联想、窗口大小调整)。

  2. 实现思路:

    • 用定时器(setTimeout)延迟执行目标函数。
    • 每次事件触发时,先清除之前的定时器(clearTimeout),再重新设置新定时器。
    • 可选“立即执行”版本(首次触发时立即执行,后续触发需等待延迟)。
  3. 基础实现代码(非立即执行版):

    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));
    
  4. 立即执行版(首次触发立即执行,后续需等待):

    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)

  1. 概念:高频事件触发时,每隔 n 秒仅执行一次函数(无论事件触发多少次,n 秒内只执行一次)。
    核心逻辑:“控制函数执行频率,固定时间间隔内必执行一次”,适用于“需持续响应但避免过度执行”的场景(如滚动加载数据、鼠标移动绘制)。

  2. 实现思路(两种常用方案):

    • 时间戳方案:记录上次执行时间,每次事件触发时判断“当前时间 - 上次执行时间 ≥ 延迟”,若满足则执行函数并更新上次时间。
    • 定时器方案:设置定时器,函数执行后清除定时器并重新设置,确保 n 秒内仅执行一次。
  3. 时间戳方案实现(立即执行):

    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));
    
  4. 定时器方案实现(延迟执行):

    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. 什么是跨域?跨域的原因是什么?如何解决跨域问题?

一、概念与跨域原因

  1. 跨域:指浏览器中“当前页面的域名”与“请求目标资源的域名”不一致(包括协议、域名、端口任一不同),导致请求被浏览器拦截的现象。
    例如:http://localhost:3000(前端页面)请求 https://api.example.com(后端接口),因协议(http/https)和域名(localhost/example.com)不同,属于跨域。

  2. 跨域的本质:浏览器的“同源策略(Same-Origin Policy)”限制。
    同源策略是浏览器的安全机制,规定“非同源的页面不能访问对方的资源”,目的是防止恶意网站窃取用户数据(如 Cookie、LocalStorage)。
    同源定义:协议(http/https)、域名(example.com)、端口(80/443)三者完全相同。

二、常见跨域场景

前端页面 URL请求目标 URL跨域原因
http://a.comhttps://a.com协议不同(http/https)
http://a.comhttp://b.com域名不同(a.com/b.com)
http://a.com:80http://a.com:3000端口不同(80/3000)
http://a.comhttp://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 默认规范)

  1. 核心语法:

    • 导出模块:用 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"
      
  2. 核心特性:

    • 同步加载: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 均支持)

  1. 核心语法:
    • 导出模块:分 具名导出(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(); // "默认导出的函数"
      

更多推荐