The 7 best JavaScript date libraries
Tags: featuredposts, javascript
Published: 2019-07-24 20:58:00

---
title: The 7 best JavaScript date libraries
published: true
tags: Featured Posts, javascript
canonical_url: https://blog.logrocket.com/javascript-date-libraries/
---

![](https://thepracticaldev.s3.amazonaws.com/i/u9seo0fyfc7q0u9zp7bp.png)

Adding working dates to your application always seems like an easy task in theory, until you attempt to do it. There is always something getting in the way, whether it’s a time zone problem when trying to internationalize your website, issues showing the date in the needed format, or even trying to do some basic arithmetic with them (i.e subtracting three days from a date, it shouldn’t be that hard, should it?).

The problem is that, sadly, JavaScript is not really prepared to natively deal with dates. Which is a bit ironic considering it does have a Date object we can use for some basic operations.

What do I mean then, when I say JavaScript is not ready? I mean that the API for this object is not rich enough for our daily needs, it doesn’t have the high-level support you’d expect from such an object to take on problems such as internationalization, timezone support and so on.

Here is where the libraries I’m going to be reviewing come into play. These seven date libraries add layers of abstraction on top of JavaScript’s Date object and make it actually useful.

[![LogRocket Free Trial Banner](https://i0.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/f760c-1gpjapknnuyhu8esa3z0jga.png?resize=1200%2C280&ssl=1)](https://logrocket.com/signup/)

## [moment.js](https://momentjs.com/)

Reviewed version: 2.24.0

Moment.js is one of the oldest and best known date-related libraries for both, Node.js and vanilla JavaScript (making it browser compatible). And because of this, they’ve had the time to make it compatible with many of the most common web-development utilities, such as:

- [Bower](https://bower.io/)
- [requireJS](https://requirejs.org/)
- [Nuget](https://www.nuget.org/)
- [Browsify](http://browserify.org/)
- [TypeScript](https://www.typescriptlang.org/)
- [meteor](https:/www.meteor.com/)
- and others

It offers a great API without having to modify the Date object’s original prototype, instead, they created a wrapper object around it, making sure they don’t pollute the original namespace.

As a quick example, here is how you’d set up the current date. Add seven days, then subtract a month, and finally set the year and time values. All in a single line of easy-to-read code, like this:

```jsx
moment().add(7, 'days').subtract(1, 'months').year(2009).hours(0).minutes(0).seconds(0);
```

They **[support over 20 different locales](https://momentjs.com/docs/#/i18n/)**, so if you’re aiming at solving your internationalization problems, moment.js is a good bet.

### Plugin ecosystem

A good measure of the success and overall utility of a particular library is by checking out the plugin/extension ecosystem that exists around it. In the case of moment.js, there are 22 officially supported ones. That might not be a big number at first glance, but if you consider that all these libraries were designed around a single object, the Date object, then having over 20 plugins is definitely a great sign.

You can find their entire list of plugins on their [documentation page](https://momentjs.com/docs/#/utilities/), but some of the most interesting out there are:

### The twitter time

This one allows you to format your dates and times just like Twitter does (notice how they abbreviate their time ago-like dates with a single letter when it’s clear enough, such as 1h for “1 hour ago” or 2d for “2 days ago”).

![twitter time](https://i0.wp.com/blog.logrocket.com/wp-content/uploads/2019/07/twittertime.png?resize=396%2C230&ssl=1)

With this plugin you can simply do something like:

```jsx
moment().subtract(6, 'days').twitterShort();
```

To return “6d”.

### Parse format

How many times did you write the date format when trying to display your dates in one specific way? Something like YYYY-MM-dd or similar variations. But always manually, we write it, and then the library formats the date accordingly.

This plugin, instead of formatting the date, parses a date string and returns the actual format for you to re-use.

So you can do something like:

```jsx
var format = moment.parseFormat('Thursday, February 6th, 2014 9:20pm');
// format will contain: dddd, MMMM Do, YYYY h:mma
```

This particular plugin is great for adding dynamic behavior to your formatting logic, for example, making the formatting dynamic and allowing your users to enter a date example, instead of having them learn how to configure their own format.

### Timer

This one is actually a full re-write of JavaScript’s [setTimeInterval](https://www.w3schools.com/jsref/met_win_setinterval.asp) and [setTimeout](https://www.w3schools.com/jsref/met_win_settimeout.asp) functions, allowing you to mix moment’s syntax and create a much more powerful timer.

You can do something like this:

```jsx
var timer = moment.duration(5, "seconds").timer({loop: true}, function() {
  // Callback
});
```

Which is already a lot easier to read and understand than:

```jsx
setInterval(function() {
  //Callback
}, 5000)
```

Again, there are over 20 plugins, I invite you to check out their [documentation page](https://momentjs.com/docs/#/plugins/) and review the list for yourself.

## [date-fns](https://date-fns.org/)

Reviewed version: 2

Advertised as the [lodash](https://lodash.com/) of date libraries, [date-fns](https://date-fns.org/) tries to provide a better experience than the one [Moment.js](https://momentjs.com/) is able to give.

It’s [API](https://date-fns.org/docs/Getting-Started) is quite extensive with over 140 different time-related functions, their creators and contributors hope to make you switch from using Moment and get hooked into their own solution to time management.

Some of the key aspects of this library are:

- **All functions are grouped by file** , allowing you to import just what you need without having to bloat your project for just 2 methods that you’re really using. This is especially useful for front-end developers who need to optimize their bytes-per-JS-line , since every bit counts. In the case of Node.js developers, this is still useful to keep imports and requires more organized (I’ll show you some examples in a bit).
- Unlike other libraries (looking at you Moment.js), t **he date objects returned by date-fns are immutable** , helping you stay away from unwanted modifications and countless hours of debugging.
- **The FP sub-module provides a nice set of FP-related functions,**  helping you easily compose complex behavior with just a few lines of code.
- They support a total of **57 different locales** , so if you’re aiming for internationalization, here is another great option!
- **They have TypeScript and Flow support.**
- Last but not least, their **[documentation is very detailed](https://date-fns.org/docs/Getting-Started)** which is something I always appreciate from a library, especially with the ones that have such an extensive API.

### Some code samples

Let’s quickly run through some code samples to give you an idea of what makes this library unique.

```jsx
const { addYears, formatWithOptions  } = require('date-fns/fp')
const { es } = require('date-fns/locale')

const addFiveYears = addYears(5)

const dateToString = formatWithOptions({ locale: es }, 'd MMMM yyyy')

const dates = [
  new Date(2017, 0, 1),
  new Date(2017, 1, 11),
  new Date(2017, 6, 2)
]

const toUpper = arg => String(arg).toUpperCase()

const formattedDates = dates.map(addFiveYears).map(dateToString).map(toUpper)
//=> ['1 ENERO 2022', '11 FEBRERO 2022', '2 JULIO 2022']
```

This example shows two of the points I made above: the functions-per-file mechanics, allowing you to only require the bits you actually need (both imports take advantage of that in the example) and the functional programming helper functions. Notice how with those two imported functions (`addYears` and `formatWithOptions`) we’re composing the entire process in the final line (those two and the `toUpper` anonymous function as well).

_A quick note about the code: Even though it’s the same example as the one shown on the library’s homepage, I had to adapt it to be compatible with Node.js._

## [Luxon](https://moment.github.io/luxon)

Reviewed version: 1.16.1

Luxon is a very interesting project because if you look at it’s URL, it lives under the Moment.js project, so why is it there? You can read the [whole story from the author himself](https://github.com/moment/luxon/blob/master/docs/why.md), but the main gist of it is that it attempts to be a better version of Moment, however:

1. It doesn’t really [support all features Moment.js](https://moment.github.io/luxon/docs/index.html) supports at the moment.
2. It relies heavily on the [Intl API](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) from modern browsers, so older ones will have a hard time dealing with internationalization-related methods.

One of the main differences in Luxon when compared to it’s predecessor (if we can call Moment.js that), is that this time around, all objects are immutable (notice a pattern here? One could argue Moment.js made a poor decision making their objects mutable and everyone in the community went out of their way to fix that problem).

```jsx
var m1 = moment();
var m2 = m1.add(1, 'hours');
m1.valueOf() === m2.valueOf(); //=> true

var d1 = DateTime.local();
var d2 = d1.plus({ hours: 1 });
d1.valueOf() === d2.valueOf(); //=> false
```

In the above example you can see this difference in action, while with Moment.js (first example), you’d run into that kind of “problem” (the quotes are there because the problem only happens if you’re not paying attention) since the `add` method would mutate `m1` instead of returning the new value on `m2`, the API from Luxon would prevent you from having that problem since `plus` returns a new object on `d2` instead of modifying `d1`.

The other big difference with Moment.js is the fact that internationalization is based on the Intl API from browsers. Essentially, what this means is:

1. You don’t need extra configuration files to deal with locales, the browser does that for you.
2. If you want to make this work on Node, you’ll need either a [polyfill module](https://www.npmjs.com/package/full-icu) or build node with full [ICU support](https://github.com/nodejs/node). If you don’t do either one of them, the library will still work, but localization functions will do nothing.

There are other changes that might be of interest to you if you’re a Moment.js user, so make sure to [check them out on their documentation](https://moment.github.io/luxon/docs/manual/moment.html).

## [DayJS](https://github.com/iamkun/dayjs)

Reviewed version: 1.8.14

DayJS attempts to be a minified version of Moment.js (are we seeing the patterns here, people?). There is something to be said for a library that claims to have the [same API](https://github.com/iamkun/dayjs/blob/dev/docs/en/API-reference.md) of Moment.js and reduce its file size by 97%. That’s right, where Moment.js full minified file weights a total of 67,9Kb, DayJS minified file is only 2Kb. That’s crazy and yet they have support for internationalization, plugins and everything else.

You can think of DayJS as [lodash](https://lodash.com/) when everyone was using [underscore](https://underscorejs.org/) (remember?).  Suddenly lodash came into the picture boosting a similar claim, they had a very similar API with a reduced footprint, winning the hearts of many front-end developers who, as I mentioned above, are always trying to save as many bytes as possible to reduce loading times.

And just like Moment.js, this library has around 20 plugins officially supported which you can check out on [their documentation](https://github.com/iamkun/dayjs/blob/dev/docs/en/Plugin.md).

Finally, while this library appears to be everything it claims to be and developers are starting to adopt it as seen in the following download trends chart:

![day js downloads](https://i2.wp.com/blog.logrocket.com/wp-content/uploads/2019/07/dayjsdownloads.png?resize=1178%2C559&ssl=1)

MomentJS is still rocking the monthly downloads, since it’s been around for 8+ years (compared to the 1+ year of DayJS). It’ll take some time, but if MomentJS doesn’t adapt (maybe Luxon could be an option?) it’ll eventually be replaced by this new kid on the block.

There is no point in showing code samples since the API is practically the same as MomentJS, just check their [official documentation](https://github.com/iamkun/dayjs/blob/dev/docs/en/API-reference.md) if you need anything in particular and switch to DayJS if you’re worried about loading times and data usage (a big problem for mobile web developers).

## [ms](https://github.com/zeit/ms)

Reviewed version: 2.1.2

To change things up a bit, this next library was not created as a replacement for MomentJS (I know, shocking!) but instead, it only has one job, and it does so very well.

The objective of MS is to convert any kind of date format into milliseconds and back.

This is a very narrow use case, I know, but as you very well know, turning dates into milliseconds has its advantages, especially if you’re trying to do things like comparison, and some forms of arithmetic operations (it’s a lot easier to add 1000 milliseconds to a number, than saying you need to add 1 second to a Date object).

So in other words, with this library you can do things like this:

```jsx
ms('2 days')  // 172800000
ms('1d')      // 86400000
ms('10h')     // 36000000
ms('2.5 hrs') // 9000000
ms('2h')      // 7200000
ms('1m')      // 60000
ms('5s')      // 5000

ms(60000)             // "1m"
ms(2 * 60000)         // "2m"
ms(-3 * 60000)        // "-3m"
```

Now, I know what you’re thinking, why? Who’s using it? Well, given the fact that this library has over 30 million downloads **every week** , I’d say it covers a very specific and yet, common use case. So consider [checking it out](https://github.com/zeit/ms) if this is all you need for your time-related logic.

## [js-joda](https://js-joda.github.io/js-joda/)

Reviewed version: 1.11.0

Yet another general time management library aiming at replacing MomentJS and others from the above list. It tries to differ from others like MomentJS by avoiding the same wrapper around the Date object technique and instead, it implements the entire logic from scratch.

Is that better? The jury is still out on that one, it probably gives the maintainers more room to play around with basic concepts and twist them in ways the Date object can’t go. That being said, this library is marginally smaller than MomentJS (sitting at around 40Kb) far away from the tiny 2Kb of DayJS.

It does, however, provide immutability (shocking) and domain-specific classes, helping you, the developer, write cleaner OOP code.

A very interesting feature of js-joda is the extensibility it provides. As immutable objects don’t really have setters, this library provides the `with` method, which returns a new object with the new value set. And if instead of setting it a value, you set it a special object, you can extend the way you get values.

Let me show you:

```jsx
// implement a TemporalAdjuster that returns the next or same even day of month
var nextOrSameEvenDay = {
  adjustInto: function(t) {
    return t.dayOfMonth() % 2 === 0 ? t : t.plusDays(1);
  }
};

LocalDateTime.parse("2012-12-23T12:00").with(nextOrSameEvenDay); // '2012-12-24T12:00'
LocalDate.parse("2012-12-24").with(nextOrSameEvenDay); // '2012-12-24'
```

Basically, we’re parsing a date string (nothing fancy there), and then with the custom object (notice the special `adjustInto` method) we’re adding a very random behavior, but valid none the less.

I would personally recommend this library if you’re looking for this type of flexibility, otherwise, I’ve already covered better ones above.

## [Spacetime](http://spacetime.how/)

Reviewed version: 5.9.0

I couldn’t leave out a time library called Spacetime, sorry, but my nerdy side won that battle. That being said, this one has a very interesting focused: timezones.

Yes, it provides a MomentJS-like API, with immutable objects (yawn!) too, but the main focus of this library is to help you deal with timezones easily. And remember, timezones tend to be one of the main issues when dealing with any type of internationalization development, so already this looks promising.

Let me show you some code:

```jsx
const spacetime = require('spacetime')

let d = spacetime('March 1 2012', 'America/New_York')
//set the time
d = d.time('4:20pm')
console.log(d.time())

d = d.goto('America/Los_Angeles')
console.log(d.time())
//'1:20pm'
```

That was super easy, wasn’t it? A note about Spacetime though, is that it doesn’t rely on the Intl API like Luxon did, so the library itself is not really lightweight sitting at around 40Kb. That being said, timezones still follow the [IANA naming convention](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones), which is great for standardizing your code.

Another cool thing about our last library is that it can observe daylight saving times where applicable, so the following happens:

```jsx
d = d.goto('Eastern Time') // "America/New_York"
d = d.goto('PST') // automatically becomes 'PDT' in the summer
```

There are other nifty methods such as `season` which returns the current season for a particular date (either summer/winter/spring/fall is returned) as well as `hasDST` and `inDST` which return whether a timezone ever uses daylight saving times and if it has it active at the particular date/time configuration.

Finally, extending Spacetime is quite straightforward, which helps add extra features, such as:

```jsx
spacetime.extend({
  isHappyHour: function() {
    return this.hour() === 16
  }
})
d = d.time('4:15pm')
console.log(d.isHappyHour())
//true
```

## Conclusion

These were 7 of the most common JavaScript libraries that deal with date and time. Given the existing information and the usage data available online, if you’re having to deal with very complex date-time related features my recommendations would be going with either **MomentJS** because it’s a classic and time tested library, or simply try the brand new and faster model: **DayJS** , same API, better object management and all-around smaller footprint.  
If on the other hand, you have very specific needs, think about going with **ms** or **Spacetime.**

Which libraries are you using now? Did I miss yours? Leave a comment below and let us know!

_See you on the next one!_
* * *
## Plug: [LogRocket](https://logrocket.com/signup/), a DVR for web apps
 
![LogRocket Dashboard Free Trial Banner](https://i2.wp.com/blog.logrocket.com/wp-content/uploads/2017/03/1d0cd-1s_rmyo6nbrasp-xtvbaxfg.png?resize=1200%2C677&ssl=1)
 
[LogRocket](https://logrocket.com/signup/) is a frontend logging tool that lets you replay problems as if they happened in your own browser. Instead of guessing why errors happen, or asking users for screenshots and log dumps, LogRocket lets you replay the session to quickly understand what went wrong. It works perfectly with any app, regardless of framework, and has plugins to log additional context from Redux, Vuex, and @ngrx/store.
 
In addition to logging Redux actions and state, LogRocket records console logs, JavaScript errors, stacktraces, network requests/responses with headers + bodies, browser metadata, and custom logs. It also instruments the DOM to record the HTML and CSS on the page, recreating pixel-perfect videos of even the most complex single-page apps.
 
[Try it for free](https://logrocket.com/signup/).
* * *
The post [The 7 best JavaScript date libraries](https://blog.logrocket.com/javascript-date-libraries/) appeared first on [LogRocket Blog](https://blog.logrocket.com).