J'ai remarqué que la new Date()fonction 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 trouvé aucune documentation montrant tous les formats de chaîne valides lors de l'appel de la new Date()fonction.

C'est pour convertir une chaîne en une 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 formater un objet date en chaîne.

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

Aujourd'hui, j'ai joué avec la toString()méthode sur l'objet date et, étonnamment, elle sert à formater la date aux 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 dont nous pouvons formater l'objet date dans une chaîne.

Où est la documentation qui répertorie les spécificateurs de format pris en charge par l' Date()objet?

J'adore 10 façons de formater l'heure et la date à l'aide de JavaScript et de l'utilisation des dates .

Fondamentalement, vous avez trois méthodes et vous devez combiner les chaînes pour vous-même:

getDate() // Returns the date
getMonth() // Returns the month
getFullYear() // Returns the year

Exemple:

var d = new Date();
var curr_date = d.getDate();
var curr_month = d.getMonth() + 1; //Months are zero based
var curr_year = d.getFullYear();
console.log(curr_date + "-" + curr_month + "-" + curr_year);

Moment.js

Il s'agit d'une bibliothèque de dates JavaScript (légère) * pour l'analyse, la manipulation et le formatage 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"

(*) léger signifiant 9,3 Ko minifié + compressé dans la plus petite configuration possible (fév 2014)

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 sélecteur de date ne met en forme que les dates et ne peut pas formater les heures.

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

Où est la documentation qui répertorie les spécificateurs de format pris en charge par l' Date()objet?

Je suis tombé sur ce sujet aujourd'hui et j'ai été très surpris que personne n'ait pris le temps de répondre à cette simple question. Certes, il existe de nombreuses bibliothèques pour aider à la manipulation de la date. Certains sont meilleurs que d'autres. Mais ce n'était pas la question posée.

AFAIK, JavaScript pur ne prend pas en charge les spécificateurs de format de la manière dont vous avez indiqué que vous souhaitez les utiliser . Mais il fait des méthodes de soutien pour le formatage des dates et / ou temps, tels que .toLocaleDateString(), .toLocaleTimeString()et.toUTCString() .

La Dateréférence d'objet que j'utilise le plus souvent se trouve sur le site w3schools.com (mais une recherche rapide sur Google en révèlera bien d'autres qui pourraient mieux répondre à vos besoins).

Notez également que la section Propriétés de l'objet Date fournit un lien vers prototype, qui illustre certaines façons d'étendre l'objet Date avec des méthodes personnalisées. Il y a eu un débat au sein de la communauté JavaScript au fil des ans sur la question de savoir s'il s'agit ou non de la meilleure pratique, et je ne plaide pas pour ou contre, juste pour souligner son existence.

Fonction de formatage personnalisé:

Pour les formats fixes, une fonction simple fait l'affaire. 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);
}

Remarque: Cependant, ce n'est généralement pas une bonne idée d'étendre les bibliothèques standard 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 y a beaucoup de bibliothèques autour desquelles cela se fait. Quelques autres réponses les énumèrent déjà. Mais l'augmentation des dépendances a également sa contrepartie.

Fonctions de formatage ECMAScript standard:

Depuis les versions plus récentes d'ECMAscript, la Dateclasse a 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 : affiche 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 local.

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, une date et une heure au format local.

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 local.

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 une sortie personnalisée à partir de ces fonctions de formatage:

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

La réponse courte

Il n'y a pas de documentation «universelle» à laquelle javascript s'adresse; chaque navigateur qui a javascript est vraiment une implémentation. Cependant, il existe une norme que la plupart des navigateurs 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 y a une deuxième norme établie par l' IETF que les navigateurs ont tendance à suivre également, qui est la définition des horodatages faite dans la 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 à des fonctionnalités de base, mais ce qui «devrait» ne pas être intrinsèquement ce qui «est». Je vais cependant approfondir cette procédure, car il semble que seules trois personnes ont répondu à la question (Scott, goofballLogic et Peller notamment), ce qui, pour moi, suggère que la plupart des gens ne savent pas ce qui se passe réellement lorsque vous créer un objet Date.

