Python como herencia para JavaScript

En python puedo hacer algo como esto.

main.py

class MainClass: def __init__(self): self.name = "some_name" def startDoingStuff(self): print("I'm doing something boring") def printName(self): print("My name is " + self.name) 

sub.py

 import main class Sub(main.MainClass): def startDoingStuff(self): print("I'm doing something interesting") self.name = "sub" sub = Sub() sub.printName() # prints 'My name is some_name' sub.startDoingStuff() sub.printName() # prints 'My name is sub' 

¿Hay un equivalente de JavaScript?

Si la herencia basada en prototipos es un poco desalentadora, puede buscar en la herencia basada en extensión .

Una implementación realmente básica se ve así. (La implementación de John Resig vinculada anteriormente es más robusta, pero creo que es un poco más legible, pero con el mismo concepto básico)

 var extend = function(subTypeInit) { var SuperType = this; var SubType = function () { function SuperTypeProxy(args) { return SuperType.apply(this, args); } var base = new SuperTypeProxy(arguments); subTypeInit.apply(base, arguments); return base; } SubType.extend = extend.bind(SubType); return SubType; } 

Entonces se puede usar así:

 var Main = function (name) { var self = this; self.name = name; self.doSomething = function () { console.log("something boring"); }; self.printName = function () { console.log("Hi, I'm "+name); }; }; Main.extend = extend.bind(Main); //Manually attach to first parent. var Sub = Main.extend(function () { var self = this; self.doSomething = function () { console.log("something interesting"); }; var superPrintName = self.printName; self.printName = function () { superPrintName(); console.log("And I'm a sub class"); }; }); var sub = new Sub("foo"); sub.doSomething(); //logs "something interesting" sub.printName(); //logs "Hi, I'm foo" "And I'm a sub class" 

Algunas advertencias aquí, es posible que realmente debas buscar en la herencia basada en prototipos, que es para lo que se construye realmente JavaScript. La herencia basada en extensión es un poco más natural para alguien que está acostumbrado a los enfoques de herencia de otros idiomas OO, pero la desventaja es que consume más recursos para hacer la herencia de esta manera; estás creando muchas funciones (y muchos cierres), que realmente pueden sumrse.