JavaScript
Oggetti

Sintassi

• oggetto = {}
• oggetto = nuovo oggetto ()
• object = Object.create (prototype [, propertiesObject])
• oggetto.key = valore
• oggetto ["chiave"] = valore
• oggetto [Symbol ()] = valore
• oggetto = {chiave1: valore1, "chiave2": valore2, 'chiave3': valore3}
• object = {conciseMethod () {...}}
• object = {[computed () + "key"]: valore}
• Object.defineProperty (obj, propertyName, propertyDescriptor)
• property_desc = Object.getOwnPropertyDescriptor (obj, propertyName)
• Object.freeze (obj)
• Object.seal (obj)

Parametri

Osservazioni

Object.keys

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

var keys = Object.keys(obj);

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

Clonazione superficiale

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

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

Il resto dell'oggetto / diffusione destrutturazione che è attualmente una proposta di stage 3 fornisce un modo ancora più semplice per creare cloni superficiali di istanze di Object:

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

const { ...clone } = existing;

Se hai bisogno di supportare versioni precedenti di JavaScript, il modo più compatibile per clonare un oggetto è iterandolo manualmente sulle sue proprietà e filtrando quelle ereditate usando .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);

Uscita della console

foo

Object.defineProperty può essere richiamato con le seguenti opzioni:

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 consente di definire più proprietà alla volta.

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

Proprietà di sola lettura

La proprietà writable in un descrittore di proprietà indica se tale proprietà può essere modificata o meno.

var a  = { };

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

a.foo = 'new';

console.log(a.foo);

Uscita della console

originale

Proprietà non enumerabile

La proprietà enumerable del descrittore di proprietà indica se tale proprietà verrà enumerata durante il looping delle proprietà dell'oggetto.

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]);
}

Uscita della console

mostrare

Blocca descrizione proprietà

La proprietà configurable del descrittore di proprietà viene utilizzata per impedire ulteriori modifiche sul descrittore.

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});

Questo errore verrà generato:

TypeError: impossibile ridefinire la proprietà: foo

E la proprietà sarà ancora di sola lettura.

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

Uscita della console

valore originale

Proprietà Accesor (ottieni e imposta)

La proprietà get del descrittore di proprietà è una funzione che verrà chiamata per recuperare il valore dalla proprietà.

La proprietà set è anche una funzione, verrà chiamata quando alla proprietà è stato assegnato un valore e il nuovo valore verrà passato come argomento.

Non è possibile assegnare un value o writable a un descrittore che ha 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"

Proprietà con caratteri speciali o parole riservate

Mentre la notazione delle proprietà degli oggetti viene solitamente scritta come proprietà myObject.property , ciò consentirà solo i caratteri normalmente presenti nei nomi delle variabili JavaScript , che sono principalmente lettere, numeri e underscore ( _ ).

Se sono necessari caratteri speciali, come spazio, ☺ o contenuto fornito dall'utente, è possibile utilizzare la notazione della parentesi [] .

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

Proprietà a tutte le cifre:

Oltre ai caratteri speciali, i nomi di proprietà che sono tutti numeri richiedono notazione di parentesi. Tuttavia, in questo caso la proprietà non deve essere scritta come una stringa.

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'

Tuttavia, gli zero iniziali non sono raccomandati in quanto interpretati come notazione ottale. (TODO, dovremmo produrre e collegare ad un esempio che descriva la notazione ottale, esadecimale ed esponente)

Vedi anche: [Arrays are Objects] esempio.

Nomi di proprietà dinamici / variabili

A volte il nome della proprietà deve essere memorizzato in una variabile. In questo esempio, chiediamo all'utente quale parola deve essere cercata e quindi fornire il risultato da un oggetto che ho chiamato 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)

Nota come stiamo usando la notazione della parentesi [] per guardare la variabile chiamata word ; se dovessimo usare il tradizionale . notazione, quindi prenderebbe il valore letteralmente, quindi:

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)

È anche possibile scrivere valori letterali con la notazione [] sostituendo la word variabile con una stringa 'apple' . Vedi [Proprietà con caratteri speciali o parole riservate] esempio.

Puoi anche impostare proprietà dinamiche con la sintassi della parentesi:

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

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

Fa lo stesso di:

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

Le matrici sono oggetti

