5 caratteristiche di Json che non conoscevi

Il JSON è un formato di scambio dati ampiamente utilizzato nell’ambito della programmazione web e delle API. Sicuramente l’avrai già sentito nominare in quanto di frequente un file JSON viene utilizzato per la trasmissione e archiviazione di dati strutturati, spesso anche in database NoSQL. In questo articolo vedremo 5 caratteristiche dei file JSON che potresti non conoscere.

Prima, però, facciamo un piccolo approfondimento.
 

JSON, cos’è?

La dicitura JSON è un acronimo di JavaScript Object Notation, è un formato di dati leggero e facilmente leggibile (molto simile ai dizionari in Python). È utilizzato per rappresentare strutture dati complesse in un formato gerarchico e facile da parsare. La sua sintassi si avvicina a quella degli oggetti in JavaScript ed è una risorsa cruciale nella gestione e aggiornamento di dati in Database NoSQL.

Le caratteristiche dei file JSON che potresti non conoscere

Esploriamo ora le diverse e funzionali features che JSON mette a disposizione degli sviluppatori, che non tutti potrebbero conoscere!

1. Formattazione: JSON ci permette di migliorare la visualizzazione anche del log. Avendo a che fare con grandi quantità di dati, poter leggere il log in maniera pulita e ordinata diventa una pratica fondamentale per non incappare in eventuali errori. Vediamo come farlo.

Il metodo stringify (built-in) usato senza specificare parametri:

 

1. const user = {
 2.   name: 'John',
 3.   age: 30,
 4.   isAdmin: true,
 5.   friends: ['Bob', 'Jane'],
 6.   address: {
 7.     city: 'New York',
 8.     country: 'USA'
 9.   }
10. };
11.  
12. console.log(JSON.stringify(user));
13. //=> {"name":"John","age":30,"isAdmin":true,"friends":["Bob","Jane"],"address":{"city":"New York","country":"USA"}}
14.  

Il metodo stringify (built-in) usato migliorando l’output:

 

 1. console.log(JSON.stringify(user, null, 2));
 2. // {
 3. //   "name": "John",
 4. //   "age": 30,
 5. //   "isAdmin": true,
 6. //   "friends": [
 7. //     "Bob",
 8. //     "Jane"
 9. //   ],
10. //   "address": {
11. //     "city": "New York",
12. //     "country": "USA"
13. //   }
14. // }

2. Nascondere determinate proprietà nei dati “stringfield”: il già citato metodo stringify possiede un secondo argomento che a molti risulta sconosciuto. Questo parametro chiamato replacer consente di nascondere o conservare determinati dati nell’output. Un file JSON esempio semplice potrebbe essere voler nascondere la password di un utente.

 

 1. const user = {
 2.   name: 'John',
 3.   password: '12345',
 4.   age: 30
 5. };
 6.  
 7. console.log(JSON.stringify(user, (key, value) => {
 8.     if (key === 'password') {
 9.             return;
10.     }
11.  
12.     return value;
13. }));

È possibile anche passare un array per ottenere solo determinate chiavi:

 

. const user = {
2.     name: 'John',
3.     password: '12345',
4.     age: 30
5. }
6.  
7. console.log(JSON.stringify(user, ['name', 'age']))

3. Usare la funzione toJSON per creare formati di output personalizzati: consideriamo questo formato JSON

 

1. class Fraction {
2.   constructor(n, d) {
3.     this.numerator = n;
4.     this.denominator = d;
5.   }
6. }
7.  
8. console.log(JSON.stringify(new Fraction(1, 2)))

Questo pezzo di codice restituirà in output {“numerator”:1,”denominator”:2}. Ma cosa succede se voglio rimpiazzare questo con una stringa ½? Introduco la funzione toJSON.

 

 1. class Fraction {
 2.   constructor(n, d) {
 3.     this.numerator = n;
 4.     this.denominator = d;
 5.   }
 6.  
 7.   toJSON() {
 8.       return `${this.numerator}/${this.denominator}`
 9.   }
10. }
11.  
12. console.log(JSON.stringify(new Fraction(1, 2)))

4. Recuperare i dati: è possibile “riportare indietro” i dati all’interno di un file JSON. Tutto ciò introducendo i revivers! Prendiamo come esempio la frazione ottenuta come output nel punto precedente.

 

 1. class Fraction {
 2.   constructor(n, d) {
 3.     this.numerator = n;
 4.     this.denominator = d;
 5.   }
 6.  
 7.   toJSON() {
 8.       return `${this.numerator}/${this.denominator}`
 9.   }
10.  
11.   static fromJSON(key, value) {
12.       if (typeof value === 'string') {
13.           const parts = value.split('/').map(Number);
14.         if (parts.length === 2) return new Fraction(parts);
15.       }
16.  
17.     return value;
18.   }
19. }
20.  
21. const fraction = new Fraction(1, 2);
22. const stringified = JSON.stringify(fraction);
23. console.log(stringified);
24. // "1/2"
25. const revived = JSON.parse(stringified, Fraction.fromJSON);
26. console.log(revived);
27. // Fraction { numerator: 1, denominator: 2 }
28.  

Passando un secondo argomento a JSON.parse specifichiamo la “reviver function”. Il compito del reviver è quello di “ripristinare” i dati stringfied nella loro forma originale. Qui stiamo passando un reviver, che è la proprietà statica fromJSON della classe Fraction. Nel nostro esempio il reviver verifica se il valore è una frazione valida e, se lo è, crea un nuovo oggetto Fraction per poterlo ritornare.

5. Valori NaNe Infinity: Sebbene JSON sia utilizzato principalmente per rappresentare dati strutturati, può trattare anche valori speciali come “NaN” e “Infinity”, che sono spesso associati a calcoli matematici.

 

. {
2.     "value": NaN,
3.     "other_value": Infinity
4. }

In conclusione, JSON è molto più che un semplice formato di rappresentazione e organizzazione dei dati. Spesso ci sono features e caratteristiche nascoste che possono dare maggiore fascino a questo genere di strumenti. Tenere sempre a mente la potenza che JSON dà ad uno sviluppatore quando si trova a gestire e manovrare grosse quantità di dati.

E tu, lo sapevi?