recursal/MDN huggingface dataset:
Object.prototype.propertyIsEnumerable()
=======================================

O método **`propertyIsEnumerable()`** retorna um booleano indicando quando a propriedade especificada é enumerável e é a propriedade do próprio objeto

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

Sintaxe
-------
```

obj.propertyIsEnumerable(prop)
```

### Parâmetros

`prop`

O nome da propriedade para teste

### Valor de Retorno

O `Boolean` indicando se a propriedade especificada é enumeravel e é a propriedade do objeto

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

Every object has a `propertyIsEnumerable` method. This method can determine whether the specified property in an object can be enumerated by a `for...in` loop, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns `false`.

Exemplos
--------

### O uso basico de `propertyIsEnumerable`

O exemplos a seguir mostram o uso de `propertyIsEnumerable` em um objeto e um array:


```js
var o = {};
var a = [];
o.prop = "is enumerable";
a[0] = "is enumerable";

o.propertyIsEnumerable("prop"); // returns true
a.propertyIsEnumerable(0); // returns true
```

### Objetos User-defined vs. built-in

Os exemplos a seguir demostram a enumerabilidade da propriedade user-defined vs. built-in :


```js
var a = ["is enumerable"];

a.propertyIsEnumerable(0); // returns true
a.propertyIsEnumerable("length"); // returns false

Math.propertyIsEnumerable("random"); // returns false
this.propertyIsEnumerable("Math"); // returns false
```

### Propriedade Direct vs. inherited


```js
var a = [];
a.propertyIsEnumerable("constructor"); // returns false

function firstConstructor() {
  this.property = "is not enumerable";
}

firstConstructor.prototype.firstMethod = function () {};

function secondConstructor() {
  this.method = function () {
    return "is enumerable";
  };
}

secondConstructor.prototype = new firstConstructor();
secondConstructor.prototype.constructor = secondConstructor;

var o = new secondConstructor();
o.arbitraryProperty = "is enumerable";

o.propertyIsEnumerable("arbitraryProperty"); // returns true
o.propertyIsEnumerable("method"); // returns true
o.propertyIsEnumerable("property"); // returns false

o.property = "is enumerable";

o.propertyIsEnumerable("property"); // returns true

// These return false as they are on the prototype which
// propertyIsEnumerable does not consider (even though the last two
// are iteratable with for-in)
o.propertyIsEnumerable("prototype"); // returns false (as of JS 1.8.1/FF3.6)
o.propertyIsEnumerable("constructor"); // returns false
o.propertyIsEnumerable("firstMethod"); // returns false
```

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

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

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

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

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

* Enumerability and ownership of properties
* `for...in`
* `Object.keys()`
* `Object.defineProperty()`
Object.values()
===============

**Experimental:** **Esta é uma tecnologia experimental (en-US)**  
Verifique a tabela de compatibilidade entre Navegadores cuidadosamente antes de usar essa funcionalidade em produção.

O método **`Object.values()`** retorna um array com os valores das propriedades de um dado objeto, na mesma ordem provida pelo `for...in` laço (sendo a diferença que o laço for-in também enumera as propriedades na cadeia prototype).

Sintaxe
-------
```

Object.values(obj)
```

### Parâmetros

`obj`

O objeto cujos valores das propriedades enumeradas serão retornados.

### Valor de retorno

Um array contendo os valores das propriedades enumeradas do dado objeto.

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

`Object.values()` retorna um array cujos elementos são os valores das propriedades enumeradas encontradas no objeto. A ordem das propriedades é a mesma que a dada pelo laço sobre os valores da propriedade do objeto manualmente.

Exemplos
--------


```js
var obj = { foo: "bar", baz: 42 };
console.log(Object.values(obj)); // ['bar', 42]

// array como objeto
var obj = { 0: "a", 1: "b", 2: "c" };
console.log(Object.values(obj)); // ['a', 'b', 'c']

// array como objeto com ordenação de chave aleatória
var an_obj = { 100: "a", 2: "b", 7: "c" };
console.log(Object.values(an_obj)); // ['b', 'c', 'a']

// getFoo é a propriedade a qual não é enumerável
var my_obj = Object.create(
  {},
  {
    getFoo: {
      value: function () {
        return this.foo;
      },
    },
  },
);
my_obj.foo = "bar";
console.log(Object.values(my_obj)); // ['bar']

// argumento não-objeto será coagido num objeto
console.log(Object.values("foo")); // ['f', 'o', 'o']
```

