 |
In JavaScript, sia gli oggetti (Object) che le mappe (Map) possono essere utilizzati per memorizzare coppie chiave-valore. Tuttavia, ci sono differenze fondamentali tra i due, sia in termini di comportamento che di prestazioni. Conoscere queste differenze è cruciale per scegliere la struttura dati più adatta in ogni situazione.
1. Tipi di chiavi
Una delle differenze più evidenti è il tipo di chiavi che possono essere utilizzate.
- Oggetti: Le chiavi sono sempre convertite in stringhe (o
Symbol). - Mappe: Le chiavi possono essere di qualsiasi tipo, inclusi oggetti, funzioni e primitive.
Esempio:
const obj = {};
const map = new Map();
const keyObj = { id: 1 };
obj[keyObj] = 'value';
map.set(keyObj, 'value');
console.log(obj[keyObj]); // 'value', ma la chiave è stata convertita in "[object Object]"
console.log(map.get(keyObj)); // 'value', la chiave è mantenuta intatta
2. Ordine di iterazione
- Oggetti: L'ordine delle proprietà non è garantito (anche se nei browser moderni è prevedibile per la maggior parte dei casi).
- Mappe: Mantengono l'ordine di inserimento delle chiavi.
Esempio:
const obj = { b: 2, a: 1 };
const map = new Map([['b', 2], ['a', 1]]);
console.log(Object.keys(obj)); // ['b', 'a'] (ma non garantito in tutti i motori JS)
console.log([...map.keys()]); // ['b', 'a'] — garantito
3. Performance
- Oggetti: Ottimizzati per set e get di proprietà semplici.
- Mappe: Ottimizzate per frequenti operazioni di aggiunta/rimozione e per collezioni dinamiche di chiavi.
In generale: Se hai un grande numero di operazioni dinamiche (inserimenti/cancellazioni), una Map sarà più performante.
4. Metodi e proprietà
- Oggetti: Hanno un set limitato di metodi utili (come
Object.keys,Object.entries, ecc.). - Mappe: Offrono metodi integrati molto comodi (
set,get,has,delete,clear, ecc.).
Esempio:
const map = new Map();
map.set('name', 'Alice');
map.set('age', 30);
console.log(map.has('name')); // true
map.delete('age');
console.log(map.size); // 1
5. Prototype pollution e ereditarietà
- Oggetti: Ereditano da
Object.prototype, il che può causare problemi (es.obj['toString']). - Mappe: Non hanno proprietà ereditate per default; sono "pulite".
Esempio problematico:
const obj = {};
console.log(obj['toString']); // function, ereditata
Con Map, questo non succede:
const map = new Map();
console.log(map.get('toString')); // undefined
Quando usare Map
Usa una Map quando:
- Hai bisogno di chiavi non-stringa (es. oggetti, funzioni).
- Ti serve mantenere l’ordine di inserimento delle chiavi.
- Hai una collezione dinamica e frequenti operazioni di aggiunta/rimozione.
- Vuoi evitare interferenze con proprietà ereditate.
- Hai bisogno di performance migliori su set/get/has/delete.
Quando usare Object
Usa un oggetto quando:
- Hai bisogno di rappresentare entità con proprietà note e statiche.
- Vuoi usare la notazione letterale (
{}) per maggiore semplicità. - Le chiavi sono tutte stringhe e conosciute a priori.
- Vuoi beneficiare di tecniche come destructuring o object spread.
Esempio classico:
const user = {
name: 'Alice',
age: 30,
role: 'admin'
};
console.log(user.name); // 'Alice'
Conclusione
In JavaScript moderno, Map è spesso preferibile a Object per strutture dati dinamiche e complesse, grazie alla sua flessibilità e alle performance migliori. Tuttavia, gli oggetti rimangono ideali per rappresentare entità con proprietà note, in modo semplice e leggibile.
La scelta tra Map e Object non è solo tecnica, ma anche semantica: chiediti cosa stai rappresentando e come interagirai con quei dati.
Follow me #techelopment
Official site: www.techelopment.it
facebook: Techelopment
instagram: @techelopment
X: techelopment
Bluesky: @techelopment
telegram: @techelopment_channel
whatsapp: Techelopment
youtube: @techelopment
