JavaScript 對象創建：new 操作符全解析

引言

在 JavaScript 中，new 操作符是實現面向對象編程的??核心機制??之一。本文將從原理層面對 new 操作符進行深度剖析，探討其工作機制、內部實現和實際應用場景。無論您是 JavaScript 初學者還是資深開發者，都能從本文獲得以下知識和技能：

理解 new 操作符的??底層執行原理??
掌握手動模擬 new 操作符的??完整實現方案??
學會處理構造函數中的??返回值邊界情況??
理解原型鏈繼承的??核心工作機制??
避免常見 new 操作符??陷阱與反模式??
深入認識 class 語法糖的本質
掌握高級應用場景下的性能優化策略

讓我們共同踏上這場對 JavaScript 對象創建機制的探索之旅！

文章大綱

new 操作符基本概念
- 對象創建的兩種方式
- 構造函數定義與約定
new 操作符執行原理
- 內部執行步驟詳解
- 內存模型圖解
- 原型鏈構建過程
手動實現 new 操作符
- 分步實現方案
- 邊界條件處理
- 完整參考實現
構造函數返回值處理
- 基本類型返回值
- 對象類型返回值
- ES6類中的特殊行為
原型繼承機制解析
- prototype 作用
- 原型鏈查找圖解
- Object.create 底層實現
new 操作符的現代實踐
- ES6類與構造函數對比
- 工廠函數替代方案
- 性能優化策略
常見陷阱與最佳實踐
- 遺漏 new 的解決方案
- 原型污染風險
- 類變量共享問題
總結與展望

1. `new` 操作符基本概念

1.1 對象創建的兩種方式

JavaScript 提供了兩種對象創建方式：

// 字面量語法（Literal Syntax）
const person = {name: 'Alice',greet() {console.log(`Hello, I'm ${this.name}`);}
};// 構造函數模式（Constructor Pattern）
function Person(name) {this.name = name;
}
Person.prototype.greet = function() {console.log(`Hello, I'm ${this.name}`);
};const alice = new Person('Alice');

雖然對象字面量語法簡潔高效，但當我們需要創建??多個相似對象??時，使用 new 結合構造函數的方式更符合 DRY（Don’t Repeat Yourself） 原則。

1.2 構造函數的約定

JavaScript 中的構造函數遵循特定約定，便于開發者識別：

??首字母大寫??命名（大駝峰式）
通過 new 操作符調用
使用 this 初始化實例屬性
在原型上定義共享方法

function Animal(species) {// 實例屬性初始化this.species = species;this.isAlive = true;
}// 原型共享方法
Animal.prototype.describe = function() {return `${this.species} is ${this.isAlive ? 'alive' : 'dead'}`;
};const tiger = new Animal('Tiger');

2. `new` 操作符執行原理

2.1 內部執行步驟詳解

當執行 new Constructor(...args) 時，JavaScript 引擎內部按順序執行以下步驟：

??1. 創建一個新對象：?? 在內存中創建一個全新的、空白的普通 JavaScript 對象 ({} 或 new Object() 的結果)。

??2. 鏈接原型鏈：?? 將這個新創建的對象的內部 [[Prototype]] (即 __proto__ 屬性) 指向??構造函數的 prototype 屬性??所指向的對象。這步是關鍵！它建立了新對象和構造函數原型之間的鏈接，使得新對象可以訪問構造函數原型上定義的所有屬性和方法。

3. 綁定 this：?? 將構造函數內部的 this 關鍵字綁定到步驟 1 創建的這個新對象上。這樣在構造函數內部通過 this 添加的屬性或方法，實際上就添加到了這個新對象上。

??4. 執行構造函數：?? 調用構造函數 (Constructor() 函數體開始執行)。構造函數內部的代碼通常使用 this 來初始化新對象的屬性和方法。

?5. 返回新對象：?? 除非構造函數自身返回??另一個對象（非 null 的對象或函數）??，否則 new 表達式會??自動返回步驟 1 創建的那個新對象??。如果構造函數返回了一個非 null 對象（包括數組、函數、自定義對象等），那么這個返回的對象就會替代最初創建的那個對象作為 new 表達式的結果（這種情況下，步驟 1 創建的對象可能就會被垃圾回收）。如果構造函數返回原始值（undefined, null, number, string, boolean, symbol, bigint），返回值會被忽略，步驟 1 創建的對象仍然會被返回。

