yyyy Où puis-je trouver de la documentation sur le formatage d'une date en JavaScript?




tolocaledatestring (24)

J'ai remarqué que la new Date() JavaScript est très intelligente pour accepter des dates dans plusieurs formats.

Xmas95 = new Date("25 Dec, 1995 23:15:00")
Xmas95 = new Date("2009 06 12,12:52:39")
Xmas95 = new Date("20 09 2006,12:52:39")

Je n'ai pas trouvé de documentation où que ce soit montrant tous les formats de chaînes valides lors de l'appel de la new Date() .

C'est pour convertir une chaîne en date. Si nous regardons le côté opposé, c'est-à-dire, la conversion d'un objet date en chaîne, jusqu'à présent, j'avais l'impression que JavaScript n'avait pas d'API intégrée pour mettre en forme un objet date dans une chaîne.

Note de l'éditeur: L'approche suivante est la tentative du demandeur qui a travaillé sur un navigateur particulier mais ne fonctionne pas en général; voir les réponses sur cette page pour voir des solutions réelles.

Aujourd'hui, j'ai joué avec la toString() sur l'objet date et, étonnamment, cela sert à formater la date en chaînes.

var d1 = new Date();
d1.toString('yyyy-MM-dd');       //Returns "2009-06-29" in Internet Explorer, but not Firefox or Chrome
d1.toString('dddd, MMMM ,yyyy')  //Returns "Monday, June 29,2009" in Internet Explorer, but not Firefox or Chrome

Ici aussi, je n'ai trouvé aucune documentation sur toutes les façons de formater l'objet date en une chaîne.

Où se trouve la documentation répertoriant les spécificateurs de format pris en charge par l'objet Date() ?


JsSimpleDateFormat is a library that can format the date object and parse the formatted string back to Date object. It uses the Java format (SimpleDateFormat class). The name of months and days can be localized.

Exemple:

var sdf = new JsSimpleDateFormat("EEEE, MMMM dd, yyyy");
var formattedString = sdf.format(new Date());
var dateObject = sdf.parse("Monday, June 29, 2009");

Ayant examiné plusieurs des options fournies dans d'autres réponses, j'ai décidé d'écrire ma propre solution limitée mais simple que d'autres pourraient trouver utile.

/**
* Format date as a string
* @param date - a date object (usually "new Date();")
* @param format - a string format, eg. "DD-MM-YYYY"
*/
function dateFormat(date, format) {
    // Calculate date parts and replace instances in format string accordingly
    format = format.replace("DD", (date.getDate() < 10 ? '0' : '') + date.getDate()); // Pad with '0' if needed
    format = format.replace("MM", (date.getMonth() < 9 ? '0' : '') + (date.getMonth() + 1)); // Months are zero-based
    format = format.replace("YYYY", date.getFullYear());
    return format;
}

Exemple d'utilisation:

console.log("The date is: " + dateFormat(new Date(), "DD/MM/YYYY"));

See dtmFRM.js . If you are familiar with C#'s custom date and time format string, this library should do the exact same thing.

DEMO :

var format = new dtmFRM();
var now = new Date().getTime();

$('#s2').append(format.ToString(now,"This month is : MMMM") + "</br>");
$('#s2').append(format.ToString(now,"Year is  : y or yyyy or yy") + "</br>");
$('#s2').append(format.ToString(now,"mm/yyyy/dd") + "</br>");
$('#s2').append(format.ToString(now,"dddd, MM yyyy ") + "</br>");
$('#s2').append(format.ToString(now,"Time is : hh:mm:ss ampm") + "</br>");
$('#s2').append(format.ToString(now,"HH:mm") + "</br>");
$('#s2').append(format.ToString(now,"[ddd,MMM,d,dddd]") + "</br></br>");

now = '11/11/2011 10:15:12' ;

$('#s2').append(format.ToString(now,"MM/dd/yyyy hh:mm:ss ampm") + "</br></br>");

