joyson v1.0.5

JOYSON - JSON

Performance Discussion

JOYSON:

• Performance: JOYSON excels in performance when dealing with TypedArrays and ArrayBuffers due to its `pack` and `unpack` methods. It uniquely supports the sharing of ArrayBuffers across objects, ensuring that when a TypedArray is shallow-copied, it remains linked across instances and is stored only once. This results in significant memory and speed optimizations for complex data structures.
• API: JOYSON has a similar API to JSON, making it easy to use with `stringify` and `parse` methods. This simplicity, combined with high performance, makes it a prodigious tool for developers needing efficient serialization and deserialization.

CBOR:

• Performance: CBOR is designed for small code size and high efficiency. However, it does not support all TypedArrays and ArrayBuffers, which limits its performance with these specific data types. It is considerably slower than JOYSON and MESSAGEPACK
• API: CBOR focuses on compact binary representation but lacks a JSON-like API, which can make it less intuitive for developers familiar with JSON.

MessagePack:

• Performance: MessagePack provides equaling efficient serialization and deserialization speed compared to Joyson. It supports TypedArrays and ArrayBuffers, but it does not support the sharing of ArrayBuffers across objects or shallow copying of TypedArrays, so that means that all TypedArray's subarray are copied the wrong way.
• API: It has a different API from JSON, which might require additional learning for developers used to JSON methods.

FlexBuffers:

• Performance: FlexBuffers offers high performance and flexibility, supporting TypedArrays and ArrayBuffers. However, similar to MessagePack, it does not support the sharing of ArrayBuffers across objects or shallow copying of TypedArrays.
• API: FlexBuffers also has a unique API, distinct from JSON, which might require additional learning.

In summary, JOYSON stands out for its unique capabilities in handling complex data structures and memory optimization, along with a user-friendly JSON-like API, making it a versatile and high-performance choice for serialization and deserialization in JavaScript.

Key Differences

• Standard JSON Methods: stringify and parse convert objects to/from JSON strings.
• Extended Binary Methods: pack and unpack handle serialization/deserialization of data into/from a compact binary format, beneficial for performance-intensive applications.

Features

• TypedArray Support: Seamless encoding and decoding of TypedArrays within JSON objects.
• Memory Efficiency: Optimized for minimal memory footprint during processing.
• Binary Serialization: The pack method allows for compact binary serialization of data, while unpack restores it, ensuring efficient data handling.

Installation

Install joyson using npm:

npm install joyson

Usage

Import JOYSON from joyson:

import JOYSON from 'joyson';

Using /dist/browser.min.js` enable you to directly use JOYSON like JSON

Encoding/Decoding an Object

const object = {test: "hello", data: [1, 23, 5, 6, {"##": undefined, "##test": /regex/i, date: new Date(), table: [-0, 111111111n, -666.777, new Set([1, 2, "blue", {}]), new Map()], arr: Int16Array.of(-6, 777, 12), arr2: new Uint8Array(9)}, "hello here is asaitama I love JS"]};
const encoded = JOYSON.stringify(object); // `{"test":"hello","data":[1,23,5,6,{"#$IyM=":"data:joyson/undefined;","#$IyN0ZXN0":"data:joyson/regexp;cmVnZXg=:aQ==","##date":"data:joyson/date;2023-12-25T00:33:37.935Z","table":["data:joyson/number;-0","data:joyson/bigint;111111111",-666.777,"data:joyson/set;WzEsMiwiYmx1ZSIse31d","data:joyson/map;W10="],"##arr":"data:joyson/int16array;base64,+v8JAwwA","##arr2":"data:joyson/uint8array;base64,AAAAAAAAAAAA"},"hello here is asaitama I love JS"]}`
const decoded = JOYSON.parse(encoded);

console.log(object, encoded, decoded);

Packing/Unpacking Data

const yourObject = {test: "hello", data: [1, 23, 5, 6, {arr: Int16Array.of(-6, 777, 12), arr2: new Uint8Array(9)}]};
const packedData = JOYSON.pack(yourObject); // Uint8Array of 151 Bytes
const unpackedData = JOYSON.unpack(packedData);

console.log(packedData, unpackedData);

Introducing JOYSON, the versatile NPM library that excels in supporting all typed arrays—a feature that is lacking in CBOR, BSON, and various other libraries. With JOYSON, you gain the advantage of support for ArrayBuffer that are shared across typed arrays. JOYSON stores typed arrays and buffers separately, ensuring proper references and seamless data handling.

Dive into the robust capabilities of JOYSON, which fully understands the critical aspects of serialization for a wide range of data structures, including RegExp, Errors, Sets, Maps, Dates, ArrayBuffer, TypedArray, Arrays, Object Literals, Objects, BigInt, standard Numbers, complex Numbers, Strings, special character strings, nullish values, and more.

While JOYSON is slightly less fast (-10%) than MessagePacker when processing mixed values, it significantly outperforms with big typed arrays, boasting a +30% increase in speed compared to messagepacker. And of course, when compared to CBOR, BSON, structured clone, and others, MessagePacker is much faster, but JOYSON is the library that combines speed with versatility and comprehensive data type support.