How do I format a date in JavaScript?

You can format a Date object to a string in JavaScript by following these steps:

1. Use the toLocaleDateString() method to format the date according to the user's locale.
2. Pass in options to customize the date format. For example:

   const date = new Date();
   const options = { year: 'numeric', month: 'long', day: 'numeric' };
   const formattedDate = date.toLocaleDateString('en-US', options);
   console.log(formattedDate); // Output: "March 1, 2022"
   

3. You can also use libraries like Moment.js or date-fns for more advanced date formatting options if needed.

1. Use the built-in toLocaleDateString() method:

   • This method returns a string with a language sensitive representation of the Date object's value.

   let date = new Date();
   let formattedDate = date.toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
   console.log(formattedDate); // Output: "June 1, 2023" (example)
   

2. Use a third-party library like date-fns or moment.js:

   • These libraries provide more customization options for date formatting.

   // Using date-fns
   import { format } from 'date-fns';
   let formattedDate = format(new Date(), "MMMM d, yyyy");
   console.log(formattedDate); // Output: "June 1, 2023" (example)
   
   // Using moment.js
   import moment from 'moment';
   let formattedDate = moment(new Date()).format('MMMM Do YYYY');
   console.log(formattedDate); // Output: "June 1st 2023" (example)
   

Note: Always check the documentation of these libraries for more formatting options and compatibility with different locales.

To format a Date object in JavaScript, you can use the built-in Date methods to retrieve the date components and then concatenate them into a string in the desired format. Here's a step-by-step guide to format a date:

function formatDate(date) {
  // Create a new date object if one is not provided
  const now = date ? new Date(date) : new Date();

  // Retrieve the date components
  const year = now.getFullYear();
  const month = String(now.getMonth() + 1).padStart(2, '0'); // Months are 0-indexed
  const day = String(now.getDate()).padStart(2, '0');

  // You can also retrieve time components if needed
  const hours = String(now.getHours()).padStart(2, '0');
  const minutes = String(now.getMinutes()).padStart(2, '0');
  const seconds = String(now.getSeconds()).padStart(2, '0');

  // Format the date string however you want
  // For example, YYYY-MM-DD
  const formattedDate = `${year}-${month}-${day}`;

  // If you need time as well, you can append it
  // For example, YYYY-MM-DD HH:MM:SS
  const formattedDateTime = `${formattedDate} ${hours}:${minutes}:${seconds}`;

  return formattedDate; // or return formattedDateTime if you need time
}

// Usage
const formatted = formatDate(); // Current date
console.log(formatted); // Outputs something like "2023-04-05"

const specificDate = new Date('2023-04-05T08:00:00');
const formattedSpecific = formatDate(specificDate);
console.log(formattedSpecific); // Outputs "2023-04-05"

Alternatively, you can use a library like date-fns or moment.js for more complex formatting and to handle edge cases more gracefully:

Using date-fns:

import { format } from 'date-fns';

const formatted = format(new Date(), 'yyyy-MM-dd');
console.log(formatted); // Outputs something like "2023-04-05"

Using moment.js:

const moment = require('moment');

const formatted = moment().format('YYYY-MM-DD');
console.log(formatted); // Outputs something like "2023-04-05"

Remember to install the library using npm or include it in your project if you choose to use date-fns or moment.js.

To format a Date object to a string in JavaScript, you can use the built-in toLocaleString(), toLocaleDateString(), or toLocaleTimeString() methods, or you can create a custom date format using string manipulation.

Here are a few examples:

1. Using toLocaleString():

   const myDate = new Date();
   const formattedDate = myDate.toLocaleString();
   console.log(formattedDate); // Output: "5/23/2023, 10:30:00 AM"
   

2. Using toLocaleDateString():

   const myDate = new Date();
   const formattedDate = myDate.toLocaleDateString();
   console.log(formattedDate); // Output: "5/23/2023"
   

3. Using toLocaleTimeString():

   const myDate = new Date();
   const formattedTime = myDate.toLocaleTimeString();
   console.log(formattedTime); // Output: "10:30:00 AM"
   

4. Creating a custom date format:

   function formatDate(date, format) {
     const map = {
       mm: date.getMonth() + 1,
       dd: date.getDate(),
       yyyy: date.getFullYear(),
       hh: date.getHours(),
       MM: date.getMinutes(),
       ss: date.getSeconds(),
     };
   
     return format.replace(/mm|dd|yyyy|hh|MM|ss/gi, (matched) => map[matched]);
   }
   
   const myDate = new Date();
   const formattedDate = formatDate(myDate, 'mm/dd/yyyy hh:MM:ss');
   console.log(formattedDate); // Output: "05/23/2023 10:30:00"
   

