JavaScript
Objetos

Sintaxis

• objeto = {}
• objeto = nuevo objeto ()
• object = Object.create (prototype [, propertiesObject])
• object.key = valor
• objeto ["clave"] = valor
• objeto [Símbolo ()] = valor
• object = {key1: value1, "key2": value2, 'key3': value3}
• object = {conciseMethod () {…}}
• object = {[computed () + "key"]: value}
• Object.defineProperty (obj, propertyName, propertyDescriptor)
• property_desc = Object.getOwnPropertyDescriptor (obj, propertyName)
• Object.freeze (obj)
• Object.seal (obj)

Parámetros

Observaciones

Object.keys

var obj = {
    a: "hello",
    b: "this is",
    c: "javascript!"
};

var keys = Object.keys(obj);

console.log(keys); // ["a", "b", "c"]

Clonación superficial

const existing = { a: 1, b: 2, c: 3 };

const clone = Object.assign({}, existing);

La desestructuración de objetos / reposo de objetos, que actualmente es una propuesta de la etapa 3, proporciona una forma aún más sencilla de crear clones superficiales de instancias de objetos:

const existing = { a: 1, b: 2, c: 3 };

const { ...clone } = existing;

Si necesita admitir versiones anteriores de JavaScript, la forma más compatible de clonar un Objeto es iterar manualmente sus propiedades y filtrar las heredadas utilizando .hasOwnProperty() .

var existing = { a: 1, b: 2, c: 3 };

var clone = {};
for (var prop in existing) {
  if (existing.hasOwnProperty(prop)) {
    clone[prop] = existing[prop];
  }
}

Object.defineProperty

var obj = { };

Object.defineProperty(obj, 'foo', { value: 'foo' });

console.log(obj.foo);

Salida de consola

foo

Object.defineProperty puede llamar a Object.defineProperty con las siguientes opciones:

Object.defineProperty(obj, 'nameOfTheProperty', {
  value: valueOfTheProperty, 
  writable: true, // if false, the property is read-only
  configurable : true, // true means the property can be changed later
  enumerable : true // true means property can be enumerated such as in a for..in loop
});

Object.defineProperties permite definir múltiples propiedades a la vez.

var obj = {};
Object.defineProperties(obj, {
  property1: {
    value: true,
    writable: true
  },
  property2: {
    value: 'Hello',
    writable: false
  }      
});

Propiedad de solo lectura

La propiedad de writable en un descriptor de propiedad indica si esa propiedad se puede cambiar o no.

var a  = { };

Object.defineProperty(a, 'foo', { value: 'original', writable: false });

a.foo = 'new';

console.log(a.foo);

Salida de consola

original

Propiedad no enumerable

La propiedad enumerable del descriptor de propiedad indica si esa propiedad se enumerará mientras recorre las propiedades del objeto.

var obj = { };

Object.defineProperty(obj, "foo", { value: 'show', enumerable: true });
Object.defineProperty(obj, "bar", { value: 'hide', enumerable: false });

for (var prop in obj) {
    console.log(obj[prop]);
}

Salida de consola

espectáculo

Descripción de la propiedad de bloqueo

La propiedad configurable del descriptor de propiedad se utiliza para rechazar cualquier cambio adicional en el descriptor.

var obj = {};

// Define 'foo' as read only and lock it
Object.defineProperty(obj, "foo", { 
    value: "original value", 
    writable: false, 
    configurable: false
});
 
Object.defineProperty(obj, "foo", {writable: true});

Este error será lanzado:

TypeError: No se puede redefinir la propiedad: foo

Y la propiedad seguirá siendo de solo lectura.

obj.foo = "new value";
console.log(foo);

Salida de consola

Valor original

Propiedades de accesorios (obtener y configurar)

La propiedad get del descriptor de propiedad es una función que se llamará para recuperar el valor de la propiedad.

La propiedad set es también una función, se llamará cuando la propiedad tenga asignado un valor y el nuevo valor se pasará como argumento.

No puede asignar un value o writable a un descriptor que tiene get o set

