Existe-t-il un moyen d'analyser les chaînes en tant que JSON dans Typescript.
Exemple: Dans JS, nous pouvons utiliser JSON.parse(). Existe-t-il une fonction similaire dans Typescript?

J'ai une chaîne d'objet JSON comme suit:

{"name": "Bob", "error": false}

Typescript est (un sur-ensemble de) javascript, vous utilisez donc simplement JSON.parsecomme vous le feriez en javascript:

let obj = JSON.parse(jsonString);

Seulement que dans dactylographié, vous pouvez avoir un type pour l'objet résultant:

interface MyObj {
    myString: string;
    myNumber: number;
}

let obj: MyObj = JSON.parse('{ "myString": "string", "myNumber": 4 }');
console.log(obj.myString);
console.log(obj.myNumber);

( code dans la cour de récréation )

Type-safe JSON.parse

Vous pouvez continuer à utiliser JSON.parse, car TS est un sur-ensemble JS. Il reste un problème: les JSON.parseretours any, qui sapent la sécurité des types. Voici deux options pour les types plus forts:

1. Protections de type défini par l'utilisateur ( terrain de jeu )

Les protections de type personnalisées sont la solution la plus simple et souvent suffisante pour la validation externe des données:

// For example, you expect to parse a given value with `MyType` shape
type MyType = { name: string; description: string; }

// Validate this value with a custom type guard
function isMyType(o: any): o is MyType {
  return "name" in o && "description" in o
}

Un JSON.parsewrapper peut alors prendre un type guard comme entrée et renvoyer la valeur typée analysée:

const safeJsonParse = <T>(guard: (o: any) => o is T) => (text: string): ParseResult<T> => {
  const parsed = JSON.parse(text)
  return guard(parsed) ? { parsed, hasError: false } : { hasError: true }
}

type ParseResult<T> =
  | { parsed: T; hasError: false; error?: undefined }
  | { parsed?: undefined; hasError: true; error?: unknown }

const json = '{ "name": "Foo", "description": "Bar" }';
const result = safeJsonParse(isMyType)(json) // result: ParseResult<MyType>
if (result.hasError) {
  console.log("error :/")  // further error handling here
} else {
  console.log(result.parsed.description) // result.parsed now has type `MyType`
}

safeJsonParsepeut être étendu pour échouer rapidement ou essayer / attraper des JSON.parseerreurs.

2. Bibliothèques externes

L'écriture manuelle des fonctions de protection de type devient fastidieuse, si vous devez valider de nombreuses valeurs différentes. Il existe des bibliothèques pour vous aider dans cette tâche - exemples (pas de liste complète):

• io-ts: rel. populaire (3,2k étoiles actuellement), fp-tsdépendance des pairs, style de programmation fonctionnel
• zod: tout à fait nouveau (repo: 2020-03-07), s'efforce d'être plus procédural / orienté objet queio-ts
• typescript-is: Transformateur TS pour l'API du compilateur, wrapper supplémentaire comme ttypescript nécessaire
• typescript-json-schema/ ajv: Créez un schéma JSON à partir de types et validez-le avecajv

Plus d'infos

• Vérification du type d'exécution # 1573
• Vérification du type d'interface avec Typescript
• TypeScript: validation des données externes

Si vous souhaitez que votre JSON ait un type Typecript validé, vous devrez effectuer vous-même ce travail de validation. Cela n’a rien de nouveau. En Javascript simple, vous devrez faire de même.

Validation

J'aime exprimer ma logique de validation comme un ensemble de «transformations». Je définis a Descriptorcomme une carte de transformations:

type Descriptor<T> = {
  [P in keyof T]: (v: any) => T[P];
};

Ensuite, je peux créer une fonction qui appliquera ces transformations à une entrée arbitraire:

function pick<T>(v: any, d: Descriptor<T>): T {
  const ret: any = {};
  for (let key in d) {
    try {
      const val = d[key](v[key]);
      if (typeof val !== "undefined") {
        ret[key] = val;
      }
    } catch (err) {
      const msg = err instanceof Error ? err.message : String(err);
      throw new Error(`could not pick ${key}: ${msg}`);
    }
  }
  return ret;
}

Maintenant, non seulement je valide mon entrée JSON, mais je construis un type Typecript au fur et à mesure. Les types génériques ci-dessus garantissent que le résultat infère les types à partir de vos "transformations".

Au cas où la transformation lèverait une erreur (c'est ainsi que vous implémenteriez la validation), j'aime l'envelopper avec une autre erreur indiquant quelle clé a causé l'erreur.

Usage

Dans votre exemple, j'utiliserais ceci comme suit:

const value = pick(JSON.parse('{"name": "Bob", "error": false}'), {
  name: String,
  error: Boolean,
});

Maintenant valuesera tapé, puisque Stringet Booleansont tous deux des "transformateurs" dans le sens où ils prennent une entrée et retournent une sortie typée.

De plus, le valuesera réellement de ce type. En d'autres termes, si namec'était réellement 123, il sera transformé en "123"afin que vous ayez une chaîne valide. C'est parce que nous avons utilisé Stringau moment de l'exécution, une fonction intégrée qui accepte une entrée arbitraire et renvoie unstring .

Vous pouvez voir cela fonctionner ici . Essayez les choses suivantes pour vous convaincre:

• Survolez la const valuedéfinition pour voir que la fenêtre contextuelle affiche le type correct.
• Essayez de changer "Bob"à 123et re-exécuter l'exemple. Dans votre console, vous verrez que le nom a été correctement converti en chaîne "123".

Vous pouvez en outre utiliser des bibliothèques qui effectuent la validation de type de votre json, telles que Sparkson . Ils vous permettent de définir une classe TypeScript, à laquelle vous souhaitez analyser votre réponse, dans votre cas cela pourrait être:

import { Field } from "sparkson";
class Response {
   constructor(
      @Field("name") public name: string,
      @Field("error") public error: boolean
   ) {}
}

La bibliothèque validera si les champs obligatoires sont présents dans la charge utile JSON et si leurs types sont corrects. Il peut également effectuer un tas de validations et de conversions.

Il existe une excellente bibliothèque pour cela ts-json-object

Dans votre cas, vous devrez exécuter le code suivant:

import {JSONObject, required} from 'ts-json-object'

class Response extends JSONObject {
    @required
    name: string;

    @required
    error: boolean;
}

let resp = new Response({"name": "Bob", "error": false});

Cette bibliothèque validera le json avant l'analyse

JSON.parse est disponible dans TypeScript, vous pouvez donc simplement l'utiliser:

JSON.parse('{"name": "Bob", "error": false}') // Returns a value of type 'any'

Cependant, vous souhaiterez souvent analyser un objet JSON tout en vous assurant qu'il correspond à un certain type, plutôt que de traiter une valeur de type any. Dans ce cas, vous pouvez définir une fonction telle que la suivante:

function parse_json<TargetType extends Object>(
  json: string,
  type_definitions: { [Key in keyof TargetType]: (raw_value: any) => TargetType[Key] }
): TargetType {
  const raw = JSON.parse(json); 
  const result: any = {};
  for (const key in type_definitions) result[key] = type_definitions[key](raw[key]);
  return result;
}

Cette fonction prend une chaîne JSON et un objet contenant des fonctions individuelles qui chargent chaque champ de l'objet que vous créez. Vous pouvez l'utiliser comme ceci:

const value = parse_json(
  '{"name": "Bob", "error": false}',
  { name: String, error: Boolean, }
);