邵山欢JavaScript笔记:核心知识点与代码案例汇总

作者:代码拾荒

时间:2026-11-17

浏览:625

邵山欢JavaScript核心笔记精粹,系统整理执行上下文、作用域与闭包、原型链与继承体系、this调用机制及核心手写实战代码案例。

文章目录

一、预解析、执行上下文与作用域链底层机制

很多开发者在学习 JavaScript 时,经常把变量提升、函数提升与作用域混为一谈。邵山欢老师在讲解这部分机制时,强调必须站在 JavaScript 引擎的底层运转周期来看待:代码在执行前必须经历“语法预解析阶段”与“运行时创建执行上下文阶段”。

1. 预解析(Hoisting)的三大铁律

在 JavaScript 引擎正式执行任何代码前,会优先开辟词法环境并检索当前作用域内的声明语句,其解析规则如下:

  • 变量声明提升:使用 var 声明的变量,在预解析期仅提升变量名到当前作用域顶部,其默认初值为 undefined,赋值操作停留在原代码位置。
  • 函数声明优先:使用标准 function foo() {} 声明的函数,在预解析期整个函数体均被提升。
  • 重名覆盖冲突:若变量名与函数名同名,预解析阶段函数声明会覆盖变量声明;但当代码执行至变量赋值语句时,变量的值会覆写该标识符。

2. 执行上下文(Execution Context)与活动对象(AO)

当函数被调用的一瞬间,JavaScript 引擎会将其推入执行环境栈(Execution Context Stack, ECS),并经历两个关键生命周期阶段:

  1. 创建阶段:为函数创建执行上下文(EC),建立活动对象(Activation Object, AO)。首先将函数的形参填入 AO,并由传入的实际参数(arguments)对形参完成赋值;随后将局部变量和内部函数声明填入 AO;最后确定运行时的 this 初始指向。
  2. 执行阶段:引擎按顺序逐行执行函数内部的代码指令,动态更新 AO 中各属性的值并执行相关逻辑运算。函数执行完毕后,执行上下文从栈顶弹出。

3. 词法作用域与作用域链推导

JavaScript 采用词法作用域(静态作用域),函数的作用域链早在“声明创建”的那一刻就已经被静态锁定在内部属性 [[Scope]] 中,而不是在调用时决定。当函数被激活执行时,其完整作用域链由当前自身的活动对象(AO)加上所有外层函数的活动对象直至全局对象(Global Object, GO)串联而成。变量的查找严格遵循从链条顶端向底端单向检索。

邵山欢JavaScript笔记:核心知识点与代码案例汇总
图1:JavaScript 执行上下文生命周期与作用域链推导流程

4. 闭包(Closure)本质与内存管理

闭包是 JavaScript 最强大的特性之一。在垃圾回收(Garbage Collection)机制中,如果一个外层函数执行完毕,其对应的 AO 通常会被释放;但如果其内部声明的函数被返回或赋值到了外部,导致内部函数的作用域链依然引用着外层函数的 AO,垃圾回收器就无法回收该 AO。这种即使外部函数已执行退出,内部函数依然能持久访问并操作外部局部变量的现象,就是闭包。

经典实战:循环事件绑定中的作用域陷阱与闭包方案
在 DOM 节点列表循环绑定点击事件中,使用 var 会导致所有事件处理函数共享同一个外部作用域变量 i。以下为三种标准解法:
// 场景复现与三种闭包修复方式
var lis = document.getElementsByTagName('li');

// 错误写法:点击任何 li 输出的都是 lis.length(循环结束后的最终值)
for (var i = 0; i < lis.length; i++) {
  lis[i].onclick = function () {
    console.log(i); // 共享外层同一个 AO 中的 i
  };
}

// 修复方案一:邵氏经典 IIFE 立即执行函数生成独立闭包上下文
for (var i = 0; i < lis.length; i++) {
  (function (index) {
    lis[index].onclick = function () {
      console.log('方案一点击下标:', index); // 捕获当前 IIFE 作用域内的形参 index
    };
  })(i);
}