now = '40/23/2012'
$('#s2').append(format.ToString(now,"Year is  : y or yyyy or yy") + "</br></br>");

Cadre libre, limité mais léger

var d = (new Date()+'').split(' ');
// ["Tue", "Sep", "03", "2013", "21:54:52", "GMT-0500", "(Central", "Daylight", "Time)"]

[d[3], d[1], d[2], d[4]].join(' ');
// "2013 Sep 03 21:58:03"


Vous pouvez simplement développer l'objet Date avec une nouvelle méthode de format comme indiqué par meizz , ci-dessous est le code donné par l'auteur. Et voici un jsfiddle .

Date.prototype.format = function(format) //author: meizz
{
  var o = {
    "M+" : this.getMonth()+1, //month
    "d+" : this.getDate(),    //day
    "h+" : this.getHours(),   //hour
    "m+" : this.getMinutes(), //minute
    "s+" : this.getSeconds(), //second
    "q+" : Math.floor((this.getMonth()+3)/3),  //quarter
    "S" : this.getMilliseconds() //millisecond
  }

  if(/(y+)/.test(format)) format=format.replace(RegExp.$1,
    (this.getFullYear()+"").substr(4 - RegExp.$1.length));
  for(var k in o)if(new RegExp("("+ k +")").test(format))
    format = format.replace(RegExp.$1,
      RegExp.$1.length==1 ? o[k] :
        ("00"+ o[k]).substr((""+ o[k]).length));
  return format;
}

alert(new Date().format("yyyy-MM-dd"));
alert(new Date("january 12 2008 11:12:30").format("yyyy-MM-dd h:mm:ss"));

The correct way to format a date to return "2012-12-29" is with the script from JavaScript Date Format :

var d1 = new Date();
return d1.format("dd-m-yy");

This code does NOT work:

var d1 = new Date();
d1.toString('yyyy-MM-dd');      

Just another option, which I wrote:

DP_DateExtensions Library

Not sure if it'll help, but I've found it useful in several projects - looks like it'll do what you need.

Supports date/time formatting, date math (add/subtract date parts), date compare, date parsing, etc. It's liberally open sourced.

No reason to consider it if you're already using a framework (they're all capable), but if you just need to quickly add date manipulation to a project give it a chance.


Exemple de code:

var d = new Date();
var time = d.toISOString().replace(/.*?T(\d+:\d+:\d+).*/, "$1");

Sortie:

"13:45:20"


La réponse courte

Il n'y a pas de documentation "universelle" sur laquelle javascript s'adresse; tout navigateur qui a javascript est vraiment une implémentation. Cependant, il existe une norme que les navigateurs les plus modernes ont tendance à suivre, et c'est la norme EMCAScript; les chaînes standard ECMAScript prendraient, au minimum, une implémentation modifiée de la définition ISO 8601.

En plus de cela, il existe un deuxième standard mis en avant par l' IETF que les navigateurs ont tendance à suivre, ce qui est la définition des horodateurs faite dans le RFC 2822. La documentation réelle peut être trouvée dans la liste des références en bas.

De cela, vous pouvez vous attendre à une fonctionnalité de base, mais ce que "devrait" être n'est pas intrinsèquement ce qui "est". Je vais aller un peu en profondeur avec cette procédure, car il semble que seulement trois personnes ont répondu à la question (Scott, goofballLogic et peller), ce qui, à mon avis, suggère que la plupart des gens ignorent ce qui se passe réellement créer un objet Date.

La longue réponse

Où se trouve la documentation répertoriant les spécificateurs de format pris en charge par l'objet Date ()?


