Où puis-je trouver de la documentation sur le formatage d'une date en JavaScript? [fermé]

https://stackoverflow.com/questions/1056728

20-08-2019
|

Question

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

Ceci est pour convertir une chaîne en une date. Si nous examinons le côté opposé, c’est-à-dire la conversion d’un objet de date en une chaîne, j’avais jusqu’à présent l’impression que JavaScript ne dispose pas d’une API intégrée pour formater un objet de date en chaîne.

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

Aujourd'hui, j'ai joué avec la méthode Date() sur l'objet date et, de manière surprenante, elle 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 manières de formater l'objet de date en chaîne.

Où se trouve la documentation répertoriant les spécificateurs de format pris en charge par l'objet <=>?

La solution

J'aime 10 façons de formater l'heure et la date en utilisant JavaScript et Travailler avec Dates .

En gros, 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);

Autres conseils

Moment.js

C’est une * bibliothèque de dates JavaScript (légère) * 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 signifiant 9,3 Ko minifié + gzippé dans la configuration la plus petite possible (février 2014)

Si vous utilisez déjà l'interface utilisateur jQuery dans votre projet, vous pouvez utiliser la fonction intégrée. méthode datepicker pour formater votre objet de date:

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

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

Consultez le jQuery UI datepicker formatDate , les exemples.

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

Je suis tombé sur cela aujourd'hui et je suis assez surpris que personne ne prenne le temps de répondre à cette simple question. Certes, il existe de nombreuses bibliothèques pour vous aider avec la manipulation de date. Certains sont meilleurs que d'autres. Mais ce n’était pas la question posée.

Ce que je sais, JavaScript pur ne prend pas en charge les spécificateurs de format comme vous avez indiqué que vous souhaitez les utiliser . Mais il prend en charge les méthodes de formatage des dates et / ou des heures, telles que .toLocaleDateString(), .toLocaleTimeString() et .toUTCString().