La réponse longue

Où est la documentation qui répertorie les spécificateurs de format pris en charge par l'objet Date ()?

Pour répondre à la question, ou même généralement chercher la réponse à cette question, vous devez savoir que javascript n'est pas une langue nouvelle; il s'agit en fait d'une implémentation d'ECMAScript et suit les normes ECMAScript (mais notez que javascript est également antérieur à ces normes; les normes EMCAScript sont construites à partir de l'implémentation précoce 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 a été publiée peu de temps après la publication à la fin de 2009. Cela devrait indiquer un problème; quelle norme une implémentation javascript peut suivre, peut ne pas refléter ce qui est réellement en place, car a) c'est une implémentation d'une norme donnée, b) toutes les implémentations d'une norme ne sont pas puritaines,

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). Par exemple, le V8 de Google implémente ECMAScript 5.0, mais JScript d'Internet Explorer ne tente de se conformer à aucune norme ECMAScript, mais Internet Explorer 9 est conforme à ECMAScript 5.0.

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

new Date(value)

Lorsque deux ou plusieurs arguments sont passés à new Date (), il convertit 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 quantifie comme un «format de date» acceptable nécessite des explications supplémentaires. Lorsque vous passez une chaîne à new Date (), il appellera le prototype (notez que j'utilise le mot prototype de façon lâche; les versions peuvent être des fonctions individuelles ou faire partie d'une instruction conditionnelle dans une seule fonction) pour new Date (valeur) avec votre chaîne comme argument pour le paramètre «value». Cette fonction vérifiera d'abord s'il s'agit d'un nombre ou d'une chaîne. La documentation de cette fonction se trouve ici:

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

De cela, nous pouvons déduire que pour obtenir le formatage de chaîne autorisé pour la nouvelle date (valeur), nous devons examiner la méthode Date.parse (chaîne). La documentation de cette méthode se trouve ici:

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

Et nous pouvons en 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é par l'existence de cette question en premier lieu), et cela ne pose pas de problème car ECMAScript permet la mise en œuvre de formats spécifiques. 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 examiner l'implémentation javascript de Google, V8; veuillez noter que je ne suggère pas que ce soit 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 que c'est juste à supposer qu'ils suivent les attentes modernes.

Google V8, 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 fait référence 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 fonction qui nous intéresse dans cette fonction est pour DateParser :: Parse (); ignorer la logique entourant ces appels de fonction, ce ne sont que des vérifications pour se conformer au type de codage (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 les formats qu'elle accepte. Essentiellement, il vérifie la norme EMCAScript 5.0 ISO 8601 et s'il n'est pas conforme aux normes, il tentera de construire la date en fonction des formats hérités. Quelques points clés sur la base des commentaires:

1. Les mots avant le premier nombre inconnus de 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 une «composante temporelle».
4. Chiffres non signés suivis de "." sont interprétés comme une «composante temporelle» et doivent être suivis de millisecondes.
5. Les nombres signés suivis de l'heure ou des minutes (par exemple +5: 15 ou +0515) sont interprétés comme le fuseau horaire.
6. Lors de la déclaration des heures et des minutes, 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 les minutes et les heures ensemble dans l'un des deux formats: «hh: mm» ou «hhmm».
11. Les symboles comme "+", "-" et sans correspondance ")" ne sont pas autorisés après le traitement d'un numéro.
12. Les éléments qui correspondent à plusieurs formats (par exemple, le 01/01/1970) sont traités comme une chaîne conforme à la norme EMCAScript 5.0 ISO 8601.

Cela devrait donc être suffisant pour vous donner une idée de base de ce à quoi vous attendre quand il s'agit de passer une chaîne dans un objet Date. Vous pouvez développer cela en consultant les spécifications suivantes que Mozilla pointe sur le réseau de développeurs Mozilla (conformes aux horodatages 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 ECMAScript Internationalization API, qui complète la norme ECMAScript 5.1 (et les futures). Cela peut être trouvé ici:

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

Dans tous les cas, cela devrait aider à souligner 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 disponible pour donner un sens raisonnable aux chaînes acceptables pour un objet Date. Une question assez chargée quand on y pense, oui? : P

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

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

Assurez-vous de vérifier 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 souligne que datejs est obsolète. Je l'utilise dans mon projet actuel et je n'ai eu aucun problème avec cela, mais vous devez en être conscient et envisager des alternatives.

Vous pouvez simplement développer l' Dateobjet avec une nouvelle formatméthode comme l'a noté 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"));

La fonctionnalité que vous citez n'est pas du Javascript standard, il est peu probable qu'elle soit portable sur tous les navigateurs et n'est donc pas une bonne pratique. La spécification ECMAScript 3 laisse la fonction d'analyse et de format de sortie à l'implémentation Javascript. ECMAScript 5 ajoute un sous-ensemble de prise en charge ISO8601. Je pense que la fonction toString () que vous mentionnez est une innovation dans un navigateur (Mozilla?)

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

J'ai fait ce formateur très simple, il est coupé / n / collable (mis à jour avec une version plus soignée):

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/

Cadre gratuit, 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"

DateJS est certainement complet, mais je recommanderais cette librairie BEAUCOUP plus simple (format de date JavaScript) que je préfère simplement parce que ce n'est que 120 lignes environ.

Après avoir 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 également 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"));

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);
}