var person = { name: "John", surname: "Doe"};
Object.defineProperty(person, 'fullName', { 
    get: function () { 
        return this.name + " " + this.surname;
    },
    set: function (value) {
        [this.name, this.surname] = value.split(" ");
    }
});

console.log(person.fullName); // -> "John Doe"

person.surname = "Hill";
console.log(person.fullName); // -> "John Hill"

person.fullName = "Mary Jones";
console.log(person.name) // -> "Mary"

Propiedades con caracteres especiales o palabras reservadas.

Si bien la notación de propiedad del objeto generalmente se escribe como myObject.property , esto solo permitirá caracteres que normalmente se encuentran en los nombres de variables de JavaScript , que son principalmente letras, números y guiones bajos ( _ ).

Si necesita caracteres especiales, como espacio, o contenido proporcionado por el usuario, esto es posible mediante la notación de corchetes [] .

myObject['special property ☺'] = 'it works!'
console.log(myObject['special property ☺'])

Propiedades de todos los dígitos:

Además de los caracteres especiales, los nombres de propiedades que son todos dígitos requieren notación de corchete. Sin embargo, en este caso, la propiedad no necesita escribirse como una cadena.

myObject[123] = 'hi!' // number 123 is automatically converted to a string
console.log(myObject['123']) // notice how using string 123 produced the same result
console.log(myObject['12' + '3']) // string concatenation
console.log(myObject[120 + 3]) // arithmetic, still resulting in 123 and producing the same result
console.log(myObject[123.0]) // this works too because 123.0 evaluates to 123
console.log(myObject['123.0']) // this does NOT work, because '123' != '123.0'

Sin embargo, los ceros iniciales no se recomiendan, ya que se interpreta como notación octal. (TODO, deberíamos producir y vincular a un ejemplo que describa la notación octal, hexadecimal y exponente)

Véase también el ejemplo: [Las matrices son objetos].

Nombres de propiedades dinámicas / variables

A veces, el nombre de la propiedad debe almacenarse en una variable. En este ejemplo, le preguntamos al usuario qué palabra debe buscarse y luego proporcionamos el resultado de un objeto que he llamado dictionary .

var dictionary = {
    lettuce: 'a veggie',
    banana: 'a fruit',
    tomato: 'it depends on who you ask',
    apple: 'a fruit',
    Apple: 'Steve Jobs rocks!' // properties are case-sensitive
}

var word = prompt('What word would you like to look up today?')
var definition = dictionary[word]
alert(word + '\n\n' + definition)

Observe cómo estamos usando la notación de corchetes [] para ver la variable denominada word ; Si tuviéramos que utilizar el tradicional . notación, entonces tomaría el valor literalmente, por lo tanto:

console.log(dictionary.word)  // doesn't work because word is taken literally and dictionary has no field named `word`
console.log(dictionary.apple) // it works! because apple is taken literally

console.log(dictionary[word]) // it works! because word is a variable, and the user perfectly typed in one of the words from our dictionary when prompted
console.log(dictionary[apple]) // error! apple is not defined (as a variable)

También puede escribir valores literales con notación [] reemplazando la word variable con una cadena 'apple' . Ver el ejemplo de [Propiedades con caracteres especiales o palabras reservadas].

También puede establecer propiedades dinámicas con la sintaxis de corchete:

var property="test";
var obj={
 [property]=1;
};

console.log(obj.test);//1

Hace lo mismo que:

var property="test";
var obj={};
obj[property]=1;

Las matrices son objetos

Descargo de responsabilidad: no se recomienda crear objetos de tipo matriz. Sin embargo, es útil comprender cómo funcionan, especialmente cuando se trabaja con DOM. Esto explicará por qué las operaciones de matriz regulares no funcionan en objetos DOM devueltos por muchas funciones de document DOM. (es decir querySelectorAll , form.elements )

Suponiendo que creamos el siguiente objeto que tiene algunas propiedades que esperaría ver en un Array.

var anObject = {
    foo: 'bar',
    length: 'interesting',
    '0': 'zero!',
    '1': 'one!'
};

Entonces vamos a crear una matriz.

var anArray = ['zero.', 'one.'];

Ahora, observe cómo podemos inspeccionar tanto el objeto como la matriz de la misma manera.