Biblioteca de Suporte
---------------------

`Para adicionar compatibilidade ao suporte de Object.values` em ambientes antigos que nativamente não o suportam, você pode encontrar uma biblioteca de suporte nos repositórios tc39/proposal-object-values-entries ou no es-shims/Object.values.

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

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

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

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

Ver também
----------

* Enumerability and ownership of properties
* `Object.keys()`
* `Object.entries()` 
Experimental
* `Object.prototype.propertyIsEnumerable()`
* `Object.create()`
* `Object.getOwnPropertyNames()`
Object.prototype.\_\_defineSetter\_\_()
=======================================

**Aviso:** Esta funcionalidade está depreciada em favor da definição de setters usando a sintaxe de inicialização de objeto ou a API `Object.defineProperty()`.

Entretando, como ele é largamente implementado e usado na Web, é bem improvável que os navegadores vão parar de implementá-lo.

O método **`__defineSetter__`** vincula uma propriedade de um objeto a uma função a ser chamada quando é feita uma tentativa de atribuir algo a aquela propriedade.

Sintaxe
-------
```

obj.__defineSetter__(prop, fun)
```

### Parâmetros

`prop`

Uma cadeia de caracteres (*string*) contendo o nome da propriedade que vai ser vinculada a função dada.

`fun`

A função a ser chamada quando houver uma tentativa de atribuir na propriedade especificada. Esta função toma a forma


```js
function(val) { . . . }
```


`val`

Um apelido para a variável que contém o valor que se tentou atribuir a `prop`.


### Valor de retorno

`undefined`.

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

O método `__defineSetter__` permite um setter (en-US) ser definido a um objeto pré-existente.

Exemplos
--------

### Não padronizados e forma depreciada


```js
var o = {};
o.\_\_defineSetter\_\_("value", function (val) {
  this.anotherValue = val;
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

### Formas compatíveis padronizadas


```js
// Usando o operador set
var o = {
  set value(val) {
    this.anotherValue = val;
  },
};
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5

// Usando Object.defineProperty
var o = {};
Object.defineProperty(o, "value", {
  set: function (val) {
    this.anotherValue = val;
  },
});
o.value = 5;
console.log(o.value); // undefined
console.log(o.anotherValue); // 5
```

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

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

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

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

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

* `Object.prototype.__defineGetter__()`
* Operador `set` (en-US)
* `Object.defineProperty()`
* `Object.prototype.__lookupGetter__()`
* `Object.prototype.__lookupSetter__()`
* JS Guide: Defining Getters and Setters
* [Blog Post] Deprecation of \_\_defineGetter\_\_ and \_\_defineSetter\_\_
* bug 647423
Object.isExtensible()
=====================

O método **`Object.isExtensible()`** verifica se um objeto pode ser extendido (se é ou não possível adicinar novas propriedades).

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

Sintaxe
-------
```

Object.isExtensible(obj)
```

### Parâmetros

`obj`

O objeto a ser verificado.

### Valor de retorno

Um valor booleano (`Boolean`) que indica se o objeto pode ser extendido.

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

Objetos são extensíveis por padrão: novas propriedades podem ser adicionadas, e (em ambientes que suportam `Object.prototype.__proto__` 
Deprecated
) a propriedade \_\_proto\_\_ pode ser modificada. Um objeto pode ser marcado como não extensível usando `Object.preventExtensions()`, `Object.seal()`, ou `Object.freeze()`.

Exemplos
--------


```js
// Novos objetos podem ser extendidos.
var empty = {};
Object.isExtensible(empty); // === true

// ...mas isso pode mudar.
Object.preventExtensions(empty);
Object.isExtensible(empty); // === false

// Objetos selados, não podem ser extendidos.
var sealed = Object.seal({});
Object.isExtensible(sealed); // === false

