Gibt es eine Möglichkeit, Zeichenfolgen als JSON in Typescript zu analysieren?
Beispiel: In JS können wir verwenden JSON.parse(). Gibt es eine ähnliche Funktion in Typescript?

Ich habe eine JSON-Objektzeichenfolge wie folgt:

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

Typoskript ist (eine Obermenge von) Javascript, also verwenden Sie es einfach JSON.parsewie in Javascript:

let obj = JSON.parse(jsonString);

Nur dass Sie im Typoskript einen Typ für das resultierende Objekt haben können:

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

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

( Code auf dem Spielplatz )

Wenn Ihr JSON einen validierten Typescript-Typ haben soll, müssen Sie diese Validierungsarbeit selbst ausführen. Das ist nichts Neues. In einfachem Javascript müssten Sie dasselbe tun.

Validierung

Ich möchte meine Validierungslogik als eine Reihe von "Transformationen" ausdrücken. Ich definiere a Descriptorals Karte von Transformationen:

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

Dann kann ich eine Funktion erstellen, die diese Transformationen auf beliebige Eingaben anwendet:

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;
}

Jetzt validiere ich nicht nur meine JSON-Eingabe, sondern baue auch unterwegs einen Typescript-Typ auf. Die oben genannten generischen Typen stellen sicher, dass das Ergebnis die Typen aus Ihren "Transformationen" ableitet.

Falls die Transformation einen Fehler auslöst (so würden Sie die Validierung implementieren), möchte ich sie mit einem weiteren Fehler umschließen, der anzeigt, welcher Schlüssel den Fehler verursacht hat.

Verwendung

In Ihrem Beispiel würde ich dies wie folgt verwenden:

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

Jetzt valuewird getippt, da Stringund Booleanbeide "Transformatoren" in dem Sinne sind, dass sie Eingaben nehmen und eine getippte Ausgabe zurückgeben.

Darüber hinaus ist der valueWille tatsächlich , dass Art. Mit anderen Worten, wenn dies nametatsächlich der 123Fall wäre , wird es so transformiert, "123"dass Sie eine gültige Zeichenfolge haben. Dies liegt daran, dass wir zur StringLaufzeit eine integrierte Funktion verwendet haben, die beliebige Eingaben akzeptiert und a zurückgibt string.

Sie können dies hier sehen . Versuchen Sie Folgendes, um sich selbst zu überzeugen:

• Bewegen Sie den Mauszeiger über die const valueDefinition, um anzuzeigen, dass im Popup der richtige Typ angezeigt wird.
• Versuchen Sie , "Bob"auf 123und die Probe erneut aus. In Ihrer Konsole sehen Sie, dass der Name ordnungsgemäß in die Zeichenfolge konvertiert wurde "123".

Typensicher JSON.parse

Sie können weiterhin verwenden JSON.parse, da TS eine JS-Obermenge ist. Es gibt immer noch ein Problem: JSON.parseRückgabe any, die die Typensicherheit untergräbt. Hier sind zwei Optionen für stärkere Typen:

1. Benutzerdefinierte Typwächter ( Spielplatz )

Type Guards sind die einfachste Lösung und oft ausreichend für die externe Datenvalidierung:

// 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
}

Ein JSON.parseWrapper nimmt dann einen Typschutz als Eingabe und gibt den analysierten, typisierten Wert zurück:

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

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 }
}

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

safeJsonParsekann erweitert werden, um schnell zu versagen oder JSON.parseFehler zu versuchen / zu fangen .

2. Externe Bibliotheken

Das manuelle Schreiben von Typschutzfunktionen wird umständlich, wenn Sie viele verschiedene Werte validieren müssen. Es gibt einige Bibliotheken, die bei dieser Aufgabe helfen - Beispiele (keine umfassende Liste):

• io-ts: rel. beliebt (derzeit 3,2k Sterne), fp-tsPeer-Abhängigkeit, funktionaler Programmierstil
• zod: ganz neu (repo: 2020-03-07), strebt danach, prozeduraler / objektorientierter zu sein alsio-ts
• typescript-is: TS-Transformator für Compiler-API, zusätzlicher Wrapper wie ttypescript erforderlich
• typescript-json-schema/ ajv: JSON-Schema aus Typen erstellen und mit validierenajv

Weitere Infos

• Überprüfung des Laufzeit-Typs # 1573
• Schnittstellentypprüfung mit Typescript
• TypeScript: Überprüfung externer Daten

Sie können zusätzlich Bibliotheken verwenden, die eine Typüberprüfung Ihres JSON durchführen, z. B. Sparkson . Mit ihnen können Sie eine TypeScript-Klasse definieren, auf die Sie Ihre Antwort analysieren möchten. In Ihrem Fall könnte dies sein:

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

Die Bibliothek überprüft, ob die erforderlichen Felder in der JSON-Nutzlast vorhanden sind und ob ihre Typen korrekt sind. Es kann auch eine Reihe von Validierungen und Konvertierungen durchführen.

Es gibt eine großartige Bibliothek für das ts-json-Objekt

In Ihrem Fall müssten Sie den folgenden Code ausführen:

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});

Diese Bibliothek überprüft den JSON vor dem Parsen

JSON.parse ist in TypeScript verfügbar, Sie können es also einfach verwenden:

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

Sie möchten jedoch häufig ein JSON-Objekt analysieren, während Sie sicherstellen, dass es einem bestimmten Typ entspricht, anstatt sich mit einem Wert vom Typ zu befassen any. In diesem Fall können Sie eine Funktion wie die folgende definieren:

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;
}

Diese Funktion verwendet eine JSON-Zeichenfolge und ein Objekt, das einzelne Funktionen enthält, die jedes Feld des von Ihnen erstellten Objekts laden. Sie können es so verwenden:

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