console.log(anArray[0], anObject[0]); // outputs: zero.  zero!
console.log(anArray[1], anObject[1]); // outputs: one.  one!
console.log(anArray.length, anObject.length); // outputs: 2 interesting
console.log(anArray.foo, anObject.foo); // outputs: undefined bar

Dado que anArray es en realidad un objeto, al igual que anObject , incluso podemos agregar propiedades personalizadas a anArray

Descargo de responsabilidad: las matrices con propiedades personalizadas generalmente no se recomiendan ya que pueden ser confusas, pero pueden ser útiles en casos avanzados en los que necesite las funciones optimizadas de una matriz. (es decir, objetos jQuery)

anArray.foo = 'it works!';
console.log(anArray.foo);

Incluso podemos hacer que un anObject sea ​​un objeto anObject a una matriz agregando una length .

anObject.length = 2;

Luego, puede usar el estilo C for bucle para iterar sobre un anObject como si fuera un Array. Ver Iteración de Array

Tenga en cuenta que anObject es solo un objeto similar a una matriz . (También conocido como una lista) No es una verdadera matriz. Esto es importante, ya que las funciones como push y forEach (o cualquier función de conveniencia que se encuentre en Array.prototype ) no funcionarán de forma predeterminada en los objetos similares a una matriz.

Muchos de los DOM document funciones devolverá una lista (es decir querySelectorAll , form.elements ), que es similar a la matriz similar a anObject que hemos creado anteriormente. Consulte Conversión de objetos similares a matrices en matrices.

console.log(typeof anArray == 'object', typeof anObject == 'object'); // outputs: true  true
console.log(anArray instanceof Object, anObject instanceof Object); // outputs: true  true
console.log(anArray instanceof Array, anObject instanceof Array); // outputs: true  false
console.log(Array.isArray(anArray), Array.isArray(anObject)); // outputs: true  false

Object.freeze

Las operaciones que siguen a la congelación fallarán silenciosamente a menos que el código se ejecute en modo estricto. Si el código está en modo estricto, se lanzará un TypeError .

var obj = {
  foo: 'foo',
  bar: [1, 2, 3],
  baz: {
    foo: 'nested-foo'
  }
};

Object.freeze(obj);

// Cannot add new properties
obj.newProperty = true;

// Cannot modify existing values or their descriptors
obj.foo = 'not foo';
Object.defineProperty(obj, 'foo', {
    writable: true
});

// Cannot delete existing properties
delete obj.foo;

// Nested objects are not frozen
obj.bar.push(4);
obj.baz.foo = 'new foo';

Object.seal

var obj = { foo: 'foo', bar: function () { return 'bar'; } };

Object.seal(obj)

obj.newFoo = 'newFoo';
obj.bar = function () { return 'foo' };

obj.newFoo; // undefined
obj.bar(); // 'foo'

// Can't make foo an accessor property
Object.defineProperty(obj, 'foo', { 
    get: function () { return 'newFoo'; }
}); // TypeError

// But you can make it read only
Object.defineProperty(obj, 'foo', { 
    writable: false
}); // TypeError

obj.foo = 'newFoo';
obj.foo; // 'foo';

(function () {
    'use strict';

    var obj = { foo: 'foo' };

    Object.seal(obj);

    obj.newFoo = 'newFoo'; // TypeError
}());

Creando un objeto iterable

var myIterableObject = {};
// An Iterable object must define a method located at the Symbol.iterator key:
myIterableObject[Symbol.iterator] = function () {
  // The iterator should return an Iterator object
  return {
    // The Iterator object must implement a method, next()
    next: function () {
      // next must itself return an IteratorResult object 
      if (!this.iterated) {
        this.iterated = true;
        // The IteratorResult object has two properties
        return {
          // whether the iteration is complete, and
          done: false,
          // the value of the current iteration
          value: 'One'
        };
      }
      return {
        // When iteration is complete, just the done property is needed
        done: true
      };
    },
    iterated: false
  };
};

for (var c of myIterableObject) {
  console.log(c); 
}

Objeto reposo / propagación (...)

let obj = { a: 1 };

let obj2 = { ...obj, b: 2, c: 3 };