??關鍵特性：??

??原型繼承:?? new 是 JavaScript 實現基于原型的繼承的核心機制。通過將實例的 [[Prototype]] 鏈接到構造函數的 prototype，實例可以訪問和“繼承”定義在構造函數原型上的屬性和方法。
??隔離狀態：?? 每次調用 new 都會創建一個全新的對象實例。即使多個實例由同一個構造函數創建，它們各自的屬性（在構造函數內部通過 this 添加的屬性）也是相互獨立的。

2.2 內存模型圖解

下列模型展示了 new 操作執行時的對象之間的關系：

原型鏈的對象關系圖

關注點：

每個構造函數通過 prototype 引用原型對象（同樣，原型對象通過 constructor 關聯構造函數，上圖沒有展示）。
prototype 只會出現在構造函數中，非構造器的對象是沒有 prototype 屬性的。
內部屬性 [[Prototype]] 用來鏈接原型對象，形成原型鏈，[[Prototype]] 即 __proto__ 屬性。
Function 的 prototype 和 [[Prototype]] 同時指向 Function.prototype，因為 Function.prototype 定義了所有函數對象的共享屬性與方法。

2.3 原型鏈構建過程

使用 new 操作符時創建的原型鏈關系如下：

當訪問實例屬性時，JavaScript 引擎會沿著原型鏈向上查找：

首先檢查實例自身屬性
若不存在則檢查原型對象
直到找到屬性或到達原型鏈頂端（null）

3. 手動實現 `new` 操作符

3.1 分步實現方案

我們通過 createInstance 函數模擬 new 操作符的行為：

function createInstance(Constructor, ...args) {// Step 1: 創建新對象const obj = {};// Step 2: 連接原型鏈obj.__proto__ = Constructor.prototype;// Step 3: 執行構造函數const result = Constructor.apply(obj, args);// Step 4: 處理返回值return typeof result === 'object' ? result : obj;
}// 使用示例
function Person(name) {this.name = name;
}
const john = createInstance(Person, 'John');
console.log(john.name); // 輸出: John

3.2 邊界條件處理

實際生產環境需要考慮更多邊界情況：

function createInstance(Constructor, ...args) {// 處理非構造函數調用if (typeof Constructor !== 'function') {throw new TypeError(Constructor + ' is not a constructor');}// 創建原型鏈連接的對象（支持ES5+環境）const obj = Object.create(Constructor.prototype);// 執行構造函數const result = Constructor.apply(obj, args);// 判斷返回值類型const isObject = result !== null && typeof result === 'object';const isFunction = typeof result === 'function';return isObject || isFunction ? result : obj;
}

3.3 完整參考實現（兼容現代規范）

考慮構造函數可能返回 Symbol、null 等特殊值：

function createInstance(Constructor, ...args) {if (typeof Constructor !== 'function') {throw new TypeError(`${String(Constructor)} is not a constructor`);}const proto = Constructor.prototype;const obj = Object.create(proto !== null && typeof proto === 'object' ? proto : Object.prototype);const result = Reflect.apply(Constructor, obj, args);// ES規范：構造函數返回非對象時自動返回新對象return result !== null && (typeof result === 'object' || typeof result === 'function')? result : obj;
}

4. 構造函數返回值處理

4.1 返回值類型影響

function Normal() {this.value = 'normal';
}function ReturnPrimitive() {this.value = 'primitive';return 42; // 基本類型返回值
}function ReturnObject() {this.value = 'overridden';return { custom: 'object' };
}console.log(new Normal().value);     // 'normal'
console.log(new ReturnPrimitive());  // 實例對象 { value: 'primitive' }
console.log(new ReturnObject());     // { custom: 'object' } (不是 ReturnObject 實例)

4.2 ES6 類中的特殊行為

ES6 class 語法對返回值有更嚴格的限制：

class StrictClass {constructor() {return 42; // 基本類型會被忽略}
}console.log(new StrictClass() instanceof StrictClass); // trueclass ReturnObjectClass {constructor() {return { custom: 'object' };}
}console.log(new ReturnObjectClass() instanceof ReturnObjectClass); // false

5. 原型繼承機制解析