In the custom formatDate() function, you can use the replace() method to replace the placeholders (mm, dd, yyyy, hh, MM, ss) with the corresponding values from the Date object.

The toLocaleString(), toLocaleDateString(), and toLocaleTimeString() methods are convenient for basic date formatting, but they may not provide the exact format you need. In those cases, you can create a custom date formatting function like the one shown in the last example.

Remember that date formatting can be localized and may vary depending on the user's locale settings. The built-in methods like toLocaleString() will automatically format the date according to the user's locale, while the custom formatting function allows you to specify the exact format you need.

To format a JavaScript Date object as a string, you have a few different options. Here are some common approaches:

1. Using the built-in Date methods:

   • toDateString(): Returns the date portion of the Date object as a human-readable string.
   • toLocaleDateString(): Returns the date portion as a string, using locale conventions.
   • toISOString(): Returns the date as an ISO 8601 extended format string.

   Example:

   const date = new Date();
   console.log(date.toDateString());       // e.g., "Thu Jun 08 2023"
   console.log(date.toLocaleDateString()); // e.g., "6/8/2023" (locale-specific)
   console.log(date.toISOString());        // e.g., "2023-06-08T12:34:56.789Z"
   

2. Using the Date.prototype.toString() method:

   • This method returns a string representation of the Date object.

   Example:

   const date = new Date();
   console.log(date.toString()); // e.g., "Thu Jun 08 2023 14:34:56 GMT+0200 (Central European Summer Time)"
   

3. Custom formatting using Date methods:

   • You can extract individual components of the Date object using methods like getFullYear(), getMonth(), getDate(), etc., and then combine them into a custom-formatted string.

   Example:

   const date = new Date();
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, '0');
   const day = String(date.getDate()).padStart(2, '0');
   const formattedDate = `${year}-${month}-${day}`;
   console.log(formattedDate); // e.g., "2023-06-08"
   

4. Using a library like Moment.js or date-fns:

   • These libraries provide extensive date formatting capabilities and offer more flexibility and ease of use compared to the native JavaScript Date object.

   Example using Moment.js:

   const moment = require('moment');
   const date = moment();
   console.log(date.format('YYYY-MM-DD')); // e.g., "2023-06-08"
   console.log(date.format('MMM Do, YYYY')); // e.g., "Jun 8th, 2023"
   

   Example using date-fns:

   const format = require('date-fns/format');
   const date = new Date();
   console.log(format(date, 'yyyy-MM-dd')); // e.g., "2023-06-08"
   console.log(format(date, 'MMM do, yyyy')); // e.g., "Jun 8th, 2023"
   

Choose the approach that best fits your needs based on the desired format, locale considerations, and whether you want to use a third-party library or stick with native JavaScript functionality.

To format a Date object in JavaScript, you can use the built-in Date object methods or use a third-party library like Moment.js. Here are some examples of how to format a date using the built-in methods:

1. Using Date.prototype.toLocaleString():

This method returns a string with a language-sensitive representation of the date and time. The format of the output is determined by the locale settings of the computer.

const date = new Date();
const formattedDate = date.toLocaleString();
console.log(formattedDate); // Output: 4/13/2023, 2:34:56 PM (for my local settings)

2. Using Date.prototype.toLocaleDateString():

This method returns a string with a language-sensitive representation of the date portion only.

const date = new Date();
const formattedDate = date.toLocaleDateString();
console.log(formattedDate); // Output: 4/13/2023 (for my local settings)

3. Using Date.prototype.toLocaleTimeString():

This method returns a string with a language-sensitive representation of the time portion only.

const date = new Date();
const formattedTime = date.toLocaleTimeString();
console.log(formattedTime); // Output: 2:36:12 PM (for my local settings)

4. Using Date.prototype.toISOString():

This method returns a string representing the date and time in the ISO format (YYYY-MM-DDTHH:mm:ss.sssZ).

const date = new Date();
const isoString = date.toISOString();
console.log(isoString); // Output: 2023-04-13T14:37:28.123Z