Pour répondre à la question, ou même rechercher la réponse à cette question, vous devez savoir que javascript n'est pas une langue originale; il s'agit en fait d'une implémentation d'ECMAScript, et suit les standards ECMAScript (mais notez que javascript est également antérieur à ces standards, les standards EMCAScript sont construits à partir de la première implémentation de LiveScript / JavaScript). La norme ECMAScript actuelle est 5.1 (2011); au moment où la question a été posée à l'origine (juin 2009), la norme était de 3 (4 ont été abandonnées), mais 5 ont été publiées peu après le poste à la fin de 2009. Cela devrait indiquer un problème; quelle implémentation javascript peut suivre, peut ne pas refléter ce qui est réellement en place, parce que a) c'est une implémentation d'un standard donné, b) toutes les implémentations d'un standard ne sont pas puritan, et c) la fonctionnalité n'est pas libérée en synchronisation avec un nouvelle norme comme d) une mise en œuvre est un travail constant en cours

Essentiellement, lorsque vous traitez avec javascript, vous avez affaire à un dérivé (javascript spécifique au navigateur) d'une implémentation (javascript lui-même). Le V8 de Google, par exemple, implémente ECMAScript 5.0, mais JScript d'Internet Explorer ne tente pas de se conformer à n'importe quel standard ECMAScript, mais Internet Explorer 9 est conforme à ECMAScript 5.0.

Lorsqu'un seul argument est passé à new Date (), il lance ce prototype de fonction:

new Date(value)

Lorsque deux ou plusieurs arguments sont passés à new Date (), il lance ce prototype de fonction:

new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )


Ces deux fonctions devraient vous sembler familières, mais cela ne répond pas immédiatement à votre question et ce qui est quantifié en tant que «format de date» acceptable nécessite des explications supplémentaires. Quand vous passez une chaîne à new Date (), elle appellera le prototype (notez que j'utilise le mot prototype de manière lâche, les versions peuvent être des fonctions individuelles, ou faire partie d'une instruction conditionnelle dans une seule fonction) pour new Date (value) avec votre chaîne comme argument pour le paramètre "value". Cette fonction vérifie d'abord s'il s'agit d'un nombre ou d'une chaîne. La documentation de cette fonction peut être trouvée ici:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

De ceci, nous pouvons déduire que pour obtenir la mise en forme de chaîne autorisée pour la nouvelle date (valeur), nous devons regarder la méthode Date.parse (chaîne). La documentation de cette méthode peut être trouvée ici:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

Et nous pouvons en outre déduire que les dates devraient être dans un format étendu ISO 8601 modifié, comme spécifié ici:

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

