Object.prototype

A propriedade Object.prototype representa o Object protótipo do objeto.

Praticamente todos os 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.

Object.prototype.constructor

Especifica a função que cria um objeto protótipo.

Object.prototype.__proto__ (en-US)

Aponta para o objeto que foi usado como protótipo 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úmero 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.

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__ (en-US) método.

Object.prototype.__lookupSetter__()

Retorna a função associada com a propriedade especificada pelo __defineSetter__ (en-US) 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.

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