// 修复方案二:闭包工厂函数返回事件处理句柄
function createClickAction(index) {
  return function () {
    console.log('方案二点击下标:', index);
  };
}
for (var i = 0; i < lis.length; i++) {
  lis[i].onclick = createClickAction(i);
}

// 修复方案三:ES6 块级作用域 let(底层本质是每次迭代生成独立词法环境)
for (let i = 0; i < lis.length; i++) {
  lis[i].onclick = function () {
    console.log('方案三点击下标:', i);
  };
}
案例 1.2:模块化私有状态管理(闭包安全封装)
闭包不仅用于解决异步变量捕获,还广泛应用于构建私有变量与沙箱封装:
// 私有状态计数器与存取器封装
function createSafeCounter(initialValue) {
  // 私有变量:外部无法直接通过 obj.count 篡改
  var _count = typeof initialValue === 'number' ? initialValue : 0;
  var _history = [];

  function record(action) {
    _history.push({ time: Date.now(), action: action, val: _count });
  }

  return {
    increment: function (step) {
      step = step || 1;
      _count += step;
      record('increment');
      return _count;
    },
    decrement: function (step) {
      step = step || 1;
      _count -= step;
      record('decrement');
      return _count;
    },
    getValue: function () {
      return _count;
    },
    getHistory: function () {
      // 返回只读浅拷贝,防止外部直接 push 污染内部私有记录
      return _history.slice();
    },
    destroy: function () {
      // 显式解绑内部引用,辅助 GC 回收闭包内存
      _history = null;
    }
  };
}

var counter = createSafeCounter(10);
console.log(counter.increment(5)); // 输出 15
console.log(counter.getValue());       // 输出 15
console.log(counter._count);          // 输出 undefined(外部无法穿透访问)

二、面向对象与原型链底层拓扑架构

在面向对象模型上,JavaScript 并没有像 Java 或 C++ 那样的“基于类的继承体系”,而是基于纯粹的原型委托机制(Prototypal Inheritance)。理解原型链的核心,在于搞清楚构造函数、原型对象(prototype)与实例隐式原型(__proto__)的拓扑关系。

1. 原型三要素的铁律关系

  • 所有函数都有 prototype 属性:在声明任何函数时,JS 引擎都会为其自动创建原型对象 Function.prototype,该对象默认具有一个 constructor 属性,反向指向该构造函数本身。
  • 所有普通对象都有 __proto__ 属性:使用 new 运算符创建实例时,新对象的内部隐式原型 __proto__ 会自动链接到构造函数的 prototype。
  • 原型链查找终点:Object.prototype.__proto__ 为 null,这是所有对象原型查找的最顶层哨兵。
邵山欢JavaScript笔记:核心知识点与代码案例汇总
图2:构造函数、原型对象与实例的原型链拓扑架构

2. 继承模式的演进与最优寄生组合继承

邵山欢老师的 JavaScript 进阶课中,将面向对象继承归纳为四个发展阶段:

  1. 原型链继承:Child.prototype = new Parent()。缺陷在于父类的引用类型属性会被所有子类实例公用,且无法向父类构造函数传参。
  2. 借用构造函数继承:在子类构造函数中执行 Parent.call(this, args)。解决了传参和引用共享问题,但无法继承父类原型上的公共方法。
  3. 组合继承:结合前两者,但缺点是父类构造函数被执行了两次,造成内存冗余。
  4. 寄生组合式继承(规范推荐):使用干净的空原型对象或者 Object.create 桥接父类原型,既实现方法共享与私有属性隔离,又避免重复调用父构造函数。
// 工业级标准:寄生组合式继承完整手写实现
function inheritPrototype(Child, Parent) {
  // 1. 创建父类原型的一个干净浅拷贝副本(切断直接赋值的原型污染)
  var prototype = Object.create ? Object.create(Parent.prototype) : (function (superProto) {
    function F() {}
    F.prototype = superProto;
    return new F();
  })(Parent.prototype);

  // 2. 修复原型上的 constructor 指针,使其正确指向子类
  prototype.constructor = Child;

  // 3. 将新原型赋给子类
  Child.prototype = prototype;
}

