Comment restaurer des objets à partir de JSON tout en…

Pour restaurer des objets avec des métadonnées sauvegardées depuis JSON, vous pouvez utiliser la méthode JSON.parse() en combinaison avec une fonction reviver. Reviver est une fonction optionnelle appelée pour chaque paire clé-valeur lors de l'analyse JSON. Elle permet de modifier les valeurs décodées avant qu'elles ne soient renvoyées.

Exemple d'utilisation de reviver pour conserver le type :

const jsonString = '{"date": "2023-10-27T10:00:00.000Z", "regexp": "/test/i"}';

const restoredObject = JSON.parse(jsonString, (key, value) => {
  if (typeof value === 'string' && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z$/.test(value)) {
    return new Date(value);
  }
  if (typeof value === 'string' && /^\/.+\/[gimyus]*$/.test(value)) {
    try {
       const match = value.match(/^\/(.+)\/([gimyus]*)$/);
       if (match) {
           return new RegExp(match[1], match[2]);
       }
    } catch (e) {
    }
  }
  return value;
});

console.log(restoredObject.date instanceof Date); // true
console.log(restoredObject.regexp instanceof RegExp); // true

Pour des cas plus complexes, où les métadonnées peuvent inclure des informations sur des classes personnalisées ou d'autres types, il est nécessaire d'inclure des marqueurs explicites ou un schéma dans JSON décrivant les types de données.

Exemple avec des marqueurs explicites :

{
  "user": {
    "_type": "User",
    "name": "Alice",
    "registrationDate": {
      "_type": "Date",
      "value": "2023-10-26T12:00:00.000Z"
    }
  },
  "settings": {
    "theme": "dark"
  }
}

Et le reviver correspondant :

class User {
  constructor(name, registrationDate) {
    this.name = name;
    this.registrationDate = registrationDate;
  }
}

const jsonWithMetadata = '{"user": {"_type": "User", "name": "Alice", "registrationDate": {"_type": "Date", "value": "2023-10-26T12:00:00.000Z"}}, "settings": {"theme": "dark"}}';

const restoredObjectWithMetadata = JSON.parse(jsonWithMetadata, (key, value) => {
  if (value && typeof value === 'object' && value._type) {
    switch (value._type) {
      case 'Date':
        return new Date(value.value);
      case 'User':
        return new User(value.name, new Date(value.registrationDate.value));
      default:
        return value;
    }
  }
  return value;
});

console.log(restoredObjectWithMetadata.user instanceof User); // true
console.log(restoredObjectWithMetadata.user.registrationDate instanceof Date); // true

Cette approche nécessite un accord préalable sur la structure des métadonnées dans JSON (par exemple, l'utilisation de la clé _type) et la mise en œuvre de la logique de restauration dans le reviver pour chaque type. Pour sauvegarder des objets complexes, comme des instances de classes personnalisées avec des méthodes, une approche plus sophistiquée, incluant la sérialisation et la désérialisation des méthodes séparément ou l'utilisation de bibliothèques spécialisées, peut être nécessaire. Cependant, pour la sauvegarde de types standard et de structures de données simples, le reviver est assez efficace.

Comment restaurer des objets à partir de JSON tout en conservant les métadonnées?