原型鏈 (Prototype Chain) 是 JavaScript 實現??基于原型的繼承 (Prototypal Inheritance)?? 的核心機制。它讓對象能夠訪問到自身不存在的屬性和方法，沿著一個由對象和原型鏈接而成的鏈條向上查找。理解原型鏈對掌握 JavaScript 的面向對象編程、繼承、屬性和方法查找至關重要。

5.1 核心概念

??[[Prototype]] (__proto__) 屬性：??
- 每一個 JavaScript 對象（包括函數對象，因為函數也是對象）在創建時，都會內置一個叫做 [[Prototype]] 的內部屬性（在 ES5 標準中引入）。這個屬性對外不可直接訪問。
- 為了方便調試和訪問，大多數瀏覽器環境提供了一個非標準但被廣泛實現的屬性 __proto__ 來訪問對象的 [[Prototype]]。
- ??重要：?? [[Prototype]] 指向的是對象的??原型對象??。
??prototype 屬性：??
- ??只有函數對象才擁有 prototype 屬性。??
- 當你使用 new 操作符調用這個函數（作為構造函數）時，新創建對象的 [[Prototype]] (即 __proto__) 會指向該函數的 prototype 屬性所指向的對象。
- Constructor.prototype 本身也是一個對象，它通常被設計用來存放該構造函數創建的??所有實例對象共享的屬性和方法??。
- function Foo() {} 創建的實例 obj = new Foo()，其 obj.__proto__ === Foo.prototype。

5.2 `prototype` 核心作用

??關鍵原則??：構造函數的 prototype 屬性被所有實例共享，這提供了：

方法共享（節省內存）
動態添加方法的能力
繼承機制的實現基礎

5.3 `Object.create` 原理

Object.create() 核心思想就是 ??顯式地創建一個新對象，并設置其內部原型鏈 ([[Prototype]]) 指向我們指定的對象??，而不需要通過構造函數的 new 操作。

核心原理

Object.create(proto[, propertiesObject])

??proto 參數：?? 新創建對象的 [[Prototype]]（即 __proto__）將被設置為 proto。這是唯一必需的參數。
- 如果 proto 是 null，新創建的對象將沒有原型（[[Prototype]] = null），它是一個非常純凈的對象，不會繼承任何屬性和方法（包括 Object.prototype 上的 toString, hasOwnProperty 等）。
- 如果 proto 是一個對象（包括 Object, Array, 自定義構造函數的 prototype 或其他對象），那么新對象的原型鏈就直接指向這個對象。
??propertiesObject 參數 (可選)：?? 一個對象，用來為新創建的對象添加自身的??可枚舉屬性??（就像通過 Object.defineProperties() 添加的一樣）。這些屬性描述符（configurable, enumerable, writable, value, get, set）直接定義在新對象自身上，而不在其原型鏈上。

手動模擬實現 (Polyfill)

理解原理最好的方式之一是手動模擬。在 ES5 之前或在不支持的舊環境中（嚴格來說，__proto__ 是非標準的，但實際可用），我們可以這樣模擬 Object.create 的核心功能（只處理第一個參數 proto）：

