JsSimpleDateFormat

  v3.0

Table of Contents

• Description
• Date and Time Patterns
• Class JsSimpleDateFormat
• Class JsDateFormatSymbols
• Class NetDateTimeFormat
• Class TimerFormat
• Class TimerFormatSymbols
• Used as Node.js Module

Description

JsSimpleDateFormat is for formatting Date object to be a string as the pattern we define and also for parsing a string to be a Date object based on the defined pattern. JsSimpleDateFormat works similar with Java SimpleDateFormat class which uses the same pattern letters with similar rules. If you have been familiar with Java SimpleDateFormat class, you should be able to use JsSimpleDateFormat easily. This library also contains JsDateFormatSymbols which is like Java DateFormatSymbols class to encapsulate the localizable date-time components, such as: the name of days, months etc.

Beside Java formatting pattern, this library also supports .Net DateTime formatting pattern. The .Net pattern is handled by NetDateTimeFormat class.

This library also supports the formatting for duration. The format pattern is based on .Net TimeSpan formatting pattern with some extensions. For this purpose, this library provides TimerFormat class. TimerFormatSymbols class is used to handle the localization for duration.

Date and Time Patterns

Java Compatible Date and Time Patterns

As mentioned above, JsSimpleDateFormat uses the same pattern letters with similar rules as used by Java SimpleDateFormat class. To make the same comprehension, the explanation about the pattern letters here is copied from Java Standard Ed. 8 Documentation with some modifications to note the difference between JsSimpleDateFormat and Java SimpleDateFormat.

