What steps can be taken to ensure that JSON.parse() interprets all numbers as BigInt values?

Question

What steps can be taken to ensure that JSON.parse() interprets all numbers as BigInt values?

I'm dealing with numbers in JSON that exceed the limits of the Number type, so I'd like to convert them to bigint. How can I do this?

{"foo":[[0],[64],[89],[97]],"bar":[[2323866757078990912,144636906343245838,441695983932742154,163402272522524744],[2477006750808014916,78818525534420994],[18577623609266200],[9008333127155712]]}

javascript json

Answer 1

Answer №1

TLDR;

If you want to customize the behavior of `JSON.parse()`, you can utilize the `reviver` parameter.

Detailed Solution

To modify the behavior of `JSON.parse()`, you can use the `reviver` parameter, which is the second parameter of `JSON.parse`. This parameter is a function that preprocesses key-value pairs and can even convert values to `BigInt()`.

However, numbers are still coerced by default, as pointed out by @YohanesGultom. To preserve big numbers, you can wrap them in quotes in the source JSON string to convert them to `bigint`.

If you only want to convert certain numbers to `bigint`, you need to establish specific criteria, such as checking if the value exceeds `Number.MAX_SAFE_INTEGER` with `Number.isSafeInteger()`, recommended by @PeterSeliger.

One way to handle this problem is by implementing a function like this:

// Implementing desired criteria 
// for separating big numbers from small ones

const isBigNumber = num => !Number.isSafeInteger(+num)

// Wrapping big numbers in quotes inside
// the JSON string based on the criteria

const enquoteBigNumber = (jsonString, bigNumChecker) =>
    jsonString
        .replaceAll(
            /([:\s\[,]*)(\d+)([\s,\]]*)/g,
            (matchingSubstr, prefix, bigNum, suffix) =>
                bigNumChecker(bigNum)
                    ? `${prefix}"${bigNum}"${suffix}`
                    : matchingSubstr
        )

// Parsing the source JSON string 
// and converting matching big numbers to bigint

const parseWithBigInt = (jsonString, bigNumChecker) =>
    JSON.parse(
        enquoteBigNumber(jsonString, bigNumChecker),
        (key, value) =>
            !isNaN(value) && bigNumChecker(value)
                ? BigInt(value)
                : value
    )

// Output result

const output = parseWithBigInt(input, isBigNumber)

console.log("output.foo[1][0]: \n", output.foo[1][0], `(type: ${typeof output.foo[1][0]})`)
console.log("output.bar[0][0]: \n", output.bar[0][0].toString(), `(type: ${typeof output.bar[0][0]})`)

.as-console-wrapper{min-height: 100% !important;}

Note: If you find the RegExp pattern to match digit strings in JSON values lacking, feel free to create your own.

Note: While libraries are available, it's essential to consider the additional size they may add to your project, as mentioned by @YohanesGultom. Adding unnecessary bulk to your project for a single purpose may not be ideal.

Answer 2

TLDR;

If you want to customize the behavior of `JSON.parse()`, you can utilize the `reviver` parameter.

Detailed Solution

To modify the behavior of `JSON.parse()`, you can use the `reviver` parameter, which is the second parameter of `JSON.parse`. This parameter is a function that preprocesses key-value pairs and can even convert values to `BigInt()`.

However, numbers are still coerced by default, as pointed out by @YohanesGultom. To preserve big numbers, you can wrap them in quotes in the source JSON string to convert them to `bigint`.

If you only want to convert certain numbers to `bigint`, you need to establish specific criteria, such as checking if the value exceeds `Number.MAX_SAFE_INTEGER` with `Number.isSafeInteger()`, recommended by @PeterSeliger.

One way to handle this problem is by implementing a function like this:

// Implementing desired criteria 
// for separating big numbers from small ones

const isBigNumber = num => !Number.isSafeInteger(+num)

// Wrapping big numbers in quotes inside
// the JSON string based on the criteria

const enquoteBigNumber = (jsonString, bigNumChecker) =>
    jsonString
        .replaceAll(
            /([:\s\[,]*)(\d+)([\s,\]]*)/g,
            (matchingSubstr, prefix, bigNum, suffix) =>
                bigNumChecker(bigNum)
                    ? `${prefix}"${bigNum}"${suffix}`
                    : matchingSubstr
        )

// Parsing the source JSON string 
// and converting matching big numbers to bigint