Vous pouvez trouver utile cette modification de l'objet date, qui est plus petite que n'importe quelle bibliothèque et est facilement extensible pour prendre en charge différents formats:

REMARQUE:

• Il utilise Object.keys () qui n'est pas défini dans les anciens navigateurs, vous devrez donc peut-être implémenter le polyfill à partir d'un lien donné.

CODE

Date.prototype.format = function(format) {
    // set default format if function argument not provided
    format = format || 'YYYY-MM-DD hh:mm';

    var zeropad = function(number, length) {
            number = number.toString();
            length = length || 2;
            while(number.length < length)
                number = '0' + number;
            return number;
        },
        // here you can define your formats
        formats = {
            YYYY: this.getFullYear(),
            MM: zeropad(this.getMonth() + 1),
            DD: zeropad(this.getDate()),
            hh: zeropad(this.getHours()),
            mm: zeropad(this.getMinutes())
        },
        pattern = '(' + Object.keys(formats).join(')|(') + ')';

    return format.replace(new RegExp(pattern, 'g'), function(match) {
        return formats[match];
    });
};

UTILISATION

var now = new Date;
console.log(now.format());
// outputs: 2015-02-09 11:47
var yesterday = new Date('2015-02-08');
console.log(yesterday.format('hh:mm YYYY/MM/DD'));
// outputs: 00:00 2015/02/08

Juste pour continuer la réponse solide de Gongzhitaao - cela gère 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;
}

Je n'ai pas pu trouver de documentation définitive sur les formats de date valides, j'ai donc écrit mon propre test pour voir ce qui est pris en charge dans divers navigateurs.

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

Mes résultats ont conclu que les formats suivants sont valables dans tous les navigateurs que j'ai testés (les exemples utilisent la date "9 août 2013"):

[Année complète] / [Mois] / [Numéro de date] - Le mois peut être le nombre avec ou sans zéro non significatif ou le nom du mois en format court ou long, et le numéro de date peut être avec ou sans zéro non significatif.

• 2013/08/09
• 2013/08/9
• 2013/8/09
• 2013/8/9
• 2013 / août / 09
• 2013 / août / 9
• 2013 / août / 09
• 2013 / août / 9

[Mois] / [Année complète] / [Numéro de date] - Le mois peut être le nombre avec ou sans zéro non significatif ou le nom du mois en format court ou long, et le numéro de date peut être avec ou sans zéro non significatif.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• Août / 2013/09
• Août / 2013/9
• Août / 2013/09
• Août / 2013/9

