邵山欢JavaScript核心笔记精粹,系统整理执行上下文、作用域与闭包、原型链与继承体系、this调用机制及核心手写实战代码案例。
邵山欢JavaScript笔记:核心知识点与代码案例汇总
时间:2026-11-17
浏览:625
文章目录
一、预解析、执行上下文与作用域链底层机制
很多开发者在学习 JavaScript 时,经常把变量提升、函数提升与作用域混为一谈。邵山欢老师在讲解这部分机制时,强调必须站在 JavaScript 引擎的底层运转周期来看待:代码在执行前必须经历“语法预解析阶段”与“运行时创建执行上下文阶段”。
1. 预解析(Hoisting)的三大铁律
在 JavaScript 引擎正式执行任何代码前,会优先开辟词法环境并检索当前作用域内的声明语句,其解析规则如下:
- 变量声明提升:使用
var声明的变量,在预解析期仅提升变量名到当前作用域顶部,其默认初值为undefined,赋值操作停留在原代码位置。 - 函数声明优先:使用标准
function foo() {}声明的函数,在预解析期整个函数体均被提升。 - 重名覆盖冲突:若变量名与函数名同名,预解析阶段函数声明会覆盖变量声明;但当代码执行至变量赋值语句时,变量的值会覆写该标识符。
2. 执行上下文(Execution Context)与活动对象(AO)
当函数被调用的一瞬间,JavaScript 引擎会将其推入执行环境栈(Execution Context Stack, ECS),并经历两个关键生命周期阶段:
- 创建阶段:为函数创建执行上下文(EC),建立活动对象(Activation Object, AO)。首先将函数的形参填入 AO,并由传入的实际参数(
arguments)对形参完成赋值;随后将局部变量和内部函数声明填入 AO;最后确定运行时的this初始指向。 - 执行阶段:引擎按顺序逐行执行函数内部的代码指令,动态更新 AO 中各属性的值并执行相关逻辑运算。函数执行完毕后,执行上下文从栈顶弹出。
3. 词法作用域与作用域链推导
JavaScript 采用词法作用域(静态作用域),函数的作用域链早在“声明创建”的那一刻就已经被静态锁定在内部属性 [[Scope]] 中,而不是在调用时决定。当函数被激活执行时,其完整作用域链由当前自身的活动对象(AO)加上所有外层函数的活动对象直至全局对象(Global Object, GO)串联而成。变量的查找严格遵循从链条顶端向底端单向检索。
4. 闭包(Closure)本质与内存管理
闭包是 JavaScript 最强大的特性之一。在垃圾回收(Garbage Collection)机制中,如果一个外层函数执行完毕,其对应的 AO 通常会被释放;但如果其内部声明的函数被返回或赋值到了外部,导致内部函数的作用域链依然引用着外层函数的 AO,垃圾回收器就无法回收该 AO。这种即使外部函数已执行退出,内部函数依然能持久访问并操作外部局部变量的现象,就是闭包。
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);
};
}
// 私有状态计数器与存取器封装
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,这是所有对象原型查找的最顶层哨兵。
2. 继承模式的演进与最优寄生组合继承
邵山欢老师的 JavaScript 进阶课中,将面向对象继承归纳为四个发展阶段:
- 原型链继承:
Child.prototype = new Parent()。缺陷在于父类的引用类型属性会被所有子类实例公用,且无法向父类构造函数传参。 - 借用构造函数继承:在子类构造函数中执行
Parent.call(this, args)。解决了传参和引用共享问题,但无法继承父类原型上的公共方法。 - 组合继承:结合前两者,但缺点是父类构造函数被执行了两次,造成内存冗余。
- 寄生组合式继承(规范推荐):使用干净的空原型对象或者
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绑定到第一个参数所指定的对象上。
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);
}
};
}
五、核心复盘与开发排查避坑清单
为了帮助开发者在实际开发和排查问题时快速定位根因,下表归纳总结了本文涉及的核心知识点与典型陷阱对照:
| 知识维度 | 底层运作原理 | 生产环境高频隐蔽 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)。 |
实用工具推荐
绿化、压缩、噪点和虚拟水印,自由调节做旧程度。
选择画质和输出格式,预览压缩前后的大小。