1. 項目概述從“new”到“工廠”JS實例化的深度探索在JavaScript的世界里“實例化”這個詞聽起來有點學(xué)術(shù)但說白了就是“造東西”。我們寫代碼本質(zhì)上是在定義藍圖類或構(gòu)造函數(shù)而實例化就是拿著這張藍圖在內(nèi)存里實實在在地蓋出一棟房子對象。這個過程是面向?qū)ο缶幊痰幕彩俏覀內(nèi)粘ｉ_發(fā)中無時無刻不在進行的操作。從最簡單的new Object()到復(fù)雜的工廠模式、單例模式再到ES6的class每一種實例化方式背后都藏著不同的設(shè)計考量、性能特性和適用場景。很多開發(fā)者尤其是剛?cè)腴T的同學(xué)可能覺得會用new關(guān)鍵字就夠了。但當(dāng)你開始構(gòu)建更復(fù)雜的應(yīng)用需要考慮代碼的可維護性、可測試性、性能優(yōu)化時你會發(fā)現(xiàn)不同的“造物”方式帶來的結(jié)果天差地別。比如為什么有的庫推薦用工廠函數(shù)而不是newObject.create()和new有什么區(qū)別如何在不同的場景下選擇最合適的實例化方式這些問題直接關(guān)系到你代碼的健壯性和優(yōu)雅度。這篇文章我將結(jié)合自己十多年的前端開發(fā)經(jīng)驗為你徹底拆解JavaScript中各種實例化方式。我們不會停留在語法表面而是深入到內(nèi)存、原型鏈、設(shè)計模式的層面去理解每一種方式的“為什么”。無論你是想夯實基礎(chǔ)的新手還是希望優(yōu)化現(xiàn)有架構(gòu)的老手相信都能從中獲得實用的“干貨”。2. 核心概念與原理理解“藍圖”與“房子”的關(guān)系在深入各種實例化方式之前我們必須先統(tǒng)一幾個核心概念。這就像蓋房子前得先搞清楚圖紙、施工隊和成品之間的關(guān)系。2.1 構(gòu)造函數(shù)負責(zé)施工的“施工隊”在ES6的class語法出現(xiàn)之前構(gòu)造函數(shù)是JavaScript創(chuàng)建對象類型的主要方式。它本質(zhì)上就是一個普通的函數(shù)但約定俗成構(gòu)造函數(shù)的名字首字母大寫。function Person(name, age) { this.name name; this.age age; this.sayHello function() { console.log(Hello, Im ${this.name}); }; }這里Person就是一個構(gòu)造函數(shù)。當(dāng)你用new關(guān)鍵字調(diào)用它時它就扮演了“施工隊”的角色。new操作符會做四件關(guān)鍵事情創(chuàng)建一個全新的空對象。將這個新對象的內(nèi)部[[Prototype]]即__proto__鏈接到構(gòu)造函數(shù)的prototype對象。這是實現(xiàn)繼承的關(guān)鍵。將構(gòu)造函數(shù)內(nèi)部的this綁定到這個新創(chuàng)建的對象。執(zhí)行構(gòu)造函數(shù)內(nèi)部的代碼為這個新對象添加屬性。如果構(gòu)造函數(shù)沒有顯式返回一個對象則自動返回這個新創(chuàng)建的對象。理解這五步尤其是第二步是理解JavaScript原型繼承和實例化本質(zhì)的核心。2.2 原型Prototype共享的“標準配件庫”每個函數(shù)都有一個prototype屬性箭頭函數(shù)除外。當(dāng)這個函數(shù)被用作構(gòu)造函數(shù)時它的prototype屬性所指向的對象就成為了所有通過該構(gòu)造函數(shù)創(chuàng)建的實例的“原型”。Person.prototype.species Homo sapiens; Person.prototype.introduce function() { console.log(I am a ${this.species}. My name is ${this.name}.); }; const alice new Person(Alice, 30); const bob new Person(Bob, 25); console.log(alice.species); // 輸出Homo sapiens console.log(bob.species); // 輸出Homo sapiens console.log(alice.introduce bob.introduce); // 輸出true注意species和introduce并不是直接存在于alice或bob對象上而是存在于它們的原型Person.prototype上。當(dāng)訪問一個對象的屬性時JavaScript引擎會先查找對象本身如果沒有則沿著原型鏈向上查找。這種方式實現(xiàn)了方法的共享避免了每個實例都創(chuàng)建一份相同的函數(shù)節(jié)省了內(nèi)存。2.3 實例最終建好的“房子”通過new操作符調(diào)用構(gòu)造函數(shù)后得到的結(jié)果就是一個實例。它是根據(jù)“藍圖”構(gòu)造函數(shù)原型建造出來的、擁有獨立狀態(tài)屬性的個體。const alice new Person(Alice, 30); // alice 是一個實例 console.log(alice instanceof Person); // 輸出trueinstanceof操作符就是用來檢查一個對象是否是某個構(gòu)造函數(shù)的實例其原理就是檢查對象的原型鏈上是否存在該構(gòu)造函數(shù)的prototype屬性。注意一個常見的誤區(qū)是在構(gòu)造函數(shù)內(nèi)部定義方法。如上例中的this.sayHello這會導(dǎo)致每個實例都擁有一個獨立的sayHello函數(shù)副本造成不必要的內(nèi)存消耗。最佳實踐是將方法定義在構(gòu)造函數(shù)的prototype上。3. 主流實例化方式深度解析掌握了基本原理我們來看看JavaScript中幾種主流的“造物”方式。它們各有優(yōu)劣適用于不同的場景。3.1 經(jīng)典方式new 操作符這是最傳統(tǒng)、最廣為人知的方式?；菊Z法與流程function Car(model, year) { this.model model; this.year year; } Car.prototype.drive function() { console.log(Vroom!); }; const myCar new Car(Tesla Model 3, 2023); myCar.drive(); // 輸出Vroom!內(nèi)部機制再探我們模擬一下new操作符的行為這能讓你理解得更透徹function myNew(constructorFn, ...args) { // 1. 創(chuàng)建一個新對象并將其原型指向構(gòu)造函數(shù)的prototype const obj Object.create(constructorFn.prototype); // 2. 執(zhí)行構(gòu)造函數(shù)并將this綁定到新對象 const result constructorFn.apply(obj, args); // 3. 如果構(gòu)造函數(shù)返回了一個對象則返回該對象否則返回新創(chuàng)建的對象 return result instanceof Object ? result : obj; } const myCar2 myNew(Car, BMW i4, 2024); console.log(myCar2 instanceof Car); // 輸出true console.log(myCar2.model); // 輸出BMW i4優(yōu)點語法直觀符合傳統(tǒng)面向?qū)ο笳Z言的習(xí)慣。能清晰地建立原型鏈關(guān)系便于使用instanceof進行類型檢查。社區(qū)接受度最高文檔和資料最豐富。缺點與坑點忘記寫new如果調(diào)用構(gòu)造函數(shù)時忘了寫new那么函數(shù)內(nèi)部的this在非嚴格模式下會指向全局對象如window造成屬性泄露和難以調(diào)試的錯誤。const badCar Car(Toyota, 2020); // 糟糕沒有new console.log(window.model); // 輸出Toyota 污染了全局 console.log(badCar); // 輸出undefined規(guī)避方法在構(gòu)造函數(shù)內(nèi)部使用new.targetES6或判斷this是否為構(gòu)造函數(shù)實例來強制使用new。function SafeCar(model) { if (!new.target) { throw new Error(SafeCar must be called with new); } this.model model; }構(gòu)造函數(shù)有返回值如果構(gòu)造函數(shù)顯式返回了一個對象那么new表達式的結(jié)果將是這個返回的對象而不是新創(chuàng)建的那個this對象。這可能會破壞原型鏈。function WeirdCar() { this.name BMW; return { name: Audi }; // 返回一個新對象 } const car new WeirdCar(); console.log(car.name); // 輸出Audi console.log(car instanceof WeirdCar); // 輸出false 原型鏈斷了3.2 工廠函數(shù)模式更靈活的“制造車間”工廠函數(shù)不依賴于new關(guān)鍵字它只是一個返回新對象的普通函數(shù)?；灸Ｊ絝unction createPerson(name, age) { const obj {}; obj.name name; obj.age age; obj.greet function() { console.log(Hi, Im ${name}); }; // 可以在這里進行一些私有計算或初始化 const secretId Math.random().toString(36).substr(2); obj.getId function() { return secretId; }; // 閉包實現(xiàn)私有變量 return obj; } const person1 createPerson(Charlie, 28); const person2 createPerson(Diana, 35); person1.greet(); // 輸出Hi, Im Charlie console.log(person1.getId()); // 輸出一個隨機ID console.log(person1 instanceof createPerson); // 輸出false進階帶原型的工廠函數(shù)為了復(fù)用方法工廠函數(shù)也可以結(jié)合原型const personMethods { greet() { console.log(Hi, Im ${this.name}); }, introduce() { console.log(Im ${this.age} years old.); } }; function createPerson(name, age) { const obj Object.create(personMethods); // 關(guān)鍵設(shè)置原型 obj.name name; obj.age age; return obj; } const p createPerson(Eve, 40); p.greet(); // 方法來自原型 console.log(personMethods.isPrototypeOf(p)); // 輸出true優(yōu)點無需new完全避免了忘記寫new導(dǎo)致的錯誤。封裝性更強可以輕松地通過閉包創(chuàng)建真正的私有變量如上例中的secretId這是class的私有字段#出現(xiàn)前最常用的實現(xiàn)私有性的方式。更靈活的控制你可以在函數(shù)內(nèi)部進行復(fù)雜的邏輯判斷決定返回哪種對象甚至返回緩存的對象實現(xiàn)類似單例的效果。解耦使用者完全不需要關(guān)心對象是如何被構(gòu)造出來的只需要調(diào)用工廠函數(shù)。缺點無法使用instanceof返回的對象與工廠函數(shù)本身沒有原型鏈關(guān)系因此instanceof操作符失效。類型判斷需要依賴其他方式比如“鴨子類型”檢查是否有某個方法或自定義標簽屬性。內(nèi)存效率可能稍低如果每個對象的方法都是獨立的不使用共享原型會占用更多內(nèi)存。但通過上述結(jié)合Object.create的方式可以避免。適用場景當(dāng)你需要創(chuàng)建過程復(fù)雜、需要封裝私有狀態(tài)、或者不想強制使用者使用new關(guān)鍵字時工廠函數(shù)是絕佳選擇。許多現(xiàn)代JavaScript庫如Redux的API設(shè)計都傾向于使用工廠函數(shù)。3.3 Object.create()直接指定原型的“精準克隆”O(jiān)bject.create()方法創(chuàng)建一個新對象并使用現(xiàn)有的對象來提供新創(chuàng)建的對象的__proto__。它是直接操作原型鏈的底層工具?；居梅╟onst prototypeObj { greet() { console.log(Hello from prototype!); } }; const myObj Object.create(prototypeObj); myObj.name My Object; myObj.greet(); // 輸出Hello from prototype! console.log(prototypeObj.isPrototypeOf(myObj)); // 輸出true模擬“純凈”的繼承這是實現(xiàn)原型式繼承Prototypal Inheritance最純粹的方式不涉及任何構(gòu)造函數(shù)。const animal { init(name) { // 一個初始化方法類似構(gòu)造函數(shù) this.name name; return this; }, eat() { console.log(${this.name} is eating.); } }; const dog Object.create(animal); dog.bark function() { console.log(Woof!); }; const myDog Object.create(dog).init(Buddy); myDog.eat(); // 輸出Buddy is eating. myDog.bark(); // 輸出Woof! console.log(animal.isPrototypeOf(myDog)); // 輸出true (通過dog)與new的區(qū)別new Constructor()創(chuàng)建對象 → 鏈接到Constructor.prototype→ 執(zhí)行Constructor初始化。Object.create(proto)創(chuàng)建對象 → 鏈接到proto。初始化需要額外步驟。優(yōu)點極其靈活可以基于任何對象創(chuàng)建新對象實現(xiàn)非常動態(tài)的原型鏈。是new的基石正如我們在myNew模擬中看到的Object.create是構(gòu)建new行為的基礎(chǔ)。適合創(chuàng)建“純凈”的數(shù)據(jù)對象當(dāng)你想創(chuàng)建一個沒有原型null的純粹數(shù)據(jù)字典時Object.create(null)是唯一選擇這樣可以避免與Object.prototype上的屬性如toString,hasOwnProperty發(fā)生沖突。const pureDict Object.create(null); pureDict.key value; console.log(pureDict.toString); // 輸出undefined缺點初始化不便沒有自動的初始化過程構(gòu)造函數(shù)需要手動調(diào)用初始化方法或設(shè)置屬性。語法相對不直觀對于習(xí)慣了類式繼承的開發(fā)者來說直接操作原型鏈可能顯得抽象。3.4 ES6 Class 語法糖更優(yōu)雅的“施工藍圖”ES6引入的class語法本質(zhì)上是構(gòu)造函數(shù)和原型繼承的語法糖但它提供了更清晰、更接近傳統(tǒng)面向?qū)ο笳Z言的寫法?；菊Z法class Rectangle { constructor(height, width) { this.height height; this.width width; this._privateCache null; // 約定俗成的“私有”屬性非真正私有 } // Getter get area() { return this.height * this.width; } // 實例方法實際上存在于 Rectangle.prototype 上 calcArea() { return this.area; } // 靜態(tài)方法存在于 Rectangle 本身上 static describe() { return I am a rectangle class.; } } const square new Rectangle(10, 10); console.log(square.area); // 輸出100 (通過getter訪問) console.log(square.calcArea()); // 輸出100 console.log(Rectangle.describe()); // 輸出I am a rectangle class. console.log(square instanceof Rectangle); // 輸出true底層原理class聲明的Rectangle本質(zhì)上仍然是一個函數(shù)構(gòu)造函數(shù)constructor里的代碼就是原來構(gòu)造函數(shù)的函數(shù)體類中定義的方法都掛在Rectangle.prototype上。static方法則掛在Rectangle函數(shù)對象本身上。真正的私有字段ES2022class Counter { #count 0; // 真正的私有字段以#開頭 increment() { this.#count; console.log(this.#count); } // 無法從外部訪問 #count } const c new Counter(); c.increment(); // 輸出1 // console.log(c.#count); // SyntaxError: Private field #count must be declared in an enclosing class優(yōu)點語法簡潔清晰將構(gòu)造函數(shù)、原型方法、靜態(tài)方法、繼承等集中在一個聲明里結(jié)構(gòu)一目了然。內(nèi)置new檢查必須使用new調(diào)用否則直接報錯避免了傳統(tǒng)構(gòu)造函數(shù)的陷阱。支持繼承的super關(guān)鍵字使繼承的寫法更加直觀。真正的私有字段ES2022提供了語言級別的封裝支持。缺點依然是原型繼承需要理解其本質(zhì)否則容易產(chǎn)生誤解比如認為class帶來了全新的繼承機制。兼容性雖然現(xiàn)代瀏覽器和Node.js都已支持但在一些非常老的環(huán)境如舊版IE中需要轉(zhuǎn)譯。實操心得對于大多數(shù)新的項目class是首選。它既保留了JavaScript原型鏈的靈活性又提供了更友好的語法。但在編寫庫或框架時有時為了更極致的控制如工廠模式的靈活性或兼容性仍會采用傳統(tǒng)的構(gòu)造函數(shù)或工廠函數(shù)。4. 高級模式與場景化應(yīng)用掌握了基礎(chǔ)方式我們來看看在一些特定場景和高級模式中如何組合運用這些實例化技術(shù)。4.1 單例模式確保全局唯一的“實例”單例模式確保一個類只有一個實例并提供一個全局訪問點。在前端常用于全局狀態(tài)管理如Vuex Store、Redux Store、對話框管理器、日志服務(wù)等。實現(xiàn)方式1利用模塊作用域推薦這是最簡潔、最符合ES6模塊規(guī)范的方式。// Logger.js class Logger { constructor() { this.logs []; } log(message) { const entry [${new Date().toISOString()}] ${message}; this.logs.push(entry); console.log(entry); } getHistory() { return [...this.logs]; } } // 關(guān)鍵在模塊頂層創(chuàng)建并導(dǎo)出唯一實例 const loggerInstance new Logger(); export default loggerInstance; // 在其他文件中使用 // import logger from ./Logger.js; // logger.log(App started);這種方式利用了ES6模塊的“單例”特性一個模塊只會被加載和執(zhí)行一次因此loggerInstance只會被創(chuàng)建一次。實現(xiàn)方式2構(gòu)造函數(shù)內(nèi)判斷class Singleton { constructor() { // 如果實例已存在則返回該實例 if (Singleton.instance) { return Singleton.instance; } // 否則進行初始化 this.data {}; Singleton.instance this; // 確保構(gòu)造函數(shù)總是返回這個唯一實例 return this; } } const s1 new Singleton(); const s2 new Singleton(); console.log(s1 s2); // 輸出true注意這種方式有一個潛在問題。如果使用者忘記了用new雖然class會報錯或者通過Object.create(Singleton.prototype)等方式創(chuàng)建對象就會破壞單例。因此模塊作用域的實現(xiàn)更健壯。4.2 對象池模式管理“實例”的生命周期以提升性能在需要頻繁創(chuàng)建和銷毀大量相似對象的場景如游戲中的子彈、粒子效果DOM操作中的節(jié)點對象池可以顯著提升性能。其核心思想是預(yù)先創(chuàng)建一組對象池使用時從池中取出用完后不銷毀而是放回池中供下次復(fù)用。簡易對象池實現(xiàn)class ObjectPool { constructor(createFn, resetFn, initialSize 10) { this.createFn createFn; // 創(chuàng)建新對象的函數(shù) this.resetFn resetFn; // 重置對象狀態(tài)的函數(shù) this.pool []; // 初始化對象池 for (let i 0; i initialSize; i) { this.pool.push(this.createFn()); } } acquire() { // 如果池中有空閑對象則取出并重置 if (this.pool.length 0) { const obj this.pool.pop(); this.resetFn(obj); return obj; } // 否則創(chuàng)建新對象池已耗盡 console.warn(Object pool exhausted, creating new instance.); return this.createFn(); } release(obj) { // 將對象放回池中 this.pool.push(obj); } get size() { return this.pool.length; } } // 使用示例管理一個簡單的向量對象池 const vectorPool new ObjectPool( () ({ x: 0, y: 0 }), // 創(chuàng)建函數(shù) (vec) { vec.x 0; vec.y 0; } // 重置函數(shù) ); const v1 vectorPool.acquire(); v1.x 5; v1.y 10; console.log(Using vector: (${v1.x}, ${v1.y})); // ... 使用v1進行一些計算 ... vectorPool.release(v1); // 用完后放回池中 console.log(Pool size after release: ${vectorPool.size}); // 池大小恢復(fù) const v2 vectorPool.acquire(); console.log(Reacquired vector: (${v2.x}, ${v2.y})); // 輸出(0, 0) 已被重置性能考量對象池避免了頻繁的垃圾回收GC對于性能敏感的應(yīng)用至關(guān)重要。但要注意池的大小需要根據(jù)實際需求調(diào)整太小會導(dǎo)致頻繁創(chuàng)建新對象太大則會占用過多初始內(nèi)存。4.3 依賴注入與可測試性松耦合的“實例”創(chuàng)建在大型應(yīng)用中直接在一個模塊內(nèi)部使用new來創(chuàng)建依賴對象會導(dǎo)致代碼高度耦合難以測試。依賴注入Dependency Injection, DI是一種將對象的創(chuàng)建與其使用分離的設(shè)計模式。問題代碼緊耦合// UserService.js (難以測試) class UserService { constructor() { this.db new DatabaseConnection(localhost, 3306, myapp); // 直接創(chuàng)建依賴 } getUser(id) { return this.db.query(SELECT * FROM users WHERE id ${id}); } } // 測試UserService時必須連接真實數(shù)據(jù)庫改進依賴注入構(gòu)造函數(shù)注入// UserService.js (可測試) class UserService { constructor(databaseConnection) { // 依賴通過參數(shù)傳入 this.db databaseConnection; } getUser(id) { return this.db.query(SELECT * FROM users WHERE id ${id}); } } // 在生產(chǎn)環(huán)境中 const prodDb new DatabaseConnection(prod-host, 3306, myapp); const userService new UserService(prodDb); // 在測試環(huán)境中 class MockDatabase { query(sql) { console.log(Mock query: ${sql}); return { id: 1, name: Test User }; } } const mockDb new MockDatabase(); const testUserService new UserService(mockDb); // 輕松注入模擬對象 const user testUserService.getUser(1); // 不會觸及真實數(shù)據(jù)庫工廠函數(shù)與依賴注入的結(jié)合我們可以創(chuàng)建一個工廠函數(shù)來集中管理這些依賴的創(chuàng)建和組裝。// container.js (簡單的依賴注入容器) const dependencies {}; export function register(key, factoryFn) { dependencies[key] factoryFn; } export function resolve(key) { if (dependencies[key]) { return dependencies[key](); } throw new Error(Dependency ${key} not registered.); } // 注冊依賴 register(database, () new DatabaseConnection(localhost, 3306, myapp)); register(userService, () { const db resolve(database); return new UserService(db); }); // 在應(yīng)用入口 import { resolve } from ./container.js; const userService resolve(userService);這種方式將對象的創(chuàng)建邏輯集中管理使核心業(yè)務(wù)代碼如UserService更加純凈和可測試。許多前端框架如Angular、NestJS內(nèi)置了強大的依賴注入容器。5. 性能優(yōu)化、內(nèi)存管理與常見陷阱不同的實例化方式對性能和內(nèi)存的影響不同了解這些細節(jié)有助于你寫出更高效的代碼。5.1 內(nèi)存占用分析在構(gòu)造函數(shù)內(nèi)定義方法每個實例都會擁有一份獨立的函數(shù)副本。function HeavyObject() { this.method function() { /* ... */ }; // 每個實例都創(chuàng)建新函數(shù) } const arr []; for (let i 0; i 10000; i) arr.push(new HeavyObject()); // 內(nèi)存占用高因為有一萬個不同的method函數(shù)在原型上定義方法所有實例共享同一個函數(shù)引用。function LightObject() {} LightObject.prototype.method function() { /* ... */ }; // 所有實例共享 const arr []; for (let i 0; i 10000; i) arr.push(new LightObject()); // 內(nèi)存占用低一萬個實例共享一個method函數(shù)結(jié)論對于需要大量創(chuàng)建的同類型對象務(wù)必將方法定義在原型上。這是JavaScript性能優(yōu)化中最基本也最重要的一條原則。5.2 實例化速度微基準測試雖然大多數(shù)情況下差異不大但在極端性能敏感的場景如每秒創(chuàng)建數(shù)萬個對象選擇更快的實例化方式可能有意義。// 簡單測試三種方式的創(chuàng)建速度 function TestClass() { this.value 1; } TestClass.prototype.method function() {}; function testFactory() { return { value: 1, method: function() {} }; } const proto { method: function() {} }; function testObjectCreate() { const obj Object.create(proto); obj.value 1; return obj; } function runTest(name, fn, iterations 1000000) { console.time(name); for (let i 0; i iterations; i) { fn(); } console.timeEnd(name); } runTest(new with class, () new TestClass()); runTest(factory, testFactory); runTest(Object.create, testObjectCreate);在我的測試環(huán)境中Chrome瀏覽器通常new和工廠函數(shù)速度接近Object.create可能會稍慢一點因為多了一次原型鏈接的設(shè)置。但絕對不要過早優(yōu)化除非性能分析工具明確顯示對象創(chuàng)建是瓶頸。代碼的清晰度和可維護性永遠應(yīng)該放在第一位。5.3 原型鏈污染與屬性屏蔽這是一個高級但重要的概念。當(dāng)通過實例訪問一個屬性時如果實例自身沒有就會去原型鏈上找。但如果給實例設(shè)置一個與原型鏈上同名的屬性就會發(fā)生“屬性屏蔽”。const proto { value: 10 }; const obj Object.create(proto); console.log(obj.value); // 輸出10 (來自原型) obj.value 20; // 在obj自身上創(chuàng)建屬性value屏蔽了原型上的value console.log(obj.value); // 輸出20 (來自自身) console.log(proto.value); // 輸出10 (原型未變) delete obj.value; // 刪除自身屬性 console.log(obj.value); // 輸出10 (再次來自原型)注意事項在修改對象屬性時要清楚你修改的是自身屬性還是原型屬性。無意中屏蔽原型屬性可能導(dǎo)致難以察覺的bug。可以使用Object.hasOwn(obj, prop)來檢查屬性是否直接存在于對象自身。5.4 循環(huán)引用與內(nèi)存泄漏雖然現(xiàn)代垃圾回收機制GC很強大但不當(dāng)?shù)囊萌詴?dǎo)致內(nèi)存泄漏尤其是在單頁應(yīng)用SPA和Node.js長期運行的服務(wù)中。典型場景事件監(jiān)聽器class Component { constructor(element) { this.element element; this.handleClick this.handleClick.bind(this); this.element.addEventListener(click, this.handleClick); } handleClick() { console.log(Clicked, this); } destroy() { // 忘記移除監(jiān)聽器會導(dǎo)致內(nèi)存泄漏 // this.element.removeEventListener(click, this.handleClick); } } const div document.createElement(div); const comp new Component(div); // 即使comp不再被使用因為div還持有對comp.handleClick的引用 // comp無法被GC回收div本身也因被comp引用而無法回收。 comp null; // 僅僅這樣是不夠的解決方案在實例需要被銷毀時如組件卸載必須手動清理對外部資源的引用如移除事件監(jiān)聽器、清除定時器、斷開WebSocket連接等。這就是為什么在React的useEffect或Vue的beforeUnmount等生命周期鉤子中清理副作用如此重要。6. 現(xiàn)代框架中的實例化實踐看看主流框架是如何運用這些實例化概念的能幫助我們更好地理解其設(shè)計哲學(xué)。6.1 React函數(shù)組件與HooksReact推崇函數(shù)式編程其函數(shù)組件本質(zhì)上就是一個返回React元素描述UI的對象的工廠函數(shù)。// 函數(shù)組件一個創(chuàng)建UI描述的工廠 function Welcome(props) { // 每次渲染都會調(diào)用這個函數(shù)生成新的React元素 return h1Hello, {props.name}/h1; } // 使用Welcome nameSara /useState,useEffect等Hooks可以看作是React在背后為每個組件實例維護了一個“記憶單元格”鏈表將狀態(tài)與特定的組件函數(shù)調(diào)用關(guān)聯(lián)起來。雖然組件函數(shù)本身被多次調(diào)用但Hooks機制保證了狀態(tài)的持續(xù)性。6.2 Vue響應(yīng)式代理與工廠Vue 3的reactive()和ref()函數(shù)是創(chuàng)建響應(yīng)式對象的工廠函數(shù)。import { reactive, ref } from vue; // reactive 工廠函數(shù)創(chuàng)建一個響應(yīng)式代理對象 const state reactive({ count: 0 }); // ref 工廠函數(shù)創(chuàng)建一個包裝了值的響應(yīng)式引用對象 const message ref(Hello); // 在組合式API中setup()函數(shù)類似于一個為組件實例創(chuàng)建響應(yīng)式上下文的工廠 export default { setup() { const state reactive({ /* ... */ }); const double computed(() state.count * 2); // computed也是工廠函數(shù) return { state, double }; // 返回的對象被暴露給模板 } }Vue的響應(yīng)式系統(tǒng)基于Proxyreactive()工廠函數(shù)創(chuàng)建了一個代理對象攔截所有g(shù)et/set操作從而實現(xiàn)依賴追蹤和觸發(fā)更新。6.3 框架共性與啟示無論是React的函數(shù)組件還是Vue的組合式API現(xiàn)代前端框架都在弱化傳統(tǒng)的new和class盡管Vue選項式API和React Class組件仍支持轉(zhuǎn)而擁抱工廠函數(shù)和函數(shù)式編程的理念。這帶來了以下好處更好的可測試性純函數(shù)或工廠函數(shù)沒有內(nèi)部狀態(tài)依賴更容易測試。更靈活的代碼組織邏輯可以更容易地被抽取和復(fù)用如自定義Hooks、Composables。更小的打包體積Tree-shaking對函數(shù)比對類更友好。7. 實戰(zhàn)構(gòu)建一個可配置的日志器工廠最后我們綜合運用所學(xué)構(gòu)建一個實用的、可配置的日志器工廠。它將支持不同日志級別、可定制的輸出格式、以及可插拔的日志存儲后端如控制臺、本地存儲、遠程服務(wù)器。// 1. 定義日志級別常量 const LogLevel { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, NONE: 4 }; // 2. 定義存儲后端接口抽象 class LogStorage { write(level, message, meta) { throw new Error(Method write must be implemented by subclasses.); } } // 3. 實現(xiàn)具體的存儲后端 class ConsoleStorage extends LogStorage { write(level, message, meta) { const prefix [${new Date().toISOString()}] [${level.toUpperCase()}]; const logFn console[level] || console.log; logFn(prefix, message, meta || ); } } class LocalStorageStorage extends LogStorage { constructor(key app_logs, maxEntries 100) { super(); this.key key; this.maxEntries maxEntries; } write(level, message, meta) { const entry { timestamp: Date.now(), level, message, meta }; const logs JSON.parse(localStorage.getItem(this.key) || []); logs.push(entry); // 保持日志數(shù)量不超過最大值 if (logs.length this.maxEntries) { logs.splice(0, logs.length - this.maxEntries); } localStorage.setItem(this.key, JSON.stringify(logs)); } } // 4. 核心日志器工廠函數(shù) function createLogger(options {}) { const { level LogLevel.INFO, storage new ConsoleStorage(), // 默認使用控制臺 formatter (level, msg, meta) ${level}: ${msg}, // 默認格式化器 enableStackTrace false // 是否記錄調(diào)用棧性能開銷大僅用于調(diào)試 } options; // 私有狀態(tài)和工具函數(shù) const currentLevel level; const logStorage storage; function shouldLog(msgLevel) { return msgLevel currentLevel; } function getStackTrace() { try { throw new Error(); } catch (e) { return e.stack; } } // 創(chuàng)建實際的日志方法 function makeLogMethod(levelName, levelValue) { return function(message, meta) { if (!shouldLog(levelValue)) return; const finalMeta { ...meta }; if (enableStackTrace levelValue LogLevel.ERROR) { finalMeta.stackTrace getStackTrace(); } const formattedMessage formatter(levelName, message, finalMeta); try { logStorage.write(levelName, formattedMessage, finalMeta); } catch (err) { // 防止日志記錄本身出錯導(dǎo)致應(yīng)用崩潰 console.error(Logger failed:, err); } }; } // 返回日志器實例 return { debug: makeLogMethod(DEBUG, LogLevel.DEBUG), info: makeLogMethod(INFO, LogLevel.INFO), warn: makeLogMethod(WARN, LogLevel.WARN), error: makeLogMethod(ERROR, LogLevel.ERROR), // 可以動態(tài)修改配置 setLevel(newLevel) { if (Object.values(LogLevel).includes(newLevel)) { currentLevel newLevel; } }, // 添加新的存儲后端 addStorage(newStorage) { // 可以組合多個存儲后端這里簡單覆蓋 logStorage newStorage; } }; } // 5. 使用示例 // 創(chuàng)建一個開發(fā)環(huán)境日志器 const devLogger createLogger({ level: LogLevel.DEBUG, storage: new ConsoleStorage(), enableStackTrace: true }); // 創(chuàng)建一個生產(chǎn)環(huán)境日志器只記錄WARN和ERROR const prodLogger createLogger({ level: LogLevel.WARN, storage: new LocalStorageStorage(prod_logs, 500) }); // 使用 devLogger.info(Application started, { version: 1.0.0 }); devLogger.debug(User clicked button, { buttonId: submit }); try { // 模擬一個錯誤 throw new Error(Network request failed); } catch (err) { prodLogger.error(Operation failed, { error: err.message, code: 500 }); } // 6. 擴展創(chuàng)建一個單例的全局日志器結(jié)合模塊模式 // globalLogger.js const globalLogger createLogger({ level: process.env.NODE_ENV production ? LogLevel.WARN : LogLevel.DEBUG, storage: process.env.NODE_ENV production ? new LocalStorageStorage() : new ConsoleStorage() }); export default globalLogger;這個實戰(zhàn)案例展示了如何將工廠函數(shù)、組合模式、策略模式不同的存儲后端和單例模式結(jié)合起來創(chuàng)建一個靈活、健壯、可維護的工具。它避免了使用new和class帶來的繼承復(fù)雜性通過函數(shù)組合和配置化提供了強大的擴展能力。你可以輕松地添加新的存儲后端如發(fā)送到服務(wù)器或者改變?nèi)罩靖袷蕉鵁o需修改核心日志邏輯。這正是現(xiàn)代JavaScript庫設(shè)計所推崇的“組合優(yōu)于繼承”和“關(guān)注點分離”原則的體現(xiàn)。