If you need more control over the date format or want to use a specific locale, you can use a third-party library like Moment.js, which provides a more robust and flexible way to format dates. Here's an example using Moment.js:

const moment = require('moment'); // Import Moment.js library

const date = new Date();
const formattedDate = moment(date).format('MMMM D, YYYY');
console.log(formattedDate); // Output: April 13, 2023

Moment.js provides a wide range of formatting options, allowing you to customize the date format according to your needs. You can find more information about date formatting in Moment.js in their documentation: https://momentjs.com/docs/#/displaying/

You can use the following methods to format a Date object:

1. toString(): Converts the date into a string in the format: "Wed Dec 25 2024 16:38:19 GMT+0800 (Singapore Standard Time)".

2. toLocaleString(): This is useful when you want to format the date according to the user's locale. It might return a string like: "Dec 25, 2024, 4:38:19 PM".

3. toISOString(): This will give you a ISO format: "2024-12-25T16:38:19.791Z".

4. toJSON(): Similar to toISOString(), but it adds double quotes and the timezone will be in the ±hh:mm format, like: "2024-12-25T16:38:19.791+08:00".

5. toUTCString(): It produces a string in the following format: "Tue, 25 Dec 2024 08:38:19 GMT".

6. toGMTString(): Similar to toUTCString(), but with a different textual description: "Tue, 25 Dec 2023 16:38:19 GMT".

7. getMonth() and other getters: You can call methods like getMonth(), getDay(), getFullYear(), etc., to get the individual parts of the date and then use string concatenation to create your custom format.

Here's an example:

const date = new Date("2024-12-25T16:38:19.791Z");
const formatted = date.toLocaleDateString() + ' ' + date.toLocaleTimeString(); 
// Output: "Tue Dec 25, 2024  4:38:19 PM"

You can also use template literals with tagged templates and the format() function from the intl package to achieve this.

To format a Date object to a string, you can use the toLocaleDateString() or toLocaleTimeString() methods.

The toLocaleDateString() method formats the date according to the locale of the browser. For example, in the United States, the date would be formatted as "MM/DD/YYYY". In France, the date would be formatted as "DD/MM/YYYY".

The toLocaleTimeString() method formats the time according to the locale of the browser. For example, in the United States, the time would be formatted as "hh:mm:ss AM/PM". In France, the time would be formatted as "hh:mm:ss".

You can also specify a format string to the toLocaleDateString() and toLocaleTimeString() methods. This allows you to control the exact format of the date or time string.

For example, the following code formats the date as "YYYY-MM-DD":

const date = new Date();
const formattedDate = date.toLocaleDateString("en-US", { year: "numeric", month: "2-digit", day: "2-digit" });
console.log(formattedDate); // Output: "2023-03-08"

The following code formats the time as "hh:mm:ss AM/PM":

const date = new Date();
const formattedTime = date.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: true });
console.log(formattedTime); // Output: "03:08:32 PM"

You can find more information about the toLocaleDateString() and toLocaleTimeString() methods in the MDN documentation:

• toLocaleDateString()
• toLocaleTimeString()

Sure, here's how you format a Date object to a string in JavaScript:

const date = new Date();
const formattedDate = date.toLocaleString();
console.log(formattedDate); // Output: October 26, 2023 at 1:23:45 PM

The toLocaleString() method formats the date object according to the current locale settings. You can also specify a specific format like this:

const date = new Date();
const formattedDate = date.toLocaleString('en-US', {
  month: 'short',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  second: 'numeric',
});
console.log(formattedDate); // Output: Oct 26, 2023 01:23:45

Here are some of the available formatting options:

• Month: short, long
• Day: numeric, 2-digit, numeric-leading-zero
• Hour: numeric, numeric-leading-zero, short, short-offset, long
• Minute: numeric, numeric-leading-zero
• Second: numeric, numeric-leading-zero
• Time Zone: short, long

For more information on formatting dates in JavaScript, you can refer to the documentation:

• MDN Web Docs: Date.prototype.toLocaleString() - mdn.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
• Stack Overflow: Date formatting in JavaScript - stackoverflow.com/questions/2858169/how-to-format-a-date-in-javascript

I hope this helps! Please let me know if you have any further questions.

In JavaScript, you can use the toLocaleString() method or Intl.DateTimeFormat() function to format a Date object as a string with a specific date and time format. Here's how you can do it using both methods:

Method 1 - Using toLocaleString()

