slow json stringify

Sjs

Le stringficateur le plus lent dans l'univers connu. Je plaisante, c'est le plus rapide (:

Toc

• Tl; dr

• Installation

• Comment ça marche

• Mises en garde

• Repères

• Courir les repères

• Machine d'essai

• Quelques nombres

• Usage

• Types pris en charge

• Définir un schéma

• Définition du schéma avec un tableau simple

• Définition du schéma avec un tableau complexe

• Définition du schéma avec des objets imbriqués

• Serialiseurs

• API

• sjs

• s'échapper

• Licence

Tl; dr

SJS montre une augmentation significative des performances par rapport aux deux JSON.stringify natifs.Strinfify et fast-json-stringify . Pour certains cas d'utilisation (traitant du texte long), il fonctionne 21000% plus rapidement que le natif et fast-json-stringify .

Remarque: la prise en charge des propriétés non définies a été ajoutée à partir de 1.0.1 . SJS est maintenant prêt à la production.

Benchmarks Checkout.

Installation

SJS est entièrement compatible avec Node.js et le navigateur ??

Nœud:

 NPM installer lent-json-stringify

Sur le navigateur:

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

Comment ça marche

Pourquoi SJS est le StringIfier le plus rapide? L'approche traditionnelle consiste à sérialiser chaque propriété prise singulièrement. SJS utilise une approche différente de la sérialisation.

Préparation:

• Un schéma est fourni

• Le schéma est chaîné

• Une chaîne modèle est construite avec le schéma fourni.

Sérialisation:

• Les valeurs d'objets sont insérées dans le modèle déjà construit.

C'est plus rapide simplement parce qu'il fait beaucoup moins de travail.

Mises en garde

SJS nécessite des travaux de configuration par rapport à JSON.stringify natif. Mais, si vous avez affaire à JSON avec une structure fixe, SJS vous fera gagner une tonne de temps. Surtout lorsque la charge utile augmente. Et incroyablement lorsque la sérialisation de JSON avec un long texte à l'intérieur (pensez à un article de blog ou à une description du produit. De plus, SJS rend possible la sérialisation de types qui ne sont pas soutenus nativement par JSON.stringify grâce à des sérialiseurs personnalisés.

Remarque: SJS ne fera pas d'échappement car vous n'en aurez généralement pas besoin en petites charges utiles. Si vous travaillez avec un gros texte, cela pourrait être très peu d'efforts pour stocker dans votre DB un texte déjà échappé.

Cependant, SJS fournit un peu d'utilité pour vos besoins d'échappement. escape utilise un regex par défaut si aucun regex supplémentaire n'est fourni.

chaîne regex par défaut:

 / n | r | t | "|  / gm

Vous pouvez utiliser escape comme ce qui suit:

 const {Escape} = required ('Slow-Json-Stringtifify'); // Si vous ne transmettez aucun regex supplémentaire, un par défaut sera utilisé.const Escaper = Escape (); Escaper ('Ceci est "drôle" '); // c'est "drôle" // Vous pouvez passer n'importe quel regex que vous voulez pour votre stratégie d'échappement.

Repères

Nous savons tous qu'il y a trois types de mensonges.

Mensonges, mensonges damnés .. et repères.

N'oubliez pas de tester si SJS pourrait être une réelle amélioration pour votre cas d'utilisation. Parce qu'il y a des moments où les avantages de performance avec les inconvénients supplémentaires n'en valaient pas la peine.

Courir les repères

Chaque référence est reproductible sur votre propre machine. Pour exécuter vos tests:

• Cloner ce repo.

• Installez les dépendances.

• cd benchmark .

• Accordez les droits exécutables pour run.sh script chmod +x ./run.sh .

• Enregistrer les résultats de benchmark pour fichier ./run.sh >> benchmark.md

Machine d'essai

Les repères ont été effectués sur un Dell XPS 15 9550.

• CPU: Intel i7 6700hq

• RAM: 16 Go

• OS: Ubuntu 18.04

Quelques nombres

Benchmarks Vérifiez ici

Usage

Types pris en charge

La création de schéma se produit grâce à l'assistante attr exportée du bundle principal.

 const {att} = require ('sjs');

 att (type, sérialiseur?)

L'assistance attr prend en charge les types suivants:

• string

• number

• boolean

• null

• array , tableau dynamique avec structure simple, dans ce scénario JSON.stringify natif.Strinify sera utilisé. Car il n'y a pas de réels avantages de performance.

La sérialisation de tout autre type est possible grâce aux sérialiseurs personnalisés.

Définir un schéma

Pour une cordification correcte de votre charge utile JSON, un schéma correct est obligatoire. Définir un schéma est assez pratique et non verbeux du tout.

 const {sjs} = require ('lent-json-stringify'); // schéma de définitionConst stringify = sjs ({{
  a: att ('string'),
  b: att ('numéro'),
  c: att ('booléen'),}); // alors vous pouvez corriger tout avec cette structure.stringify ({
  A: «monde»,
  B: 42,
  c: true,}); // {"a": "world", "b": 42, "c": true}