const parseWithBigInt = (jsonString, bigNumChecker) =>
    JSON.parse(
        enquoteBigNumber(jsonString, bigNumChecker),
        (key, value) =>
            !isNaN(value) && bigNumChecker(value)
                ? BigInt(value)
                : value
    )

// Output result

const output = parseWithBigInt(input, isBigNumber)

console.log("output.foo[1][0]: \n", output.foo[1][0], `(type: ${typeof output.foo[1][0]})`)
console.log("output.bar[0][0]: \n", output.bar[0][0].toString(), `(type: ${typeof output.bar[0][0]})`)

.as-console-wrapper{min-height: 100% !important;}

Note: If you find the RegExp pattern to match digit strings in JSON values lacking, feel free to create your own.

Note: While libraries are available, it's essential to consider the additional size they may add to your project, as mentioned by @YohanesGultom. Adding unnecessary bulk to your project for a single purpose may not be ideal.

Answer 3

Answer №2

If you're looking for a solution to handle large integers in JSON objects, my library might be just what you need. Check it out here: https://www.npmjs.com/package/json-with-bigint

Here's an example of how you can use it:

import { JSONParse } from 'json-with-bigint';
    
const yourJSON = `{"someValue":42,"someBigValue":10000000000000000365}`;

JSONParse(yourJSON); // { someValue: 42, someBigValue: 10000000000000000365n }

The library is smart enough to detect BigInt values automatically, so there's no need to specify which keys contain BigInt values.

Additionally, it provides consistent round-trip operations (parse - stringify - parse). This means that the values you deserialize will be identical to the ones you initially serialized, and vice versa.

import { JSONParse, JSONStringify } from 'json-with-bigint';
    
const yourJSON = `{"someValue":42,"someBigValue":10000000000000000365}`;

JSONParse(yourJSON); // { someValue: 42, someBigValue: 10000000000000000365n }
JSONStringify(data); // '{"someValue":42,"someBigValue":10000000000000000365}'
JSONParse(JSONStringify(data)); // { someValue: 42, someBigValue: 10000000000000000365n }

Answer 4

If you're looking for a solution to handle large integers in JSON objects, my library might be just what you need. Check it out here: https://www.npmjs.com/package/json-with-bigint

Here's an example of how you can use it:

import { JSONParse } from 'json-with-bigint';
    
const yourJSON = `{"someValue":42,"someBigValue":10000000000000000365}`;

JSONParse(yourJSON); // { someValue: 42, someBigValue: 10000000000000000365n }

The library is smart enough to detect BigInt values automatically, so there's no need to specify which keys contain BigInt values.

Additionally, it provides consistent round-trip operations (parse - stringify - parse). This means that the values you deserialize will be identical to the ones you initially serialized, and vice versa.

import { JSONParse, JSONStringify } from 'json-with-bigint';
    
const yourJSON = `{"someValue":42,"someBigValue":10000000000000000365}`;

JSONParse(yourJSON); // { someValue: 42, someBigValue: 10000000000000000365n }
JSONStringify(data); // '{"someValue":42,"someBigValue":10000000000000000365}'
JSONParse(JSONStringify(data)); // { someValue: 42, someBigValue: 10000000000000000365n }

What steps can be taken to ensure that JSON.parse() interprets all numbers as BigInt values?

Answer №1

TLDR;

Detailed Solution

Answer №2

Similar questions

Inverting the order of vertices in a THREE.js face

Converting a C++ string array to JSON: A step-by-step guide

Tips for updating an object variable dynamically in an Angular application

Creating a tree-view in Vue.js that includes clickable components which trigger a Vue.js modal to open up

Creating a dynamic dropdown menu based on a class value using JavaScript in PHP

Upgrading the Spring framework from version 3.0.2 to 3.2.0 can lead to issues with Spring JSON functionality

Verify if a set of Radio buttons contains at least one option selected

Developing an uncomplicated Angular promise following the invocation of a service

What are the steps for enlarging the display containing components with the 'position: absolute' style?

Guide to setting up npm openlpr in a Node.js environment

How come my form isn't functioning properly on mobile devices?

AngularJs stops the link from being clicked more than once

Exploring the json simple library in Java to decode a jsonobject

Retrieving the text content from a JSON key

Modifying a gridview cell through a Modal popup that is displayed using the rel attribute

Obtaining the designated item within the list

Struggling to accurately convert the string into a date object

Quick method to send HTTPS JSON data (including headers and body) in Node.js

Issues with React's onSelect event functionality are persisting

Exploring a React JS option for filtering repeated elements, as an alternative to Angular