Sérialisation d'objets en TypeScript : bibliothèques, méthodes et exemples

Sérialisation d'objets en TypeScript : guide complet

La sérialisation est le processus de conversion d'un objet en flux d'octets ou en chaîne de caractères pour transmission sur un réseau ou sauvegarde. En TypeScript, cette tâche est complexifiée par la nécessité de préserver les types, de supporter le polymorphisme et de travailler avec des classes. Examinons les principaux outils et approches.

1. Sérialisation intégrée : JSON.stringify / JSON.parse

Le mécanisme de base en JavaScript/TypeScript est l'objet global JSON. Il sérialise uniquement les types simples : chaînes, nombres, booléens, tableaux et objets plats. Les méthodes, symboles, undefined, Date et instances de classes sont perdus.

// Exemple : sérialisation d'une classe\nclass User {\n  constructor(\n    public name: string,\n    private password: string,\n    public createdAt: Date = new Date()\n  ) {}\n}\n\nconst user = new User('Alice', 'secret123');\nconst json = JSON.stringify(user);\n// Résultat : {"name":"Alice","createdAt":"2025-03-24T10:00:00.000Z"}\n// password n'est pas dans le JSON (private), mais Date est devenu une chaîne\n// Lors de la désérialisation, nous obtenons un objet ordinaire, pas une instance de User\n\nconst parsed: User = JSON.parse(json) as User;\nconsole.log(parsed instanceof User); // false\n

Problèmes :

\n
• Perte de type (l'instance de classe devient object).
\n
• Les champs privés, méthodes, getters ne sont pas sérialisés.
\n
• Les dates, Map, Set, BigInt nécessitent une conversion manuelle.
\n
• Le polymorphisme n'est pas supporté — il faut restaurer le type manuellement.
\n

2. Bibliothèque class-transformer

class-transformer est la solution la plus populaire pour la sérialisation/désérialisation de classes en TypeScript. Elle utilise des décorateurs pour décrire les règles de transformation.

Installation

npm install class-transformer reflect-metadata

Exemple d'utilisation

import { plainToClass, classToPlain, Expose, Transform, Type } from 'class-transformer';\nimport 'reflect-metadata';\n\nclass Address {\n  @Expose()\n  city!: string;\n\n  @Expose()\n  street!: string;\n}\n\nclass Employee {\n  @Expose()\n  id!: number;\n\n  @Expose()\n  name!: string;\n\n  @Expose()\n  @Type(() => Address) // transformation imbriquée\n  address!: Address;\n\n  @Expose()\n  @Transform(({ value }) => new Date(value)) // transformation personnalisée\n  hireDate!: Date;\n\n  // La méthode n'est pas sérialisée\n  get displayName(): string {\n    return `${this.name} (ID: ${this.id})`;\n  }\n}\n\n// Désérialisation à partir d'un objet plain\nconst plainData = {\n  id: 1,\n  name: 'Bob',\n  address: { city: 'Moscow', street: 'Tverskaya' },\n  hireDate: '2024-01-15T00:00:00.000Z'\n};\n\nconst employee = plainToClass(Employee, plainData);\nconsole.log(employee instanceof Employee);          // true\nconsole.log(employee.hireDate instanceof Date);     // true\n\n// Sérialisation en retour\nconst plain = classToPlain(employee);\nconsole.log(plain); // { id: 1, name: 'Bob', address: { city: 'Moscow', street: 'Tverskaya' }, hireDate: '2024-01-15T00:00:00.000Z' }\n

Avantages :

\n
• Restauration automatique des types (objets imbriqués, tableaux).
\n
• Support du polymorphisme via @Type avec discriminateur.
\n
• Transformation des valeurs (dates, nombres, formats personnalisés).
\n
• Travail avec des champs privés via @Expose.
\n

Inconvénients :

\n
• Dépendance aux décorateurs (nécessite experimentalDecorators dans tsconfig).
\n
• Ne convient pas aux systèmes à forte charge (la réflexion ralentit le travail).
\n
• Taille du bundle ~15KB (gzip).
\n

3. Protocol Buffers avec protobuf-ts

Pour l'architecture microservices et gRPC, on utilise souvent Protocol Buffers. L'implémentation TypeScript protobuf-ts génère des types