// Objetos congelados também não podem ser extendidos.
var frozen = Object.freeze({});
Object.isExtensible(frozen); // === false
```

Notas
-----

No ES5, se o argumento fornecido não for um objeto (um tipo primitivo), isso vai causar um erro do tipo `TypeError`. No ES2015, um argumento que não é um objeto será tratado como um objeto não extensível, simplesmente retornando `false`.


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

Object.isExtensible(1);
// false (ES2015 code)
```

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

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

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

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

See also
--------

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

O método **`Object.getPrototypeOf()`** retorna o prototype (isto é, o valor da propriedade interna `[[Prototype]]`) do objeto especificado.

Sintaxe
-------
```

Object.getPrototypeOf(obj)
```

### Parâmetros

`obj`

O objeto cujo prototype será retornado.

Exemplos
--------


```js
var proto = {};
var obj = Object.create(proto);
Object.getPrototypeOf(obj) === proto; // true
```

Notas
-----

No ES5 será lançada uma exceção `TypeError` se o parâmetro obj não for um objeto. No ES6, no entanto, esse valor será submetido a um `Object` equivalente ao seu tipo e retornado.


```js
Object.getPrototypeOf("foo");
// TypeError: "foo" não é um objeto (código ES5)
Object.getPrototypeOf("foo");
// String.prototype (código ES6)
```

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

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

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

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

Notas específicas para o Opera
------------------------------

Embora as versões mais antigas do Opera não suportem `Object.getPrototypeOf()`, ele suporta a propriedade não oficial `Object.prototype.__proto__` desde de a sua versão 10.50.

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

* `Object.prototype.isPrototypeOf()`
* `Object.setPrototypeOf()` 
Experimental
* `Object.prototype.__proto__`
* John Resig's post on getPrototypeOf
* `Reflect.getPrototypeOf()` (en-US)
Object.getOwnPropertySymbols()
==============================

O **`Object.getOwnPropertySymbols()`** método retorna uma array com todas propriedades de símbolo encontradas diretamente em um determinado objeto dado.

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

Sintaxe
-------


```js
Object.getOwnPropertySymbols(obj);
```

### Parâmetro

`obj`

O objeto pelo qual as propriedades de símbolos são retornas.

### Valor retornado

Uma array com todas as propriedades de símbolos encontradas diretamente pelo o objeto dado.

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

Similar do `Object.getOwnPropertyNames()`, você pode obter todas as propriedades de símbolo de um objeto dado como um array de símbolos. Lembre que o próprio `Object.getOwnPropertyNames()` não contém as propriedades de símbolo de um objeto e somente as propriedades de string.

Como todos os objetos não possuem símbolos próprios inicialmente, o `Object.getOwnPropertySymbols()` retorna uma array vazia a menos que você tenha definido as propriedades de símbolo do seu objeto .

Exemplos
--------

### Usando getOwnPropertySymbols


```js
var obj = {};
var a = Symbol("a");
var b = Symbol.for("b");

obj[a] = "localSymbol";
obj[b] = "globalSymbol";

var objectSymbols = Object.getOwnPropertySymbols(obj);

console.log(objectSymbols.length); // retorno esperado 2
console.log(objectSymbols); // retorno esperado (2) [Symbol(a), Symbol(b)]
console.log(objectSymbols[0]); // retorno esperado Symbol(a)
```

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

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

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

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

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

* `Object.getOwnPropertyNames()`
* `Symbol`
Object.prototype.\_\_lookupGetter\_\_()
=======================================

**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 **`__lookupGetter__`** retorna a função limite como uma getter para a específica propriedade.

Sintaxe
-------
```

obj.__lookupGetter__(sprop)
```

### Parâmetros

`sprop`

Uma sequência de caracteres contendo o nome da propriedade cuja getter deve retornar.

### Valores de retorno

A função limite como uma getter para a específica propriedade.

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

Se uma getter foi definida por uma propriedade de um objeto, não é possível referir-se a função getter através da propriedade, porque essa propriedade se refere ao retorno do valor daquela função. `__lookupGetter__` pode ser usado para obter referência à função getter.

