recursal/MDN huggingface dataset:
Object.prototype.constructor
============================

Sumário
-------

Retorna uma referência para a função `Object` que cria a instância do protótipo. Note que o valor desse protótipo é uma referência para a própria função, não uma string contendo o nome da função. O valor é apenas *read-only* para valores primitivos como `1`, `true` e `"test"`.

Descrição
---------

Todos os objetos herdam a propriedade *construtor* de seu protótipo:


```js
var o = {};
o.constructor === Object; // true

var a = [];
a.constructor === Array; // true

var n = new Number(3);
n.constructor === Number; // true
```

Exemplos
--------

### Exemplo: Apresentando o construtor de um objeto

O exemplo a seguir cria um protótipo, `Tree`, e um objeto desse tipo, `theTree`. O exemplo, então, apresenta a propriedade *constructor* do objeto `theTree`.


```js
function Tree(name) {
  this.name = name;
}

var theTree = new Tree("Redwood");
console.log("theTree.constructor is " + theTree.constructor);
```


Esse exemplo apresenta a seguinte saída:


```js
theTree.constructor is function Tree(name) {
  this.name = name;
}
```

### Exemplo: Mudando o construtor de um objeto

O exemplo a seguir apresenta como modificar o valor do construtor de um objeto genérico. Apenas `true`, `1` e `"test"` não serão afetados sendo que eles tem `construtores` *read-only* nativos. Esse exemplo apresenta que nem sempre é seguro depender da propriedade `constructor` de um objeto.


```js
function Type() {}

var types = [
  new Array(),
  [],
  new Boolean(),
  true, // remains unchanged
  new Date(),
  new Error(),
  new Function(),
  function () {},
  Math,
  new Number(),
  1, // remains unchanged
  new Object(),
  {},
  new RegExp(),
  /(?:)/,
  new String(),
  "test", // remains unchanged
];

for (var i = 0; i < types.length; i++) {
  types[i].constructor = Type;
  types[i] = [
    types[i].constructor,
    types[i] instanceof Type,
    types[i].toString(),
  ];
}

console.log(types.join("\n"));
```


Esse exemplo apresenta a seguinte saída:


```js
function Type() {},false,
function Type() {},false,
function Type() {},false,false
function Boolean() {
    [native code]
},false,true
function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600
function Type() {},false,Error
function Type() {},false,function anonymous() {

}
function Type() {},false,function () {}
function Type() {},false,[object Math]
function Type() {},false,0
function Number() {
    [native code]
},false,1
function Type() {},false,[object Object]
function Type() {},false,[object Object]
function Type() {},false,/(?:)/
function Type() {},false,/(?:)/
function Type() {},false,
function String() {
    [native code]
},false,test
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.constructor |

Compatibilidade de Browser
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Object.prototype.\_\_defineGetter\_\_()
=======================================

**Aviso:** Esta característica está descontinuada em favor de definindo getters usando a sintaxe de inicialização de objetoou a API `Object.defineProperty()`. Enquanto esta característica é amplamente implementada, ela está somente descrita na especificação ECMAScript por causa do uso legado. Este método não deveria ser usado desde que exista existam melhores alternativas.

O método **`__defineGetter__`** conecta uma propriedade do objeto à uma função para ser chamada quando isso é consultado.

Sintaxe
-------
```

obj.__defineGetter__(prop, func)
```

### Parâmetros

`prop`

Uma string contendo o nome da propriedade para conectar a função dada.

`func`

Uma função para ser ligada a uma consulta da propriedade especificada.

### Valor de Retorno

`undefined`.

Descrição
---------

O `__defineGetter__` permite um getter (en-US) ser definido sobre um objeto preexistente.

Exemplos
--------


```js
// Forma não-padrão e depreciada

var o = {};
o.\_\_defineGetter\_\_("gimmeFive", function () {
  return 5;
});
console.log(o.gimmeFive); // 5

// Formas padrão-compatível

// Usando o operador get
var o = {
  get gimmeFive() {
    return 5;
  },
};
console.log(o.gimmeFive); // 5