// ===== 定义父类 =====
function Person(name, age) {
  this.name = name;
  this.age = age;
  this.hobbies = ['coding', 'reading'];
}
Person.prototype.sayHi = function () {
  return '你好,我是 ' + this.name;
};

// ===== 定义子类 =====
function Student(name, age, score) {
  // 核心步骤一:借用构造函数继承,私有属性隔离并可传参
  Person.call(this, name, age);
  this.score = score;
}

// 核心步骤二:通过寄生式方法建立原型链链接
inheritPrototype(Student, Person);

// 核心步骤三:在原型上扩展子类独有的方法
Student.prototype.showScore = function () {
  return this.name + ' 的期末考分数为: ' + this.score;
};

// 实例化验证
var s1 = new Student('邵同学', 20, 98);
var s2 = new Student('王同学', 21, 85);

s1.hobbies.push('basketball');
console.log(s1.hobbies); // ['coding', 'reading', 'basketball']
console.log(s2.hobbies); // ['coding', 'reading'](互不干扰,私有安全)
console.log(s1.sayHi()); // 成功调用父类原型方法: "你好,我是 邵同学"
console.log(s1 instanceof Student); // true
console.log(s1 instanceof Person);  // true
console.log(s1.constructor === Student); // true(指针修复无误)

三、函数调用模式与 this 绑定的精准判定

在 JavaScript 中,this 的指向并不是在函数定义时静态确定的,而是在函数被真正调用的那一瞬间,根据其具体的调用语法结构动态绑定的。牢记邵山欢老师经典的“调用模式口诀”,可以瞬间看透任何复杂的 this 迷惑代码。

1. 四大基础调用模式分析

  • 普通函数调用模式:即形如 fn() 的独立调用。非严格模式下指向全局对象(浏览器环境为 window,Node 环境为 global);严格模式('use strict')下指向 undefined。
  • 对象方法调用模式:即形如 obj.method() 或 a.b.c.method()。此时 this 严格指向紧挨着圆括号左侧最近的那个调用主体对象。
  • 构造器(new)调用模式:即形如 new Person()。JavaScript 引擎会在内部创建一个全新对象,将其原型关联至构造函数的原型,并将内部的 this 绑定到该新对象,若构造函数无显式返回引用对象,则自动返回此 this。
  • 上下文(显式)绑定模式:通过 call、apply、bind 强制将 this 绑定到第一个参数所指定的对象上。
邵山欢JavaScript笔记:核心知识点与代码案例汇总
图3:JavaScript this指向判定决策树与模式对照

2. 核心手写实战:模拟 call、apply 与 bind 底层原理

为了彻底理解上下文绑定的原理,面试与进阶必备的考核点就是手写实现 call 和 bind:

// 手写模拟 Function.prototype.myCall
Function.prototype.myCall = function (context) {
  // 1. 若传入 null 或 undefined,在非严格模式下降级为 window/global
  context = (context !== null && context !== undefined) ? Object(context) : (typeof window !== 'undefined' ? window : global);

  // 2. 使用 Symbol 生成唯一临时属性,避免覆盖宿主对象原有属性
  var fnKey = Symbol('fnKey');
  context[fnKey] = this; // 这里的 this 即为当前需要被调用的函数本身

  // 3. 截取从下标 1 开始的所有后续实参
  var args = [];
  for (var i = 1; i < arguments.length; i++) {
    args.push(arguments[i]);
  }

  // 4. 利用对象方法调用模式(context.fnKey()),自然把 this 绑定给 context
  var result = context[fnKey](...args);

  // 5. 清理现场,删除临时属性
  delete context[fnKey];
  return result;
};

