alternativa per il __proto__ deprecato

Question

Concesso Sono un noob javascript (nel migliore dei casi). Il seguente codice sembra funzionare correttamente. Qualche idea su come mantenere lo stesso approccio di "inizializzatore" e farlo funzionare senza usare __proto__ e senza convertire tutto in funzioni di costruzione?

var Employee = 
    { 
    paygrade: 1, 
    name: "", 
    dept: "general", 

    init: function() 
     { 
     return this; 
     }, 

    salary: function() 
     { 
     return this.paygrade * 30000; 
     } 
    }; 



var WorkerBee = 
    { 
    paygrade: 2, 
    projects: ["Project1", "Project2"], 

    init: function() 
     { 
     this.__proto__ = Inherit_Employee; // Inherit My Employee "Pseudo Prototype" 
     return this; 
     } 
    }; 


var SalesPerson = 
    { 
    dept: "Sales", 
    quota: 100, 

    init: function() 
     { 
     this.__proto__ = Inherit_WorkerBee; // Inherit My WorkerBee "Pseudo Prototype" 
     return this; 
     } 
    }; 


var Engineer = 
    { 
    dept: "Engineering", 
    machine: "im the start machine", 

    init: function() 
     { 
     this.__proto__ = Inherit_WorkerBee; // Inherit My WorkerBee "Pseudo Prototype" 
     return this; 
     } 
    }; 


var Inherit_Employee = Object.create(Employee).init();  // Create My Employee Pseudo-Prototype 
var Inherit_WorkerBee = Object.create(WorkerBee).init(); // Create My WorkerBee Pseudo-Prototype 


var jane = Object.create(Engineer).init(); 
var jill = Object.create(Engineer).init(); 

Ho un approccio che funziona, ma mi chiedo se esiste un approccio più efficiente. Per ora, quello che ho fatto è sostituire le linee che fanno riferimento allo __proto__ con una chiamata alla mia funzione di ereditarietà come questa.

init: function() 
     { 
     inherit(this, WorkerBee); // Inherit WorkerBee 
     return this; 
     } 

E questa è la mia eredita funzione

function inherit(childObject, parentObject) 
    { 
    // childObject inherits all of parentObjects properties 
    // 
    for (var attrname in parentObject) 
     if (childObject[attrname] == undefined) 
      childObject[attrname] = parentObject[attrname]; 

    // childObject runs parentObject 'init' function on itself 
    // 
    for (var attrname in parentObject) 
     if (typeof parentObject[attrname] == "function") 
      if (attrname == 'init') 
       parentObject[attrname].call(childObject); 
    } 

Answer 1

Perché tu non utilizzare la funzione standard di ereditarietà javascript()? Per esempio:

function inherit(childClass,parentClass) { 
    var f=function(){}; // defining temp empty function 
    f.prototype=parentClass.prototype; 
    f.prototype.constructor=f; 

    childClass.prototype=new f; 

    childClass.prototype.constructor=childClass; // restoring proper constructor for child class 
    parentClass.prototype.constructor=parentClass; // restoring proper constructor for parent class 
} 


Employee = function Employee(/*list of constructor parameters, if needed*/) { 
} 
Employee.prototype.paygrade = 1; 
Employee.prototype.name = ""; 
Employee.prototype.dept = "general"; 
Employee.prototype.salary = function() { 
    return this.paygrade * 30000; 
} 


WorkerBee = function WorkerBee(/*list of constructor parameters, if needed*/) { 
    this.projects = ["Project1", "Project2"]; 
} 
inherit(WorkerBee,Employee); // for this implementation of *inherit* must be placed just after defining constructor 
WorkerBee.prototype.paygrade = 2; 
WorkerBee.prototype.projects = null; // only literals and function-methods can properly initialized for instances with prototype 


Engineer = function Engineer(/*list of constructor parameters, if needed*/) { 
} 
inherit(Engineer,WorkerBee); 
Engineer.prototype.dept = "Programming"; 
Engineer.prototype.language = "Objective-C"; 




var jane = new Engineer(/*Engineer parameters if needed*/); 
var jill = new Engineer(/*Engineer parameters if needed*/); 
var cow = new Employee(/*Employee parameters if needed*/); 

Answer 2

__proto__ sarà a ES6, quindi forse se stai leggendo questo ora, non dovrebbe essere necessario questo ma è comunque bene sapere

Answer 3

Object.getPrototypeOf

// old-way 
obj.__proto__ 

// new-way 
Object.getPrototypeOf(obj)