I made 10x faster JSON.stringify() functions, even type safe

// FASTER STRINGIFY FUNCTIONS
export function stringify<T>(input: T): string; // unsafe but fatest
export function assertStringify<T>(input: T): string; // throws TypeGuardError
export function isStringify<T>(input: T): string | null; // wrong type be null

// RUNTIME VALIDATORS ALLOWING SUPERFLUOUS PROPERTIES
export function is<T>(input: unknown): input is T; // returns boolean
export function assertType<T>(input: unknown): T; // throws TypeGuardError
export function validate<T>(input: unknown): IValidation; // detailed reasons

// DO NOT ALLOW SUPERFLUOUS PROPERTIES
export function equals<T>(input: unknown): input is T;
export function assertType<T>(input: unknown): T;
export function validate<T>(input: unknown): IValidation;

Hello, I'm a developer of typescript-json, which can validate instance type by only one line, what I'd introduced as "1,000x faster runtime validator library" in here dev.to. In today, I came back with powerful JSON string conversion functions.

As you can see from the above code, the new JSON string conversion functions throw TypedGuardError or return null value when input value is different with target type T. One thing amazing is, those JSON string conversion functions are much faster than the native JSON.stringify() function despite of type validation process.

Of course, as this benchmark measured by myself, someone can doubt its objectivity.

Therefore, to ensure the objectivity, I diclose all code used in the benchmark. Below codes are being used in the benchmark. You also can run the benchmark program by running npm install and npm run benchmark commands after cloning typescript-json repository.

• stringify() functions
• is() functions
• assertType() functions
• validate() functions

How to use

If you want to utilize those type safe JSON functions, just install and import typescript-json. After that, call those functions like below. You don't need to define any extra dedication like fast-json-stringify which requires JSON schema definition. Only you need is only one line with pure TypeScript type.

Note that, TSON.assertStringify() function throws TypeGuardError exception and TSON.isStringify() function returns boolean value when parametric input value is different with the target type T. Of course, if input value is matched with the type T, just JSON string would be returned. Anyway, choose one of them depending on your purpose.

import TSON from "typescript-json";

interface IMember {

    name: string;

    age: number;

}

// NO PROBLEM

const exact: IMember = { name: "someone", age: 0 };

TSON.assertStringify(exact);

TSON.isStringify(exact);

// WRONG TYPE

const wrong: IMember = { name: "someone", age: false as any };

TSON.assertStringify(wrong); // throws TypeGuardError

TSON.isStringify(wrong); // returns null

How can be such faster

AOT (Ahead of Time) compilation.

typescript-json analyzes your code (type T) in the compilation level and generates optimized runtime code for JSON string conversion. Such optimized runtime code generation by analzying source code is called AOT (Ahead of Time) compilation and it is the reason why typescript-json's JSON string conversion functions are much faster than the native JSON.stringify() function despite of type validation process.

In the same reason, validation functions of typescript-json are much faster than other validation libraries. Only TypeBox can be competitive and TypeBox utilizes JIT (Just-in-time) compilation. Other libraries without special skills are extremely slow, and the gap can widen by thousands of times.

Someone may have question, "Why are you comparing with other validator libraries? Where's the other JSON string converter library?" Unfortunately, there's not any other library that can convert JSON string safely like typescript-json. Therefore, I had to compare with validator libraries. Please understand me and such circumstance.

Full Spec of TypeScript Type

typescript-json supports full spec of TypeScript type.

Therefore, use TSON.assertStringify() and TSON.isStringify() functions enhance your program's type safety with confidence. I hope those functions to be really useful for network systems using JSON data, especially for enhancing type safety.

• TSON: typescript-json
• C.V.: class-validator