Toute combinaison de [Année complète], [Nom du mois] et [Numéro de date] séparés par des espaces - Le nom du mois peut être au format court ou long, et le numéro de la date peut être avec ou sans zéro non significatif.

• 09 août 2013
• Août 2013 09
• 09 août 2013
• 09 août 2013
• 9 août 2013
• 2013 9 août
• etc...

Également valable dans les "navigateurs modernes" (ou en d'autres termes tous les navigateurs sauf IE9 et inférieurs)

[Année complète] - [Numéro de mois] - [Numéro de date] - Le numéro de mois et de date doit inclure des zéros non significatifs (c'est le format utilisé par le type de date MySQL )

• 2013-08-09

Utilisation des noms de mois:
Fait intéressant, lorsque j'ai utilisé des noms de mois, j'ai découvert que seuls les 3 premiers caractères du nom de mois sont utilisés, de sorte que tous les éléments suivants sont parfaitement valides:

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

Le formatage et en particulier l'analyse des dates en JavaScript peut être un peu un casse-tête. Tous les navigateurs ne traitent pas les dates de la même manière. Ainsi, bien qu'il soit utile de connaître les méthodes de base, il est plus pratique d'utiliser une bibliothèque d'assistance.

La bibliothèque javascript XDate par Adam Shaw existe depuis la mi-2011 et est toujours en développement actif. Il a une documentation fantastique, une excellente API, un formatage, essaie de rester rétrocompatible et prend même en charge les chaînes localisées.

Lien pour changer les chaînes de paramètres régionaux: https://gist.github.com/1221376

Exemple de code:

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

Production:

"13:45:20"

La bibliothèque sugar.js a de grandes fonctionnalités pour travailler avec des dates en JavaScript. Et c'est très bien documenté .

Sugar donne beaucoup d'amour à la classe Date en commençant par la méthode Date.create qui peut comprendre les dates dans à peu près n'importe quel format dans 15 langues principales, y compris des formats relatifs comme "il y a 1 heure". Les dates peuvent également être sorties dans n'importe quel format ou langue en utilisant une syntaxe facile à comprendre, avec des raccourcis vers les formats de date couramment utilisés. La comparaison de dates complexes est également possible avec des méthodes comme is, qui comprennent tous les formats et appliquent une précision intégrée.

Quelques exemples:

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"

Tous les navigateurs

La façon la plus fiable de formater une date avec le format source que vous utilisez est d'appliquer les étapes suivantes:

1. Utilisez new Date()pour créer unDate objet
2. Utiliser .getDate(), .getMonth()et.getFullYear() pour obtenir respectivement le jour, le mois et l'année
3. Collez les morceaux ensemble selon votre format cible

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

(Voir aussi ce violon ).

Navigateurs modernes uniquement

Vous pouvez également utiliser la .toLocaleDateStringméthode intégrée pour effectuer le formatage pour vous. Vous avez juste besoin de transmettre les paramètres régionaux et les options appropriés pour correspondre au bon format, qui n'est malheureusement pris en charge que par les navigateurs modernes (*) :

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

(Voir aussi ce violon ).

(*) Selon le MDN , "navigateurs modernes" signifie Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ et Safari tous les soirs

Juste une autre option, que j'ai écrite:

Bibliothèque DP_DateExtensions

Je ne sais pas si cela vous aidera, mais je l'ai trouvé utile dans plusieurs projets - il semble qu'il fera ce dont vous avez besoin.

Prend en charge le formatage de la date et de l'heure, les calculs de date (ajouter / soustraire des parties de date), la comparaison de date, l'analyse de date, etc.

Aucune raison de le considérer si vous utilisez déjà un framework (ils sont tous capables), mais si vous avez juste besoin d'ajouter rapidement une manipulation de date à un projet, donnez-lui une chance.

Si vous souhaitez afficher uniquement l'heure avec deux chiffres, cela peut vous aider:

var now = new Date();
var cHour = now.getHours();
var cMinuts = now.getMinutes();
var cSeconds = now.getSeconds();

var outStr = (cHour <= 0 ? ('0' + cHour) : cHour) + ':' + (cMinuts <= 9 ? ('0' + cMinuts) : cMinuts) + ':' + (cSeconds <= 9 ? '0' + cSeconds : cSeconds);

utiliser ces fonctions

toTimeString() and toLocaleDateString()

reportez-vous au lien ci-dessous pour plus de détails https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat est une bibliothèque qui peut formater l'objet date et réanalyser la chaîne formatée en objet Date. Il utilise le format Java (classe SimpleDateFormat). Le nom des mois et des jours peut être localisé.

Exemple:

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

La réponse est "nulle part" puisque le formatage de la date est une fonctionnalité propriétaire. Je ne pense pas que les fonctions toString soient conçues pour se conformer à un format spécifique. Par exemple, dans la spécification ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, page 173), la fonction toString est documentée comme suit :

"Le contenu de la chaîne dépend de l'implémentation"

Des fonctions telles que les exemples ci-dessous peuvent être utilisées pour effectuer un formatage assez facilement.

function pad(toPad, padWith) {
    return (String(padWith) + String(toPad)).slice(-1 * padWith.length);
}

function dateAsInputValue(toFormat) {
    if(!(toFormat instanceof Date)) return null;
    return toFormat.getFullYear() + "-" + pad(toFormat.getMonth() + 1, "00") + "-" + pad(toFormat.getDate(), "00");
}

function timeAsInputValue(toFormat) {
    if(!(toFormat instanceof Date)) return null;        
    return pad(toFormat.getHours(), "00") + ":" + pad(toFormat.getMinutes(), "00") + ":" + pad(toFormat.getSeconds(), "00");
}

Si vous n'avez pas besoin de toutes les fonctionnalités fournies par une bibliothèque comme Moment.js , vous pouvez utiliser mon port de strftime . Il est léger (1,35 Ko contre 57,9 Ko minimisé par rapport à Moment.js 2.15.0) et fournit la plupart des fonctionnalités de strftime().

/* Port of strftime(). Compatibility notes:
 *
 * %c - formatted string is slightly different
 * %D - not implemented (use "%m/%d/%y" or "%d/%m/%y")
 * %e - space is not added
 * %E - not implemented
 * %h - not implemented (use "%b")
 * %k - space is not added
 * %n - not implemented (use "\n")
 * %O - not implemented
 * %r - not implemented (use "%I:%M:%S %p")
 * %R - not implemented (use "%H:%M")
 * %t - not implemented (use "\t")
 * %T - not implemented (use "%H:%M:%S")
 * %U - not implemented
 * %W - not implemented
 * %+ - not implemented
 * %% - not implemented (use "%")
 *
 * strftime() reference:
 * http://man7.org/linux/man-pages/man3/strftime.3.html
 *
 * Day of year (%j) code based on Joe Orost's answer:
 * http://stackoverflow.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
 *
 * Week number (%V) code based on Taco van den Broek's prototype:
 * http://techblog.procurios.nl/k/news/view/33796/14863/calculate-iso-8601-week-and-year-in-javascript.html
 */
function strftime(sFormat, date) {
  if (!(date instanceof Date)) date = new Date();
  var nDay = date.getDay(),
    nDate = date.getDate(),
    nMonth = date.getMonth(),
    nYear = date.getFullYear(),
    nHour = date.getHours(),
    aDays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
    aMonths = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
    aDayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
    isLeapYear = function() {
      if (nYear&3!==0) return false;
      return nYear%100!==0 || year%400===0;
    },
    getThursday = function() {
      var target = new Date(date);
      target.setDate(nDate - ((nDay+6)%7) + 3);
      return target;
    },
    zeroPad = function(nNum, nPad) {
      return ('' + (Math.pow(10, nPad) + nNum)).slice(1);
    };
  return sFormat.replace(/%[a-z]/gi, function(sMatch) {
    return {
      '%a': aDays[nDay].slice(0,3),
      '%A': aDays[nDay],
      '%b': aMonths[nMonth].slice(0,3),
      '%B': aMonths[nMonth],
      '%c': date.toUTCString(),
      '%C': Math.floor(nYear/100),
      '%d': zeroPad(nDate, 2),
      '%e': nDate,
      '%F': date.toISOString().slice(0,10),
      '%G': getThursday().getFullYear(),
      '%g': ('' + getThursday().getFullYear()).slice(2),
      '%H': zeroPad(nHour, 2),
      '%I': zeroPad((nHour+11)%12 + 1, 2),
      '%j': zeroPad(aDayCount[nMonth] + nDate + ((nMonth>1 && isLeapYear()) ? 1 : 0), 3),
      '%k': '' + nHour,
      '%l': (nHour+11)%12 + 1,
      '%m': zeroPad(nMonth + 1, 2),
      '%M': zeroPad(date.getMinutes(), 2),
      '%p': (nHour<12) ? 'AM' : 'PM',
      '%P': (nHour<12) ? 'am' : 'pm',
      '%s': Math.round(date.getTime()/1000),
      '%S': zeroPad(date.getSeconds(), 2),
      '%u': nDay || 7,
      '%V': (function() {
              var target = getThursday(),
                n1stThu = target.valueOf();
              target.setMonth(0, 1);
              var nJan1 = target.getDay();
              if (nJan1!==4) target.setMonth(0, 1 + ((4-nJan1)+7)%7);
              return zeroPad(1 + Math.ceil((n1stThu-target)/604800000), 2);
            })(),
      '%w': '' + nDay,
      '%x': date.toLocaleDateString(),
      '%X': date.toLocaleTimeString(),
      '%y': ('' + nYear).slice(2),
      '%Y': nYear,
      '%z': date.toTimeString().replace(/.+GMT([+-]\d+).+/, '$1'),
      '%Z': date.toTimeString().replace(/.+\((.+?)\)$/, '$1')
    }[sMatch] || sMatch;
  });
}

Exemple d'utilisation:

strftime('%F'); // Returns "2016-09-15"
strftime('%A, %B %e, %Y'); // Returns "Thursday, September 15, 2016"

// You can optionally pass it a Date object...

strftime('%x %X', new Date('1/1/2016')); // Returns "1/1/2016 12:00:00 AM"

Le dernier code est disponible ici: https://github.com/thdoan/strftime

La bonne façon de formater une date pour renvoyer "29/12/2012" est avec le script du format de date JavaScript :

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

Ce code ne fonctionne PAS:

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

Personnellement, parce que j'utilise à la fois PHP et jQuery / javascript dans des mesures égales, j'utilise la fonction date de php.js http://phpjs.org/functions/date/

Utiliser une bibliothèque qui utilise les mêmes chaînes de format que quelque chose que je connais déjà est plus facile pour moi, et le manuel contenant toutes les possibilités de chaîne de format pour la fonction date est bien sûr en ligne sur php.net

Vous incluez simplement le fichier date.js dans votre HTML en utilisant votre méthode préférée, puis vous l'appelez comme ceci:

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

Vous pouvez utiliser d1.getTime () au lieu de valueOf () si vous le souhaitez, ils font la même chose.

La division par 1 000 de l'horodatage javascript est due au fait qu'un horodatage javascript est en millisecondes mais qu'un horodatage PHP est en secondes.

De nombreux frameworks (que vous utilisez peut-être déjà) ont un formatage de date que vous ne connaissez peut-être pas. jQueryUI a déjà été mentionné, mais d'autres cadres tels que Kendo UI (Globalisation) , Yahoo UI (Util) et AngularJS les ont également.

// 11/6/2000
kendo.toString(new Date(value), "d")

// Monday, November 06, 2000
kendo.toString(new Date(2000, 10, 6), "D")