Una pregunta rápida pero difícil de search en Google:
var child = Object.create(parent.prototype); var child = Object(parent.prototype); ¿Son idénticos?
editar:
Mi pregunta fue planteada por estos dos ejemplos de henetworkingar las funciones de prototipo utilizadas para implementar el Patrón de inheritance de combinación parasitaria.
function inheritPrototype(childObject, parentObject) { var copyOfParent = Object.create(parentObject.prototype); copyOfParent.constructor = childObject; childObject.prototype = copyOfParent; }
http://javascriptissexy.com/oop-in-javascript-what-you-need-to-know/
function inheritPrototype(subType, superType){ var prototype = object(superType.prototype); prototype.constructor = subType; subType.prototype = prototype; }
"Herencia Combinada Parasitaria" en JavaScript Profesional para Desarrolladores Web
No, no son idénticos, ver abajo:
Object.create(prototype) creará un nuevo prototipo que henetworkinga del prototype pasado como argumento
Object(obj) u new Object(obj) creará una nueva instancia de obj llamando al constructor también.
Ahora que los prototypes también son objects de JavaScript, la diferencia puede ser mínima. Sin embargo, Object.create puede manejar constructores que puedan necesitar arguments, mientras que new Object() no lo hará
Más información en esta respuesta relacionada con SO (por ejemplo, inheritance diferencial, properties personalizadas, etc.)
Referencias
Object.create en MDN new Object en MDN ACTUALIZACIÓN después de la edición OP
En mi OOP javascript framework Classy.js hay este polyfill alnetworkingedor de Object.create para browseres más antiguos que podría arrojar luz sobre su pregunta adicional entre las diferencias:
Create = Obj.create || function( proto, properties ) { var Type = function () {}, TypeObject; Type[PROTO] = proto; TypeObject = new Type( ); TypeObject[__PROTO__] = proto; if ( 'object' === typeOf(properties) ) defineProperties(TypeObject, properties); return TypeObject; }
Este polyfill puede manejar constructores arbitrarios (con arguments) como Object.create can, y también asegurarse de que __proto__ se asigna correctamente. El patrón que usa Object(prototype) en cuestión es un bash de (débilmente) referencer el prototype .
No, no son lo mismo:
El object (X) o el nuevo object (X) son los mismos que Object.create (X.prototype)
Object(X) creará un object y ejecutará el Constructor (es decir, el object recién creado henetworkinga del prototipo del constructor). Object.create(X.prototype) está creando un object con un Constructor adicional.
El object (X) o el nuevo object (X) no son como Object.create ()
Object.create() crea un object sin ejecutar Constructor (es decir, creará un object que no henetworkinga de nada)
Nuevo object establece que el hijo sea el padre:
var parent = {name : 'proto'}; var child = new Object(parent); console.log(child === parent);//=true //if I set child.name it will change parent.name
Object create devuelve una instancia de object que usa el primer argumento ya que es proto (primer prototipo utilizado en la cadena de prototypes).
child = Object.create(parent); console.log(child === parent);//=false //I can set child.name because it will be shadowed // and will not change parent.name console.log(child.hasOwnProperty('name'));//=false
Más sobre el prototipo se puede encontrar aquí: https://stackoverflow.com/a/16063711/1641941