slow json stringify

SJS

El tringificador más lento en el universo conocido. Es broma, es el más rápido (:

Tocarse

• Tl; Dr

• Instalación

• Cómo funciona

• Advertencias

• Puntos de referencia

• Ejecutando los puntos de referencia

• Máquina de prueba

• Algunos números

• Uso

• Tipos compatibles

• Definición de un esquema

• Definición del esquema con una matriz simple

• Definición del esquema con una matriz compleja

• Definición del esquema con objetos anidados

• Serializadores

• API

• SJS

• escapar

• Licencia

Tl; Dr

SJS muestra un aumento significativo en el rendimiento sobre JSON.stringify nativo. Stringify y fast-json-stringify . Para algunos casos de uso (que se ocupan de texto largo), realiza un 21000% más rápido que el nativo y fast-json-stringify .

Nota: El soporte de propiedades indefinidas se ha agregado desde 1.0.1 . SJS ahora está listo para la producción.

Vista de referencia de referencia.

Instalación

SJS es completamente compatible con Node.js y el navegador?

Nodo:

 NPM instalar lento-json-stringify

En el navegador:

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

Cómo funciona

¿Por qué SJS es el stringificador más rápido? El enfoque tradicional consiste en serializar cada propiedad tomada singularmente. SJS utiliza un enfoque diferente para la serialización.

Preparación:

• Se proporciona un esquema

• El esquema se triunfa

• Se construye una cadena templada con el esquema provisto.

Publicación por entregas:

• Los valores del objeto se insertan en la plantilla ya construida.

Es más rápido simplemente porque realiza mucho menos trabajo.

Advertencias

SJS requieren algún trabajo de configuración en comparación con JSON.stringify nativo. Stringify. Pero, si está tratando con JSON con una estructura fija, SJS le ahorrará un montón de tiempo. Especialmente cuando crece la carga útil. E increíblemente al serializar JSON con texto largo en el interior (piense en un artículo de blog o una descripción del producto. Además, SJS hace posible la serialización de los tipos que JSON.stringify no respalda de forma nativa.

Nota: SJS no realizará ningún escape, ya que generalmente no lo necesitará en pequeñas cargas. Si está trabajando con un gran texto, podría ser de muy poco esfuerzo almacenar en su DB un texto ya escapado.

Sin embargo, SJS proporciona un poco de utilidad para sus necesidades de escape. escape utiliza un Regex predeterminado si no se proporciona regex adicional.

cadena Regex predeterminada:

 /n | r | t | "| /gm

Puedes usar escape como lo siguiente:

 const {escudo} = require ('lento-json-stringify'); // Si no pasa ninguna regex adicional, se usará una predeterminada. '); // Esto es "divertido" // Puede pasar cualquier regex que desee para su estrategia de escape.

Puntos de referencia

Todos sabemos que hay tres tipos de mentiras.

Mentiras, malditas mentiras ... y puntos de referencia.

Recuerde probar si SJS podría ser una mejora real para su caso de uso. Porque hay momentos en que las ventajas de rendimiento con los inconvenientes adicionales no podrían valer la pena.

Ejecutando los puntos de referencia

Cada punto de referencia es replicable en su propia máquina. Para ejecutar sus pruebas:

• Clon este repositorio.

• Instalar dependencias.

• cd benchmark .

• Subvención de derechos ejecutables para run.sh Script chmod +x ./run.sh .

• Guardar resultados de referencia en el archivo ./run.sh >> benchmark.md

Máquina de prueba

Los puntos de referencia se realizaron en un Dell XPS 15 9550.

• CPU: Intel i7 6700HQ

• Ram: 16 GB

• OS: Ubuntu 18.04

Algunos números

Vuelva a verificar los puntos de referencia aquí

Uso

Tipos compatibles

La creación del esquema ocurre gracias al ayudante attr exportado desde el paquete principal.

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

 attr (tipo, serializador?)

El attr auxil admite de forma nativa los siguientes tipos:

• string

• number

• boolean

• null

• array , matriz dinámica con estructura simple, en este escenario se utilizará JSON.stringify . Como no hay ventajas de rendimiento reales.

La serialización de cualquier otro tipo es posible gracias a los serializadores personalizados.

Definición de un esquema

Para una cicatrización correcta de su carga útil JSON, un esquema correcto es obligatorio. Definir un esquema es bastante útil y no detallado.

 const {sjs} = require ('slow-json-stringify'); // schema definitionConst stringify = sjs ({
  A: attr ('cadena'),
  b: attr ('número'),
  c: attr ('boolean'),}); // entonces puede triturar cualquier cosa con esa estructura.stringify ({
  A: 'Mundo',
  B: 42,
  c: true,}); // {"a": "mundo", "b": 42, "c": true}