Agora é possível fazer isso de um jeito uniforme usando:. `Object.getOwnPropertyDescriptor()` e `Object.getPrototypeOf()`.

Exemplos
--------


```js
var obj = {
  get foo() {
    return Math.random() > 0.5 ? "foo" : "bar";
  },
};

// Non-standard and deprecated way
obj.\_\_lookupGetter\_\_("foo");
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })

// Standard-compliant way
Object.getOwnPropertyDescriptor(obj, "foo").get;
// (function() { return Math.random() > 0.5 ? 'foo' : 'bar'; })
```

Specificações
-------------

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

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

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

Ver também
----------

* `Object.prototype.__lookupSetter__()`
* `get` operador
* `Object.getOwnPropertyDescriptor()` e `Object.getPrototypeOf()`
* `Object.prototype.__defineGetter__()`
* `Object.prototype.__defineSetter__()`
* JS Guide: Defining Getters and Setters
Object.getOwnPropertyDescriptors()
==================================

O **`Object.getOwnPropertyDescriptors()`** método retorna todas as descrições próprias da propriedade de um dado objeto.

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

Sintaxe
-------
```

Object.getOwnPropertyDescriptors(obj)
```

### Parâmetro

`obj`

O objeto pelo o qual deseja obter todos os descritores de propriedade próprios.

### Valor retornado

Um objeto contendo todas as propriedades descritivas de um objeto. Pode ser um objeto vazio, se não existir propriedade.

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

Esse método permite examinar a descrição precisa de todas as propriedades de um objeto. Uma propriedade em JavaScript consiste de um nome com valor string ou um `Symbol` e uma propriedade descritora. Outras informações sobre propriedade de tipo descritoras e seus atributos podem ser encontradas em `Object.defineProperty()`.

Uma propriedade descritora é um registro com alguns dos seguintes atributos:

`value`

O valor associdado com à propriedade (somente descritores de dados).

**`writable`**

`true` se somente o valor associado com a propriedade pode ser alterada (somente descritores de dados).

`get`

Uma função que serve como um capturador para a propriedade ou `undefined` se não existir um capturador (somente descritores de acesso).

`set`

Uma função que serve como um configurador para a propriedade, ou `undefined` se não existir um configurador (somente descritores de acesso).

`configurable`

`true` se e somente se o tipo da propriedade descritora pode ser alterada e se a propriedade pode ser deletada do objeto correspondente.

`enumerable`

`true` se e somente se essa propriedade se mostrar durante a enumeração da propriedade no objeto correspondente.

Exemplos
--------

### Criando um clone superficial

Enquanto o `Object.assign()` método vai copiar somente o enumerável e as próprias propriedades da origem de um objeto para o objeto alvo, você é capaz de usar esse método e `Object.create()` para uma cópia superficial entre dois objetos desconhecidos:


```js
Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj),
);
```

### Criando uma subclasse

Um modo típico de criar uma subclasse é definir a subclasse, configurar um protótipo para uma instância da superclasse e depois difinir as propriedades daquela instância. Isso pode ficar estranho especialmente para os capturadores e configuradores. Ao invés disso, você pode usar esse código para configurar o protótipo :


```js
function superclass() {}
superclass.prototype = {
  // Define seu método e propriedades aqui
};
function subclass() {}
subclass.prototype = Object.create(superclass.prototype, {
  // Define seu método e propriedades aqui
});
```

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

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

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

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

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

* `Object.getOwnPropertyDescriptor()`
* `Object.defineProperty()`
* Polyfill
Object.fromEntries()
====================

O método **`Object.fromEntries()`** transforma uma lista de pares chave-valor em um objeto.

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

Sintaxe
-------
```

Object.fromEntries(iterable);
```

### Parâmetros

`iterable`

Um iterável como `Array` ou `Map` ou qualquer outro objeto que implemente o protocolo iterável.

### Valor de retorno

Um novo objeto com suas propriedades definidas pelas entradas fornecidadas pelo iterável.

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

