slow json stringify

Sjs

Der langsamste Stringifier im bekannten Universum. Nur ein Scherz, es ist das schnellste (:

Toc

• Tl; dr

• Installation

• Wie es funktioniert

• Einschränkungen

• Benchmarks

• Die Benchmarks laufen

• Testmaschine

• Einige Zahlen

• Verwendung

• Unterstützte Typen

• Ein Schema definieren

• Definieren von Schema mit einfachem Array

• Definieren von Schema mit komplexem Array

• Das Schema mit verschachtelten Objekten definieren

• Serialisierer

• API

• sjs

• Flucht

• Lizenz

Tl; dr

SJS zeigt eine signifikante Leistungserhöhung bei den nativen JSON.stringify und fast-json-stringify . Für einige Anwendungsfälle (der sich mit langem Text befindet) wird 21000% schneller ausgeführt als native und fast-json-stringify .

Hinweis: Die Unterstützung für undefinierte Eigenschaften wurde ab 1.0.1 hinzugefügt. SJS ist jetzt die Produktion bereit.

Checkout -Benchmarks.

Installation

SJS ist sowohl mit Node.js als auch mit dem Browser vollständig kompatibel?

Knoten:

 NPM Installieren Sie Slow-Json-Stringify

Auf dem Browser:

 <script src = "https://unpkg.com/slow-json-stringify/dist/sjs.umd.js"> </script>

Wie es funktioniert

Warum ist SJS der schnellste Stringungser? Der traditionelle Ansatz besteht darin, jede einzigartige Eigenschaft zu serialisieren. SJS verwendet einen anderen Ansatz zur Serialisierung.

Vorbereitung:

• Es wird ein Schema zur Verfügung gestellt

• Das Schema ist stringifiziert

• Mit dem bereitgestellten Schema wird eine Vorlagenschnur erstellt.

Serialisierung:

• Objektwerte werden in die bereits erstellte Vorlage eingefügt.

Es ist schneller, weil es viel weniger Arbeit leistet.

Einschränkungen

SJS benötigen im Vergleich zu nativem JSON.stringify einige Einrichtungsarbeiten. Wenn Sie jedoch mit JSON mit einer festen Struktur zu tun haben, sparen SJS eine Menge Zeit. Vor allem, wenn die Nutzlast wächst. Und unglaublich, wenn JSON mit langem Text im Inneren serialisiert wird (denken Sie an einen Blog -Artikel oder eine Produktbeschreibung. Darüber hinaus ermöglicht SJS die Serialisierung von Typen, die dank benutzerdefinierter JSON.stringify nicht nativ unterstützt werden.

Hinweis: SJS führt keine Flucht durch, da Sie es normalerweise nicht in kleinen Nutzlasten benötigen. Wenn Sie mit großem Text arbeiten, könnte es sehr wenig Anstrengungen sein, in Ihrem DB einen bereits entkommenen Text zu speichern.

SJS bietet jedoch einen kleinen Nutzen für Ihre Fluchtbedürfnisse. escape verwendet einen Standard -Regex, wenn kein zusätzlicher Regex bereitgestellt wird.

Standard -Regex -Zeichenfolge:

 /n | r | t | "| /gm

Sie können escape wie folgt verwenden:

 const {Escape} = fordert ('Slow-Json-Stringify'); // Wenn Sie keine zusätzlichen Regex übergeben, wird ein Standard verwendet. '); // Dies ist "lustig" // Sie können jeden Regex übergeben, den Sie für Ihre Fluchtstrategie wollen

Benchmarks

Wir alle wissen, dass es drei Arten von Lügen gibt.

Lügen, verdammte Lügen .. und Benchmarks.

Denken Sie daran, zu testen, ob SJS eine echte Verbesserung für Ihren Anwendungsfall sein könnten. Weil es Zeiten gibt, in denen die Leistungsvorteile mit den zusätzlichen Nachteilen nicht wert sein könnten.

Die Benchmarks laufen

Jeder Benchmark ist auf Ihrer eigenen Maschine reproduzierbar. Um Ihre Tests durchzuführen:

• Klonen Sie dieses Repo.

• Abhängigkeiten installieren.

• cd benchmark .

• Zugeben ausführbare Rechte für run.sh script chmod +x ./run.sh .

• Speichern Sie Benchmarkergebnisse in Datei ./run.sh >> benchmark.md

Testmaschine

Die Benchmarks wurden auf einem Dell XPS 15 9550 durchgeführt.

• CPU: Intel i7 6700HQ

• RAM: 16 GB

• OS: Ubuntu 18.04

Einige Zahlen

Checkout -Benchmarks hier

Verwendung

Unterstützte Typen

Die Schema -Kreation erfolgt dank des aus dem Hauptbündel exportierten attr -Helfer.

 const {attr} = fordert ('sjs');

 Attr (Typ, Serializer?)

Der attr -Helfer unterstützt nativ die folgenden Typen:

• string

• number

• boolean

• null

• array , dynamisches Array mit einfacher Struktur, wird in diesem Szenario native JSON.stringify verwendet. Da es keine wirklichen Leistungsvorteile gibt.

Die Serialisierung eines anderen Typs ist dank benutzerdefinierter Serialisierer möglich.

Ein Schema definieren

Für eine korrekte Zeichenfolge Ihrer JSON -Nutzlast ist ein korrektes Schema obligatorisch. Das Definieren eines Schemas ist ziemlich praktisch und überhaupt nicht ausführlich.

 const {sjs} = required ('Slow-json-Stringify'); // Schema Definitionconst Stringify = sjs ({{{{{{
  A: Attr ('String'),
  B: Attr ('Nummer'),
  C: attr ('boolean'),}); // Dann können Sie mit dieser Struktur alles streiten.
  A: 'Welt',
  B: 42,
  C: wahr,}); // {"a": "Welt", "B": 42, "C": true}