Definición del esquema con una matriz simple

Al trucar la matriz simple JSON.stringify se utilizará internamente.

 const {sjs} = require ('slow-json-stringify'); // schema definitionConst stringify = sjs ({
  a: attr ('array'),}); // entonces puede triturar cualquier cosa con esa estructura.stringify ({
  A: [1, 2, 3, verdadero, 'mundo'],}); // {"A": [1,2,3, verdadero, "Mundo"]}

Definición del esquema con una matriz compleja

El attr ayudante acepta un esquema sjs adicional para las propiedades array .

 const {sjs} = require ('slow-json-stringify'); // schema definitionConst stringify = sjs ({
  a: attr ('array', sjs ({b: array ('string'), c: array ('número'),
  }))}); // entonces puede triturar cualquier cosa con esa estructura.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}]}

Definición del esquema con objetos anidados

Definir esquemas con objetos anidados es bastante sencillo.

 const {sjs} = require ('slow-json-stringify'); // schema definitionConst stringify = sjs ({
  a: {b: {c: attr ('string'),},
  },
  D: {e: attr ('número'),
  },}); stringify ({
  a: {b: {c: 'hola',},
  },
  D: {E: 42,
  },}); // {"A": {"B": {"C": "Hello"}}, "D": {"E": 42}}

Serializadores

El attr ayudante acepta una función de serializador. La función de serializador se invoca con el valor real que debe ser triturado.

 Serializer (RawValue)

Los serializadores de la propiedad son útiles para realizar una serialización personalizada en cualquier tipo proporcional que no sea compatible de forma nativa incluso por JSON.stringify (fechas, expresiones regulares). Se pueden usar también para omitir la propiedad Serializarion al regresar undefined .

 const {sjs} = require ('slow-json-stringify'); // schema definitionConst stringify = sjs ({
  a: attr ('number', (valor) => {if (valor> 10) {value de retorno;} return undefined;
  })}); Stringify ({a: 20}); // {"a": 20} Stringify ({a: 5}); // {}

Caso de uso: serialización de cualquier tipo.

 // Datesconst Stringify = SJS ({
  fecha: attr ('string', (value) => value.tolocaleString ()),}); // regexpconst stringify = sjs ({
  regexp: attr ('string', (value) => value.ToString ()),});

Caso de uso: Personalice las cargas útiles según los derechos de acceso.

 const stringify = sjs ({
  publicprop: attr ('string'),
  restringedprop: attr ('string', (value) => isadmin? Value: Undefined),});

Caso de uso: formato de valor

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

API

SJS

parámetro	tipo	requerido	por defecto	especulación
esquema	objeto	Sí	indefinido	Esquema que define el comportamiento de la ctriz.

atencia

parámetro	tipo	requerido	por defecto	especulación
tipo	cadena	Sí	indefinido	Tipo de propiedad.
serializador	función	No	identidad	Función utilizada para serializar / validar propiedades.

escapar

parámetro	tipo	requerido	por defecto	especulación
regular	Expresión regular	No	REGEX predeterminado	Regex se usa para escapar del texto

Licencia

Mit.