if (typeof Object.create !== 'function') {Object.create = function(proto) {// 1. 參數類型檢查 (簡化版，真實實現會更嚴謹)if (typeof proto !== 'object' && typeof proto !== 'function' && proto !== null) {throw new TypeError('Object prototype may only be an Object or null');}// 2. 創建一個空的構造函數function F() {} // 這個函數體是空的，不會執行任何初始化邏輯// 3. **核心操作**：將構造函數的 prototype 指向傳入的 proto 對象F.prototype = proto; // 關鍵步驟：建立原型鏈接的橋梁// 4. 使用 new 操作符創建新對象。根據 new 規則：//    a. 創建一個新對象 {}//    b. 這個新對象的 [[Prototype]] (__proto__) 會被設置為 F.prototype，也就是我們傳入的 `proto`//    c. 執行 F 函數體（空函數，什么也不做）//    d. 返回這個新對象return new F();};
}

關鍵原理分析

??利用構造函數原型鏈機制：?? 這個模擬實現巧妙利用了 new 操作符的第 2 步（鏈接原型鏈）。它通過將空函數 F 的 prototype 屬性設置為目標原型對象 proto，然后 new F() 創建的新對象自然將其 [[Prototype]] 指向了 F.prototype，從而指向了我們指定的 proto。
??與 new 的區別：??
- ??構造函數調用：?? Object.create 本身??不會調用任何構造函數??（模擬中 F 是空的）。它只關心建立原型鏈。而 new Constructor() ??會執行 Constructor 函數體??用于初始化。
- ??原型來源：?? Object.create(proto) 直接設置新對象的原型為 proto。new Constructor() 設置新對象的原型為 Constructor.prototype。
- ??靈活性：?? Object.create 可以創建??原型為任意指定對象??（包括 null）的新對象，非常靈活。new 要求是一個函數（構造函數）。
- ??純凈對象 (null 原型)：?? Object.create(null) 是創建完全沒有繼承任何屬性（包括 Object.prototype）的對象的??唯一??安全、標準方式。new Object() 或 {} 創建的對象原型都是 Object.prototype。
??propertiesObject 的實現：?? 模擬實現中未處理該參數。標準實現中，它會使用 Object.defineProperties(newObj, propertiesObject) 將屬性描述符定義到新對象 newObj 自身上。這些屬性不是從 proto 繼承來的，而是新對象本身的屬性。

核心用途

??純粹的原型繼承：?? 在不定義構造函數的情況下直接基于某個對象創建新實例，共享其方法和部分屬性。
??創建無原型的對象 (Object.create(null))：??
- 性能優化：移除 Object.prototype 上的方法，適合作為高性能鍵值對（字典）。
- 避免命名沖突：防止無意中繼承或覆蓋 Object.prototype 上的屬性。
??替代 new 的復雜原型設置：?? 當需要靈活設置新對象的原型（比如直接指向另一個非構造函數 prototype 的普通對象）時。
??ES5 及之后標準繼承的基礎：?? ES6 class 的 extends 在底層依賴于此機制設置子類的原型鏈。
??屬性添加 (可選參數)：?? 配合屬性描述符精確控制新對象的自身屬性。

??總結：?? Object.create() 的原理是直接操作原型鏈，通過??顯式指定一個新創建對象的 [[Prototype]]?? 來實現。它繞過了構造函數的初始化過程，提供了一種更靈活、底層的對象創建方式，是實現原型繼承和創建特殊類型對象（如無原型對象）的關鍵工具。它的核心就是??建立新對象與被指定為原型的對象之間的鏈接??。

實際 new 操作的第一步可以用 Object.create 表示：

function Animal() {}
const proto = Animal.prototype;const obj = Object.create(proto);
// 等價于
const obj = {};
Object.setPrototypeOf(obj, proto); // ES6 寫法

5.4 原型鏈查找性能優化

原型鏈查找是 JavaScript 性能優化中一個需要關注的潛在瓶頸。

為什么原型鏈查找可能影響性能？

??屬性搜索成本：?? 當訪問一個對象的屬性時，JavaScript 引擎需要??沿原型鏈逐級搜索??，直到找到該屬性或到達 null（終點）。??鏈越長，搜索層級越多，查找時間越長??，尤其對于深層鏈頂部的屬性。
??Hidden Classes (V8等引擎)：?? 現代引擎使用 ??Hidden Classes (或 Shapes, Map)?? 來優化對象訪問。
- 對象的 Hidden Class 記錄了??對象的布局信息??（有哪些自身屬性及其偏移量）。
- 當訪問一個??自身的、在 Hidden Class 中明確記錄的??屬性時，速度極快（幾乎接近靜態語言）。
- ??問題在于原型鏈查找：??
  - 訪問不在自身 Hidden Class 中的屬性（在原型鏈上）時，引擎需要：
    1. 檢查當前對象的 Hidden Class。
    2. 如果找不到，跳到原型鏈的下一個對象 ([[Prototype]])。
    3. 檢查_那個_對象的 Hidden Class。
    4. 重復步驟 2-3，直到找到屬性或到達鏈尾。
  - 這個過程涉及到多個對象的 Hidden Class 查找和上下文的切換，比訪問自身屬性慢得多。
??多態與內聯緩存失效：??
- 引擎使用 ??內聯緩存 (Inline Caches, ICs)?? 來記住之前訪問過的屬性和它在哪找到的（自身還是哪個原型的 Hidden Class）。
- 如果??同一個位置的代碼??訪問原型鏈上的屬性，但??this指向的對象來自不同的原型分支??（導致屬性出現在不同的 Hidden Class 里），內聯緩存就會變得??多態 (Polymorphic)?? 甚至??巨態 (Megamorphic)??，其性能會顯著下降，因為它需要處理多種情況。
- 如果每次查找的 Hidden Class 都不同（巨態），緩存幾乎無用，每次查找都接近于全量搜索。

優化策略與最佳實踐

??扁平化原型鏈 (Minimize Prototype Chain Depth)：??
- 這是??最核心、最有效??的策略。??避免過深、過寬、復雜的原型鏈。??
- 仔細評估繼承層次：是否真的需要多層深度繼承？組合（Composition）模式（將功能對象作為成員引入）通常是更好的選擇。
- ES6 class 通常有較淺的原型鏈（實例->類原型->父類原型->Object.prototype->null），避免過深層級。
- 對于共享方法，考慮將它們放在第一層（類原型）上。

??優先在對象自身存儲頻繁訪問的屬性 (Promote Frequently Accessed Properties to Own Properties)：??

如果一個屬性（尤其是數據屬性）在對象的生命周期內會被??非常高頻率地訪問??，考慮在構造函數中??初始化它作為自身屬性 (this.prop = val) 或使用類字段（ES2022+)??。
??自身屬性的訪問速度最快??（直接通過 Hidden Class 定位）。不要僅僅為了“省點內存”而把高頻訪問的數據放在原型鏈深處。
優化前：