O método `Object.fromEntries()` recebe uma lista de pares chave-valor e retorna um novo objeto cujas propriedades foram definidas pelas entradas da lista. O parâmetro *iterable* deve ser um objeto que implemente o método `@@iterator`, que retorne um objeto iterador que produza um objeto *array-like* de dois elementos, onde o primeiro será a chave da propriedade e o segundo será o valor associado à chave.

`Object.fromEntries()` faz o inverso de `Object.entries()`.

Exemplos
--------

### Convertendo um `Map` em um `Object`

Com o método `Object.fromEntries`, é possível fazer a conveeção de um `Map` em um `Object`:


```js
const map = new Map([
  ["foo", "bar"],
  ["baz", 42],
]);
const obj = Object.fromEntries(map);
console.log(obj); // { foo: "bar", baz: 42 }
```

### Convertendo um `Array` em um `Object`

Com o método `Object.fromEntries`, é possível converter um `Array` em um `Object`:


```js
const arr = [
  ["0", "a"],
  ["1", "b"],
  ["2", "c"],
];
const obj = Object.fromEntries(arr);
console.log(obj); // { 0: "a", 1: "b", 2: "c" }
```

### Transformações de objetos

Com o método `Object.fromEntries`, seu inverso `Object.entries()`, e os métodos para manipulação de arrays, é possível fazer transformações em objetos como por exemplo:


```js
const object1 = { a: 1, b: 2, c: 3 };

const object2 = Object.fromEntries(
  Object.entries(object1).map(([key, val]) => [key, val \* 2]),
);

console.log(object2);
// { a: 2, b: 4, c: 6 }
```

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

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

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

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

Veja Também
-----------

* `Object.entries()`
* `Object.keys()`
* `Object.values()`
* `Map.prototype.entries()`
* `Map.prototype.keys()`
* `Map.prototype.values()`
Object.prototype.toLocaleString()
=================================

O método **`toLocaleString()`** retorna uma cadeia de caracteres (*string*) representando o objeto. Este método é feito para ser sobrescrito por objetos derivados para propósitos de localização específica.

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

Sintaxe
-------
```

obj.toLocaleString()
```

### Valor de retorno

Uma *string* representando o objeto.

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

`toLocaleString` do `Object` retorna o resultado da chamada `toString()`.

Esta função é provida para dar aos objetos um método `toLocaleString` genérico, mesmo que nem todos os usem. Veja a lista abaixo.

### Objetos sobrescrevendo toLocaleString

* `Array`: `Array.prototype.toLocaleString()`
* `Number`: `Number.prototype.toLocaleString()`
* `Date`: `Date.prototype.toLocaleString()` (en-US)
* `TypedArray` (en-US): `TypedArray.prototype.toLocaleString()` (en-US)
* `BigInt`: `BigInt.prototype.toLocaleString()` (en-US)
Exemplos
--------

### Sobrescrita do Array toLocaleString()

Em objetos `Array`, `toLocaleString()` pode ser usado para imprimir valores do arranjo como uma *string*, opcionalmente com identificadores de localização específicos (como símbolos monetários) atrelados a eles:

Por exemplo:


```js
const testArray = [4, 7, 10];

let euroPrices = testArray.toLocaleString("fr", {
  style: "currency",
  currency: "EUR",
});
// "4,00 €,7,00 €,10,00 €"
```

### Sobrescrita do Date toLocaleString()

Em objetos `Date`, `toLocaleString()` (en-US) é usado para imprimir datas mais apropriadas para localizações específicas:

Por exemplo:


```js
const testDate = new Date(Date.now());
// "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)"

let deDate = testDate.toLocaleString("de");
// "29.5.2020, 18:04:24"

var frDate = testDate.toLocaleString("fr");
//"29/05/2020 à 18:04:24"
```

### Sobrescrita de Number toLocaleString()

Em objetos `Number`, `toLocaleString()` é usado para imprimir números para localizações específicas, e.g. com os corretos separadores:

Por exemplo:


```js
const testNumber = 2901234564;
// "2901234564"

let deNumber = testNumber.toLocaleString("de");
// "2.901.234.564"

let frNumber = testNumber.toLocaleString("fr");
// "2 901 234 564"
```

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

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

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

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

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

* `Object.prototype.toString()`