Cependant, nous pouvons reconnaître par expérience que l'objet Date de javascript accepte d'autres formats (imposés par l'existence de cette question en premier lieu), ce qui est correct car ECMAScript permet des formats spécifiques à l'implémentation. Cependant, cela ne répond toujours pas à la question de savoir quelle documentation est disponible sur les formats disponibles, ni quels formats sont réellement autorisés. Nous allons regarder l'implémentation javascript de Google, V8; S'il vous plaît noter que je ne suggère pas que c'est le "meilleur" moteur JavaScript (comment peut-on définir "meilleur" ou même "bon") et on ne peut pas supposer que les formats autorisés dans V8 représentent tous les formats disponibles aujourd'hui, mais je pense supposer qu'ils suivent les attentes modernes.

V8 de Google, date.js, DateConstructor

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

En regardant la fonction DateConstructor, nous pouvons déduire que nous devons trouver la fonction DateParse; cependant, notez que "année" n'est pas l'année réelle et n'est qu'une référence au paramètre "année".

Google V8, date.js, DateParse

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

Cela appelle% DateParseString, qui est en fait une référence de fonction d'exécution pour une fonction C ++. Il se réfère au code suivant:

Google V8, runtime.cc,% DateParseString

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

L'appel de la fonction qui nous intéresse dans cette fonction est pour DateParser :: Parse (); ignorez la logique entourant ces appels de fonction, ce sont juste des vérifications pour se conformer au type d'encodage (ASCII et UC16). DateParser :: Parse est défini ici:

Google V8, dateparser-inl.h, DateParser :: Parse

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

C'est la fonction qui définit réellement quels formats il accepte. Essentiellement, il vérifie la norme EMCAScript 5.0 ISO 8601 et s'il n'est pas conforme aux normes, il tente de construire la date en fonction des formats hérités. Quelques points clés basés sur les commentaires:

  1. Les mots avant le premier nombre qui sont inconnus à l'analyseur sont ignorés.
  2. Le texte entre parenthèses est ignoré.
  3. Les nombres non signés suivis de ":" sont interprétés comme un "composant de temps".
  4. Les nombres non signés suivis de "." Sont interprétés comme un "composant de temps" et doivent être suivis en millisecondes.
  5. Les chiffres signés suivis de l'heure ou de la minute (par exemple +5: 15 ou +0515) sont interprétés comme le fuseau horaire.
  6. Lorsque vous déclarez l'heure et la minute, vous pouvez utiliser "hh: mm" ou "hhmm".
  7. Les mots qui indiquent un fuseau horaire sont interprétés comme un fuseau horaire.
  8. Tous les autres nombres sont interprétés comme des "composants de date".
  9. Tous les mots commençant par les trois premiers chiffres d'un mois sont interprétés comme le mois.
  10. Vous pouvez définir des minutes et des heures dans l'un des deux formats: "hh: mm" ou "hhmm".
  11. Les symboles tels que "+", "-" et "" non apparié ")" ne sont pas autorisés après qu'un nombre a été traité.
  12. Les éléments qui correspondent à plusieurs formats (par exemple 1970-01-01) sont traités comme une chaîne conforme à la norme ISO 8601 EMCAScript 5.0 conforme.

Cela devrait donc suffire à vous donner une idée de base de ce à quoi il faut s'attendre quand il s'agit de passer une chaîne dans un objet Date. Vous pouvez approfondir cette question en examinant la spécification suivante, pointée par Mozilla sur le réseau de développeurs Mozilla (conforme aux horodatages de l'IETF RFC 2822):

http://tools.ietf.org/html/rfc2822#page-14

Le Microsoft Developer Network mentionne en outre une norme supplémentaire pour l'objet Date: ECMA-402, la spécification d'ECMAScript Internationalization API, qui est complémentaire au standard ECMAScript 5.1 (et futurs). Cela peut être trouvé ici:

http://www.ecma-international.org/ecma-402/1.0/

Dans tous les cas, ceci devrait aider à mettre en évidence qu'il n'y a pas de "documentation" qui représente universellement toutes les implémentations de javascript, mais il y a encore suffisamment de documentation pour comprendre les chaînes acceptables pour un objet Date. Tout à fait la question chargée quand vous y pensez, oui? : P

Les références

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

http://tools.ietf.org/html/rfc2822#page-14

http://www.ecma-international.org/ecma-402/1.0/

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Ressources

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

http://msdn.microsoft.com/en-us/library/ff743760(v=vs.94).aspx


J'ai fait ce formateur très simple, c'est cut / n / pastable (Mis à jour avec une version plus récente):

function DateFmt(fstr) {
  this.formatString = fstr

  var mthNames = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  var dayNames = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var zeroPad = function(number) {
     return ("0"+number).substr(-2,2);
  }

  var dateMarkers = {
    d:['getDate',function(v) { return zeroPad(v)}],
    m:['getMonth',function(v) { return zeroPad(v+1)}],
    n:['getMonth',function(v) { return mthNames[v]; }],
    w:['getDay',function(v) { return dayNames[v]; }],
    y:['getFullYear'],
    H:['getHours',function(v) { return zeroPad(v)}],
    M:['getMinutes',function(v) { return zeroPad(v)}],
    S:['getSeconds',function(v) { return zeroPad(v)}],
    i:['toISOString']
  };

  this.format = function(date) {
    var dateTxt = this.formatString.replace(/%(.)/g, function(m, p) {
      var rv = date[(dateMarkers[p])[0]]()

      if ( dateMarkers[p][1] != null ) rv = dateMarkers[p][1](rv)

      return rv

    });

    return dateTxt
  }

}

fmt = new DateFmt("%w %d:%n:%y - %H:%M:%S  %i")
v = fmt.format(new Date())

http://snipplr.com/view/66968.82825/


Just to continue gongzhitaao's solid answer - this handles AM/PM

 Date.prototype.format = function (format) //author: meizz
{
    var hours = this.getHours();
    var ttime = "AM";
    if(format.indexOf("t") > -1 && hours > 12)
    {
        hours = hours - 12;
        ttime = "PM";
     }

var o = {
    "M+": this.getMonth() + 1, //month
    "d+": this.getDate(),    //day
    "h+": hours,   //hour
    "m+": this.getMinutes(), //minute
    "s+": this.getSeconds(), //second
    "q+": Math.floor((this.getMonth() + 3) / 3),  //quarter
    "S": this.getMilliseconds(), //millisecond,
    "t+": ttime
}

if (/(y+)/.test(format)) format = format.replace(RegExp.$1,
  (this.getFullYear() + "").substr(4 - RegExp.$1.length));
for (var k in o) if (new RegExp("(" + k + ")").test(format))
    format = format.replace(RegExp.$1,
      RegExp.$1.length == 1 ? o[k] :
        ("00" + o[k]).substr(("" + o[k]).length));
return format;
}

Assurez-vous de Datejs à Datejs lorsque vous traitez des dates en JavaScript. C'est assez impressionnant et bien documenté comme vous pouvez le voir dans le cas de la fonction toString .

EDIT : Tyler Forsythe fait remarquer que cette date est obsolète. Je l'utilise dans mon projet actuel et je n'ai eu aucun problème avec cela, cependant vous devriez être conscient de cela et envisager des alternatives.


I was unable to find any definitive documentation on valid date formats so I wrote my own test to see what is supported in various browsers.

http://blarg.co.uk/blog/javascript-date-formats

My results concluded the following formats are valid in all browsers that I tested (examples use the date "9th August 2013"):

[Full Year]/[Month]/[Date number] - Month can be either the number with or without a leading zero or the month name in short or long format, and date number can be with or without a leading zero.

  • 2013/08/09
  • 2013/08/9
  • 2013/8/09
  • 2013/8/9
  • 2013/August/09
  • 2013/August/9
  • 2013/Aug/09
  • 2013/Aug/9

[Month]/[Full Year]/[Date Number] - Month can be either the number with or without a leading zero or the month name in short or long format, and date number can be with or without a leading zero.

  • 08/2013/09
  • 08/2013/9
  • 8/2013/09
  • 8/2013/9
  • August/2013/09
  • August/2013/9
  • Aug/2013/09
  • Aug/2013/9

Any combination of [Full Year], [Month Name] and [Date Number] separated by spaces - Month name can be in either short or long format, and date number can be with or without a leading zero.

  • 2013 August 09
  • August 2013 09
  • 09 August 2013
  • 2013 Aug 09
  • Aug 9 2013
  • 2013 9 Aug
  • etc...

Also valid in "modern browsers" (or in other words all browsers except IE9 and below)

[Full Year]-[Month Number]-[Date Number] - Month and Date Number must include leading zeros (this is the format that the MySQL Date type uses)

  • 2013-08-09

Using month names:
Interestingly, when using month names I discovered that only the first 3 characters of the month name are ever used so all the of the following are perfectly valid:

new Date('9 August 2013');
new Date('9 Aug 2013');
new Date('9 Augu 2013');
new Date('9 Augustagfsdgsd 2013');

Fonction de formatage personnalisée:

Pour les formats fixes, une simple fonction fait le travail. L'exemple suivant génère le format international AAAA-MM-JJ:

function dateToYMD(date) {
    var d = date.getDate();
    var m = date.getMonth() + 1;
    var y = date.getFullYear();
    return '' + y + '-' + (m<=9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
}

Note: Cependant, il n'est généralement pas judicieux d'étendre les librairies standards Javascript (par exemple en ajoutant cette fonction au prototype de Date).

Une fonction plus avancée pourrait générer une sortie configurable basée sur un paramètre de format. Il y a quelques bons exemples dans cette même page.

Si écrire une fonction de formatage est trop long, il existe de nombreuses bibliothèques autour desquelles le faire. D'autres réponses les énumèrent déjà. Mais l'augmentation des dépendances a aussi son contre-partie.

Fonctions de formatage ECMAScript standard:

Depuis les versions plus récentes d'ECMAscript, la classe Date possède des fonctions de formatage spécifiques:

toDateString : dépend de l'implémentation, affiche uniquement la date.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.todatestring

new Date().toDateString(); // e.g. "Fri Nov 11 2016"

toISOString : Afficher la date et l'heure ISO 8601.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.toisostring

new Date().toISOString(); // e.g. "2016-11-21T08:00:00.000Z"

toJSON : Stringifier pour JSON.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tojson

new Date().toJSON(); // e.g. "2016-11-21T08:00:00.000Z"

toLocaleDateString : dépend de l'implémentation, une date au format locale.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaledatestring

new Date().toLocaleDateString(); // e.g. "21/11/2016"

toLocaleString : dépend de l'implémentation, date et heure au format locale.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocalestring

new Date().toLocaleString(); // e.g. "21/11/2016, 08:00:00 AM"

toLocaleTimeString : dépend de l'implémentation, une heure au format locale.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaletimestring

new Date().toLocaleTimeString(); // e.g. "08:00:00 AM"

toString : toString générique pour la date.

http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tostring

new Date().toString(); // e.g. "Fri Nov 11 2016 08:00:00 GMT+0100 (W. Europe Standard Time)"

Remarque: il est possible de générer des sorties personnalisées à partir de ces fonctions de formatage:

new Date().toISOString().slice(0,10); // By @Image72, return YYYY-MM-DD

Si vous utilisez déjà jQuery UI dans votre projet, vous pouvez utiliser la méthode intégrée datepicker pour formater votre objet date:

$.datepicker.formatDate('yy-mm-dd', new Date(2007, 1 - 1, 26));

Cependant, le programme datepicker ne formate que les dates et ne peut pas formater les heures.

Jetez un oeil à jQuery UI datepicker formatDate , les exemples.


All browsers

The most reliable way to format a date with the source format you're using, is to apply the following steps :

  1. Use new Date() to create a Date object
  2. Use .getDate() , .getMonth() and .getFullYear() to get respectively the day, month and year
  3. Paste the pieces together according to your target format

Exemple :

var date = '2015-11-09T10:46:15.097Z';

function format(input) {
    var date = new Date(input);
    return [
       ("0" + date.getDate()).slice(-2),
       ("0" + (date.getMonth()+1)).slice(-2),
       date.getFullYear()
    ].join('/');
}

document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

(See also this Fiddle ).

Modern browsers only

You can also use the built-in .toLocaleDateString method to do the formatting for you. You just need pass along the proper locale and options to match the right format, which unfortunately is only supported by modern browsers (*) :

var date = '2015-11-09T10:46:15.097Z';

function format(input) {
    return new Date(input).toLocaleDateString('en-GB', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit'
    });
}

document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

(See also this Fiddle ).

(*) According to the MDN , "Modern browsers" means Chrome 24+, Firefox 29+, IE11, Edge12+, Opera 15+ & Safari nightly build


Voici une fonction que j'utilise beaucoup. Le résultat est aaaa-mm-jj hh: mm: ss.nnn.

function date_and_time() {
    var date = new Date();
    //zero-pad a single zero if needed
    var zp = function (val){
        return (val <= 9 ? '0' + val : '' + val);
    }

    //zero-pad up to two zeroes if needed
    var zp2 = function(val){
        return val <= 99? (val <=9? '00' + val : '0' + val) : ('' + val ) ;
    }

    var d = date.getDate();
    var m = date.getMonth() + 1;
    var y = date.getFullYear();
    var h = date.getHours();
    var min = date.getMinutes();
    var s = date.getSeconds();
    var ms = date.getMilliseconds();
    return '' + y + '-' + zp(m) + '-' + zp(d) + ' ' + zp(h) + ':' + zp(min) + ':' + zp(s) + '.' + zp2(ms);
}


Formatting and especially parsing dates in JavaScript can be a bit of a headache. Not all browsers handle dates in the same way. So while it's useful to know the base methods, its more practical to use a helper library.

The XDate javascript library by Adam Shaw has been around since mid-2011 and is still under active development. It has fantastic documentation, a great API, formatting, tries to remain backwards-compatible and even supports localized strings.

Link to changing the locale strings: https://gist.github.com/1221376


Personally, because I use both PHP and jQuery/javascript in equal measures, I use the date function from php.js http://phpjs.org/functions/date/

Using a library that uses the same format strings as something I already know is easier for me, and the manual containing all of the format string possibilities for the date function is of course online at php.net

You simply include the date.js file in your HTML using your preferred method then call it like this:

var d1=new Date();
var datestring = date('Y-m-d', d1.valueOf()/1000);

You can use d1.getTime() instead of valueOf() if you want, they do the same thing.

The divide by 1000 of the javascript timestamp is because a javascript timestamp is in miliseconds but a PHP timestamp is in seconds.


The library sugar.js has some great functionality for working with dates in JavaScript. And it is very well documented .

Sugar gives the Date class much love starting with the Date.create method which can understand dates in just about any format in 15 major languages, including relative formats like "1 hour ago". Dates can also be output in any format or language using an easy to understand syntax, with shortcuts to commonly used date formats. Complex date comparison is also possible with methods like is, which understand any format and apply built in precision.

A few examples:

Date.create('July 4, 1776')  -> July 4, 1776
Date.create(-446806800000)   -> November 5, 1955
Date.create(1776, 6, 4)      -> July 4, 1776
Date.create('1776年07月04日', 'ja') -> July 4, 1776
Date.utc.create('July 4, 1776', 'en')  -> July 4, 1776

Date.create().format('{Weekday} {d} {Month}, {yyyy}')    -> Monday July 4, 2003
Date.create().format('{hh}:{mm}')                        -> 15:57
Date.create().format('{12hr}:{mm}{tt}')                  -> 3:57pm
Date.create().format(Date.ISO8601_DATETIME)              -> 2011-07-05 12:24:55.528Z

Date.create().is('the 7th of June') -> false
Date.create().addMonths(2); ->"Sunday, June 15, 2014 13:39"

momentjs

Il s'agit d'une bibliothèque de date (légère) * JavaScript pour l'analyse, la manipulation et la mise en forme des dates.

var a = moment([2010, 1, 14, 15, 25, 50, 125]);
a.format("dddd, MMMM Do YYYY, h:mm:ss a"); // "Sunday, February 14th 2010, 3:25:50 pm"
a.format("ddd, hA");                       // "Sun, 3PM"

(*) poids léger 9.3KB minifié + gzippé dans la plus petite configuration possible (feb 2014)


La fonctionnalité que vous citez n'est pas standard Javascript, pas susceptible d'être portable dans les navigateurs et donc pas une bonne pratique. La spécification ECMAScript 3 laisse les formats d'analyse et de sortie fonctionner jusqu'à l'implémentation Javascript. ECMAScript 5 ajoute un sous-ensemble du support ISO8601. Je crois que la fonction toString () que vous mentionnez est une innovation dans un navigateur (Mozilla?)

Plusieurs bibliothèques fournissent des routines pour paramétrer ceci, certaines avec un support de localisation étendu. Vous pouvez également consulter les méthodes dans dojo.date.locale .





date