La Date référence d'objet que j'utilise le plus souvent se trouve sur le site Web w3schools.com (mais une recherche rapide dans Google en révélera de nombreux autres susceptibles de 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 manières d'étendre l'objet Date avec des méthodes personnalisées. Il y a eu un débat sur la communauté JavaScript au cours des années pour savoir si Ce n’est pas une bonne pratique, et je ne prône ni pour ni contre elle, mais pour souligner son existence.

Fonction de mise en forme personnalisée:

Pour les formats fixes, une fonction simple effectue le travail. Les exemples suivants génèrent 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: Toutefois, il n’est généralement pas conseillé d’étendre les bibliothèques Javascript standard (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 le faire. Certaines autres réponses les énumèrent déjà. Mais l’augmentation des dépendances a aussi son pendant.

Fonctions de formatage ECMAScript standard:

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

toDateString : dépend de la mise en oeuvre, affichez 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 : identificateur de chaîne 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 de l'environnement 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 la mise en oeuvre, une date & et de l'heure au format régional.

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 de paramètres régionaux.

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 & # 8220; Universel & # 8221; documentation à laquelle javascript est destiné; 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 & # 8217; 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 une deuxième norme définie par IETF que les navigateurs ont tendance à afficher. À suivre également, qui est la définition des horodatages établie dans la RFC 2822. La documentation actuelle se trouve dans la liste de références en bas.

De là, vous pouvez vous attendre à des fonctionnalités de base, mais qu'est-ce que & # 8220; devrait & # 8221; être n'est pas en soi ce que & # 8220; est & # 8221 ;. Je vais & # 8217; vais approfondir cette procédure, même s’il apparaît que trois personnes seulement ont effectivement répondu à la question (Scott, goofballLogic et peller notamment), ce qui, à mon sens, suggère que la plupart des gens ne sont pas au courant. que se passe-t-il lorsque vous créez un objet Date.

La réponse longue

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 généralement même rechercher la réponse à cette question, vous devez savoir que javascript n'est pas un nouveau langage. il & # 8217; est en fait 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 la première implémentation de LiveScript / JavaScript). La norme ECMAScript actuelle est 5.1 (2011); au moment où la question avait été posée à l'origine (juin & # 8217; 09), le standard était de 3 (4 ont été abandonnées), mais 5 ont été publiées peu de temps après la publication du poste à la fin de 2009. Cela devrait définir 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) il s'agit d'une implémentation d'une norme donnée, b) toutes les implémentations d'une norme ne sont pas puritaines, et c) des fonctionnalités n'est pas publié en synchronisation avec une nouvelle norme comme d) une implémentation est un travail constant

En gros, lorsque vous utilisez du javascript, vous & # 8217; traitez avec un dérivé (javascript spécifique au navigateur) d'une implémentation (le javascript lui-même). La version 8 de Google & # 8217; par exemple, implémente ECMAScript 5.0, mais JScript d’Internet Explorer & # 8217; ne & # 8217; ne tente pas de se conformer à toute norme ECMAScript, mais Internet & Nbsp ; Explorer & Nbsp; 9 est conforme à ECMAScript 5.0.

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

new Date(value)

Lorsque deux arguments ou plus sont passés à new Date (), le prototype de fonction ci-après est lancé:

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

Ces deux fonctions doivent vous paraître familières, mais cela ne répond pas immédiatement à votre question et à ce qui est considéré comme un format de format & # 8220; date acceptable & # 8221; nécessite des explications supplémentaires. Lorsque vous transmettez une chaîne à new Date (), elle appelle le prototype (notez que j'utilise le mot prototype de manière approximative; les versions peuvent être des fonctions individuelles ou faire partie d'un test conditionnel. déclaration dans une seule fonction) pour nouvelle Date (valeur) avec votre chaîne comme argument pour & # 8220; valeur & # 8221; paramètre. Cette fonction va d'abord vérifier s'il s'agit d'un nombre ou d'une chaîne. La documentation de cette fonction est disponible ici:

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

De cela, nous pouvons en déduire que pour obtenir le formatage de chaîne autorisé pour la nouvelle Date (valeur), nous devons examinerla 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 déduire que les dates doivent être dans un format étendu modifié selon ISO 8601, comme spécifié ici:

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

Cependant, nous savons d'expérience que javascript & # 8217; son objet Date accepte d'autres formats (imposés par l'existence de cette question à l'origine), ce qui est correct, car ECMAScript permet l'utilisation de formats spécifiques. Toutefois, cela > n ° 8217 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 & # 8217; examiner l’implémentation javascript de Google & # 8217; V8; veuillez noter que je & # 8217; je ne suggère pas qu'il s'agit du & # 8220; meilleur & # 8221; Moteur javascript (comment définir & # 8220; meilleur & # 8221; ou même & # 8220; bon & # 8221;) et on ne peut supposer que les formats autorisés dans V8 représentent tous les formats disponibles aujourd’hui, mais je pense qu'il est & # 8217; juste de supposer qu'ils répondent aux attentes modernes.

Google & # 8217; s 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 en déduire que nous avons besoin de trouver la fonction DateParse; notez cependant que & # 8220; année & # 8221; n’est pas l’année actuelle et fait uniquement référence à & # 8220; année & # 8221; paramètre.

Google & # 8217; s V8, date.js, DateParse

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

Ceci 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 & # 8217; s V8, runtime.cc,% DateParseString

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

L’appel de fonction auquel nous & # 8217 sont concernés par 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:

V8 de Google, 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 acceptés. Essentiellement, il vérifie la norme EMCAScript 5.0 ISO 8601 et, s’il n’est pas conforme aux normes, il tentera de générer la date en fonction des formats existants. Quelques points clés basés sur les commentaires:

Les mots précédant le premier nombre inconnus de l'analyseur sont ignorés.
Les textes entre parenthèses sont ignorés.
Numéros non signés suivis de & # 8220;: & # 8221; sont interprétées comme une & # 8220; composante temporelle & # 8221;.
Numéros non signés suivis de & # 8220;. & # 8221; sont interprétées en tant que & # 8220; composant horaire & # 8221 ;, et doivent être suivies de millisecondes.
Numéros signés suivis de l'heure ou de l'heure minute (par exemple +5: 15 ou +0515) sont interprétés comme le fuseau horaire.
Lors de la déclaration de l'heure et de la minute, vous pouvez utiliser & # 8220; hh: mm & # 8221; ou & # 8220; hhmm & # 8221;.
Les mots qui indiquent un fuseau horaire sont interprétés comme un fuseau horaire.
Tous les autres nombres sont interprétés comme & # 8220; composants de date & # 8221;.
Tous les mots commençant par les trois premiers chiffres d'un mois sont interprétés comme le mois.
Vous pouvez définir les minutes et les heures ensemble dans l'un des deux formats suivants: & # 8220; hh: mm & # 8221; ou & # 8220; hhmm & # 8221;.
Des symboles tels que & # 8220; + & # 8221 ;, & # 8220; - & # 8220; et sans égal & # 8220;) & # 8221; ne sont pas autorisés après le traitement d'un numéro.
Les éléments correspondant à plusieurs formats (par exemple, 1970-01-01) 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 s'attendre lorsqu'il s'agit de passer une chaîne à un objet Date. Pour en savoir plus, consultez la spécification suivante indiquée par Mozilla sur le réseau de développeurs Mozilla (conforme aux horodatages IETF RFC 2822):

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

Microsoft Developer Network mentionne en outre un standard supplémentaire pour l'objet Date: ECMA-402, spécification API d'internationalisation ECMAScript, complémentaire du standard ECMAScript 5.1 (et de ceux à venir). Cela peut être trouvé ici:

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

Dans tous les cas, cela devrait aider à souligner le fait qu'il n'y a pas de " documentation " cela représente universellement toutes les implémentations de javascript, mais il reste suffisamment de documentation pour donner une idée raisonnable des chaînes acceptables pour un objet Date. Toute la question chargée quand vous y réfléchissez, 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 / Référence / Global_Objects / Date

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

Assurez-vous de bien Datejs lorsque vous utilisez des dates en JavaScript. C'est assez impressionnant et bien documenté, comme vous pouvez le voir avec la fonction toString .

MODIFIER : Tyler Forsythe fait remarquer que cette date est obsolète. Je l’utilise dans mon projet actuel et je n’ai aucun problème avec ce dernier. Toutefois, vous devez en être conscient et envisager des solutions de remplacement.

Vous pouvez simplement développer l'objet Date avec une nouvelle format méthode, 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"));

La fonctionnalité que vous citez n’est pas du Javascript standard, elle n’est probablement pas portable sur les navigateurs et n’est 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 pense 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 étendu de la localisation. Vous pouvez également consulter les méthodes dans dojo.date.locale .

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

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 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"

DateJS est certes complet, mais je vous recommanderais cette bibliothèque beaucoup plus simple (format de date JavaScript) que je préfère tout simplement parce qu’il n’ya que 120 lignes ou plus.

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 d'objet de date, qui est plus petite que n'importe quelle bibliothèque et peut facilement être étendue pour prendre en charge différents formats:

REMARQUE:

Il utilise Object.keys () qui n’est pas défini dans les anciens navigateurs, vous devrez peut-être implémenter 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 ferme 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;
}

Comme je ne pouvais trouver aucune documentation définitive sur les formats de date valides, j’ai écrit mon propre test pour voir ce qui est pris en charge par divers navigateurs.

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

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

[Année complète] / [Mois] / [Date] : le mois peut être le nombre avec ou sans zéro, le nom du mois en format court ou long, 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] / [Date] : le mois peut être le nombre avec ou sans zéro, le nom du mois en format court ou long, 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 date peut être avec ou sans. un zéro non significatif.

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

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

[Année complète] - [Numéro du mois] - [Numéro de la date] - Le mois et le numéro de la date doivent inclure des zéros à gauche (il s'agit du format que le Le type de date MySQL utilise)

2013-08-09

Utilisation des noms de mois:
Fait intéressant, lors de l’utilisation des noms de mois, j’ai découvert que seuls les 3 premiers caractères du nom de mois étaient utilisés. Tous les éléments suivants sont donc parfaitement valables:

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 peuvent être un casse-tête. Tous les navigateurs ne traitent pas les dates de la même manière. Ainsi, s’il est utile de connaître les méthodes de base, il est plus pratique d’utiliser une bibliothèque d’aides.

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

Lien permettant de modifier 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");

Sortie:

& "; 13h45: 20 &";

La bibliothèque sugar.js dispose de fonctionnalités très utiles pour l'utilisation de dates en JavaScript. Et il est très bien documenté .

Sugar donne beaucoup d’amour à la classe Date en commençant par Date.create méthode qui peut comprendre les dates dans à peu près n'importe quel format en 15 majeurs langues, y compris les formats relatifs tels que " il y a 1 heure " ;. Les dates peuvent également être sortie dans n'importe quel format ou langue en utilisant un facile à comprendre syntaxe, avec des raccourcis vers les formats de date couramment utilisés. Date complexe la comparaison est également possible avec des méthodes telles que is, qui comprennent tout formater et appliquer la 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

Le moyen le plus fiable de formater une date avec le format source que vous utilisez consiste à appliquer les étapes suivantes:

Utilisez new Date() pour créer un Date objet
Utilisez .getDate(), .getMonth() et .getFullYear() pour obtenir respectivement le jour, le mois et l'année
Collez les morceaux ensemble en fonction du format de votre 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 méthode intégrée .toLocaleDateString pour effectuer le formatage à votre place. Il vous suffit de transmettre les paramètres régionaux et les options appropriés pour correspondre au bon format, ce 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 , &" Les navigateurs modernes & "; signifie Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ & amp; Safari construction nocturne

Juste une autre option que j'ai écrite:

Bibliothèque DP_DateExtensions

Je ne sais pas si ça va aider, mais je l'ai trouvé utile dans plusieurs projets - on dirait que ça fera tout ce dont vous avez besoin.

Prend en charge le formatage date / heure, le calcul de la date (ajout / soustraction d'éléments de date), la comparaison de date, l'analyse de la date, etc. Le code source est largement ouvert.

Aucune raison de l’envisager 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.

La manière correcte de formater une date pour renvoyer " 2012-12-29 " est avec le script de 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');

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 cette fonction

toTimeString() and toLocaleDateString()

voir le lien ci-dessous pour plus de détails https://developer.mozilla.org/en-US / docs / Web / JavaScript / Référence / Global_Objects / Date

JsSimpleDateFormat est une bibliothèque qui permet de formater le fichier. date et analyser la chaîne formatée en retour à l’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 , 8/02/2013, page 173), la fonction toString est documentée comme suit:

" le contenu de la chaîne dépend de la mise en oeuvre "

Des fonctions telles que les exemples ci-dessous pourraient être utilisées pour réaliser le 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 qu'une bibliothèque comme Moment.js fournit, vous pouvez utiliser mon port de strftime . Il est léger (1,35 Ko contre 57,9 Ko réduit 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

Personnellement, comme j'utilise PHP et jQuery / javascript de manière équivalente, j'utilise la fonction de date de php.js http://phpjs.org/functions/date/

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

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

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 1000 de l'horodatage javascript est due au fait qu'un horodatage javascript est exprimé en millisecondes, mais qu'un horodatage PHP est exprimé en secondes.

De nombreux frameworks (que vous utilisez peut-être déjà) ont un format de date que vous ignorez peut-être. jQueryUI a déjà été mentionné, mais d'autres frameworks tels que de Kendo UI (Globalisation) , Interface utilisateur Yahoo (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")

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow