slow json stringify

SJS

O rigor mais lento do universo conhecido. Brincadeira, é o mais rápido (:

Toc

• Tl; dr

• Instalação

• Como funciona

• Advertências

• Benchmarks

• Executando os benchmarks

• Máquina de teste

• Alguns números

• Uso

• Tipos suportados

• Definindo um esquema

• Definindo esquema com matriz simples

• Definindo esquema com matriz complexa

• Definindo esquema com objetos aninhados

• Serializadores

• API

• SJS

• escapar

• Licença

Tl; dr

SJS mostra um aumento significativo no desempenho em JSON.stringify nativo.Stringify e fast-json-stringify . Para alguns casos de uso (lidando com texto longo), ele tem 21000% mais rápido do que o nativo e fast-json-stringify .

Nota: O suporte para propriedades indefinidas foi adicionado a partir de 1.0.1 . SJS agora está pronto para a produção.

Referências de checkout.

Instalação

SJS é totalmente compatível com o Node.js e o navegador ??

Nó:

 NPM Instale Slow-Json-Stringify

No navegador:

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

Como funciona

Por que SJS é o rigor mais rápido? A abordagem tradicional consiste em serializar todas as propriedades tomadas de maneira singularmente. SJS usa uma abordagem diferente para a serialização.

Preparação:

• Um esquema é fornecido

• O esquema é amarrado

• Uma corda modelada é construída com o esquema fornecido.

Serialização:

• Os valores dos objetos são inseridos no modelo já construído.

É mais rápido simplesmente porque executa muito menos trabalho.

Advertências

SJS requer algum trabalho de configuração se comparado ao nativo JSON.stringify . Mas, se você estiver lidando com o JSON com uma estrutura fixa SJS economizará muito tempo. Especialmente quando a carga útil cresce. E incrivelmente ao serializar o JSON com um texto longo dentro (pense em um artigo do blog ou em uma descrição do produto. Além disso, SJS possibilita a serialização de tipos que não são suportados nativamente pelo JSON.stringify graças aos serializadores personalizados.

NOTA: SJS não executará nenhuma fuga, pois você normalmente não precisará dela em pequenas cargas úteis. Se você estiver trabalhando com um grande texto, pode ser de muito pouco esforço para armazenar em seu banco de dados um texto já escapado.

No entanto, SJS fornece um pouco de utilidade para suas necessidades de fuga. escape usa um regex padrão se nenhum regex adicional for fornecido.

String regex padrão:

 /n | r | t | "| /gm

Você pode usar escape como o seguinte:

 const {Escape} = requer ('Slow-json-stringify'); // Se você não passar nenhum regex adicional, um padrão será usado.CONST ESCAPER = Escape (); '); // Isso é "engraçado" // você pode passar qualquer regex que desejar para sua estratégia de fuga.const personalizaper = escape (/"/gm); personalizado ('Isso é" engraçado "'); // Isso é" engraçado "

Benchmarks

Todos sabemos que existem três tipos de mentiras ..

Mentiras, malditas mentiras .. e parâmetros de referência.

Lembre -se de testar se SJS pode ser uma melhoria real para o seu caso de uso. Porque há momentos em que as vantagens de desempenho com as desvantagens adicionais não podem valer a pena.

Executando os benchmarks

Cada benchmark é replicável em sua própria máquina. Para executar seus testes:

• Clone este repo.

• Instalar dependências.

• cd benchmark .

• Concessão de direitos executáveis ​​para run.sh script chmod +x ./run.sh .

• Salvar resultados de referência para arquivar ./run.sh >> benchmark.md

Máquina de teste

Os benchmarks foram realizados em um Dell XPS 15 9550.

• CPU: Intel i7 6700HQ

• RAM: 16GB

• OS: Ubuntu 18.04

Alguns números

Confira os benchmarks aqui

Uso

Tipos suportados

A criação do esquema acontece graças ao auxiliar attr exportado do pacote principal.

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

 attr (tipo, serializador?)

O attr Helper suporta nativamente os seguintes tipos:

• string

• number

• boolean

• null

• array , matriz dinâmica com estrutura simples, nesse cenário JSON.stringify será usado. Como não há vantagens de desempenho reais.

A serialização de qualquer outro tipo é possível graças aos serializadores personalizados.

Definindo um esquema

Para uma sequência correta da sua carga útil JSON, um esquema correto é obrigatório. Definir um esquema é bastante útil e não é detalhado.

 const {sjs} = requer ('lento-json-stringify'); // schema definitconst stringify = sjs ({
  a: att ('string'),
  B: Att ('Número'),
  c: att ('boolean'),}); // então você pode rigitar qualquer coisa com essa estrutura.Stringify ({
  A: 'mundo',
  B: 42,
  C: Verdadeiro,}); // {"A": "World", "B": 42, "C": True}

Definindo esquema com matriz simples

Ao formar a fila simples, JSON.stringify será usado internamente.

 const {sjs} = requer ('lento-json-stringify'); // schema definitconst stringify = sjs ({
  A: att ('Array'),}); // então você pode rigrar qualquer coisa com essa estrutura.Stringify ({
  A: [1, 2, 3, verdadeiro, 'mundo'],}); // {"a": [1,2,3, verdadeiro, "mundo"]}

Definindo esquema com matriz complexa

O auxiliar attr aceita um esquema sjs adicional para propriedades array .

 const {sjs} = requer ('lento-json-stringify'); // schema definitconst stringify = sjs ({
  A: Att ('Array', SJS ({B: Array ('String'), C: Array ('Número'),
  }))}); // então você pode rigitar qualquer coisa com essa estrutura.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}]}

Definindo esquema com objetos aninhados

Definir esquemas com objetos aninhados é bem direto.

 const {sjs} = requer ('lento-json-stringify'); // schema definitconst stringify = sjs ({
  a: {b: {c: att ('string'),},
  },
  D: {e: att ('número'),
  },}); stringify ({
  A: {b: {c: 'hello',},
  },
  D: {e: 42,
  },}); // {"a": {"b": {"c": "hello"}}, "d": {"e": 42}}

Serializadores

O auxiliar attr aceita uma função de serializador. A função do serializador é invocada com o valor real que deve ser rigoroso.

 Serializer (RawValue)

Os serializadores de propriedades são úteis para executar a serialização personalizada em qualquer tipo de fornecimento não suportado nativamente, mesmo pelo JSON.stringify (datas, expressões regulares). Eles também podem ser usados ​​para pular a Serializarion da propriedade ao retornar undefined .

 const {sjs} = requer ('lento-json-stringify'); // schema definitconst stringify = sjs ({
  a: att ('número', (valor) => {if (valor> 10) {retorna valor;} retornar indefinido;
  })}); stringify ({a: 20}); // {"a": 20} stringify ({a: 5}); // {}

Caso de uso: serialização de qualquer tipo.

 // datesconst stringify = sjs ({
  Data: att ('string', (value) => value.tolocalestring ()),}); // regexpConst stringify = sjs ({
  regexp: att ('string', (value) => value.toString ()),});

Caso de uso: personalize cargas úteis com base nos direitos de acesso.

 const stringify = sjs ({
  PublicProp: Att ('String'),
  RESTRIITOPROP: att ('string', (valor) => isadmin? Valor: indefinido),});

Caso de uso: formatação de valor

 const stringify = sjs ({
  Prop: att ('string', (value) => value.TOUPPERCASE ()),});

API

SJS

param	tipo	obrigatório	padrão	espec
esquema	objeto	sim	indefinido	Esquema que define o comportamento da rigor.

attr

param	tipo	obrigatório	padrão	espec
tipo	corda	sim	indefinido	Tipo de propriedade.
serializador	função	não	identidade	Função usada para serializar / validar propriedades.

escapar

param	tipo	obrigatório	padrão	espec
regex	Expressão regular	não	Regex padrão	Regex usado para escapar do texto

Licença

Mit.