function GameObject() {}
GameObject.prototype.position = { x: 0, y: 0 }; // 位置對象放在原型上function Player() {}
Player.prototype = Object.create(GameObject.prototype);
//...
const player = new Player();
// 高頻訪問位置 x
function renderLoop() {// 每次都在原型鏈上查找 position，再從 position 找 x (又是鏈查找)player.position.x += velocity.x;// ...其他渲染邏輯
}

優化后：

function GameObject() {this.position = { x: 0, y: 0 }; // ? 還是不對! (優化點1)
}function Player() {GameObject.call(this); // 繼承位置this.x = this.position.x; // ? 自身屬性 (優化點2)this.y = this.position.y;// 或者更徹底 (優化點3): 如果position只需存儲xy，直接:// this.x = 0;// this.y = 0;
}
Player.prototype = Object.create(GameObject.prototype);
//...
const player = new Player();
function renderLoop() {// 直接訪問 player.x (自身屬性，超快!)player.x += velocity.x;
}

??謹慎使用 delete 操作符：??
- delete obj.prop ??會改變對象的 Hidden Class??，使得引擎為刪除了屬性的對象創建新的 Hidden Class。
- 頻繁創建和銷毀 Hidden Class 會導致性能下降（尤其是在熱代碼路徑中）。
- ??替代方案：?? 將不用的屬性設置為 null 或 undefined (或初始化為無效值)，而不是刪除。這??不會改變 Hidden Class??。避免在運行時動態添加或刪除關鍵屬性。

??緩存查找結果 (Caching Lookup Results)：??

如果某個原型鏈上的屬性在??同一個作用域/函數中被多次訪問??，且無法提升為自身屬性，可以??將其緩存到局部變量??。

未緩存：

for (let i = 0; i < 1000; i++) {// 每次循環都要去原型鏈查找 `expensiveCalculation`result = obj.someProto.expensiveCalculation(obj.data);
}

緩存后：

const calcFn = obj.someProto.expensiveCalculation; // 緩存函數引用
const data = obj.data; // 如果 data 也需要查找，也緩存
for (let i = 0; i < 1000; i++) {result = calcFn(data); // 只訪問自身作用域中的變量，很快
}

