Sunday, March 3, 2024

Parse JSON Strings as JavaScript Date Objects

Must read


Nowadays, builders are inclined to retailer and transmit huge quantities of information utilizing JSON, which may additionally embrace dates. With a view to correctly use them, these strings then have to be parsed as JS Date objects. However how will we go about doing that? That is precisely what we’ll be exploring on this Byte.

JSON and Dates in JavaScript

JSON is a light-weight data-interchange format that’s simple for people to learn and write and straightforward for machines to parse and generate. It is a frequent knowledge format with various makes use of in knowledge storing and transmitting.

Then again, the Date object is a datatype constructed into the JavaScript language. Date objects are created with the new Date( ) constructor. Regardless of JavaScript’s many strengths, it has all the time had a little bit of problem with dates and instances (therefore the various datetime libraries, like second and dayjs).

So, what occurs when that you must deal with dates from a JSON string in JavaScript? Nicely, the JSON format solely helps a small variety of primary knowledge varieties: objects, arrays, numbers, strings, booleans, and null. JSON doesn’t have a built-in Date kind. As a substitute, dates in JSON are sometimes represented as strings.

If you have not finished this earlier than, it may appear sophisticated at first, however parsing JSON dates in JavaScript is simple as soon as you understand how to do it.

Find out how to Parse JSON Dates in JavaScript

There are a number of methods to parse JSON dates in JavaScript. We will discover two strategies: utilizing the Date() constructor and the Date.parse() technique. On this Byte, we’ll concentrate on utilizing the Date() constructor.

Utilizing the Date() Constructor

The Date() constructor in JavaScript creates a brand new date object with a specified date and time. If you cross a string to the Date() constructor, it tries to parse that string right into a date.

This is a easy instance:

let jsonString = '{"dateOfBirth": "2023-09-26T00:00:00.000Z"}';
let obj = JSON.parse(jsonString);
let date = new Date(obj.dateOfBirth);

// Output: 2023-09-26T00:00:00.000Z

Right here we first parse the JSON string right into a JavaScript object utilizing the JSON.parse() technique. Then, we use the Date() constructor to parse the dateOfBirth property right into a JavaScript Date object.

Notice: The Date() constructor accepts date strings in a number of codecs, together with ISO 8601, which is the format utilized in our instance. ISO 8601 dates are within the format “YYYY-MM-DDTHH:mm:ss.sssZ”, the place “Z” represents Coordinated Common Time (UTC).

Utilizing the Date.parse() Methodology

The Date.parse() technique in JavaScript is one other option to parse JSON dates. It really works by changing a date string into the variety of milliseconds since January 1, 1970, 00:00:00 UTC. This could then be used to create a brand new date object. On this instance we’ll additionally present methods to use the JSON.parse technique to instantly convert the date string to an object utilizing the reviver callback.

let jsonDate = '{"date":"2023-09-26T12:00:00Z"}';
let parsedDate = JSON.parse(jsonDate, operate(key, worth) {
    if (key == 'date') return new Date(Date.parse(worth));
    return worth;
console.log(;  // Outputs: 2023-09-26T12:00:00.000Z

On this code snippet, we use Date.parse() throughout the JSON.parse() technique. The Date.parse() technique returns the variety of milliseconds because the Unix Epoch, which we then cross to the Date constructor to create a brand new date object.

The Date.parse technique is useful whenever you wish to convert the date to a Unix timestamp as an middleman, which will be higher for storage and generally for date manipulations as effectively, relying in your use-case.

Dealing with Errors Throughout Parsing

Whereas parsing JSON dates, it is common to come across errors resulting from incorrect date codecs. To deal with this, we might often use JavaScript’s built-in strive...catch assertion, however the Date object does not throw errors in these instances, however as an alternative it returns Invalid Date, which we’ll have to test for:

let jsonDate = '{"date":"2023-13-01T12:00:00Z"}'; // Invalid month

let parsedDate = JSON.parse(jsonDate, operate(key, worth) {
    if (key == 'date') return new Date(worth);
    return worth;

let d =;
if (d instanceof Date && !isNaN(d)) {
} else {
    console.log('Invalid date!');

Right here we use the next code to test if our date is legitimate or not:

d instanceof Date && !isNaN(d)

An Invalid Date will return true for d instanceof Date, however since !isNaN(d) will return false, the general assertion turns into false, and thus it isn’t a legitimate date.

Different Methods to Parse JSON Dates

Whereas the Date() constructor and Date.parse() technique are probably the most simple methods to parse JSON dates in JavaScript, there are various options obtainable. One such resolution is utilizing a 3rd social gathering library like Second.js.

let second = require('second');
let jsonDate = '{"date":"2023-09-26T12:00:00Z"}';

let parsedDate = JSON.parse(jsonDate, operate(key, worth) {
    if (key == 'date') return second(worth).toDate();
    return worth;

console.log(;  // Outputs: 2023-09-26T12:00:00.000Z

We use the second() operate from the Second.js library to parse the date string. This strategy will be significantly helpful when coping with advanced date and time codecs, particularly customized codecs that do not adhere to any commonplace.

Notice: Whereas Second.js is a strong library, it could be overkill if you happen to solely have to parse easy date strings. All the time take into account your particular wants earlier than including exterior dependencies to your challenge. For instance, the library dayjs is far more light-weight and has an identical syntax as Second, though it will possibly take a bit extra setup to get sure options working.


On this Byte, we have appeared into totally different strategies of parsing JSON dates in JavaScript, together with the Date() constructor, Date.parse() technique, and even an exterior library like Second.js. We have additionally mentioned methods to deal with errors which may happen throughout parsing. As all the time, the most effective strategy is determined by your particular wants and the complexity of the date strings you are coping with.

Supply hyperlink

More articles


Please enter your comment!
Please enter your name here

Latest article