• Formatting dates with JavaScript

    Apr 19 2019

    There are a number of popular JavaScript date formatting libraries out there, such as Moment.js, Luxon and date-fns. Those libraries are very powerful and useful, allowing you to request various date formats using a special syntax, but they also come with many more features than most people will ever use. And that means, your users are probably downloading more JavaScript then they need to.

    In this article, I'm going to show you how to use the built in basic Date object to format dates without any third-party library. In other words, we'll be formatting dates with pure vanilla JavaScript.

    Feel free to copy and paste the solutions below to use as a starting point in your own code bases. I'll demonstrate how to generate a number of common format types, but you may need to modify the solutions below a little bit to format dates and times to be exactly the way you want.

    What about the Internationalization API?

    Before I start, I should mention that there is some formatting functionality built into JavaScript dates, using the Internationalization API.

    Using the Internationalization API, you can format dates according to a specific locale, which means formatting according to the customs of the user's location and language. If you're not picky about how dates and times will be displayed, this can work well in many cases, but it depends on each user's operating system, and which locales are installed on their devices. In other words, it can be hard to predict what the format will look like in any given browser.

    If you want to format dates in some specific way and have full control over what is being displayed, please read on.

    Date methods

    Pretty much all the information we need can be provided by a few built-in methods on the date object:

    const date = new Date; // current time & date
    date.getFullYear(); // Year
    date.getMonth(); // Month of the year 0-11 (0 = January)
    date.getDate(); // Date of the month, 1-31
    date.getDay(); // Day of the week, 0-6 (0 = Sunday)
    date.getHours(); // Hours, 0-23
    date.getMinutes(); // Minutes, 0-59
    date.getSeconds(); // Seconds, 0-59

    Now you may have noticed that all these methods return numbers. But how are you supposed to get words out of it like "Thursday" or "November"? And what if you want your month or date number to start with a zero? No problem, we can use JavaScript!


    Get the full year

    Getting the year out of the Date object is really easy, but it's a four-digit year by default:

    date.getFullYear(); // returns 2019

    What if you want only two-digits?

    There is a getYear() function in the Date object as well, and sometimes I accidently use that instead of getFullYear(). However, it's more or less useless. In 2019, it returns 119. Why?? Because there is a Y2K bug baked into JavaScript, even though JavaScript was designed in 1995! In those first five years of JavaScript, people could call getYear() for a two-digit year, and simply add 1900 to get a four-digit year. And I guess that still works, because 1900 + 119 = 2019!

    Since the getYear() function has been broken since the year 2000, I recommend getting a two-digit year using this approach instead:

    function getTwoDigitYear(date) {
        return date.getFullYear() % 100; // returns 19


    Display the month as a two-digit number

    The getMonth() function of the Date object returns a number between 0 and 11. That has got to be one of the biggest surprises when working with dates in JavaScript. It also mostly makes this method useless without writing more code. Let's see how to do that.

    function getTwoDigitMonth(date) {
        // add one to month to make it 1-12 instead of 0-11
        const month = date.getMonth() + 1;
        if (month < 10) {
            // add a 0 to the start if necessary
            return `0${month}`;
        } else {
            // for 10, 11 and 12, just return the month
            return month.toString();

    Display the month as a string

    If we want to display the month as a string of text like "February" or "Mar", then we need to use a JavaScript array with all the months. In fact, this is why the getMonth() method returns a number between 0 and 11, because arrays start counting at 0 as well!

    function getMonthName(date) {
        const months = [
        return months[date.getMonth()];

    If you want to use a short form of the month, or just a single character, or another language, you can easily adapt the code above to change the contents of the array with whatever you prefer to use.

    Days of the week

    If you're going to be displaying the day of the week, you'll probably want to be displaying some text. You can use the same approach that we used for formatting months above. Basically, you just need to define an array of text and access it using the getDay() result as an index.

    function getWeekDayName(date) {
        // make sure you start with Sunday
        const weekDays = [
        return weekDays[date.getDay()];

    Again, if you want to return different text, like 'Sun' or 'S', just replace the entries in the array with whatever you prefer.

    Day of the month

    The day of the month is pretty straightforward. You can just call getDate() to get the number, and you don't have to add one to it or anything.

    Display the day of the month as a two-digit number

    For some date formats, you may want to get a two-digit version of the date number. That's simple enough:

    function getTwoDigitDayOfTheMonth(date) {
        const dayOfTheMonth = date.getDate();
        if (dayOfTheMonth < 10) {
            // add a 0 to the start if necessary
            return `0${dayOfTheMonth}`;
        } else {
            // for 10 or greater, just return the dayOfTheMonth
            return dayOfTheMonth.toString();

    Display an ordinal with the day of the month

    If you want a fancy day of the month with an ordinal after it, like 1st, 2nd, 3rd, 4th, 21st, etc., you can easily figure that out with a switch statement:

    function getDayOfTheMonthWithOrdinal(date) {
        const dayOfTheMonth = date.getDate();
        const ordinal = getOrdinal(dayOfTheMonth);
        return `${dayOfTheMonth}${ordinal}`;
    function getOrdinal(number) {
        // using the % modulo operator to get the last digit of the number
        const lastDigitOfNumber = number % 10;
        switch (lastDigitOfNumber) {
            case 1:
                return 'st';
            case 2:
                return 'nd';
            case 3:
                return 'rd';
                return 'th';


    You can apply the techniques we used above with times as well, depending what you need. Let's say we want to display a time format in 12-hour time with "am" or "pm", like "9:45pm". Here's how:

    function formatTwelveHourTime(date) {
        // call functions below to get the pieces we need
        const hour = getHourInTwelveHourClock(date);
        const minute = getTwoDigitMinute(date);
        const meridiem = getMeridiem(date);
        // put it all together
        return `${hour}:${minute}${meridiem}`;
    function getHourInTwelveHourClock(date) {
        const hour = date.getHours();
        if (hour === 0 || hour === 12) {
            return 12;
        // otherwise, return a number between 1-11
        return hour % 12;
    function getTwoDigitMinute(date) {
        const minute = date.getMinutes();
        if (minute < 10) {
            // add a 0 to the start if necessary
            return `0${minute}`;
        } else {
            // for 10 or greater, just return the minute
            return minute.toString();
    function getMeridiem(date) {
        const hour = date.getHours();
        if (hour < 12) {
            return 'am';
        } else {
            return 'pm';

    Bringing it all together

    We've covered how to generate all the different pieces of various date formats. How about putting all the difference pieces together?

    You can use any method you like, but I suggest an approach like the following, using a template string.

    function shortDateFormat(date) {
        // use the built-in function here
        const year = date.getFullYear();
        // use the functions we wrote above
        const month = getTwoDigitMonth(date);
        const dayOfTheMonth = getTwoDigitDayOfTheMonth(date);
        // put it all together, eg. "YYYY-MM-DD"
        return `${year}-${month}-${dayOfTheMonth}`;

    You can create as many formatting functions as you have formats to generate. Here's another example:

    function longDateTimeFormat(date) {
        const weekDayName = getWeekDayName(date);
        const monthName = getMonthName(date); 
        const dayOfTheMonth = getDayOfTheMonthWithOrdinal(date);
        const year = date.getFullYear();
        const time = formatTwelveHourTime(date);
        // put it together, eg. "Friday, April 19th, 2019 at 9:45pm"
        return `${weekDayName}, ${monthName} ${dayOfTheMonth}, ${year} at ${time}`;


    I hope I've provided you with all the tools and techniques you might need to format dates and times. You can apply many of these techniques in other ways too, like formatting currencies. More importantly, with a little bit of custom JavaScript, you can avoid having additional dependencies for your project and downloads for your users.

  • Is this thing on?

    Mar 26 2019

    Can you believe it has been four years since I last posted here, and eight years since I really wrote blog articles here? Is anybody still reading this? If so, I'm thinking about writing articles again. If not, well, I will probably write them anyway!

    In the meantime, I've been streaming on Twitch for the past year. I stream at random once or twice a week, a few hours in the afternoon EST. There is an archive of videos if you want to watch past streams.

    Hope to see you there! (If there is anyone out there??!)

  • Free eBook: Unobtrusive Ajax

    Oct 22 2010

    Great news! O'Reilly has been kind enough to let me distribute my eBook Unobtrusive Ajax to readers of my blog, so now you can download and read it for free!

    Download "Unobtrusive Ajax" eBook

    From the book's cover:

    Unobtrusive Ajax is about making web applications that work for everyone all the time, even if you have JavaScript turned off, or you're using a mobile phone or a screen reader, or however you happen to be using the Web. It's about the separation of behavior (JavaScript), content (HTML), and presentation (CSS).

    This short cut will focus on the practical benefits of using Ajax and JavaScript unobtrusively and show you that unobtrusive web development and progressive enhancement benefit both web developers and users of the Web. You'll get to see many simple examples of building web interfaces that are unobtrusive. You'll quickly see that it is actually very easy to make web applications that everyone can use.

    When you're finished reading this book, you will be able to convince anyone why developing unobtrusively is the best way to build a site with JavaScript and Ajax.

    I wrote this book back in 2007, before I'd discovered jQuery, so writing unobtrusive JavaScript has become even easier than ever. That said, the principals of writing web pages that work without JavaScript remain the same: keep your content in the HTML, use real links and forms, and avoid depending on JavaScript or Flash for any critical functionality.

    Nowadays, I would also suggest bearing different user interfaces in mind. Not every visitor to your website has a mouse and a keyboard, some are using their handheld touchscreen phones, and if your shopping cart requires people to drag and drop, you may end up losing customers. Be careful not to make assumptions about your visitors. If you stick with basic HTML, you can't go wrong.

<< older posts