Ordina object JavaScript per chiave

Ho bisogno di ordinare oggetti JavaScript per chiave.

Quindi il seguente:

{ 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' } 

Potrebbe diventare:

 { 'a' : 'dsfdsfsdf', 'b' : 'asdsad', 'c' : 'masdas' } 

Le altre risposte a questa domanda sono obsolete, non hanno mai eguagliato la realtà di implementazione e sono diventate ufficialmente scorrette ora che la specifica ES6 / ES2015 è stata pubblicata.


Vedere la sezione sull’iterazione delle proprietà in Esplorazione di ES6 di Axel Rauschmayer :

Tutti i metodi che eseguono l’iterazione sulle chiavi di proprietà lo fanno nello stesso ordine:

  1. Prima tutti gli indici di matrice, ordinati numericamente.
  2. Quindi tutte le chiavi stringa (che non sono indici), nell’ordine in cui sono state create.
  3. Quindi tutti i simboli, nell’ordine in cui sono stati creati.

Quindi sì, gli oggetti JavaScript sono effettivamente ordinati e l’ordine delle loro chiavi / proprietà può essere modificato.

Ecco come puoi ordinare un object con le sue chiavi / proprietà, in ordine alfabetico:

 const unordered = { 'b': 'foo', 'c': 'bar', 'a': 'baz' }; console.log(JSON.stringify(unordered)); // → '{"b":"foo","c":"bar","a":"baz"}' const ordered = {}; Object.keys(unordered).sort().forEach(function(key) { ordered[key] = unordered[key]; }); console.log(JSON.stringify(ordered)); // → '{"a":"baz","b":"foo","c":"bar"}' 

Utilizzare var posto di const per la compatibilità con i motori ES5.

Gli oggetti JavaScript 1 non sono ordinati. Non ha senso cercare di “ordinarli”. Se si desidera eseguire un’iterazione sulle proprietà di un object, è ansible ordinare le chiavi e quindi recuperare i valori associati:

 var myObj = { 'b': 'asdsadfd', 'c': 'masdasaf', 'a': 'dsfdsfsdf' }, keys = [], k, i, len; for (k in myObj) { if (myObj.hasOwnProperty(k)) { keys.push(k); } } keys.sort(); len = keys.length; for (i = 0; i < len; i++) { k = keys[i]; alert(k + ':' + myObj[k]); } 

Un sacco di persone hanno detto che “gli oggetti non possono essere ordinati” , ma dopo ti stanno dando una soluzione che funziona. Paradosso, non è vero?

Nessuno menziona perché quelle soluzioni stanno funzionando. Lo sono, perché nella maggior parte delle implementazioni del browser i valori negli oggetti sono memorizzati nell’ordine in cui sono stati aggiunti. Ecco perché se crei un nuovo object dalla lista ordinata di chiavi viene restituito un risultato previsto.

E penso che potremmo aggiungere un’altra soluzione – ES5 modo funzionale:

 function sortObject(obj) { return Object.keys(obj).sort().reduce(function (result, key) { result[key] = obj[key]; return result; }, {}); } 

Versione ES2015 di cui sopra (formattata con “one-liner”):

 function sortObject(o) { return Object.keys(o).sort().reduce((r, k) => (r[k] = o[k], r), {}); } 

Breve spiegazione degli esempi precedenti (come richiesto nei commenti):

Object.keys sta fornendo un elenco di chiavi nell’object fornito ( obj o ), quindi stiamo ordinando quelli utilizzando l’algoritmo di ordinamento predefinito, successivamente .reduce viene utilizzato per riconvertire quell’array in un object, ma questa volta con tutti le chiavi sono ordinate

Questo funziona per me

 /** * Return an Object sorted by it's Key */ var sortObjectByKey = function(obj){ var keys = []; var sorted_obj = {}; for(var key in obj){ if(obj.hasOwnProperty(key)){ keys.push(key); } } // sort keys keys.sort(); // create new array based on Sorted Keys jQuery.each(keys, function(i, key){ sorted_obj[key] = obj[key]; }); return sorted_obj; }; 

Questa è una domanda vecchia, ma prendendo spunto dalla risposta di Mathias Bynens, ho creato una versione breve per ordinare l’object corrente , senza troppo sovraccarico.

  Object.keys(unordered).sort().forEach(function(key) { var value = unordered[key]; delete unordered[key]; unordered[key] = value; }); 

dopo l’esecuzione del codice, l’object “non ordinato” stesso avrà le chiavi in ​​ordine alfabetico.

Usando lodash questo funzionerà:

 some_map = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' } // perform a function in order of ascending key _(some_map).keys().sort().each(function (key) { var value = some_map[key]; // do something }); // or alternatively to build a sorted list sorted_list = _(some_map).keys().sort().map(function (key) { var value = some_map[key]; // return something that shall become an item in the sorted list }).value(); 

Solo spunti di riflessione.

Supponiamo che possa essere utile nel debugger di VisualStudio che mostra proprietà dell’object non ordinate.

 (function(s){var t={};Object.keys(s).sort().forEach(function(k){t[k]=s[k]});return t})({b:2,a:1,c:3}) 

Sottolineatura versione :

 function order(unordered) { return _.object(_.sortBy(_.pairs(unordered),function(o){return o[0]})); } 

Se non ti fidi del tuo browser per mantenere l’ordine delle chiavi, ti consiglio caldamente di fare affidamento su una serie ordinata di matrici abbinate a valori-chiave.

 _.sortBy(_.pairs(c),function(o){return o[0]}) 

Forse una forma un po ‘più elegante:

  /** * Sorts a key-value object by key, maintaining key to data correlations. * @param {Object} src key-value object * @returns {Object} */ var ksort = function ( src ) { var keys = Object.keys( src ), target = {}; keys.sort(); keys.forEach(function ( key ) { target[ key ] = src[ key ]; }); return target; }; // Usage console.log(ksort({ a:1, c:3, b:2 })); 

ecco il 1 liner

 var data = { zIndex:99, name:'sravan', age:25, position:'architect', amount:'100k', manager:'mammu' }; console.log(Object.entries(data).sort().reduce( (o,[k,v]) => (o[k]=v,o), {} )); 
 function sortObjectKeys(obj){ return Object.keys(obj).sort().reduce((acc,key)=>{ acc[key]=obj[key]; return acc; },{}); } sortObjectKeys({ telephone: '069911234124', name: 'Lola', access: true, }); 

ordinamento ricorsivo, per oggetti e matrici annidate

 function sortObjectKeys(obj){ return Object.keys(obj).sort().reduce((acc,key)=>{ if (Array.isArray(obj[key])){ acc[key]=obj[key].map(sortObjectKeys); } if (typeof obj[key] === 'object'){ acc[key]=sortObjectKeys(obj[key]); } else{ acc[key]=obj[key]; } return acc; },{}); } // test it sortObjectKeys({ telephone: '069911234124', name: 'Lola', access: true, cars: [ {name: 'Family', brand: 'Volvo', cc:1600}, { name: 'City', brand: 'VW', cc:1200, interior: { wheel: 'plastic', radio: 'blaupunkt' } }, { cc:2600, name: 'Killer', brand: 'Plymouth', interior: { wheel: 'wooden', radio: 'earache!' } }, ] }); 

Come già accennato, gli oggetti non sono ordinati.

Però…

Potresti trovare questo idioma utile:

 var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }; var kv = []; for (var k in o) { kv.push([k, o[k]]); } kv.sort() 

Puoi quindi eseguire iterazioni con kv e fare ciò che desideri.

 > kv.sort() [ [ 'a', 'dsfdsfsdf' ], [ 'b', 'asdsad' ], [ 'c', 'masdas' ] ] 

Ecco una versione pulita basata su lodash che funziona con oggetti nidificati

 /** * Sort of the keys of an object alphabetically */ const sortKeys = function(obj) { if(_.isArray(obj)) { return obj.map(sortKeys); } if(_.isObject(obj)) { return _.fromPairs(_.keys(obj).sort().map(key => [key, sortKeys(obj[key])])); } return obj; }; 

Sarebbe ancora più pulito se lodash avesse un metodo toObject()

Basta usare lodash per decomprimere la mappa e ordinare il primo valore di coppia e zip di nuovo restituirà la chiave ordinata.

Se si desidera che il valore sortby cambi l’indice della coppia a 1 invece di 0

 var o = { 'b' : 'asdsad', 'c' : 'masdas', 'a' : 'dsfdsfsdf' }; console.log(_(o).toPairs().sortBy(0).fromPairs().value()) 

inserisci la descrizione dell'immagine qui

Usa questo codice se hai oggetti annidati o se hai nid array obj.

 var sortObjectByKey = function(obj){ var keys = []; var sorted_obj = {}; for(var key in obj){ if(obj.hasOwnProperty(key)){ keys.push(key); } } // sort keys keys.sort(); // create new array based on Sorted Keys jQuery.each(keys, function(i, key){ var val = obj[key]; if(val instanceof Array){ //do for loop; var arr = []; jQuery.each(val,function(){ arr.push(sortObjectByKey(this)); }); val = arr; }else if(val instanceof Object){ val = sortObjectByKey(val) } sorted_obj[key] = val; }); return sorted_obj; }; 

Soluzione:

 function getSortedObject(object) { var sortedObject = {}; var keys = Object.keys(object); keys.sort(); for (var i = 0, size = keys.length; i < size; i++) { key = keys[i]; value = object[key]; sortedObject[key] = value; } return sortedObject; } // Test run getSortedObject({d: 4, a: 1, b: 2, c: 3}); 

Spiegazione:

Molti runtime JavaScript memorizzano i valori all'interno di un object nell'ordine in cui vengono aggiunti.

Per ordinare le proprietà di un object con le loro chiavi, è ansible utilizzare la funzione Object.keys che restituirà un array di chiavi. La matrice di chiavi può quindi essere ordinata dal metodo Array.prototype.sort () che ordina gli elementi di una matrice in posizione (non è necessario assegnarli a una nuova variabile).

Una volta ordinate le chiavi, è ansible iniziare a utilizzarle una per una per accedere ai contenuti del vecchio object per riempire un nuovo object (che ora è ordinato).

Di seguito è riportato un esempio della procedura (è ansible testarlo nei browser di destinazione):

 /** * Returns a copy of an object, which is ordered by the keys of the original object. * * @param {Object} object - The original object. * @returns {Object} Copy of the original object sorted by keys. */ function getSortedObject(object) { // New object which will be returned with sorted keys var sortedObject = {}; // Get array of keys from the old/current object var keys = Object.keys(object); // Sort keys (in place) keys.sort(); // Use sorted keys to copy values from old object to the new one for (var i = 0, size = keys.length; i < size; i++) { key = keys[i]; value = object[key]; sortedObject[key] = value; } // Return the new object return sortedObject; } /** * Test run */ var unsortedObject = { d: 4, a: 1, b: 2, c: 3 }; var sortedObject = getSortedObject(unsortedObject); for (var key in sortedObject) { var text = "Key: " + key + ", Value: " + sortedObject[key]; var paragraph = document.createElement('p'); paragraph.textContent = text; document.body.appendChild(paragraph); } 

Ho trasferito alcune enumerazioni Java agli oggetti javascript.

Questi oggetti hanno restituito array corretti per me. se le chiavi dell’object sono di tipo misto (string, int, char), c’è un problema.

 var Helper = { isEmpty: function (obj) { return !obj || obj === null || obj === undefined || Array.isArray(obj) && obj.length === 0; }, isObject: function (obj) { return (typeof obj === 'object'); }, sortObjectKeys: function (object) { return Object.keys(object) .sort(function (a, b) { c = a - b; return c }); }, containsItem: function (arr, item) { if (arr && Array.isArray(arr)) { return arr.indexOf(item) > -1; } else { return arr === item; } }, pushArray: function (arr1, arr2) { if (arr1 && arr2 && Array.isArray(arr1)) { arr1.push.apply(arr1, Array.isArray(arr2) ? arr2 : [arr2]); } } }; function TypeHelper() { var _types = arguments[0], _defTypeIndex = 0, _currentType, _value; if (arguments.length == 2) { _defTypeIndex = arguments[1]; } Object.defineProperties(this, { Key: { get: function () { return _currentType; }, set: function (val) { _currentType.setType(val, true); }, enumerable: true }, Value: { get: function () { return _types[_currentType]; }, set: function (val) { _value.setType(val, false); }, enumerable: true } }); this.getAsList = function (keys) { var list = []; Helper.sortObjectKeys(_types).forEach(function (key, idx, array) { if (key && _types[key]) { if (!Helper.isEmpty(keys) && Helper.containsItem(keys, key) || Helper.isEmpty(keys)) { var json = {}; json.Key = key; json.Value = _types[key]; Helper.pushArray(list, json); } } }); return list; }; this.setType = function (value, isKey) { if (!Helper.isEmpty(value)) { Object.keys(_types).forEach(function (key, idx, array) { if (Helper.isObject(value)) { if (value && value.Key == key) { _currentType = key; } } else if (isKey) { if (value && value.toString() == key.toString()) { _currentType = key; } } else if (value && value.toString() == _types[key]) { _currentType = key; } }); } else { this.setDefaultType(); } return isKey ? _types[_currentType] : _currentType; }; this.setTypeByIndex = function (index) { var keys = Helper.sortObjectKeys(_types); for (var i = 0; i < keys.length; i++) { if (index === i) { _currentType = keys[index]; break; } } }; this.setDefaultType = function () { this.setTypeByIndex(_defTypeIndex); }; this.setDefaultType(); } var TypeA = { "-1": "Any", "2": "2L", "100": "100L", "200": "200L", "1000": "1000L" }; var TypeB = { "U": "Any", "W": "1L", "V": "2L", "A": "100L", "Z": "200L", "K": "1000L" }; console.log('keys of TypeA', Helper.sortObjectKeys(TypeA));//keys of TypeA ["-1", "2", "100", "200", "1000"] console.log('keys of TypeB', Helper.sortObjectKeys(TypeB));//keys of TypeB ["U", "W", "V", "A", "Z", "K"] var objectTypeA = new TypeHelper(TypeA), objectTypeB = new TypeHelper(TypeB); console.log('list of objectA = ', objectTypeA.getAsList()); console.log('list of objectB = ', objectTypeB.getAsList()); 

Snippet semplice e leggibile, usando lodash.

È necessario inserire la chiave tra virgolette solo quando si chiama sortBy. Non deve essere tra virgolette nei dati stessi.

 _.sortBy(myObj, "key") 

Inoltre, il tuo secondo parametro da mappare è sbagliato. Dovrebbe essere una funzione, ma l’uso di cogliere è più facile.

 _.map( _.sortBy(myObj, "key") , "value"); 

C’è un grande progetto di @sindresorhus chiamato sort-keys che funziona alla grande.

Puoi controllare il suo codice sorgente qui:

https://github.com/sindresorhus/sort-keys

Oppure puoi usarlo con npm:

 $ npm install --save sort-keys 

Qui ci sono anche esempi di codice dal suo readme

 const sortKeys = require('sort-keys'); sortKeys({c: 0, a: 0, b: 0}); //=> {a: 0, b: 0, c: 0} sortKeys({b: {b: 0, a: 0}, a: 0}, {deep: true}); //=> {a: 0, b: {a: 0, b: 0}} sortKeys({c: 0, a: 0, b: 0}, { compare: (a, b) => -a.localeCompare(b) }); //=> {c: 0, b: 0, a: 0} 

Ragazzi, sono un po ‘scioccato! Certo tutte le risposte sono un po ‘vecchie, ma nessuno ha nemmeno menzionato la stabilità nell’ordinamento! Quindi, pazienza, farò del mio meglio per rispondere alla domanda stessa e entrare nei dettagli qui. Quindi mi scuserò ora sarà molto da leggere.

Dal momento che è il 2018 userò solo ES6, i Polyfill sono tutti disponibili nei documenti MDN, che collegherò alla parte data.


Rispondi alla domanda:

Se le tue chiavi sono solo numeri, puoi tranquillamente utilizzare Object.keys() insieme a Array.prototype.reduce() per restituire l’object ordinato:

 // Only numbers to show it will be sorted. const testObj = { '2000': 'Articel1', '4000': 'Articel2', '1000': 'Articel3', '3000': 'Articel4', }; // I'll explain what reduces does after the answer. console.log(Object.keys(testObj).reduce((accumulator, currentValue) => { accumulator[currentValue] = testObj[currentValue]; return accumulator; }, {})); /** * expected output: * { * '1000': 'Articel3', * '2000': 'Articel1', * '3000': 'Articel4', * '4000': 'Articel2' * } */ // if needed here is the one liner: console.log(Object.keys(testObj).reduce((a, c) => (a[c] = testObj[c], a), {})); 

Tuttavia, se stai lavorando con le stringhe ti consiglio vivamente di incatenare Array.prototype.sort() a tutto questo:

 // String example const testObj = { 'a1d78eg8fdg387fg38': 'Articel1', 'z12989dh89h31d9h39': 'Articel2', 'f1203391dhj32189h2': 'Articel3', 'b10939hd83f9032003': 'Articel4', }; // Chained sort into all of this. console.log(Object.keys(testObj).sort().reduce((accumulator, currentValue) => { accumulator[currentValue] = testObj[currentValue]; return accumulator; }, {})); /** * expected output: * { * a1d78eg8fdg387fg38: 'Articel1', * b10939hd83f9032003: 'Articel4', * f1203391dhj32189h2: 'Articel3', * z12989dh89h31d9h39aaaaaaa: 'Articel2' * } */ // again the one liner: console.log(Object.keys(testObj).sort().reduce((a, c) => (a[c] = testObj[c], a), {})); 

Se qualcuno se chiedesse cosa riduce fa:

 // Will return Keys of object as an array (sorted if only numbers or single strings like a,b,c). Object.keys(testObj) // Chaining reduce to the returned array from Object.keys(). // Array.prototype.reduce() takes one callback // (and another param look at the last line) and passes 4 arguments to it: // accumulator, currentValue, currentIndex and array .reduce((accumulator, currentValue) => { // setting the accumulator (sorted new object) with the actual property from old (unsorted) object. accumulator[currentValue] = testObj[currentValue]; // returning the newly sorted object for the next element in array. return accumulator; // the empty object {} ist the initial value for Array.prototype.reduce(). }, {}); 

Se necessario, ecco la spiegazione per l’unico rivestimento:

 Object.keys(testObj).reduce( // Arrow function as callback parameter. (a, c) => // parenthesis return! so we can safe the return a and write only (..., a); (a[c] = testObj[c], a) // initial value for reduce. ,{} ); 

Perché l’ordinamento è un po ‘complicato:

In breve Object.keys() restituirà un array con lo stesso ordine di un normale loop:

 const object1 = { a: 'somestring', b: 42, c: false }; console.log(Object.keys(object1)); // expected output: Array ["a", "b", "c"] 

Object.keys () restituisce una matrice i cui elementi sono stringhe corrispondenti alle proprietà enumerabili trovate direttamente sull’object. L’ordinamento delle proprietà è uguale a quello dato dal looping sulle proprietà dell’object manualmente.

Sidenote: puoi utilizzare Object.keys() sugli array, tieni presente che l’indice verrà restituito:

 // simple array const arr = ['a', 'b', 'c']; console.log(Object.keys(arr)); // console: ['0', '1', '2'] 

Ma non è così facile da mostrare da quegli esempi, gli oggetti del mondo reale possono contenere nunmbers e caratteri alfabetici o persino simboli (per favore non farlo).

Ecco un esempio con tutti in un unico object:

 // This is just to show what happens, please don't use symbols in keys. const testObj = { '1asc': '4444', 1000: 'a', b: '1231', '#01010101010': 'asd', 2: 'c' }; console.log(Object.keys(testObj)); // output: [ '2', '1000', '1asc', 'b', '#01010101010' ] 

Ora se usiamo Array.prototype.sort() sull’array sopra l’output cambia:

 console.log(Object.keys(testObj).sort()); // output: [ '#01010101010', '1000', '1asc', '2', 'b' ] 

Ecco una citazione dai documenti:

Il metodo sort () ordina gli elementi di una matrice e restituisce la matrice. L’ordinamento non è necessariamente stabile. L’ordinamento predefinito è in base ai punti di codice Unicode della stringa.

La complessità di tempo e spazio del tipo non può essere garantita in quanto dipende dall’implementazione.

Devi assicurarti che uno di essi restituisca l’output desiderato per te. Negli esempi di vita reale le persone tendono a mescolare le cose, soprattutto se si utilizzano input di informazioni differenti come API e database insieme.


Allora, qual è il grosso problema?

Bene, ci sono due articoli che ogni programmatore dovrebbe capire:

Algoritmo sul posto :

Nell’informatica, un algoritmo sul posto è un algoritmo che trasforma l’input senza alcuna struttura di dati ausiliari. Tuttavia è permessa una piccola quantità di spazio di memoria extra per le variabili ausiliarie. L’input viene solitamente sovrascritto dall’output mentre l’algoritmo viene eseguito. L’algoritmo sul posto aggiorna la sequenza di input solo attraverso la sostituzione o lo scambio di elementi. Un algoritmo che non è in-place viene talvolta chiamato non-in-place o out-of-place.

Quindi in pratica il nostro vecchio array verrà sovrascritto! Questo è importante se si desidera mantenere il vecchio array per altri motivi. Quindi tieni questo in mente.

Algoritmo di ordinamento

Gli algoritmi di ordinamento stabile ordinano gli elementi identici nello stesso ordine in cui appaiono nell’input. Quando si ordinano alcuni tipi di dati, solo una parte dei dati viene esaminata quando si determina l’ordinamento. Ad esempio, nell’esempio di ordinamento delle carte a destra, le carte vengono ordinate in base al loro grado e il loro seme viene ignorato. Ciò consente la possibilità di più versioni correttamente ordinate dell’elenco originale. Gli algoritmi di ordinamento stabile scelgono uno di questi, in base alla seguente regola: se due elementi si confrontano come uguali, come le due 5 carte, allora il loro ordine relativo verrà mantenuto, così che se uno viene prima dell’altro nell’input, sarà anche venire prima dell’altro nell’output.

inserisci la descrizione dell'immagine qui

Un esempio di specie stabile su carte da gioco. Quando le carte sono ordinate per rank con un ordinamento stabile, i due 5 devono rimanere nello stesso ordine nell’output ordinato in cui erano originariamente. Quando sono ordinati con un ordinamento non stabile, i 5 possono finire nell’opposto ordine nell’output ordinato.

Questo dimostra che l’ordinamento è giusto ma è cambiato. Quindi nel mondo reale, anche se l’ordinamento è corretto, dobbiamo assicurarci di ottenere ciò che ci aspettiamo! È molto importante tenerlo a mente. Per ulteriori esempi di JavaScript, consulta il file Array.prototype.sort () – doc: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

Risposta JavaScript pura per ordinare un object. Questa è l’unica risposta che so che gestirà i numeri negativi. Questa funzione è per l’ordinamento di oggetti numerici.

Input obj = {1000: {}, -1200: {}, 10000: {}, 200: {}};

 function osort(obj) { var keys = Object.keys(obj); var len = keys.length; var rObj = []; var rK = []; var t = Object.keys(obj).length; while(t > rK.length) { var l = null; for(var x in keys) { if(l && parseInt(keys[x]) < parseInt(l)) { l = keys[x]; k = x; } if(!l) { // Find Lowest var l = keys[x]; var k = x; } } delete keys[k]; rK.push(l); } for (var i = 0; i < len; i++) { k = rK[i]; rObj.push(obj[k]); } return rObj; } 

The output will be an object sorted by those numbers with new keys starting at 0.

Just to simplify it and make it more clear the answer from Matt Ball

 //your object var myObj = { b : 'asdsadfd', c : 'masdasaf', a : 'dsfdsfsdf' }; //fixed code var keys = []; for (var k in myObj) { if (myObj.hasOwnProperty(k)) { keys.push(k); } } keys.sort(); for (var i = 0; i < keys.length; i++) { k = keys[i]; alert(k + ':' + myObj[k]); } 

Sorts keys recursively while preserving references.

 function sortKeys(o){ if(o && o.constructor === Array) o.forEach(i=>sortKeys(i)); else if(o && o.constructor === Object) Object.entries(o).sort((a,b)=>a[0]>b[0]?1:-1).forEach(e=>{ sortKeys(e[1]); delete o[e[0]]; o[e[0]] = e[1]; }); } 

Esempio:

 let x = {d:3, c:{g:20, a:[3,2,{s:200, a:100}]}, a:1}; let y = xc; let z = xca[2]; sortKeys(x); console.log(x); // {a: 1, c: {a: [3, 2, {a: 1, s: 2}], g: 2}, d: 3} console.log(y); // {a: [3, 2, {a: 100, s: 200}}, g: 20} console.log(z); // {a: 100, s: 200}