// 手写模拟 Function.prototype.myBind
// 要求:支持柯里化传参,且当返回的高阶函数被 new 实例化时,原本绑定的 context 失效,指向新创建的实例
Function.prototype.myBind = function (context) {
  if (typeof this !== 'function') {
    throw new TypeError('Function.prototype.bind - 被绑定的对象必须是可执行函数');
  }

  var targetFn = this;
  // 获取 bind 时预置的初始参数
  var bindArgs = Array.prototype.slice.call(arguments, 1);

  function boundFunction() {
    // 获取调用返回函数时传入的增量参数
    var callArgs = Array.prototype.slice.call(arguments);
    var finalArgs = bindArgs.concat(callArgs);

    // 核心判定:如果被 new 运算符调用,则内部的 this 会是指向 boundFunction 的新实例
    var isNewCall = this instanceof boundFunction;
    var actualThis = isNewCall ? this : context;

    return targetFn.apply(actualThis, finalArgs);
  }

  // 维护原型关系,保证 new boundFunction() 能正确继承原函数的原型链
  if (this.prototype) {
    function Temp() {}
    Temp.prototype = this.prototype;
    boundFunction.prototype = new Temp();
  }

  return boundFunction;
};

// 验证测试
var person = { name: '小明' };
function greet(prefix, suffix) {
  return prefix + ' ' + this.name + ' ' + suffix;
}

console.log(greet.myCall(person, 'Hello,', '!')); // "Hello, 小明 !"
var boundGreet = greet.myBind(person, '尊敬的');
console.log(boundGreet('先生')); // "尊敬的 小明 先生"

四、经典手写案例与工程化实战封装

邵山欢老师的 JavaScript 体系之所以广受推崇,很大程度得益于其教学中极具实战性的“轮子演练”。从早期的 DOM 缓动动画封装,到现代前端架构常用的深度克隆、事件总线与流控函数,这些代码是打通 JS 运行时的试金石。

1. 经典原生 Tween 缓动动画框架封装

在没有 CSS3 动画的年代,所有复杂的页面交互均依赖 JavaScript 基于时间差与步长公式进行连续绘制。经典的缓动动画公式根据当前时间占比,计算出当前属性帧的具体数值:

/**
 * 邵氏经典多属性缓动动画引擎封装
 * @param {HTMLElement} elem - 目标运动 DOM 节点
 * @param {Object} targetObj - 目标属性终值集合,例如 { left: 500, top: 300, opacity: 0.8 }
 * @param {number} time - 动画总执行毫秒数
 * @param {string} easeType - 缓动类型,默认 'Linear'
 * @param {Function} callback - 动画完成后的回调函数
 */
function animate(elem, targetObj, time, easeType, callback) {
  // 经典缓动算子库
  var Tween = {
    Linear: function (t, b, c, d) { return c * t / d + b; },
    EaseIn: function (t, b, c, d) { return c * (t /= d) * t + b; },
    EaseOut: function (t, b, c, d) { return -c * (t /= d) * (t - 2) + b; },
    EaseInOut: function (t, b, c, d) {
      if ((t /= d / 2) < 1) return c / 2 * t * t + b;
      return -c / 2 * ((--t) * (t - 2) - 1) + b;
    }
  };

  var easeFormula = Tween[easeType] || Tween.Linear;
  var interval = 20; // 动画帧间隔 (ms)
  var maxFrames = Math.ceil(time / interval);
  var currentFrame = 0;

  // 提取初始状态和变化差值
  var startObj = {};
  var deltaObj = {};

  for (var k in targetObj) {
    if (k === 'opacity') {
      startObj[k] = parseFloat(window.getComputedStyle(elem, null)[k]) || 1;
    } else {
      startObj[k] = parseFloat(window.getComputedStyle(elem, null)[k]) || 0;
    }
    deltaObj[k] = targetObj[k] - startObj[k];
  }

  // 清除节点可能正在进行的动画计时器,避免叠加冲突
  if (elem.__timer) clearInterval(elem.__timer);

  elem.__timer = setInterval(function () {
    currentFrame++;

    for (var prop in targetObj) {
      // 使用 Tween 缓动算子计算当前步长值
      var currentVal = easeFormula(currentFrame, startObj[prop], deltaObj[prop], maxFrames);

      if (prop === 'opacity') {
        elem.style.opacity = currentVal;
        elem.style.filter = 'alpha(opacity=' + (currentVal * 100) + ')';
      } else {
        elem.style[prop] = currentVal + 'px';
      }
    }

    // 终止条件判断
    if (currentFrame >= maxFrames) {
      clearInterval(elem.__timer);
      elem.__timer = null;
      // 强行修正至目标属性,抵消浮点数累加误差
      for (var finalProp in targetObj) {
        elem.style[finalProp] = finalProp === 'opacity' ? targetObj[finalProp] : targetObj[finalProp] + 'px';
      }
      if (typeof callback === 'function') {
        callback.call(elem);
      }
    }
  }, interval);
}