Définition du schéma avec un tableau simple

Lorsque Stringified Simple Array JSON.stringify sera utilisé en interne.

 const {sjs} = require ('lent-json-stringify'); // schéma de définitionConst stringify = sjs ({{
  a: attr ('array'),}); // alors vous pouvez corriger tout avec cette structure.stringify ({
  a: [1, 2, 3, true, 'world'],}); // {"a": [1,2,3, true, "world"]}

Définition du schéma avec un tableau complexe

L'assistance attr accepte un schéma sjs supplémentaire pour les propriétés array .

 const {sjs} = require ('lent-json-stringify'); // schéma de définitionConst stringify = sjs ({{
  a: attr ('array', sjs ({b: array ('string'), c: array ('numéro'),
  }))}); // alors vous pouvez corriger tout avec cette structure.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}]}

Définition du schéma avec des objets imbriqués

Définir des schémas avec des objets imbriqués est assez simple.

 const {sjs} = require ('lent-json-stringify'); // schéma de définitionConst stringify = sjs ({{
  a: {b: {c: att ('string'),},
  },
  d: {e: attr ('nombre'),
  },}); stringify ({
  a: {b: {c: 'bonjour',},
  },
  d: {e: 42,
  },}); // {"a": {"b": {"C": "Hello"}, "D": {"E": 42}}

Serialiseurs

L'assistance attr accepte une fonction de sérialiseur. La fonction sérialisante est invoquée avec la valeur réelle qui doit être chaînée.

 sérialiseur (rawvalue)

Les sérialiseurs de propriétés sont utiles pour effectuer une sérialisation personnalisée sur n'importe quel type de fourniture non apparenté nativement même par JSON.stringify (dates, expressions régulières). Ils peuvent également être utilisés pour sauter la propriété Serializarion lors du retour undefined .

 const {sjs} = require ('lent-json-stringify'); // schéma de définitionConst stringify = sjs ({{
  a: att ('nombre', (valeur) => {if (value> 10) {return Value;} return undefined;
  })}); stringify ({a: 20}); // {"a": 20} stringify ({a: 5}); // {}

Cas d'utilisation: sérialisation de tout type.

 // datesconst stringify = sjs ({
  Date: att ('String', (valeur) => value.tolocalestring ()),}); // regexpconst stringify = sjs ({
  regexp: attr ('string', (valeur) => value.toString ()),});

Cas d'utilisation: Personnalisez les charges utiles en fonction des droits d'accès.

 const stristify = sjs ({
  publicprop: att ('string'),
  restredProp: attr ('string', (valeur) => IsAdmin? Value: Undefined),});

Cas d'utilisation: formatage de valeur

 const stristify = sjs ({
  Prop: attr ('string', (valeur) => value.touppercase ()),});

API

sjs

paramot	taper	requis	défaut	spécifier
schéma	objet	Oui	indéfini	Schéma qui définit le comportement de chaîne.

att

paramot	taper	requis	défaut	spécifier
taper	chaîne	Oui	indéfini	Type de propriété.
sérialiseur	fonction	Non	identité	Fonction utilisée pour les propriétés de sérialisation / validation.

s'échapper

paramot	taper	requis	défaut	spécifier
expirat	Expression régulière	Non	Regex par défaut	Regex utilisé pour échapper au texte

Licence

Mit.