Dichiarazione di non responsabilità: la creazione di oggetti tipo array non è raccomandata. Tuttavia, è utile capire come funzionano, specialmente quando si lavora con DOM. Questo spiegherà perché le normali operazioni dell'array non funzionano sugli oggetti DOM restituiti da molte funzioni del document DOM. (cioè querySelectorAll , form.elements )

Supponiamo di aver creato il seguente oggetto che ha alcune proprietà che ci si aspetterebbe di vedere in una matrice.

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

Quindi creeremo un array.

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

Ora, notiamo come possiamo ispezionare sia l'oggetto che l'array allo stesso modo.

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

Poiché anArray è in realtà un oggetto, proprio come un anObject , possiamo persino aggiungere proprietà anArray personalizzate ad anArray

Dichiarazione di non responsabilità: gli array con proprietà personalizzate di solito non sono raccomandati in quanto possono essere fonte di confusione, ma può essere utile nei casi avanzati in cui sono necessarie le funzioni ottimizzate di una matrice. (cioè oggetti jQuery)

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

Possiamo anche fare anObject essere un oggetto array simile aggiungendo una length .

anObject.length = 2;

Quindi puoi usare lo stile C for ciclo per anObject su un anObject come se fosse una matrice. Vedi Array Iteration

Si noti che anObject è solo un oggetto di tipo array . (noto anche come elenco) Non è una vera matrice. Questo è importante, perché funzioni come push e forEach (o qualsiasi funzione di convenienza trovata in Array.prototype ) non funzioneranno di default su oggetti tipo array.

Molte delle funzioni del document DOM restituiranno una lista (cioè querySelectorAll , form.elements ) che è simile anObject array-like creato in precedenza. Vedi Conversione di oggetti tipo array in matrici

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

Le operazioni successive al freeze falliranno silenziosamente a meno che il codice non sia in esecuzione in modalità rigorosa. Se il codice è in modalità rigorosa, verrà generato 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
}());

Creare un oggetto 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); 
}

Riposo / diffusione dell'oggetto (...)

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 } };

Descrittori e proprietà denominate

Le proprietà sono membri di un oggetto. Ogni proprietà denominata è una coppia di (nome, descrittore). Il nome è una stringa che consente l'accesso (utilizzando la notazione di punti object.propertyName o l' object['propertyName'] notazione parentesi quadre object['propertyName'] ). Il descrittore è un record di campi che definiscono il bevahiour della proprietà al momento dell'accesso (cosa succede alla proprietà e qual è il valore restituito dall'accesso). In generale, una proprietà associa un nome a un comportamento (possiamo pensare al comportamento come una scatola nera).

Esistono due tipi di proprietà denominate:

1. proprietà dati : il nome della proprietà è associato a un valore.
2. proprietà accessoria : il nome della proprietà è associato a una o due funzioni di accesso.

Dimostrazione:

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

Il tipo di proprietà è determinato dai campi del suo descrittore e una proprietà non può essere di entrambi i tipi.

Descrittori di dati -

• Campi obbligatori: value o writable o entrambi
• Campi opzionali: configurable , enumerable

Campione:

{
   value: 10,
   writable: true;
}

Descrittori degli accessori -

• Campi obbligatori: get o set o entrambi
• Campi opzionali: configurable , enumerable

Campione:

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

significato dei campi e dei loro valori predefiniti

• Queste chiavi sono tutte predefinite su false .
• configurable è true se e solo se il tipo di questo descrittore di proprietà può essere cambiato e se la proprietà può essere cancellata dall'oggetto corrispondente.
• enumerable è true se e solo se questa proprietà appare durante l'enumerazione delle proprietà sull'oggetto corrispondente.
• writable è true se e solo se il valore associato alla proprietà può essere cambiato con un operatore di assegnazione.

get e set :

• Queste chiavi sono predefinite in modo undefined .
• get è una funzione che serve come getter per la proprietà, o undefined se non c'è getter. La funzione return verrà utilizzata come valore della proprietà.
• set è una funzione che funge da setter per la proprietà, o undefined se non c'è setter. La funzione riceverà come argomento solo il nuovo valore assegnato alla proprietà.

value :

• Questa chiave per impostazione predefinita undefined .
• Il valore associato alla proprietà. Può essere un qualsiasi valore JavaScript valido (numero, oggetto, funzione, ecc.).

Esempio:

    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

Ottieni la descrizione di una proprietà specifica in un oggetto.