Date and time formats are specified by date and time pattern strings. Within date and time pattern strings, unquoted letters from 'A' to 'Z' and from 'a' to 'z' are interpreted as pattern letters representing the components of a date or time string. Text can be quoted using single quotes (') to avoid interpretation. "''" represents a single quote. All other characters are not interpreted; they're simply copied into the output string during formatting or matched against the input string during parsing.

Note: There is a prominent difference between JsSimpleDateFormat and Java SimpleDateFormat class when interpreting an unrecognized letter:

• If there is a letter ('a' to 'z' or 'A' to 'Z') in the pattern which doesn't have a representation (not listed in the list below), such as B, Java SimpleDateFormat class will raise error. JsSimpleDateFormat, however, will not interpret that letter but will show that letter as is.

The list of the pattern letters:

Letter	Date or Time Component	Presentation	Examples
G	Era designator	Text	AD
y	Year	Year	1996; 96
Y	Week year	Year	2009; 09
M	Month in year. Java SimpleDateFormat interprets this letter as month with context sensitive. JsSimpleDateFormat doesn't support the context sensitive format. So, it will be exactly the same as 'L' letter.	Month	7; 07; Jul; July
L	Month in year (standalone form)	Month	7; 07; Jul; July
w	Week in year	Number	27
W	Week in month	Number	2
D	Day in year	Number	189
d	Day in month	Number	10
F	Day of week in month	Number	2
E	Day name in week	Text	Tuesday; Tue
u	Day number of week (1 = Monday, ..., 7 = Sunday)	Number	1
a	Am/pm marker	Text	PM
H	Hour in day (0-23)	Number	0
k	Hour in day (1-24)	Number	24
K	Hour in am/pm (0-11)	Number	0
h	Hour in am/pm (1-12)	Number	12
m	Minute in hour	Number	30
s	Second in minute	Number	55
S	Millisecond	Number	978
z	Time zone	General time zone	For formatting: GMT+07:00 For parsing, accepts format: GMT+7:00; UTC Unlike Java, JsSimpleDateFormat doesn't support named time zone such as 'Pacific Standard Time' or 'PST'
Z	Time zone	RFC 822 time zone	+0700
X	Time zone	ISO 8601 time zone	+07; +0700; +07:00

Pattern letters are usually repeated, as their number determines the exact presentation:

• Text: For formatting, if the number of pattern letters is 4 or more, the full form is used; otherwise a short or abbreviated form is used if available.
  For parsing, both forms are accepted, independent of the number of pattern letters.
• Number: For formatting, the number of pattern letters is the minimum number of digits, and shorter numbers are zero-padded to this amount.
  For parsing, the number of pattern letters is ignored unless it's needed to separate two adjacent fields.
• Year: The following rules apply (JsSimpleDateFormat only supports Gregorian calendar):
  • For formatting, if the number of pattern letters is 2, the year is truncated to 2 digits; otherwise it is interpreted as a Number.
  • For parsing, if the number of pattern letters is more than 2, the year is interpreted literally, regardless of the number of digits. So using the pattern "MM/dd/yyyy", "01/11/12" parses to Jan 11, 12 A.D.
  • For parsing with the abbreviated year pattern ("y" or "yy"), JsSimpleDateFormat must interpret the abbreviated year relative to some century. The begin of century is set by set2DigitYearStart method. By default, it's 80 years before the JsSimpleDateFormat instance is created. For example, using a pattern of "MM/dd/yy" and the begin of century is 1917, the string "01/11/12" would be interpreted as Jan 11, 2012 while the string "05/04/64" would be interpreted as May 4, 1964. During parsing, only strings consisting of exactly two digits, will be parsed into the default century. Any other numeric string, such as a one digit string, a three or more digit string, is interpreted literally.
    NOTE: The documentation of Java SimpleDateFormat still explains how the negative year is interpreted. Actually, the recent version of SimpleDateFormat will raise an exception when parsing a negative year. Therefore, in the current version, JsSimpleDateFormat doesn't support a negative year. Please use the era designator (BC) instead.
• Month: If the number of pattern letters is 3 or more, the month is interpreted as Text; otherwise, it is interpreted as a Number.
• General time zone: Time zone follows the GMT offset value syntax as the following description:

      GMTOffsetTimeZone:
          GMT Sign Hours : Minutes
      Sign: one of
          + -
      Hours:
          Digit
          Digit Digit
      Minutes:
          Digit Digit
      Digit: one of
          0 1 2 3 4 5 6 7 8 9
    

  Hours must be between 0 and 23, and Minutes must be between 00 and 59.
  
  For parsing, RFC 822 time zones are also accepted.
  
  
• RFC 822 time zone: For formatting, the RFC 822 4-digit time zone format is used:

      RFC822TimeZone:
          Sign TwoDigitHours Minutes
      TwoDigitHours:
          Digit Digit
    

  TwoDigitHours must be between 00 and 23. Other definitions are as for general time zones.
  
  For parsing, general time zones are also accepted.
  
  
• ISO 8601 Time zone: The number of pattern letters designates the format for both formatting and parsing as follows:

      ISO8601TimeZone:
          OneLetterISO8601TimeZone
          TwoLetterISO8601TimeZone
          ThreeLetterISO8601TimeZone
      OneLetterISO8601TimeZone:
          Sign TwoDigitHours
          Z
      TwoLetterISO8601TimeZone:
          Sign TwoDigitHours Minutes
          Z
      ThreeLetterISO8601TimeZone:
          Sign TwoDigitHours : Minutes
          Z
    

  Other definitions are as for general time zones or RFC 822 time zones.
  
  For formatting, if the offset value from GMT is 0, "Z" is produced. If the number of pattern letters is 1, any fraction of an hour is ignored. For example, if the pattern is "X" and the time zone is "GMT+05:30", "+05" is produced.
  
  For parsing, "Z" is parsed as the UTC time zone designator. General time zones are not accepted.
  
  If the number of pattern letters is 4 or more, FormatError is thrown.
  
  

.NET Compatible Date and Time Patterns

If you use .Net to develop the backend application, you may prefer to use .Net-compatible pattern string. For this purpose, you can use NetDateTimeFormat class. The class supports the date time pattern which is compatible with .NET Custom date and time format strings. However, there are some different behaviors. Because NetDateTimeFormat inherits JsSimpleDateFormat, it behaves more closely to its parent. For example, with pattern "HHH" and the hour is 23, .Net DateTime produces "23" but Java SimpleDateFormat produces "023". NetDateTimeFormat also produces "023", different from the real .Net version. But if you use no awkward pattern, there will be no difference (in fact, hour will not more than two digits).

The following table lists the pattern characters which applies when using NetDateTimeFormat class:

Character	Explanation
d	For 1 or 2 letters, it's the same as Java d letter. For 3 or more letters, it's interpreted like Java E letter.
f	One letter is the tenths of a second. Two letters is the hundredths of a second. Three or more letters is the milliseconds. For example, if the value of milliseconds is 10 then the pattern "fff" will produce "010", "ff" will produce "01" and "f" will produce "0".
F	The same as f letter but without the trailing zero(s). For example, if the value of milliseconds is 10 then "FFF" will produce "01", "FF" will also produce "01" and "F" will produce an empty string.
g	The period or era. Like Java G letter.
h	The same as Java h letter.
H	The same as Java H letter.
m	The same as Java m letter.
M	The same as Java M letter.
s	The same as Java s letter.
t	The AM/PM designator. If only one letter, only the first character will be used, such as 'A' for 'AM' and 'P' for 'PM'.
y	Mostly, the same as Java y letter. The difference is in the interpretation for only one letter pattern. In formatting, one letter will also produces a truncated year without century. If the truncated year is less than 10, it will produce one digit year, different from two letters that always produces two digit years. In parsing, one digit value of year is also interpreted as a abbreviated year (relative to a century).
z	Timezone that uses the following formats: one letter: "+7" two letters: "+07" three or more letters: "+07:00"
K	It's like X letter in Java version but always uses format "+/-hh:mm"
.	A decimal point. It has a special behavior when followed by the F letter pattern. If F pattern produces an empty string (because of 0 millisecond) the the decimal point isn't shown either.
'	Single quote. The same as Java version, a quoted text is escaped from being interpreted as the pattern. Different from Java version, to escape a single quote, you must use backslash (\) in front of the single quoute.
"	Double quote. The same as the single quote, to escape a text from interpretation. It's useful if you use many single quotes in the text.
\	Backslash. To escape a single character. The character following a backslash will not be interpreted.
/	It will be replaced by the value of DateTimeFormatInfo.DateSeparator. The default value is "/". You may change its value to another character such as "-".
:	It will be replaced by the value of DateTimeFormatInfo.TimeSeparator. The default value is ":". You may change its value to another character such as ".".

Duration Patterns

Beside date-time formatting, this library also supports to format a duration. For this purpose, we use TimerFormat class. The pattern string is based on .Net Custom TimeSpan format strings but there are some differences. TimerFormat class inherits JsSimpleDateFormat class, thus the behavior of interpretation will be more closely to its parent.

Below is the list of supported pattern characters:

Character	Explanation
d	It's the total days of the duration without counting the remaining hours, minutes, seconds and milliseconds. The duration format doesn't support to format the number of months and years. So, the value of total days may exceed a month or a year.
h	The hour part (0-23)
m	The minute part (0-59)
s	The second part (0-59)
f	One letter is the tenths of a second. Two letters is the hundredths of a second. Three or more letters is the milliseconds. For example, if the value of milliseconds is 10 then the pattern "fff" will produce "010", "ff" will produce "01" and "f" will produce "0".
F	The same as f letter but without the trailing zero(s). For example, if the value of milliseconds is 10 then "FFF" will produce "01", "FF" will also produce "01" and "F" will produce an empty string.
.	A decimal point. It has a special behavior when followed by the F letter pattern. If F pattern produces an empty string (because of 0 millisecond) the the decimal point isn't shown either.
-	Minus sign. It will show a negative sign if the duration is negative. If positive, it will show nothing.
'	Single quote. Like the date-time formatting, it's to escape a text.
\	Backslash. To escape a single character. The character following a backslash will not be interpreted.

Class JsSimpleDateFormat

Constructor

• JsSimpleDateFormat()
  Creates a JsSimpleDateFormat object using default pattern and default locale. Default pattern is "dd MMMM yyyy hh:mm a" and default locale is English. If you want to change the default pattern, you may create your own class which inherits JsSimpleDateFormat and then overwrite _getDefaultPattern method, like the below one. Suppose the default pattern you want is "MMM dd, yyyy HH:mm a":

    function MyJsSimpleDateFormat() {
      JsSimpleDateFormat.apply(this,arguments);
    }
    MyJsSimpleDateFormat.__extends__(JsSimpleDateFormat, {
      _getDefaultPattern: function() {
        return "MMM dd, yyyy HH:mm a";
      }
    });
  	  

  __extends__ method is written in JsSimpleDateFormat.js. If using usual way, we write like this:

    function MyJsSimpleDateFormat() {
      JsSimpleDateFormat.apply(this,arguments);
    }
    MyJsSimpleDateFormat.prototype = new JsSimpleDateFormat();
    MyJsSimpleDateFormat.prototype._getDefaultPattern = function() {
      return "MMM dd, yyyy HH:mm a";
    }
  	  

  or you may use ES6 syntax which is more simple:

    class MyJsSimpleDateFormat extends JsSimpleDateFormat {
      _getDefaultPattern() {
        return "MMM dd, yyyy HH:mm a";
      }
    }
      

• JsSimpleDateFormat(sPattern)
  Creates a JsSimpleDateFormat object using the pattern as written in parameter and using default locale that is English.
  Parameters:
  • sPattern is the pattern for formatting date time that will be used by this object.
• JsSimpleDateFormat(sPattern, sLocale)
  Creates a JsSimpleDateFormat object using the pattern and the locale as defined by parameter.
  Parameters:
  • sPattern is the pattern for formatting date time that will be used by this object.
  • sLocale is the locale code which defines the language that will be used. There are two codes provided by this library, those are en (English) and id (Indonesian). But you can define the new one. For further information, see JsDateFormatSymbols.
• JsSimpleDateFormat(sPattern, oSymbols)
  Creates a JsSimpleDateFormat object using the pattern and the locale as defined by parameter.
  Parameters:
  • sPattern is the pattern for formatting date time that will be used by this object.
  • oSymbols is a JsDateFormatSymbols object which defines the name of days, months etc, which are usually shown in date time information.

Property

• flexWhiteSpace
  It defines the flexibility of white space (space, tab and new line). If set to true (by default) then the users can type any number of spaces regardless the number of spaces defined in the pattern for that position. This flexibility makes easier for the users so that they don't need to remember how many spaces they have typed. This setting also ignores the kind of white space (space, tab or new line). If the value of this property is false, it will parse strictly, the number and the kind of white space. This property must be set before invoking parse method.
• isLenient
  By default, JsSimpleDateFormat does strict parsing. It will check the consistency among date time components. For example, with pattern "EEE, MMM d, yyyy", it will fail to parse "Mon, Feb 1, 2008" because in the fact, "Feb 1, 2008" is Friday. If isLenient is set to true, JsSimpleDateFormat will parse more loosely. In the previous case, it will parse the string successfully.

Method

• applyPattern(sPattern)
  Applies new pattern for this object. All formatting and parsing hereafter will use the new pattern.
  Parameters:
  • sPattern is the new pattern will be applied.
• format(oDate)
  Formats a Date object using the pattern applied to this object.
  Parameters:
  • oDate is the Date object will be formatted.
  Returns:
  The string representing date time which is the result of formatting.
• get2DigitYearStart()
  Returns the Date object that have been set by set2DigitYearStart method. If set2DigitYearStart method has not been invoked yet, it will return the Date object representing the date time 80 years before this JsSimpleDateFormat object is created.
  Returns:
  The Date object which its year is the begin of century.
• getDateFormatSymbols()
  Returns the JsDateFormatSymbols object used by this object. See setDateFormatSymbols
  Returns:
  The JsDateFormatSymbols object used by this object.
• parse(s)
  Parses a string to be a Date object based on the pattern used by this object. It's possible there will be a missing field in the pattern to construct a complete date time. Perhaps, there is no year or month or day etc. To avoid that, in the beginning of parsing, this method will get the initial date time and then parse and set the appropriate field as found in the string. The initial date time is "January 1, 1970 00:00:00.000" based on your local time. If you want change the initial date time, you may create your own class inherited from JsSimpleDateFormat and overwrite _getInitDate method as below (suppose you want the iniatial date time is the current date time):
  

    function MyJsSimpleDateFormat() {
      JsSimpleDateFormat.apply(this,arguments);
    }
    MyJsSimpleDateFormat.__extends__(JsSimpleDateFormat, {
      _getInitDate: function() {
        return new Date();
      }
    });
  	  

  __extends__ method is written in JsSimpleDateFormat.js. If using usual way, we write like this:

    function MyJsSimpleDateFormat() {
      JsSimpleDateFormat.apply(this,arguments);
    }
    MyJsSimpleDateFormat.prototype = new JsSimpleDateFormat();
    MyJsSimpleDateFormat.prototype._getInitDate = function() {
      return new Date();
    }
  	  

  or you may use ES6 syntax which is more simple:

    class MyJsSimpleDateFormat extends JsSimpleDateFormat {
      constructor(sPattern, param) {
        super(sPattern, param);
        this.set2DigitYearStart(new Date(2000, 0 , 1));
      }
  
      _getInitDate() {
        return new Date();
      }
    }
      

  parse method will return null if the string cannot be parsed to be a valid date time. Note, the method may not use the entire text, only a substring positioned at index 0. For example, "Jan 3, 2008 is Thursday" will be parsed successfully using pattern "MMM d, yyyy" even if the remaining string " is Thursday" doesn't match the pattern.

  Parameters:
  • s is a string to be parsed.
  Returns:
  The Date object as the result of parsing or null if the parsing failed.
• parse(s, oPos)
  To parse a string starting at index defined by oPos. If the parsing is successful, this index will be updated to the index after the last character parsed successfully (this method may not parse until the end of string) and the Date object which is the result of parsing is returned. The updated index is useful to determine the starting index for the next parsing. Paramerter oPos is an object whose properties: index and errorIndex. The index property is the starting index as explained before. The errorIndex property will be used if the parsing failed. It notes the index where the error begins to happen. If an error occurs, the index property will not be updated but the errorIndex property will be updated. Example:

  	var oDf = new JsSimpleDateFormat("MMM d, yyyy");
  	var s = "The date of Jan 3, 2008 is Thursday";
  	var oPos = {index: 12, errorIndex: -1};
  	var oDate = oDf.parse(s, oPos);
  	  

  After parsing, index property will be updated become 23. As example above, initiate the value of errorIndex property to -1 because if an error occurs, it will be updated to the non negative value. Negative value will differentiate from the index where the error occurs. So if errorIndex property becomes 0 or higher after parsing then an error occurs. Another clue, this method will return null if the string cannot be parsed to be a valid date time.
  
  If you don't need the return back about index but only want to determine the starting index, you may do it like this:

  	var oDate = oDf.parse(s, {index:3});
  	  

  For further information, see another parse method.

  Parameters:
  • s is a string to be parsed.
  • oPos is an object whose index and error index information as explained above.
  Returns:
  The Date object as the result of parsing or null if parsing is failed.
• set2DigitYearStart(oStartDate)
  Sets the begin of century. It's for parsing two digits year. To get the full year, two digits year must be added to a number that is multiplication of a hundred. This full year will be between the begin of century and 100 years after that. Note, the parameter of this method is not an integer but a Date object. What you must do is to create a Date object and set its year by invoking setFullYear method. Then pass this Date object as parameter.
  Parameters:
  • oStartDate is a Date object which its year is the begin of century.
• setDateFormatSymbols(oFormatSymbols)
  Sets JsDateFormatSymbols object that will be used by this object. JsDateFormatSymbols object determines the name of days, months etc, which are usually shown in date time information. You can create your own JsDateFormatSymbols object and set your own name of days and months. Pass that JsDateFormatSymbols object as the parameter of this method. When a JsSimpleDateFormat object is created, it will create a JsDateFormatSymbols object for it, based on the parameter of constructor.
  Parameters:
  • oFormatSymbols is a JsDateFormatSymbols object to be set.
• toPattern()
  Returns the pattern string used by this object.
  Returns:
  The pattern string used by this object.

Class JsDateFormatSymbols

The objects of this class is to specify the name of days, months and the other keywords which are usually shown in date time information. The JsSimpleDateFormat object uses an object of JsDateFormatSymbols to get all keywords needed either for formatting or for parsing. All JsSimpleDateFormat objects always have a JsDateFormatSymbols object associated to it. When JsSimpleDateFormat object is created, it will also create JsDateFormatSymbols object based on the parameters passed to constructor. This JsDateFormatSymbols object can be obtained by getDateFormatSymbols method. You may also create a new JsDateFormatSymbols object and set it via setDateFormatSymbols method. In other words, you can set the new keywords according to your languange.

Below is an example how to change the keywords:

	var oDf = new JsSimpleDateFormat("MMM d, yyyy");
	var oSymbols = new JsDateFormatSymbols();
	oSymbols.setAmPmStrings(['AM','PM']);
	oSymbols.setEras(['AD','BC']);
	oSymbols.setMonths(['January','February','March','April','May','June','July','August','September','October','November','December']);
	oSymbols.setShortMonths(['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']);
	oSymbols.setShortWeekdays(['Sun','Mon','Tue','Wed','Thu','Fri','Sat']);
	oSymbols.setWeekdays(['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']);
	oDf.setDateFormatSymbols(oSymbols);
	alert(oDf.format(new Date()));
	

Of course, you should change the words in the example above to be the appropriate words according to your language.

Another Trick
If you want set a code for your language like "en" for English and can pass this code whenever creating JsSimpleDateFormat object, do these steps. Specify the code for you language, suppose you want the code "xx". It should be two letters as specified in http://www.loc.gov/standards/iso639-2/php/English_list.php, but you may choose what you like. Nevermind if it's for your own. Create a JavaScript file and write the code like the below one inside this JavaScript file.

	JsDateFormatSymbols.__symbols__.xx = {
		amPmStrings: ['AM','PM'],
		eras: ['AD','BC'],
		months: ['January','February','March','April','May','June','July','August','September','October','November','December'],
		shortMonths: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
		shortWeekdays: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
		weekdays: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday']
	};
	

Alter the words in the example above to be the appropriate words according to your language. Insert that JavaScript file in your HTML document after inserting JsSimpleDateFormat.js.

Method

• getAmPmStrings()
  Returns:
  Array of "AM" and "PM" text.
• getEras()
  Returns:
  Array of era designators (English: "AD" and "BC").
• getMonths()
  Returns:
  Array of month names.
• getShortMonths()
  Returns:
  Array of abbreviated month names.
• getShortWeekdays()
  Returns:
  Array of abbreviated day names.
• getWeekdays()
  Returns:
  Array of day names.
• setAmPmStrings(arAmPmStrings)
  Sets "AM" and "PM" text.
  Parameters:
  • arAmPmStrings is an array of "AM" and "PM" text. "AM" is the first elements.
• setEras(arEras)
  Sets era designators (English: "AD" and "BC").
  Parameters:
  • arEras is an array of era designators. The first element is the designator which is the same as "AD".
• setMonths(arMonths)
  Sets the month names.
  Parameters:
  • arMonths is an array of the month names, the first until the twelfth month.
• setShortMonths(arShortMonths)
  Sets the abbreviated month names.
  Parameters:
  • arShortMonths is an array of the abbreviated month names, the first until the twelfth month. The abbreviated month name usually consists of three letters.
• setShortWeekdays(arShortWeekdays)
  Sets the abbreviated day names.
  Parameters:
  • arShortWeekdays is an array of the abbreviated day names. Sunday is the first element. The abbreviated day name usually consists of three letters.
• setWeekdays(arWeekdays)
  Sets the day names.
  Parameters:
  • arWeekdays an array of the day names. Sunday is the first element.

Class NetDateTimeFormat

This class inherits JsSimpleDateFormat. All methods, properties and constructors are the same as its parent's. To use this class, you must insert two scripts in your HTML document:

<script src="JsSimpleDateFormat.min.js"></script>
<script src="NetDateTimeFormat.min.js"></script>

Class TimerFormat

This class inherits NetDateTimeFormat. This class is to format/parse using Duration Patterns. There is no Duration object in Javascript, hence, this class is also operated to the Date object. The duration is taken from the number of milliseconds returned by getTime method of the Date object.

This class overwrites its parent at some points as follows:

• Constructor
  The second parameter is TimerFormatSymbols object, not JsDateFormatSymbols
• Methods:
  • approxFormat(oDate, sPrefix, sSuffix)
    It's a new method defined by this class. This method will format the duration to be a string which tells the appoximate time long that the duration has. This method yields a string like "a few seconds", "a minute", "2 minutes", "10 days", "a month", "3 years" etc. If it says "a month" then it means "a month approximately", not exactly "a month".
    This method can be an alternative of from* and to* method of moment package.
    Parameters:
    The first parameter can be a Date object or an integer. If it's an integer then it's the total number of milliseconds for the duration.
    The second and the third parameter are optional. They are the prefix and the suffix added to the returned string.
  • format
    The parameter can be a Date object or an integer. If it's an integer then it's the total number of milliseconds for the duration.
  • getDateFormatSymbols
    It will raise an error because it's not supported anymore, replaced by getTimerFormatSymbols method.
  • getTimerFormatSymbols
    It returns a TimerFormatSymbols object that is being used.
  • setDateFormatSymbols
    It will raise an error because it's not supported anymore, replaced by setTimerFormatSymbols method.
  • setTimerFormatSymbols
    To set the localized symbols. The parameter is a TimerFormatSymbols object.

To use this class, you must insert three scripts in your HTML document:

<script src="JsSimpleDateFormat.min.js"></script>
<script src="NetDateTimeFormat.min.js"></script>
<script src="TimerFormat.min.js"></script>

Class TimerFormatSymbols

This class is to localize the duration format string. It's used by TimerFormat class, especially by approxFormat method.

Constructor

The constructor requires a parameter. The parameter can be a string or an object. If it's a string then it's a locale id ('en' or 'id'). If it's an object then it defines all localized words. The structure of the object as follows:

{
  fewSeconds: 'a few seconds',
  aMinute: 'a minute',
  minutes: '${count} minutes',
  anHour: 'an hour',
  hours: '${count} hours',
  aDay: 'a day',
  days: '${count} days',
  aMonth: 'a month',
  months: '${count} months',
  aYear: 'a year',
  years: '${count} years'
}

Method

• getFewSeconds and setFewSeconds(s)
  Gets/sets the string "a few seconds".
• getAMinute and setAMinute(s)
  Gets/sets the string "a minute".
• getMinutes and setMinutes(s)
  Gets/sets the string "${count} minutes".
• getAnHour and setAnHour(s)
  Gets/sets the string "an hour".
• getHours and setHours(s)
  Gets/sets the string "${count} hours".
• getADay and setADay(s)
  Gets/sets the string "a day".
• getDays and setDays(s)
  Gets/sets the string "${count} days".
• getAMonth and setAMonth(s)
  Gets/sets the string "a month".
• getMonths and setMonths(s)
  Gets/sets the string "${count} months".
• getAYear and setAYear(s)
  Gets/sets the string "a year".
• getYears and setYears(s)
  Gets/sets the string "${count} years".

Used as Node.js Module

To install JsSimpleDateFormat package, you can use console command:

npm install jssimpledateformat

In javascript source, you can follow the example below:

import DateFormat, {JsDateFormatSymbols} from 'jssimpledateformat';

let df = new DateFormat('d MMM yyyy HH:mm:ss', new JsDateFormatSymbols('en'));
console.log(df.format(new Date()));

The other classes that can be improted are DateTimeFormatInfo, FormatError, NetDateTimeFormat, TimerFormat and TimerFormatSymbols.