console.log(obj2); // { a: 1, b: 2, c: 3 };

let obj3 = { ...obj, b: { c: 2 } };

console.log(obj3); // { a: 1, b: { c: 2 } };

Descriptores y propiedades con nombre

Las propiedades son miembros de un objeto. Cada propiedad nombrada es un par de (nombre, descriptor). El nombre es una cadena que permite el acceso (utilizando la notación de punto object.propertyName o el object['propertyName'] notación de corchetes object['propertyName'] ). El descriptor es un registro de campos que definen el comportamiento de la propiedad cuando se accede a ella (qué sucede con la propiedad y cuál es el valor devuelto al acceder a ella). En general, una propiedad asocia un nombre a un comportamiento (podemos pensar en el comportamiento como una caja negra).

Hay dos tipos de propiedades nombradas:

1. propiedad de datos : el nombre de la propiedad está asociado con un valor.
2. propiedad de acceso : el nombre de la propiedad está asociado con una o dos funciones de acceso.

Demostración:

obj.propertyName1 = 5; //translates behind the scenes into
                       //either assigning 5 to the value field* if it is a data property
                //or calling the set function with the parameter 5 if accessor property


//*actually whether an assignment would take place in the case of a data property
//also depends on the presence and value of the writable field - on that later on

El tipo de propiedad está determinado por los campos de su descriptor, y una propiedad no puede ser de ambos tipos.

Descriptores de datos -

• Campos obligatorios: value o writable o ambos
• Campos opcionales: configurable , enumerable

Muestra:

{
   value: 10,
   writable: true;
}

Descriptores de accesorios -

• Campos obligatorios: get o set o ambos
• Campos opcionales: configurable , enumerable

Muestra:

{
    get: function () {
        return 10;
    },
    enumerable: true
}

significado de los campos y sus valores por defecto

• Todas estas claves por defecto son false .
• configurable es true si y solo si el tipo de este descriptor de propiedad se puede cambiar y si la propiedad se puede eliminar del objeto correspondiente.
• enumerable es true si y solo si esta propiedad aparece durante la enumeración de las propiedades en el objeto correspondiente.
• writable es true si y solo si el valor asociado con la propiedad se puede cambiar con un operador de asignación.

get y set :

• Estas teclas por defecto están undefined .
• get es una función que sirve como getter para la propiedad, o undefined si no hay getter. La función de retorno será utilizada como el valor de la propiedad.
• set es una función que sirve como setter para la propiedad, o undefined si no hay setter. La función recibirá como único argumento el nuevo valor que se asigna a la propiedad.

value :

• Esta clave por defecto está undefined .
• El valor asociado a la propiedad. Puede ser cualquier valor de JavaScript válido (número, objeto, función, etc.).

Ejemplo:

    var obj = {propertyName1: 1}; //the pair is actually ('propertyName1', {value:1,
                                                                    // writable:true,
                                                                    // enumerable:true,
                                                                    // configurable:true})
    Object.defineProperty(obj, 'propertyName2', {get: function() {
                                                    console.log('this will be logged ' + 
                                 'every time propertyName2 is accessed to get its value');
                                                },
                                            set: function() {
                                                    console.log('and this will be logged ' + 
                                'every time propertyName2\'s value is tried to be set')
                      //will be treated like it has enumerable:false, configurable:false
                                                }});
//propertyName1 is the name of obj's data property 
//and propertyName2 is the name of its accessor property





obj.propertyName1 = 3;
console.log(obj.propertyName1); //3

obj.propertyName2 = 3; //and this will be logged every time propertyName2's value is tried to be set
console.log(obj.propertyName2); //this will be logged every time propertyName2 is accessed to get its value 

Object.getOwnPropertyDescriptor

Obtener la descripción de una propiedad específica en un objeto.

var sampleObject = {
    hello: 'world'
};

Object.getOwnPropertyDescriptor(sampleObject, 'hello');
// Object {value: "world", writable: true, enumerable: true, configurable: true}

Clonación de objetos

Cuando desea una copia completa de un objeto (es decir, las propiedades del objeto y los valores dentro de esas propiedades, etc.), eso se denomina clonación profunda .