let currentDate = new Date();
let formattedDate = currentDate.toLocaleString("en-US", { month: "long", day: "numeric", year: "numeric", hour: "2-digit", minute: "2-digit" });
console.log(formattedDate);
// Output: "10/3/2022, 6:54:47 PM" (depends on the current date and your system's locale settings)

Method 2 - Using Intl.DateTimeFormat()

let currentDate = new Date();
let options = { month: 'long', day: 'numeric', year: 'numeric', hour: '2-digit', minute: '2-digit' };
let formattedDate = Intl.DateTimeFormat('en-US', options).format(currentDate);
console.log(formattedDate);
// Output: "October 3, 2022, 6:54:47 PM" (depends on the current date and your desired format)

Both methods provide flexibility in formatting dates by allowing you to specify which parts of the date you want to include and how they should be represented. Adjust the options object in Intl.DateTimeFormat() according to your requirements.

If you need slightly less control over formatting than the currently accepted answer, Date#toLocaleDateString can be used to create standard locale-specific renderings. The locale and options arguments let applications specify the language whose formatting conventions should be used, and allow some customization of the rendering.

Options key examples:

1. day: The representation of the day. Possible values are "numeric", "2-digit".
2. weekday: The representation of the weekday. Possible values are "narrow", "short", "long".
3. year: The representation of the year. Possible values are "numeric", "2-digit".
4. month: The representation of the month. Possible values are "numeric", "2-digit", "narrow", "short", "long".
5. hour: The representation of the hour. Possible values are "numeric", "2-digit".
6. minute: The representation of the minute. Possible values are "numeric", "2-digit".
7. second: The representation of the second. Possible values are "numeric", 2-digit".

All these keys are optional. You can change the number of options values based on your requirements, and this will also reflect the presence of each date time term. Note: If you would only like to configure the content options, but still use the current locale, passing null for the first parameter will cause an error. Use undefined instead.

For different languages:

1. "en-US": For American English
2. "en-GB": For British English
3. "hi-IN": For Hindi
4. "ja-JP": For Japanese

You can use more language options.

For example

var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
var today  = new Date();

console.log(today.toLocaleDateString("en-US")); // 9/17/2016
console.log(today.toLocaleDateString("en-US", options)); // Saturday, September 17, 2016
console.log(today.toLocaleDateString("hi-IN", options)); // शनिवार, 17 सितंबर 2016

You can also use the toLocaleString() method for the same purpose. The only difference is this function provides the time when you don't pass any options.

// Example
9/17/2016, 1:21:34 PM

References:

• toLocaleString()- toLocaleDateString()

There are several ways to format a Date object as a string in JavaScript. Here are a few common methods:

1. Using the toLocaleString() method:

const date = new Date();
console.log(date.toLocaleString());
// Output: "Sep 30, 2022" (in the default locale)

This method will format the date using the current locale.

1. Using the toDateString() method:

const date = new Date();
console.log(date.toDateString());
// Output: "Sep 30, 2022" (in the default locale)

This method will format the date using the short date style of the current locale.

1. Using the toUTCString() method:

const date = new Date();
console.log(date.toUTCString());
// Output: "Sep 30, 2022" (in the default UTC)

This method will format the date using the RFC 822 date time standard.

1. Using a string template literal:

const date = new Date();
console.log(`${date.getMonth()}/${date.getDate()}/${date.getFullYear()}`)
// Output: "09/30/2022" (in the default locale)

This method will format the date using string concatenation and the getMonth(), getDate() and getFullYear() methods.

1. Using a library like Moment.js or Luxon: These libraries provide more flexible ways to format dates, such as support for custom formats, time zones and locales.

const moment = require('moment');
const date = new Date();
console.log(moment(date).format("YYYY-MM-DD"));
// Output: "2022-09-30" (in the default locale)

const { DateTime } = require("luxon");
const date = new Date();
console.log(DateTime.fromJSDate(date).toFormat("yyyy/MM/dd"));
// Output: "2022/09/30" (in the default locale)

Sure. I can help with that!

Formatting a Date Object to String

To format a Date object to a string in JavaScript, you can use the toISOString() method. This method returns the date in the format of a string according to the ISO 8601 standard.

const date = new Date();
const dateString = date.toISOString();

console.log(dateString);

Example Output:

2023-04-08T12:34:56Z

Customization Options

You can customize the date format using optional parameters to the toISOString() method. Some valid options include:

