Esta página foi traduzida do inglês pela comunidade.Saiba mais e junte-se à comunidade MDN Web Docs.
Object.create()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since julho de 2015.
O métodoObject.create() cria um novo objeto, utilizando um outro objeto existente como protótipo para o novo objeto a ser criado.
Experimente
const person = { isHuman: false, printIntroduction: function () { console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`); },};const me = Object.create(person);me.name = "Matthew"; // "name" is a property set on "me", but not on "person"me.isHuman = true; // Inherited properties can be overwrittenme.printIntroduction();// Expected output: "My name is Matthew. Am I human? true"Sintaxe
Object.create(proto[, propertiesObject])
Parâmetros
protoO objeto que deve ser o protótipo do objeto recém-criado.
propertiesObjectOpcional. Se especificado e não
undefined, um objeto cuja as propriedades próprias enumeráveis (isto é, aquelas propriedades definidas sobre si mesmo, enão propriedades enumeráveis ao longo da sua cadeia protótipa) especificam os nomes das propriedades a serem adicionadas ao objeto recém-criado, com os nomes das propriedades correspondentes. Essas propriedades correspondem ao segundo argumento deObject.defineProperties().
Retorno
Um novo objeto com o protótipo de objeto e propriedades especificadas.
Exceções
Uma exceçãoTypeError se o parâmetroproto não fornull ou um objeto.
Exemplos
Herança tradicional comObject.create()
A seguir, um exemplo de como usarObject.create() para realizar uma herança tradicional. Isto é para herança simples, que é a única herança suportada pelo JavaScript.
// Shape - superclassefunction Shape() { this.x = 0; this.y = 0;}// método da superclasseShape.prototype.move = function (x, y) { this.x += x; this.y += y; console.info("Shape moved.");};// Rectangle - subclassefunction Rectangle() { Shape.call(this); // chama construtor-pai.}// subclasse extende superclasseRectangle.prototype = Object.create(Shape.prototype);Rectangle.prototype.constructor = Rectangle;var rect = new Rectangle();console.log("Rect é uma instância de Rectangle?", rect instanceof Rectangle); // trueconsole.log("Rect é uma instância de Shape?", rect instanceof Shape); // truerect.move(1, 1); // Saída: 'Shape moved.'Caso queira realizar herança de múltiplos objetos, então mixins ("mistura") são uma possibilidade.
function MyClass() { SuperClass.call(this); OtherSuperClass.call(this);}MyClass.prototype = Object.create(SuperClass.prototype); // herançamixin(MyClass.prototype, OtherSuperClass.prototype); // mixinMyClass.prototype.myMethod = function () { // faz algo};A funçãomixin copia as funções do protótipo da superclasse para o protótipo da subclasse, a função mixin precisa ser fornecida pelo usuário. Um exemplo de uma função do tipo mixin seriajQuery.extend().
Usando argumentopropertiesObject comObject.create()
var o;// cria um objeto com protótipo nullo = Object.create(null);o = {};// equivalente a:o = Object.create(Object.prototype);// Exemplo em que criamos um objeto com algumas propriedades// (Note que o segundo parâmetro mapeia as chaves para *descritores de propriedade*.)o = Object.create(Object.prototype, { // foo é uma 'propriedade de valor' ('value property') normal foo: { writable: true, configurable: true, value: "hello" }, // bar é uma propriedade getter-setter (accessor) bar: { configurable: false, get: function () { return 10; }, set: function (value) { console.log("Setting `o.bar` to", value); }, /* com os ES5 Accessors nosso código pode ser escrito como: get() { return 10; }, set(value) { console.log('setting `o.bar` to', value); } */ },});function Constructor() {}o = new Constructor();// equivalente a:o = Object.create(Constructor.prototype);// Claro, se há de fato um código de inicialização na função// Constructor, o Object.create() não pode refleti-la// Cria um novo objeto cujo protóptipo é um objeto novo, vazio// e adiciona a propriedade 'p' com o valor 42.o = Object.create({}, { p: { value: 42 } });// por padrão, propriedades NÃO SÃO escritas, enumeradas ou configuráveis:o.p = 24;o.p;// 42o.q = 12;for (var prop in o) { console.log(prop);}// 'q'delete o.p;// false// especificar uma propriedade ES3o2 = Object.create( {}, { p: { value: 42, writable: true, enumerable: true, configurable: true, }, },);Polyfill
Este polyfill cobre o caso de uso principal que é a crição de um novo objeto em que o protótipo foi escolhido mas não leva em consideração o segundo argumento.
Note que, enquanto a configuraçãonull as[[Prototype]] é suportada no ES5Object.create, este polyfill não suporta devido à limitação inerente em versões do ECMAScript inferiores a 5.
if (typeof Object.create != "function") { Object.create = (function () { var Temp = function () {}; return function (prototype) { if (arguments.length > 1) { throw Error("Second argument not supported"); } if (typeof prototype != "object") { throw TypeError("Argument must be an object"); } Temp.prototype = prototype; var result = new Temp(); Temp.prototype = null; return result; }; })();}Especificações
| Specification |
|---|
| ECMAScript® 2026 Language Specification # sec-object.create |
Compatibilidade com navegadores
Veja também
Object.defineProperty()Object.defineProperties()Object.prototype.isPrototypeOf()- Post de John Resig sobregetPrototypeOf()