var existing = { a: 1, b: { c: 2 } };
var copy = JSON.parse(JSON.stringify(existing));
existing.b.c = 3; // copy.b.c will not change

No hay una función incorporada en JavaScript para crear clones profundos, y no es posible en general crear clones profundos para cada objeto por muchas razones. Por ejemplo,

• los objetos pueden tener propiedades no enumerables y ocultas que no pueden ser detectadas.
• los captadores y definidores de objetos no pueden ser copiados.
• Los objetos pueden tener una estructura cíclica.
• Las propiedades de la función pueden depender del estado en un ámbito oculto.

Suponiendo que tiene un objeto "bonito" cuyas propiedades solo contienen valores primitivos, fechas, matrices u otros objetos "agradables", la siguiente función se puede usar para hacer clones profundos. Es una función recursiva que puede detectar objetos con una estructura cíclica y arrojará un error en tales casos.

function deepClone(obj) {
    function clone(obj, traversedObjects) {
        var copy;
        // primitive types
        if(obj === null || typeof obj !== "object") {
            return obj;
        }

        // detect cycles
        for(var i = 0; i < traversedObjects.length; i++) {
            if(traversedObjects[i] === obj) {
                throw new Error("Cannot clone circular object.");
            }
        }

        // dates
        if(obj instanceof Date) {
            copy = new Date();
            copy.setTime(obj.getTime());
            return copy;
        }
        // arrays
        if(obj instanceof Array) {
            copy = [];
            for(var i = 0; i < obj.length; i++) {
                copy.push(clone(obj[i], traversedObjects.concat(obj)));
            }
            return copy;
        }
        // simple objects
        if(obj instanceof Object) {
            copy = {};
            for(var key in obj) {
                if(obj.hasOwnProperty(key)) {
                    copy[key] = clone(obj[key], traversedObjects.concat(obj));
                }
            }
            return copy;
        }
        throw new Error("Not a cloneable object.");
    }

    return clone(obj, []);
}

Object.assign

El método Object.assign () se utiliza para copiar los valores de todas las propiedades propias enumerables de uno o más objetos de origen a un objeto de destino. Se devolverá el objeto de destino.

Úselo para asignar valores a un objeto existente:

var user = {
    firstName: "John"
};

Object.assign(user, {lastName: "Doe", age:39});
console.log(user); // Logs: {firstName: "John", lastName: "Doe", age: 39} 

O para crear una copia superficial de un objeto:

var obj = Object.assign({}, user);

console.log(obj); // Logs: {firstName: "John", lastName: "Doe", age: 39} 

O fusiona muchas propiedades de varios objetos en uno:

var obj1 = {
    a: 1
};
var obj2 = {
    b: 2
};
var obj3 = {
    c: 3
};
var obj = Object.assign(obj1, obj2, obj3);

console.log(obj); // Logs: { a: 1, b: 2, c: 3 }
console.log(obj1); // Logs: { a: 1, b: 2, c: 3 }, target object itself is changed

Los primitivos serán envueltos, nulos e indefinidos serán ignorados:

var var_1 = 'abc';
var var_2 = true;
var var_3 = 10;
var var_4 = Symbol('foo');

var obj = Object.assign({}, var_1, null, var_2, undefined, var_3, var_4);
console.log(obj); // Logs: { "0": "a", "1": "b", "2": "c" }

Tenga en cuenta que solo las envolturas de cadena pueden tener propiedades enumerables propias

Úselo como reductor: (combina una matriz con un objeto)

