¿Qué significa enumerable?

Me dirigieron a MDN para ... en la página cuando decía: "para ... en Itera sobre las propiedades enumerables de un objeto".

Luego fui a la página Enumerabilidad y propiedad de propiedades donde decía "Las propiedades enumerables son aquellas que pueden iterarse mediante un bucle for..in".

El diccionario define enumerable como contable, pero realmente no puedo visualizar lo que eso significa. ¿Puedo obtener un ejemplo de algo enumerable?

Una propiedad enumerable es aquella que se puede incluir y visitar durante los for..inbucles (o una iteración similar de propiedades, como Object.keys()).

Si una propiedad no se identifica como enumerable, el bucle ignorará que está dentro del objeto.

var obj = { key: 'val' };

console.log('toString' in obj); // true
console.log(typeof obj.toString); // "function"

for (var key in obj)
    console.log(key); // "key"

Una propiedad se identifica como enumerable o no por su propio [[Enumerable]]atributo . Puede ver esto como parte del descriptor de la propiedad :

var descriptor = Object.getOwnPropertyDescriptor({ bar: 1 }, 'bar');

console.log(descriptor.enumerable); // true
console.log(descriptor.value);      // 1

console.log(descriptor);
// { value: 1, writable: true, enumerable: true, configurable: true }

for..inLuego, un bucle itera a través de los nombres de propiedad del objeto.

var foo = { bar: 1, baz: 2};

for (var prop in foo)
    console.log(prop); // outputs 'bar' and 'baz'

Pero, solo evalúa su declaración, console.log(prop);en este caso, para aquellas propiedades cuyo [[Enumerable]]atributo es true.

Esta condición está en su lugar porque los objetos tienen muchas más propiedades , especialmente de herencia :

console.log(Object.getOwnPropertyNames(Object.prototype));
// ["constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", /* etc. */]

Cada una de estas propiedades todavía existe en el objeto :

console.log('constructor' in foo); // true
console.log('toString' in foo);    // true
// etc.

Pero, se saltan por el for..inciclo porque no son enumerables.

var descriptor = Object.getOwnPropertyDescriptor(Object.prototype, 'constructor');

console.log(descriptor.enumerable); // false

Si crea un objeto vía myObj = {foo: 'bar'}o algo por el estilo, todas las propiedades son enumerables. Entonces, la pregunta más fácil es: ¿qué no es enumerable? Ciertos objetos tienen algunas propiedades no enumerables, por ejemplo, si llama Object.getOwnPropertyNames([])(que devuelve una matriz de todas las propiedades, enumerables o no, en []), devolverá ['length'], que incluye la propiedad no enumerable de una matriz, 'longitud' .

Puede hacer sus propias propiedades no enumerables llamando a Object.defineProperty:

var person = { age: 18 };
Object.defineProperty(person, 'name', { value: 'Joshua', enumerable: false });

person.name; // 'Joshua'
for (prop in person) {
  console.log(prop);
}; // 'age'

Este ejemplo se basa en gran medida en propiedades no enumerables en JavaScript , pero muestra un objeto que se enumera. Las propiedades pueden ser o no escribibles, configurables o enumerables. John Resig analiza esto en el ámbito de los objetos y propiedades de ECMAScript 5 .

Y, hay una pregunta acerca de desbordamiento de pila por qué te gustaría siempre quiere hacer las propiedades no numerable .

Es mucho más aburrido que algo que debería visualizarse.

Literalmente hay un atributo en todas las propiedades llamado "enumerable". Cuando se establece en falso, el for..inmétodo omitirá esa propiedad, pretenda que no existe.

Hay muchas propiedades en los objetos que tienen "enumerable" establecido en falso, como "valueOf" y "hasOwnProperty", porque se presume que no desea que el motor de JavaScript itere sobre ellos.

Puede crear sus propias propiedades no enumerables utilizando el Object.definePropertymétodo:

  var car = {
    make: 'Honda',
    model: 'Civic',
    year: '2008',
    condition: 'bad',
    mileage: 36000
  };

  Object.defineProperty(car, 'mySecretAboutTheCar', {
    value: 'cat pee in back seat',
    enumerable: false
  });

Ahora, el hecho de que incluso hay un secreto sobre el automóvil está oculto. Por supuesto, aún pueden acceder a la propiedad directamente y obtener la respuesta:

console.log(car.mySecretAboutTheCar); // prints 'cat pee in back seat'

Pero, tendrían que saber que la propiedad existe primero, porque si están intentando acceder a ella for..ino Object.keyspermanecerá completamente en secreto:

console.log(Object.keys(car)); //prints ['make', 'model', 'year', 'condition', 'mileage']

Deberían haberlo llamado "forInAble".

Si tiene dificultades para visualizar "¿qué significa ser enumerable?" ¿Por qué no te preguntas, qué significa ser no numerable ?

Pienso un poco así, existe una propiedad no enumerable pero está parcialmente oculta ; lo que significa que no es enumerable es el extraño. Ahora puede imaginar lo enumerable como lo que queda: la propiedad más natural a la que estamos acostumbrados desde que descubrimos los Objetos . Considerar

var o = {};
o['foo'] =  0;                               // enumerable, normal
Object.defineProperty(o, 'bar', {value: 1}); // nonenumerable, weird

Ahora en un for..in, imagínelo como pseudocódigo

for property in o:
    if not property enumerable continue // skip non-enumerable, "bar"
    else do /* whatever */              // act upon enumerable, "foo"

donde el cuerpo del bucle que escribió en JavaScript está en el lugar de/* whatever */

Escribiré una definición de línea de ENUMERABLE

Enumerable: Especifica si la propiedad se puede devolver en un bucle for / in.

var obj = {};
Object.defineProperties(obj, {
    set1: {enumerable: true},
    set2: {enumerable: false},
});
Object.keys(obj); // ["set1"]
Object.getOwnPropertyNames(obj); // ["set1", "set2"]

los métodos no son enumerables; o mejor dicho, los métodos incorporados no son .. después de buscar lo que significa enumerable para el script java; solo se refiere a un atributo de propiedad ... todos los objetos creados en ecma3 son enumerables, y ecma5 ahora puede definirlo ... eso es todo ...: D lol me tomó un poco encontrar la respuesta; pero creo que se menciona en el libro de David Flanagan ... así que supongo que significa "oculto", o no "oculto", ya que los métodos no se muestran en el ciclo for in, y por lo tanto están "ocultos"

Piense en el tipo de datos enum, solo una estructura de objetos que corresponden a diferentes números. Declarar algo como enumerable es declarar que corresponde a un número específico, lo que le permite tener un lugar en un Diccionario que representa componentes contables de un objeto. En pocas palabras, hacer que un objeto sea enumerable es lo mismo que decirle al compilador: "Oye, esta propiedad cuenta, quiero ver esto cuando verifico los datos de este objeto".

Los métodos integrados que heredan los objetos no son enumerables, pero las propiedades que su código agrega a los objetos son enumerables a menos que se indique explícitamente