2. 工业级安全深拷贝(Deep Clone)

常规的 JSON.parse(JSON.stringify(obj)) 在实际生产中存在严重缺陷:无法复制函数、忽略 undefined、正则变空对象、时间戳变字符串,且遇到循环引用(Circular Reference)时会直接抛出 Uncaught TypeError: Converting circular structure to JSON。以下为采用 WeakMap 破解循环引用的标准实现:

/**
 * 完整工业级深拷贝实现
 * 支持对象、数组、Date、RegExp 及循环引用安全处理
 */
function deepClone(target, hash) {
  // 1. 原始基础类型与函数直接返回
  if (target === null || typeof target !== 'object') {
    return target;
  }

  // 2. 处理特殊内置引用对象
  if (target instanceof Date) return new Date(target);
  if (target instanceof RegExp) return new RegExp(target.source, target.flags);

  // 3. 使用 WeakMap 记录已拷贝对象,防范环状循环引用造成的死循环
  hash = hash || new WeakMap();
  if (hash.has(target)) {
    return hash.get(target);
  }

  // 4. 保持原型链一致(支持普通 Object 与自定义类实例)
  var cloneTarget = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
  hash.set(target, cloneTarget);

  // 5. 遍历自有属性(包含 Symbol 键)
  var symKeys = Object.getOwnPropertySymbols(target);
  if (symKeys.length > 0) {
    symKeys.forEach(function (sym) {
      cloneTarget[sym] = deepClone(target[sym], hash);
    });
  }

  for (var key in target) {
    if (Object.prototype.hasOwnProperty.call(target, key)) {
      cloneTarget[key] = deepClone(target[key], hash);
    }
  }

  return cloneTarget;
}

// 验证循环引用安全性
var a = { name: '循环测试' };
a.self = a; // 循环引用
var clonedA = deepClone(a);
console.log(clonedA !== a);          // true(克隆成功)
console.log(clonedA.self === clonedA); // true(自引关系正确保留,无栈溢出)

3. 发布-订阅模式(EventEmitter)完整封装

发布-订阅模式是前端架构中解耦组件通信的核心设计模式。它包含订阅注册(on)、触发广播(emit)、注销解绑(off)以及单次监听(once):

class EventEmitter {
  constructor() {
    // 采用对象字典维护事件管道中心
    this._events = Object.create(null);
  }

  on(eventName, callback) {
    if (typeof callback !== 'function') {
      throw new TypeError('事件回调必须是函数');
    }
    if (!this._events[eventName]) {
      this._events[eventName] = [];
    }
    this._events[eventName].push(callback);
    return this; // 支持链式调用
  }

  emit(eventName, ...args) {
    if (!this._events[eventName] || this._events[eventName].length === 0) {
      return false;
    }
    // 浅拷贝当前监听器数组,避免在执行期间回调内部调用 off 导致数组下移跳跃
    const listeners = this._events[eventName].slice();
    listeners.forEach((fn) => {
      try {
        fn.apply(this, args);
      } catch (err) {
        console.error(`事件 [${eventName}] 回调执行异常:`, err);
      }
    });
    return true;
  }

  off(eventName, callback) {
    if (!this._events[eventName]) return this;

    // 若未指定 callback,则清除该事件下的所有监听
    if (!callback) {
      this._events[eventName] = null;
      delete this._events[eventName];
      return this;
    }

    this._events[eventName] = this._events[eventName].filter((fn) => {
      return fn !== callback && fn.__rawCallback !== callback;
    });

    if (this._events[eventName].length === 0) {
      delete this._events[eventName];
    }
    return this;
  }

  once(eventName, callback) {
    const onceWrapper = (...args) => {
      this.off(eventName, onceWrapper);
      callback.apply(this, args);
    };
    // 保存原函数引用,便于用户在触发前通过 off(eventName, callback) 取消
    onceWrapper.__rawCallback = callback;
    this.on(eventName, onceWrapper);
    return this;
  }
}