Definieren von Schema mit einfachem Array

Beim Streben von einfachem Array JSON.stringify wird intern verwendet.

 const {sjs} = required ('Slow-json-Stringify'); // Schema Definitionconst Stringify = sjs ({{{{{{
  A: attr ('Array'),}); // Dann können Sie mit dieser Struktur alles streiten.
  A: [1, 2, 3, wahr, 'Welt'],}); // {"a": [1,2,3, wahr, "Welt"]}

Definieren von Schema mit komplexem Array

Der attr -Helfer akzeptiert ein zusätzliches sjs -Schema für array -Eigenschaften.

 const {sjs} = required ('Slow-json-Stringify'); // Schema Definitionconst Stringify = sjs ({{{{{{
  A: Attr ('Array', sjs ({b: array ('string'), c: array ('nummer'),
  })))}); // dann können Sie mit dieser Struktur alles streiten.Stringify ({{{{
  A: [{b: 'ciao1', c: 1,
  }, {b: 'ciao2', c: 2,
  }, {b: 'ciao3', c: 3,
  }, {b: 'ciao4', c: 4,
   }],}); // {"a": [{"b": "ciao1", "c": 1}, {"b": "ciao2", "c": 2}, {"B" : "CIAO3", "C": 3}, {"B": "CIAO4", "C": 4}]}

Das Schema mit verschachtelten Objekten definieren

Das Definieren von Schemata mit verschachtelten Objekten ist ziemlich einfach.

 const {sjs} = required ('Slow-json-Stringify'); // Schema Definitionconst Stringify = sjs ({{{{{{
  A: {b: {c: attr ('String'),},
  },
  d: {e: attr ('number'),
  },}); Stringify ({{{
  A: {B: {C: 'Hallo',},
  },
  d: {e: 42,
  },}); // {"a": {"b": {"c": "hello"}}, "d": {"e": 42}}

Serialisierer

Der attr -Helfer akzeptiert eine Serializerfunktion. Die Serializer -Funktion wird mit dem realen Wert aufgerufen, der angerechnet werden sollte.

 Serializer (Rohwert)

Immobilienserialisierer sind nützlich, um eine benutzerdefinierte Serialisierung auf einem beliebigen Typ zu erzielen, das auch nicht von JSON.stringify (Daten, regulären Ausdrucksformen) nativ unterstützt wird. Sie können auch verwendet werden, um die Serializarion von Eigenschaften zu überspringen, wenn sie undefined zurückkehren.

 const {sjs} = required ('Slow-json-Stringify'); // Schema Definitionconst Stringify = sjs ({{{{{{
  A: attr ('number', (value) => {if (value> 10) {return value;} return undefined;
  })}); stringify ({a: 20}); // {"a": 20} Stringify ({a: 5}); // {}

Anwendungsfall: Serialisierung jeglicher Art.

 // datesconst stringify = sjs ({{
  Datum: attr ('String', (value) => value.tolocalestring ()),}); // RegexpConst Stringify = sjs ({{{{{
  regexp: attr ('string', (value) => value.toString ()),});

Anwendungsfall: Passen Sie Nutzlasten anhand von Zugriffsrechten an.

 const stringify = sjs ({{
  PublicProp: Attr ('String'),
  restrictedProp: attr ('String', (value) => isadmin? Wert: und undefiniert),});

Anwendungsfall: Wertformatierung

 const stringify = sjs ({{
  prop: attr ('string', (value) => value.toUppercase ()),});

API

sjs

Param	Typ	erforderlich	Standard	Spezifikation
Schema	Objekt	Ja	undefiniert	Schema, das das Stringungsverhalten definiert.

Attr

Param	Typ	erforderlich	Standard	Spezifikation
Typ	Saite	Ja	undefiniert	Art der Eigenschaft.
Serializer	Funktion	NEIN	Identität	Funktion zur Serialisierung / Validierung von Eigenschaften.

Flucht

Param	Typ	erforderlich	Standard	Spezifikation
Regex	Regelmäßiger Ausdruck	NEIN	Standard Regex	Regex wurde verwendet, um dem Text zu entkommen

Lizenz

MIT.