// Usando Object.defineProperty
var o = {};
Object.defineProperty(o, "gimmeFive", {
  get: function () {
    return 5;
  },
});
console.log(o.gimmeFive); // 5
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.\_\_defineGetter\_\_ |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.__defineSetter__()`
* `get` (en-US) operator
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* Guia JS: Definindo Getters e Setters
* [Blog Post] Depreciação de \_\_defineGetter\_\_ e \_\_defineSetter\_\_
* Erro do Firefox 647423
Object.prototype.valueOf()
==========================

O método **`valueOf()`** retorna o valor primitivo do objeto especificado.

Experimente
-----------

Sintaxe
-------
```

object.valueOf()
```

### Valor retornado

O valor primitivo do objeto especificado.

Descrição
---------

JavaScript chama o método `valueOf` para converter um objeto em um valor primitivo. Você raramente precisará chamar o método `valueOf` por ele mesmo; O JavaScript chamará ele automaticamente quando encontrar um objeto onde um valor primitivo for esperado.

Por padrão, o método `valueOf` é herdado por cada objeto descendente de `Object`. Todo núcleo embutido do objeto sobrescreve esse método para retornar um valor apropriado. Se um objeto não tem um valor primitivo, `valueOf` retorna o próprio objeto.

Você pode usar `valueOf` dentro do seu próprio código para converter um objeto embutido, em um valor primitivo. Quando você criar um objeto customizado, você pode sobrescrever `Object.prototype.valueOf()` para chamar um método customizado ao invés do método padrão `Object`.

### Sobrescrevendo `valueOf` para objetos customizados

Você pode criar uma função para ser chamada no lougar do método padrão `valueOf`. Sua função não pode ter nenhum argumento.

Suponha que você tem um tipo de objeto `MyNumberType` e você quer criar um método `valueOf` para ele. O código a seguir atribui uma função definida por usuário para o método `valueOf` desse objeto:


```js
MyNumberType.prototype.valueOf = function () {
  return customPrimitiveValue;
};
```


Com o código anterior no lugar, a qualquer hora um objeto do tipo `MyNumberType` é usado em um contexto onde deve ser representado como um valor primitivo, o JavaScript chama automaticamente a função definida no código anterior.

Um método `valueOf` de um objeto é geralmente chamado pelo JavaScript, mas você pode chamá-lo se quiser da seguinte maneira:


```js
myNumberType.valueOf();
```


**Nota:** Objetos em contexto de string convertidos através do método `toString()`, o que é diferente de objetos `String` convertendo para string primiriva utlizando `valueOf`. Todos os objetos têm uma conversão string, somente se "`[object type]`". Mas muitos objetos não convertem para number, boolean, or function.

Exemplos
--------

### Usando `valueOf`


```js
function MyNumberType(n) {
  this.number = n;
}

MyNumberType.prototype.valueOf = function () {
  return this.number;
};

var myObj = new MyNumberType(4);
myObj + 3; // 7
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.prototype.valueof |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.prototype.toString()`
* `parseInt()`
* `Symbol.toPrimitive`
Object.is()
===========

O método **`Object.is()`** determina se dois valores correspondem ao mesmo valor.

Sintaxe
-------
```

Object.is(value1, value2);
```

### Parâmetros

`value1`

O primeiro valor a ser comparado.

`value2`

O segundo valor a ser comparado.

### Return value

Um `Boolean` indicando se os dois argumentos possuem o mesmo valor ou não.

Descrição
---------

`Object.is()` determina se dois valores correspondem ao mesmo valor. Dois valores correspondem ao mesmo valor se uma das seguintes condições for verdadeira:

* ambos são `undefined`
* ambos são `null`
* ambos são `true` ou ambos são `false`
* ambos são strings do mesmo comprimento, com os mesmos caracteres
* ambos são o mesmo objeto
* ambos são numéricos e
    + ambos são `+0`
    + ambos são `-0`
    + ambos são `NaN`
    + ou ambos são não-zero e ambos são não `NaN` e ambos correspondem ao mesmo valor

Isso *não é* o mesmo que ser igual de acordo com o operador `==` (en-US). O operador `==` (en-US) aplica diversas coerções para ambos os lados (se eles não correspondem ao mesmo Tipo) antes de testar a igualdade (resultando em comportamentos como a comparação `"" == false` retornar `true`), enquanto `Object.is` não realiza a coerção de nenhum dos valores.

Isso também *não* *é* o mesmo que ser igual de acordo com o operador `===` (en-US). O operador `===` (en-US) (assim como o operador `==` (en-US)) trata os valores numéricos `-0` e `+0` como iguais e trata `Number.NaN` como não igual a `NaN`.

Exemplos
--------


```js
Object.is("foo", "foo"); // true
Object.is(window, window); // true