• yyyy-MM-dd for January 1, 2023
• HH:mm:ss for 10:00 AM
• yyyy-MM-ddTHHMMSS for 2023-04-08T12:34:56

Additional Notes:

• The toISOString() method returns a string in the UTC time zone.
• You can also use the toLocaleDateString() method to format the date in a specific time zone.
• The Date object can be used directly for formatting.

Example using toLocaleDateString()

const date = new Date();

const dateString = date.toLocaleDateString();

console.log(dateString);

Output:

April 08, 2023 at 12:34:56 GMT

To format a Date object to a string in JavaScript, you can use several methods, but here's a straightforward way using the toLocaleDateString() method for a simple date format, and more custom options using Intl.DateTimeFormat. Here are step-by-step instructions:

Using toLocaleDateString():

1. Create a Date Object: First, create a date object if you don't have one.

   const date = new Date();
   

2. Format the Date:

   • To use the default locale and options:

     const dateString = date.toLocaleDateString();
     console.log(dateString); // Outputs date in default locale format, e.g., "12/31/2023"
     

   • To specify a locale and options:

     const dateString = date.toLocaleDateString("en-US", { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' });
     console.log(dateString); // Outputs, e.g., "Sunday, December 31, 2023"
     

Using Intl.DateTimeFormat() for More Customization:

1. Create a Date Object:

   const date = new Date();
   

2. Define Options for Formatting:

   • Specify the format details:

     const options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric', hour: '2-digit', minute: '2-digit', second: '2-digit' };
     

3. Create an Intl.DateTimeFormat Object:

   • Specify the locale and options:

     const formatter = new Intl.DateTimeFormat('en-US', options);
     

4. Format the Date:

   const dateString = formatter.format(date);
   console.log(dateString); // Outputs, e.g., "Sunday, December 31, 2023, 00:00:00"
   

These methods should cover most needs for formatting dates in JavaScript. Adjust the locale and options according to your specific requirements for the date format.

Here is the solution:

• Use the toLocaleString() method to format the date: date.toLocaleString('en-US', { dateStyle: 'full' });
• Use a library like Moment.js: moment(date).format('YYYY-MM-DDTHH:mm:ssZ');
• Use the toISOString() method to get the date in ISO format: date.toISOString();
• Use a regular expression to format the date: /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})Z$/
• Use the Intl.DateTimeFormat API: new Intl.DateTimeFormat('en-US').format(date);

In JavaScript, you can format a Date object to a string using various methods. Here, I'll show you two popular ways:

1. Using Date object's built-in methods
2. Using a library like moment.js

Method 1: Using Date object's built-in methods

You can use the following built-in methods of the Date object to format a date:

• getFullYear()
• getMonth()
• getDate()
• getDay()
• getHours()
• getMinutes()
• getSeconds()
• getMilliseconds()

These methods return the corresponding component of the date as a number. You can format the date by concatenating these numbers with appropriate separators.

Example:

const date = new Date();

const options = {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  weekday: 'long',
  hour: '2-digit',
  minute: '2-digit',
  second: '2-digit'
};

const formattedDate = new Intl.DateTimeFormat('en-US', options).format(date);

console.log(formattedDate);

Method 2: Using a library like moment.js

If you need more advanced formatting features, consider using a library like moment.js. It's a powerful and easy-to-use library for handling dates and times in JavaScript.

To format a date using moment.js, follow these steps:

1. Install the library:

   npm install moment
   

2. Import the library:

   import moment from 'moment';
   

3. Format the date:

   const date = moment(); // or moment('2022-03-14T13:30:25.123');
   
   const formattedDate = date.format('LLLL');
   
   console.log(formattedDate);
   

In the example above, 'LLLL' is a format token that outputs the date as "Month Day, Year, Hour:Minute:Second AM/PM." You can use various other format tokens to achieve the desired format.

For more information and format tokens, visit the official documentation:

• Date object's built-in methods
• moment.js documentation

For custom-delimited date formats, you have to pull out the date (or time) components from a DateTimeFormat object (which is part of the ECMAScript Internationalization API), and then manually create a string with the delimiters you want. To do this, you can use DateTimeFormat#formatToParts. You could destructure the array, but that is not ideal, as the array output depends on the locale:

{ // example 1
   let f = new Intl.DateTimeFormat('en');
   let a = f.formatToParts();
   console.log(a);
}
{ // example 2
   let f = new Intl.DateTimeFormat('hi');
   let a = f.formatToParts();
   console.log(a);
}

