Esta tradução está incompleta. Ajude atraduzir este artigo.
Sumário
A propriedade Object.prototype
representa o Object
protótipo do objeto.
Property attributes of Object.prototype |
|
---|---|
Writable | no |
Enumerable | no |
Configurable | no |
Descrição
Todos objetos em JavaScript descendem de Object
; todos os métodos e propriedades herdados de Object.prototype
, embora possam ser sobrescritos (exceto um Objeto
com protótipo nulo, i.e. Object.create(null)
). Por exemplo, outros protótipos construtores sobrescrevem a propriedade construtora e fornece seus próprios toString()
métodos.
Modificações no Objeto protótipo
do objeto são propagadas a todos objetos através do encadeamento de protótipos, a menos que as propriedades e métodos submetidos às mudanças sejam sobrescritos mais além no encadeamento dos protótipos. Este recurso oferece um mecânismo muito poderoso apesar de perigoso para sobrescrita e extensão de objetos.
Propriedades
Object.prototype.constructor
- Especifica a função que cria um objeto protótipo.
Object.prototype.__proto__
- Aponta para o objeto que foi usado como protóripo quando o objeto foi instanciado.
Object.prototype.__noSuchMethod__
- Permite definir uma função que será executada quando um membro indefinido do objeto for chamado como método.
Object.prototype.__count__
Usado para retornar um núemro de propriedades enumeráveis diretamente num objeto definido pelo usuário, mas foi removida.Object.prototype.__parent__
Usado para apontar a um contexto do objeto, mas foi removida.
Métodos
Object.prototype.__defineGetter__()
- Associa uma função com uma propriedade que, quando acessada, executa uma função e retorna seu valor de retorno.
Object.prototype.__defineSetter__()
- Associa uma função com uma propriedade que, quando definida, executa uma função que modifica a propriedade.
Object.prototype.__lookupGetter__()
- Retorna a função associada com a propriedade específicada pelo
__defineGetter__
método. Object.prototype.__lookupSetter__()
- Retorna a função associada com a propriedade especificada pelo
__defineSetter__
método. Object.prototype.hasOwnProperty()
- Retorna um boolean indicando se um objeto contém a propriedade especificada como uma propriedade direta de um objeto e não herdada através da cadeia de protótipo.
Object.prototype.isPrototypeOf()
- Retorna uma indicação booleana se o objeto especificado está na cadeia de protótipo do objeto este método é chamado.
Object.prototype.propertyIsEnumerable()
- Retorna um boolean indicando se o atributo interno ECMAScript DontEnum attribute está definido.
Object.prototype.toSource()
- Retorna uma string contendo o código de um objeto literal representando o objeto que este método é chamado; você pode usar este valor para criar um novo objeto.
Object.prototype.toLocaleString()
- Chama
toString()
. Object.prototype.toString()
- Retorna uma representação do objeto em forma de string.
Object.prototype.unwatch()
- Remove um ponto de escuta da propriedade do objeto.
Object.prototype.valueOf()
- Retorna o valor primitivo do objeto especificado.
Object.prototype.watch()
- Adiciona um ponto de escuta à propriedade do objeto.
Object.prototype.eval()
Usado para avaliar uma string de código JavaScript no contexto do objeto especificado, mas foi removido.
Exemplos
Quando é alterado o comportamento de um método de um Objeto protótipo, considere injetar código envolvendo sua extensão antes ou depois ta lógica existente. Por exemplo, este (não testado) código irá pré-condicionalmente executar uma lógica personalizada antes da lógica embutida ou a extensão de alguém será executada.
Quando uma função é chamada os argumentos para a chamada são segurados no array de argumentos como "variável". Por exemplo, na chamada "minhaFuncao(a, b, c)", os argumentos no corpo da minhaFuncao irão conter 3 elementos array correspondentes a (a, b, c). Quando modificamos os protótipos com ganchos, simplesmente passamos this & a variável arguments (o estado de chamada) para o comportamento atual pela chamada apply() na função. Este padrão pode ser usado por qualquer protótipo, tal como Node.prototype, Function.prototype, etc.
var current = Object.prototype.valueOf;
// Desde que minha propriedade "-prop-value" é transversal e não está
// sempre na mesma cadeia de protótipo, desejo modificar Object.prototype:
Object.prototype.valueOf = function() {
if (this.hasOwnProperty("-prop-value") {
return this["-prop-value"];
} else {
// Isto não parece com um de meus objetos, então vamos retroceder ao
// comportamento padrão para reproduzir o comportamento atual o que
// pudermos. O apply se comporta como o"super" em outras linguagens.
// Mesmo que valueOf() não receba argumentos, alguns outros ganchos podem.
return current.apply(this, arguments);
}
}
Desde que JavaScript não tem exatamente objetos de subclasse, protótipo é uma forma usual de trabalhar para fazer um objeto "classe base" de certas funções que agem como objetos. Por exemplo:
var Person = function() { this.canTalk = true; this.greet = function() { if (this.canTalk) { console.log('Hi, I\'m ' + this.name); } }; }; var Employee = function(name, title) { this.name = name; this.title = title; this.greet = function() { if (this.canTalk) { console.log("Hi, I'm " + this.name + ", the " + this.title); } }; }; Employee.prototype = new Person(); var Customer = function(name) { this.name = name; }; Customer.prototype = new Person(); var Mime = function(name) { this.name = name; this.canTalk = false; }; Mime.prototype = new Person(); var bob = new Employee('Bob', 'Builder'); var joe = new Customer('Joe'); var rg = new Employee('Red Green', 'Handyman'); var mike = new Customer('Mike'); var mime = new Mime('Mime'); bob.greet(); joe.greet(); rg.greet(); mike.greet(); mime.greet();
O retorno será:
Hi, I'm Bob, the Builder Hi, I'm Joe Hi, I'm Red Green, the Handyman Hi, I'm Mike
Especificações
Especificações | Situação | Comentário |
---|---|---|
ECMAScript 1st Edition. Implemented in JavaScript 1.0. | Padrão | Definição inicial. |
ECMAScript 5.1 (ECMA-262) The definition of 'Object.prototype' in that specification. |
Standard | |
ECMAScript 2015 (6th Edition, ECMA-262) The definition of 'Object.prototype' in that specification. |
Standard |
Compatibilidade com Navegadores
Aspecto | Chrome | Firefox (Gecko) | Internet Explorer | Opera | Safari |
---|---|---|---|---|---|
Suporte básico | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |
Aspecto | Android | Chrome para Android | Firefox Mobile (Gecko) | IE Mobile | Opera Mobile | Safari Mobile |
---|---|---|---|---|---|---|
Suporte básico. | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) | (Yes) |