// 验证测试
const bus = new EventEmitter();
const handleLogin = (user) => console.log('欢迎登录:', user);

bus.on('login', handleLogin);
bus.once('login', () => console.log('初次欢迎弹窗(仅显示一次)'));

bus.emit('login', '邵老师');
// 输出: "欢迎登录: 邵老师" 和 "初次欢迎弹窗(仅显示一次)"

bus.emit('login', '张同学');
// 仅输出: "欢迎登录: 张同学"

4. 高频防抖(Debounce)与节流(Throttle)

在处理窗口缩放(resize)、页面滚动(scroll)以及输入框搜索联想(input)等高频交互时,防抖与节流是保障渲染流畅与网络节流的必备手段:

// 1. 防抖函数(Debounce):高频触发在规定等待时间后仅执行最后一次
function debounce(fn, wait, immediate) {
  var timer = null;

  return function () {
    var context = this;
    var args = arguments;

    if (timer) clearTimeout(timer);

    if (immediate) {
      var callNow = !timer;
      timer = setTimeout(function () {
        timer = null;
      }, wait);
      if (callNow) fn.apply(context, args);
    } else {
      timer = setTimeout(function () {
        fn.apply(context, args);
      }, wait);
    }
  };
}

// 2. 节流函数(Throttle):在指定时间周期内无论触发多少次,保证仅执行一次
function throttle(fn, interval) {
  var lastTime = 0;
  var timer = null;

  return function () {
    var context = this;
    var args = arguments;
    var now = Date.now();

    var remaining = interval - (now - lastTime);

    if (remaining <= 0) {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
      lastTime = now;
      fn.apply(context, args);
    } else if (!timer) {
      timer = setTimeout(function () {
        lastTime = Date.now();
        timer = null;
        fn.apply(context, args);
      }, remaining);
    }
  };
}
邵山欢JavaScript笔记:核心知识点与代码案例汇总
图4:邵山欢 JavaScript 核心知识体系与实战封装全景矩阵

五、核心复盘与开发排查避坑清单

为了帮助开发者在实际开发和排查问题时快速定位根因,下表归纳总结了本文涉及的核心知识点与典型陷阱对照:

知识维度 底层运作原理 生产环境高频隐蔽 Bug 推荐最佳解决策略
预解析与作用域 函数声明优先提升;词法作用域在声明时静态确立。 条件分支语句中使用非标准函数声明造成不同浏览器兼容差异;异步回调中共享循环 var 变量。 使用 let/const 替代 var;复杂循环使用 IIFE 或工厂函数隔离词法环境。
闭包与内存泄露 内层函数持有外层活动对象 AO,阻断垃圾回收。 长期驻留的单例或 DOM 引用未释放,导致大量无用数据驻留内存。 不再使用时显式将外部变量置 null;事件解绑时同步清理私有引用。
原型与面向对象 通过 __proto__ 链逐级向上委托查找,终点为 Object.prototype.__proto__ === null。 直接修改 Child.prototype = Parent.prototype 导致子类方法污染父类原型。 严格采用寄生组合式继承(Object.create 隔离原型),并显式重置 constructor。
this 绑定指向 运行时调用模式决定归属:独立调用、方法调用、构造器、显式绑定、箭头函数。 把对象方法作为参数传入 setTimeout 或 Promise 回调导致 this 丢失漂移到 window。 使用箭头函数捕获词法作用域,或在传参前通过 bind(this) 进行硬绑定。
工程通用手写库 事件总线、深拷贝、缓动动画与流控(防抖节流)。 深拷贝遇到对象循环引用引发栈溢出;防抖未处理即时响应或 this 传参丢失。 使用 WeakMap 跟踪已拷贝对象拓扑;防抖节流函数内部严格维持 fn.apply(this, args)。

实用工具推荐

电子包浆

绿化、压缩、噪点和虚拟水印,自由调节做旧程度。

使用 ›
图片压缩

选择画质和输出格式,预览压缩前后的大小。

使用 ›
相关文章