Object.is("foo", "bar"); // false
Object.is([], []); // false

var test = { a: 1 };
Object.is(test, test); // true

Object.is(null, null); // true

// Casos especiais
Object.is(0, -0); // false
Object.is(-0, -0); // true
Object.is(NaN, 0 / 0); // true
```

Polyfill para navegadores que não suportam ES6
----------------------------------------------

`Object.is()` é uma adição proposta ao padrão ECMA-262; e como tal, pode não estar presente em todos os navegadores. Você pode contornar essa situação por meio da adição do seguinte código no começo de seus scripts. Isso permitirá a você utilizar `Object.is()`, mesmo quando não houver suporte por parte do navegador.


```js
if (!Object.is) {
  Object.is = function (x, y) {
    // Algoritmo para verificar se os valores sao iguais
    if (x === y) {
      // Passos 1-5, 7-10
      // Passos 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Passo 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.is |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* Comparações de igualdade — uma comparação dos três recursos implementados para verificação de igualdade.
Object.isSealed()
=================

O método **`Object.isSealed()`** determina se um objeto está selado.

Experimente
-----------

Sintaxe
-------
```

Object.isSealed(obj)
```

### Parâmetros

`obj`

O objeto que deverá ser verificado.

### Valor retornado

Um `Boolean` indicando se o objeto fornecido está ou não selado.

Descrição
---------

Retorna `true` se o objeto está selado, senão `false`. Um objeto está selado se ele for "não extensible" e se todas as suas propriedades estão como "não configuráveis" e assim sendo "não removíveis" (mas não necessariamente "não escrevíveis").

Exemplos
--------


```js
// Objetos não são selados por padrão.
var empty = {};
Object.isSealed(empty); // === false

// Se você fizer um objeto não extensível vazio,
// ele estará vagamente selado.
Object.preventExtensions(empty);
Object.isSealed(empty); // === true

// O mesmo não é verdadeiro em um objeto "não vazio",
// a não ser que todas as suas propriedades sejam "não configuráveis".
var hasProp = { fee: "fie foe fum" };
Object.preventExtensions(hasProp);
Object.isSealed(hasProp); // === false

// Mas torne-os todos "não configuráveis"
// e o objeto se tornará selado.
Object.defineProperty(hasProp, "fee", {
  configurable: false,
});
Object.isSealed(hasProp); // === true

// O jeito mais fácil de selar um objeto, com certeza,
// é Object.seal.
var sealed = {};
Object.seal(sealed);
Object.isSealed(sealed); // === true

// Um objeto selado é, por definição, não extensível.
Object.isExtensible(sealed); // === false

// Um objeto selado pode estar congelado,
// mas não precisa estar.
Object.isFrozen(sealed); // === true
// (todas as propriedades também não escrevíveis)

var s2 = Object.seal({ p: 3 });
Object.isFrozen(s2); // === false
// ('p' continua "escrevível")

var s3 = Object.seal({
  get p() {
    return 0;
  },
});
Object.isFrozen(s3); // === true
// (somente a configurabilidade importa nos assessores de propriedade)
```

Notas
-----

No ES5, se o argumento para esse método não é um objeto (um primitivo), então ele irá causar um `TypeError`. No ES2015, um argumento que não seja objeto irá ser tratado como se fosse um objeto selado qualquer, simplesmente retornando `true`.


```js
Object.isSealed(1);
// TypeError: 1 is not an object (ES5 code)

Object.isSealed(1);
// true (ES2015 code)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.issealed |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.seal()`
* `Object.preventExtensions()`
* `Object.isExtensible()`
* `Object.freeze()`
* `Object.isFrozen()`
Object.preventExtensions()
==========================

O método **`Object.preventExtensions()`** impede que novas propriedades sejam adicionadas a um objeto (isto é, impede futuras extensões ao objeto).

Syntax
------
```

Object.preventExtensions(obj)
```

### Parâmetros

`obj`

O objeto a tornar-se não-extensível.

### Valor de retorno

Um objeto tornado não-extensível.

Descrição
---------

Um objeto é extensível se novas propriedades puderem der adicionadas ao mesmo. `Object.preventExtensions()` marca um objeto como não mais extensível, de forma que este nunca terá novas propriedades além daquelas que o objeto tinha quando foi marcado como não-extensível. Note que as propriedades de um objeto não-extensível, em geral, ainda poderão ser *apagadas*. Tentativas de adicionar novas propriedades a um objeto não-extensível falharão, tanto silenciosamente ou lançando uma exceção `TypeError` (mais comumente, mas não exclusivamente, quando em strict mode (en-US)).

`Object.preventExtensions()` evita apenas a adição de novas propriedades diretas. Proprieades ainda poderão ser adicionadas ao protótipo do objeto.

É impossível tornar um objeto extensível novamente uma vez que o mesmo tenha se tornado não-extensível.

Exemplos
--------


```js
// Object.preventExtensions retorna o objeto
// tornado não-extensível.
var obj = {};
var obj2 = Object.preventExtensions(obj);
obj === obj2; // verdadeiro

// Objetos são extensíveis por padrão...
var empty = {};
Object.isExtensible(empty); // === verdadeiro

// ...mas isso pode ser mudado.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === falso

// Object.defineProperty lança erro quando adiciona-se
// uma nova propriedade a um objeto não-extensível.
var nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", {
  value: 8675309,
}); // lança um TypeError

// No modo restrito, tentar adicionar novas propriedades a
// um objeto não-extensível lança um TypeError.
function fail() {
  "use strict";
  // lança um TypeError
  nonExtensible.newProperty = "FAIL";
}
fail();
```


O protótipo não-extensível de um objeto é imutável:


```js
var fixed = Object.preventExtensions({});
// lança um 'TypeError'.
fixed.__proto__ = { oh: "hai" };
```

Notas
-----

No ES5, se o argumento atribuído a este método não for um objeto (for um primitivo), isso causará um erro de tipo `TypeError`. No ES2015, um argumento não-objeto será tratado como se o mesmo fosse um objeto não-extensível comum, simplesmente retornando-o.


```js
Object.preventExtensions(1);
// TypeError: 1 não é um objeto (código ES5)

Object.preventExtensions(1);
// 1 (código ES2015)
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.preventextensions |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Object.isExtensible()`
* `Object.seal()`
* `Object.isSealed()`
* `Object.freeze()`
* `Object.isFrozen()`
* `Reflect.preventExtensions()` (en-US)
RegExp.prototype.ignoreCase
===========================

O atributo **`ignoreCase`** indica se a flag "i" foi ou não utilizada com a expressão regular.`ignoreCase` é um atributo somente leitura de uma instância individual de expressãoregular.Experimente
-----------

| Property attributes of `RegExp.prototype.ignoreCase` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Descrição
---------

O valor de `ignoreCase` é um `Boolean` e`true` se a flag "`i`" foi usada; `false` caso contrário. A flag "i" indica que maiúsculas e minúsculas são equivalentes ao se tentar casar uma string com a expressão regular.

Você não pode alterar essa propriedade diretamente.

Exemplos
--------

### Usando `ignoreCase`


```js
var regex = new RegExp("foo", "i");

console.log(regex.ignoreCase); // true
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.ignorecase |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global` (en-US)
* `RegExp.prototype.multiline` (en-US)
* `RegExp.prototype.source` (en-US)
* `RegExp.prototype.sticky`
RegExp.prototype.sticky
=======================

A propriedade **`sticky`** indica se a busca é "pegajosa" (percorre a string somente a partir do índice indicado pela propriedade `lastIndex` (en-US) desta expressão regular). A propriedade `sticky` em um objeto de expressão regular é somente para leitura.

Experimente
-----------

| Property attributes of `RegExp.prototype.sticky` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | yes |

Descrição
---------

O valor de `sticky` é do tipo `Boolean` e será *true* quando a flag "`y`" for utilizada; senão, será *false*. A flag "`y`" indica que as correspondências ocorrerão apenas a partir do indice indicado pela propriedade `lastIndex` (en-US) desta expressão regular na string alvo (e não buscará correspondência em nenhum índice anterior). Uma expressão regular definida como `sticky` e `global` ignora a flag `global`.

Você não pode alterar essa propriedade diretamente. Ela é somente para leitura.

Exemplos
--------

### Uilizando uma expressão regular com a flag *sticky*


```js
var str = "#foo#";
var regex = /foo/y;

regex.lastIndex = 1;
regex.test(str); // true
regex.lastIndex = 5;
regex.test(str); // false (lastIndex é levado em conta com a flag sticky)
regex.lastIndex; // 0 (reinicia quando não ocorre correspondência)
```

### Flag sticky ancorada

Por diversas versões, a engine SpiderMonkey do Firefox apresentou um bug na asserção de `^` com a flag *sticky* que fazia expressões iniciando com `^` e usando a flag *sticky* encontrarem correspondências onde não deveriam. O bug foi introduzido algum tempo após o Firefox 3.6 (que possuía a flag sticky mas não apresentava o bug) e corrigido em 2015. Talvez por este motivo, a especificação ES2015 destaca especificamente que:

> 
> Quando a flag `y` for usada em um padrão, ^ indica que a correspondência ocorrerá apenas no início da entrada, ou (se `multiline` for `true`) no início de uma linha.
> 
> 
> 

Exemplos de comportamento esperado:


```js
var regex = /^foo/y;
regex.lastIndex = 2;
regex.test("..foo"); // false - índice 2 não é o início da string

var regex2 = /^foo/my;
regex2.lastIndex = 2;
regex2.test("..foo"); // false - índice 2 não é o início da string nem da linha
regex2.lastIndex = 2;
regex2.test(".\nfoo"); // true - índice 2 é o início da linha
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-get-regexp.prototype.sticky |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `RegExp.lastIndex` (en-US)
* `RegExp.prototype.global` (en-US)
* `RegExp.prototype.ignoreCase`
* `RegExp.prototype.multiline` (en-US)
* `RegExp.prototype.source` (en-US)
RegExp.prototype.compile()
==========================

**Deprecated:** This feature is no longer recommended. Though some browsers might still support it, it may have already been removed from the relevant web standards, may be in the process of being dropped, or may only be kept for compatibility purposes. Avoid using it, and update existing code if possible; see the compatibility table at the bottom of this page to guide your decision. Be aware that this feature may cease to work at any time.

O método **`compile()`** está depreciado, é usado para (re-)compilar uma expressão regular durante a execução de um script. É basicamente o mesmo que o construtor `RegExp`.

Sintaxe
-------
```

regexObj.compile(pattern, flags)
```

### Parâmetros

`pattern`

É o texto da expressão regular.

`flags`

Se especificado, as flags podem ter qualquer combinação dos seguintes valores:

`g`

global.

`i`

ignorar caso.

`m`

multilinha; trata os caracteres iniciais e finais como (^ e $), trabalhando sobre várias linhas (isto é, corresponde ao início ou ao final de cada linha (delimitado por \n ou \r), não apenas o começo, ou o final de toda a cadeia de entrada).

`y`

sticky; corresponde apenas ao índice indicado pela propriedade `lastIndex` dessa expressão regular na cadeia de destino (e não tenta corresponder a partir de índices posteriores).


Descrição
---------

O método de `compilação` é obsoleto. Você pode simplesmente usar o construtor `RegExp` para obter o mesmo efeito.

Exemplos
--------

### Usando `compile()`

O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova flag.


```js
var regexObj = new RegExp("foo", "gi");
regexObj.compile("new foo", "g");
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-regexp.prototype.compile |

Browser compativeis
-------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `RegExp`