??盡量在構造函數中初始化所有屬性 (Pre-initialize All Properties in Constructor)：??
- ??一次性??在構造函數中聲明和初始化對象的所有預期屬性（設為初始值如 undefined, null, 0, ''），即使這些值稍后才被設置。這有助于引擎創建出最“穩定”的 Hidden Class，避免后續屬性添加導致 Hidden Class 頻繁轉換。
- 不要后續通過 obj.newProp = value 在方法中隨意添加全新屬性。
??使用 Object.seal / Object.freeze (謹慎使用)：??
- 在對象初始化完成后使用 Object.seal(obj) 或 Object.freeze(obj)。
- Object.seal()：防止添加新屬性，并將所有現有屬性標記為不可配置（configurable: false）。防止屬性被刪除。
- Object.freeze()：在 seal 基礎上，防止任何現有屬性的值被修改（只讀）。
- 它們有助于??“鎖定”對象的 Hidden Class??，因為對象結構在之后不會被更改。引擎可以進行更激進的優化。但注意這極大地限制了對象的靈活性，通常只用于完全初始化好、不再更改的小型配置對象或只讀數據容器。不適合需要動態變化的大多數業務對象。
??優先使用 ES6 class 語法：??
- 現代引擎對 ES6 class 有更好的優化支持。
- class 強制方法定義在原型上，屬性初始化在構造函數中（或使用類字段），促使更優化的對象布局。
- 清晰的繼承結構 (extends) 比手寫修改 __proto__ 或 Object.setPrototypeOf 更容易被引擎理解和優化。
- ??避免使用 Object.setPrototypeOf()：?? 它比 Object.create() 更慢，而且??會強制改變已有對象的 Hidden Class 和相關聯的內聯緩存，導致嚴重的性能回退??。在創建時就確定好原型鏈（通過 new 或 Object.create）。
??分析和測量 (Profile and Measure)：??
- 性能優化最大的準則是：??不要過早優化！不要臆測瓶頸在哪里！??
- 使用瀏覽器開發者工具（如 Chrome DevTools 的 ??Performance Profiler?? 和 ??Memory Profiler??）、Node.js 的性能分析工具來??定位熱點代碼??。
- ??測量改變原型鏈結構、屬性訪問方式后的實際性能影響。?? 優化策略的實際收益取決于具體使用場景（鏈深度、訪問頻率、引擎）。

??總結：?? 原型鏈查找的性能優化關鍵在于??最小化鏈的深度??、??將高頻訪問的數據提升為自身屬性??、??避免運行時破壞對象的 Hidden Class?? 以及??善用緩存??。記住現代引擎如 V8 的 Hidden Class 和 ICs 機制是理解這些優化的基礎。但同時要警惕過度優化帶來的代碼復雜性和維護成本，始終依賴于精準的性能分析結果來指導優化方向。對于絕大多數代碼來說，遵循 ES6 class 語法和良好的設計實踐（如組合優于深層繼承）已經能提供相當不錯的性能。

6. `new` 操作符的現代實踐

6.1 ES6 類與構造函數的關系

class Animal {constructor(name) {this.name = name;}speak() {console.log(`${this.name} makes a noise.`);}
}// 本質上還是構造函數
console.log(typeof Animal); // 'function'// 構造函數的prototype不可枚舉
const descriptor = Object.getOwnPropertyDescriptor(Animal, 'prototype');
console.log(descriptor.enumerable); // false

6.2 工廠函數替代方案

function createPerson(name) {// 直接創建對象const obj = {name,// 方法直接定義（非共享）greet() {console.log(`Hello, I'm ${this.name}`);}};// 或者復用原型const proto = {greet() {console.log(`Hello, I'm ${this.name}`);}};return Object.assign(Object.create(proto), { name });
}

6.3 性能優化策略

優化大量對象創建場景：

// 方法提升到原型
function Optimized(size) {this.size = size;
}// 避免每次創建時重新定義方法
Optimized.prototype.calculate = function() {return this.size * 100;
};// 對象池技術
const pool = [];
function createFromPool() {return pool.length ? pool.pop() : new Optimized();
}function releaseToPool(obj) {pool.push(obj);
}

7. 常見陷阱與最佳實踐

7.1 遺漏 `new` 的解決方案

function User(name) {if (!(this instanceof User)) {return new User(name);  // 安全防護}this.name = name;
}// ES6新特性：new.target
function ModernUser(name) {if (!new.target) {throw new Error('Must call with new');}this.name = name;
}

7.2 原型污染風險

function SafeObject() {}// 避免直接修改內置原型
SafeObject.prototype = Object.create(null);// 創建純凈對象
const pureObj = Object.create(null);

7.3 類變量共享問題

function SharedCounter() {this.count = 0;
}
SharedCounter.prototype.increment = function() {this.count++;
}// 錯誤使用靜態屬性作為"類變量"
SharedCounter.total = 0;  // 安全用法// 正確解決方案：工廠函數
function createCounter() {let privateCount = 0;return {increment() {privateCount++;},getCount() {return privateCount;}};
}