return users.reduce((result, user) => Object.assign({}, {[user.id]: user})

Propiedades del objeto iteración

Puede acceder a cada propiedad que pertenece a un objeto con este bucle

for (var property in object) {
    // always check if an object has a property
    if (object.hasOwnProperty(property)) {
        // do stuff
    }
}

Debe incluir la verificación adicional de hasOwnProperty porque un objeto puede tener propiedades que se heredan de la clase base del objeto. No realizar esta comprobación puede generar errores.

var obj = { 0: 'a', 1: 'b', 2: 'c' };

Object.keys(obj).map(function(key) {
    console.log(key);
}); 
// outputs: 0, 1, 2

Recuperando propiedades de un objeto

Características de las propiedades:

Las propiedades que se pueden recuperar de un objeto podrían tener las siguientes características,

• Enumerable
• No Enumerable
• propio

Al crear las propiedades utilizando Object.defineProperty (ies) , podríamos establecer sus características excepto "propio" . Las propiedades que están disponibles en el nivel directo y no en el nivel de prototipo ( __proto__ ) de un objeto se llaman como propiedades propias .

Y las propiedades que se agregan a un objeto sin usar Object.defindProperty(ies) no tendrán su característica enumerable. Eso significa que sea considerado como verdadero.

Propósito de la enumerabilidad:

El propósito principal de establecer características enumerables para una propiedad es hacer que la disponibilidad de la propiedad en particular se recupere de su objeto, utilizando diferentes métodos programáticos. Esos diferentes métodos serán discutidos en profundidad a continuación.

Métodos de recuperación de propiedades:

Las propiedades de un objeto pueden ser recuperadas por los siguientes métodos,

1. for..in loop

   Este bucle es muy útil para recuperar propiedades enumerables de un objeto. Además, este bucle recuperará enumerables propiedades propias y hará la misma recuperación al atravesar la cadena del prototipo hasta que vea el prototipo como nulo.

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props = [];
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props = [];
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a","b"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props = [];
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   for(prop in x){
     props.push(prop);
   }
   
   console.log(props); //["a"]
   

2. Object.keys()

   Esta función se reveló como parte de EcmaScript 5. Se utiliza para recuperar propiedades propias enumerables de un objeto. Antes de su lanzamiento, la gente solía recuperar propiedades propias de un objeto combinando la función for..in loop y Object.prototype.hasOwnProperty() .

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props;
   
   props = Object.keys(x);
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props;
   
   props = Object.keys(x);
   
   console.log(props); //["a"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props;
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   props = Object.keys(x);
   
   console.log(props); //["a"]
   

3. Object.getOwnProperties()

   Esta función recuperará propiedades enumerables y no enumerables, propias de un objeto. También fue lanzado como parte de EcmaScript 5.

   //Ex 1 : Simple data
   var x = { a : 10 , b : 3} , props;
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a","b"]
   
   //Ex 2 : Data with enumerable properties in prototype chain
   var x = { a : 10 , __proto__ : { b : 10 }} , props;
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a"]
   
   //Ex 3 : Data with non enumerable properties
   var x = { a : 10 } , props;
   Object.defineProperty(x, "b", {value : 5, enumerable : false});
   
   props = Object.getOwnPropertyNames(x);
   
   console.log(props); //["a", "b"]
   

Misceláneos

A continuación se proporciona una técnica para recuperar todas las propiedades (propias, enumerables, no enumerables, todos los niveles de prototipos) de un objeto,

function getAllProperties(obj, props = []){
  return obj == null ? props :
           getAllProperties(Object.getPrototypeOf(obj),
               props.concat(Object.getOwnPropertyNames(obj)));
}

var x = {a:10, __proto__ : { b : 5, c : 15 }};

//adding a non enumerable property to first level prototype
Object.defineProperty(x.__proto__, "d", {value : 20, enumerable : false});

console.log(getAllProperties(x)); ["a", "b", "c", "d", "...other default core props..."]

Y esto será compatible con los navegadores que admiten EcmaScript 5.

Convertir los valores del objeto a la matriz

Teniendo en cuenta este objeto:

var obj = {
    a: "hello",
    b: "this is",
    c: "javascript!",
};

Puedes convertir sus valores a una matriz haciendo:

var array = Object.keys(obj)
    .map(function(key) {
        return obj[key];
    });

console.log(array); // ["hello", "this is", "javascript!"]

Iterando sobre las entradas de objetos - Object.entries ()

const obj = {
    one: 1,
    two: 2,
    three: 3
};

Object.entries(obj);

[
    ["one", 1],
    ["two", 2],
    ["three", 3]
]

for(const [key, value] of Object.entries(obj)) {
    console.log(key); // "one", "two" and "three"
    console.log(value); // 1, 2 and 3
}

Object.values ​​()

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