強制__proto__相等

Question

我希望這些實例的原型相同，但以下相等性檢查的計算結果爲false。

var emp1 = new(EmployeeScope())("John"); 
var emp2 = new(EmployeeScope())("Amit"); 
var mgr1 = new(ManagerScope())("Robert", "Data"); 
var mgr2 = new(ManagerScope())("Alex", "Science"); 
emp1.getName() // John 
emp2.getName() // Amit 
mgr1.getDept() // Data 
mgr2.getDept() // Science 
mgr1.getName() // Robert 
mgr2.getName() // Alex 

emp1.__proto__ === emp2.__proto__ //false 
mgr1.__proto__ === mgr2.__proto__ //false 

---

function EmployeeScope() { 
    var name; 

    function Employee(newName) { 
    name = newName; 
    } 
    Employee.prototype.getName = function() { 
    return name 
    }; 
    Employee.prototype.setName = function(newName) { 
    name = newName 
    }; 
    return Employee; 
} 

function ManagerScope() { 
    var Employee = EmployeeScope(); 
    var dept; 

    function Manager(newName, newDept) { 
    new Employee(newName); 
    dept = newDept; 
    } 
    Manager.prototype = Object.create(Employee.prototype); 
    Manager.prototype.constructor = Manager; 
    Manager.prototype.getDept = function() { 
    return dept 
    }; 
    Manager.prototype.setDept = function(newDept) { 
    dept = newDept 
    }; 
    return Manager; 
} 

Answer 1

的原因兩個對象有不同的原型是在構造函數Employee和Manager在你把它們放在包裝函數每次調用重新創建。因此，他們代表不同構造函數在包裝函數的不同調用中調用時。

讓對象方法訪問私有成員的常見解決方案是通過不是在原型上定義它們，而是在實例上定義它們。這樣，你可以在構造函數中定義範圍內它們：

function Employee(newName) { 
 
    var name = newName; 
 
    this.getName = function() { 
 
     return name 
 
    }; 
 
    this.setName = function(newName) { 
 
     name = newName 
 
    }; 
 
} 
 

 
function Manager(newName, newDept) { 
 
    var dept = newDept; 
 
    // Inherit from Employee 
 
    Employee.call(this, newName); 
 

 
    this.getDept = function() { 
 
     return dept 
 
    }; 
 
    this.setDept = function(newDept) { 
 
     dept = newDept 
 
    }; 
 
} 
 

 
var emp1 = new Employee("John"); 
 
var emp2 = new Employee("Amit"); 
 
var mgr1 = new Manager("Robert", "Data"); 
 
var mgr2 = new Manager("Alex", "Science"); 
 

 
console.log(emp1.getName()) // John 
 
console.log(emp2.getName()) // Amit 
 
console.log(mgr1.getDept()) // Data 
 
console.log(mgr2.getDept()) // Science 
 
console.log(mgr1.getName()) // Robert 
 
console.log(mgr2.getName()) // Alex 
 

 
console.log(Object.getPrototypeOf(emp1) === Object.getPrototypeOf(emp2)); 
 
console.log(Object.getPrototypeOf(mgr1) === Object.getPrototypeOf(mgr2));

注意，建議使用Object.getPrototypeOf()而不是__proto__。其次，你應該聲明局部變量爲var（或let，const），否則變量將被默默地聲明爲全局變量，並且每個員工都會得到相同的名稱。

Answer 2

也許是更容易理解他們爲什麼當你寫的代碼如下不共享相同的原型：

var EmployeeA = EmployeeScope(); 
var EmployeeB = EmployeeScope(); 
EmployeeA === EmployeeB // false 
EmployeeA.prototype === EmployeeB.prototype // false 
var emp1 = new EmployeeA("John"); 
var emp2 = new EmployeeB("Amit"); 
Object.getPrototypeOf(emp1) === EmployeeA.prototype // true 
Object.getPrototypeOf(emp2) === EmployeeB.prototype // true 

有您EmployeeScope建立在每一個新的呼叫ISN一個新的類（構造函數+原型）最好的主意。您也可以只使用它的一個實例，因爲name進行靜態存儲：

var emp3 = new EmployeeB("Dirk"); 
Object.getPrototypeOf(emp2) === Object.getPrototypeOf(emp3) // true 
emp2.getName() // Dirk - oops 

你Manager類從，當然同樣的問題困擾。所以丟棄這些「範圍」功能，使他們的標準類：

function Employee(newName) { 
    this.name = newName; 
} 
Employee.prototype.getName = function() { 
    return this.name 
}; 
Employee.prototype.setName = function(newName) { 
    this.name = newName 
}; 


function Manager(newName, newDept) { 
    Employee.call(this, newName); 
    this.dept = newDept; 
} 
Manager.prototype = Object.create(Employee.prototype); 
Manager.prototype.constructor = Manager; 
Manager.prototype.getDept = function() { 
    return this.dept 
}; 
Manager.prototype.setDept = function(newDept) { 
    this.dept = newDept 
}; 

var emp1 = new Employee("John"); 
var emp2 = new Employee("Amit"); 
var emp3 = new Employee("Dirk"); 
var mgr1 = new Manager("Robert", "Data"); 
var mgr2 = new Manager("Alex", "Science"); 
Object.getPrototypeOf(emp1) === Employee.prototype // true 
Object.getPrototypeOf(emp2) === Employee.prototype // true 
Object.getPrototypeOf(emp3) === Employee.prototype // true 
Object.getPrototypeOf(mgr1) === Manager.prototype // true 
Object.getPrototypeOf(mgr2) === Manager.prototype // true