Better would be to map a format array to resultant strings:

function join(t, a, s) {
   function format(m) {
      let f = new Intl.DateTimeFormat('en', m);
      return f.format(t);
   }
   return a.map(format).join(s);
}

let a = [{day: 'numeric'}, {month: 'short'}, {year: 'numeric'}];
let s = join(new Date, a, '-');
console.log(s);

You can also pull out the parts of a DateTimeFormat one-by-one using DateTimeFormat#format, but note that when using this method, as of March 2020, there is a bug in the ECMAScript implementation when it comes to leading zeros on minutes and seconds (this bug is circumvented by the approach above).

let d = new Date(2010, 7, 5);
let ye = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(d);
let mo = new Intl.DateTimeFormat('en', { month: 'short' }).format(d);
let da = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(d);
console.log(`${da}-${mo}-${ye}`);

When working with dates and times, it is usually worth using a library (eg. luxon, date-fns, moment.js is not recommended for new projects) because of the many hidden complexities of the field. Note that the ECMAScript Internationalization API, used in the solutions above is not supported in IE10 (0.03% global browser market share in Feb 2020).

const date = new Date();
const formattedDate = date.toLocaleDateString('en-US', {
  year: 'numeric',
  month: 'long',
  day: 'numeric'
});
console.log(formattedDate); // Output: January 1, 2024

You can use the toLocaleString() method to format a Date object to a string. Here are some examples:

• date.toLocaleString() - formats the date in the default locale format
• date.toLocaleString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }) - formats the date in the en-US locale with a long month name
• date.toLocaleString('fr-FR', { year: 'numeric', month: 'long', day: 'numeric' }) - formats the date in the fr-FR locale with a long month name

Alternatively, you can use a library like Moment.js to format dates. Here's an example:

• moment(date).format('MMMM D, YYYY') - formats the date as "Month Day, Year" (e.g. "July 12, 2022")

You can also use template literals to format the date manually:

• ${date.getMonth() + 1}/${date.getDate()}/${date.getFullYear()} - formats the date as "MM/DD/YYYY"

Note: The getMonth() method returns a value between 0 and 11, so we add 1 to get the correct month number.

To format a Date object to a string using JavaScript, you can use the .toLocaleString() method. Here's an example:

const date = new Date();
const options = {timeZone: 'UTC'}; // Change the timezone here
const formattedDate = date.toLocaleString(options);
console.log(formattedDate);

In this example, we first create a Date object and set it to today's date.

There are several methods to format dates in JavaScript, here are a few of them:

1. Using toISOString() method: It gives you the date and time in a string formatted like "2018-06-29T07:53:14.962Z"

const today = new Date();
console.log(today.toISOString()); // '2022-03-18T06:01:24.123Z'

Note that toISOString() gives you a date in UTC, and does not take timezones into account. If your dates are local to the browser/machine running this script you may want to consider using other options.

2. Using built-in JavaScript Date methods: JavaScript has some useful built-in Date properties and methods like getFullYear(), getMonth(), getDate() etc., which we can use in combination with simple string manipulations to format the date as per our requirement. Here's a basic example of how to format it in "YYYY/MM/DD" form:

const today = new Date();
const dd = String(today.getDate()).padStart(2, '0');
const mm = String(today.getMonth() + 1).padStart(2, '0'); //+1 because January is 0 in JavaScript.
const yyyy = today.getFullYear();

console.log(`${yyyy}-${mm}-${dd}`);//'2022-03-18'

In this example, the padStart() method is used to ensure that our date and month always have at least two digits (by adding a leading zero if necessary).

Remember: These examples are just basic. JavaScript has powerful tools like Date-fns or MomentJS for more complex formatting needs.

Keep in mind also that dates are not the same as calendars, and the format of date values stored or displayed depends on where they're being used. Different countries use different formats depending on their culture, so you might have to handle this aspect according to your specific requirements.

To format a Date object to a string in JavaScript, you can use the following code:

const date = new Date();
const formattedDate = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate();

This code creates a new Date object, and then uses the getFullYear(), getMonth(), and getDate() methods to extract the year, month, and day components respectively. The + operator is used to concatenate the values together into a single string, with '-' characters added to format the date as 'YYYY-MM-DD'.

dateObject.toLocaleDateString()