var sampleObject = {
    hello: 'world'
};

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

Clonazione dell'oggetto

Quando si desidera una copia completa di un oggetto (ovvero le proprietà dell'oggetto e i valori all'interno di tali proprietà, ecc.), Questa viene chiamata deep cloning .

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

Non esiste una funzione incorporata in JavaScript per la creazione di cloni profondi, e in generale non è possibile creare cloni profondi per ogni oggetto per molte ragioni. Per esempio,

• gli oggetti possono avere proprietà non enumerabili e nascoste che non possono essere rilevate.
• getter e setter di oggetti non possono essere copiati.
• gli oggetti possono avere una struttura ciclica.
• le proprietà delle funzioni possono dipendere dallo stato in un ambito nascosto.

Supponendo di avere un oggetto "bello" le cui proprietà contengono solo valori primitivi, date, matrici o altri oggetti "carini", è possibile utilizzare la seguente funzione per creare cloni profondi. È una funzione ricorsiva in grado di rilevare oggetti con una struttura ciclica e genera un errore in questi casi.

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

Il metodo Object.assign () viene utilizzato per copiare i valori di tutte le proprietà enumerabili di uno o più oggetti di origine in un oggetto di destinazione. Restituirà l'oggetto target.

Usalo per assegnare valori a un oggetto esistente:

var user = {
    firstName: "John"
};

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

O per creare una copia superficiale di un oggetto:

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

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

O unisci molte proprietà da più oggetti a 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

I primitivi saranno avvolti, nulli e indefiniti saranno ignorati:

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" }

Nota, solo i wrapper di stringhe possono avere proprie proprietà enumerabili

Usalo come riduttore: (unisce una matrice a un oggetto)

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

Iterazione delle proprietà dell'oggetto

È possibile accedere a ciascuna proprietà che appartiene a un oggetto con questo ciclo

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

È necessario includere il controllo aggiuntivo per hasOwnProperty perché un oggetto può avere proprietà ereditate dalla classe base dell'oggetto. Non eseguire questo controllo può causare errori.

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

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

Recupero di proprietà da un oggetto

Caratteristiche delle proprietà:

Le proprietà che possono essere recuperate da un oggetto potrebbero avere le seguenti caratteristiche,

• Enumerable
• Non numerabile
• proprio

Durante la creazione delle proprietà usando Object.defineProperty (ies) , potremmo impostare le sue caratteristiche ad eccezione di "own" . Le proprietà che sono disponibili nel livello diretto non nel livello di prototipo ( __proto__ ) di un oggetto sono chiamate come proprietà proprie .

E le proprietà che vengono aggiunte a un oggetto senza usare Object.defindProperty(ies) non avranno la sua caratteristica enumerabile. Ciò significa che è considerato vero.

Scopo dell'enumerabilità:

Lo scopo principale di impostare caratteristiche enumerabili per una proprietà è di rendere la disponibilità della particolare proprietà quando la si recupera dal suo oggetto, utilizzando diversi metodi di programmazione. Questi diversi metodi saranno discussi in profondità.

Metodi di recupero delle proprietà:

Le proprietà da un oggetto possono essere recuperate con i seguenti metodi,

1. for..in ciclo

   Questo ciclo è molto utile nel recupero di proprietà enumerabili da un oggetto. Inoltre questo ciclo recupererà le proprie proprietà enumerabili e eseguirà lo stesso recupero attraversando la catena del prototipo fino a quando non vedrà il prototipo come null.

   //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()

   Questa funzione è stata svelata come parte di EcmaScript 5. Viene utilizzata per recuperare le proprietà enumerabili di un oggetto. Prima del suo rilascio, le persone utilizzavano per recuperare le proprie proprietà da un oggetto combinando for..in loop e la funzione 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()

   Questa funzione recupera le proprietà enumerabili e non enumerabili di un oggetto. È stato anche rilasciato come parte di 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"]
   

Varie

Di seguito viene fornita una tecnica per il recupero di tutte le proprietà (proprie, enumerabili, non enumerabili, di tutti i prototipi) da un oggetto,

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..."]

E questo sarà supportato dai browser che supportano EcmaScript 5.

Converti i valori dell'oggetto in array

Dato questo oggetto:

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

Puoi convertire i suoi valori in un array facendo:

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

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

Iterazione su voci di oggetti - 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']