Où puis-je trouver de la documentation sur le formatage d'une date en JavaScript?
J'ai remarqué que la fonction new Date() 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 ne pouvais trouver aucune documentation indiquant tous les formats de chaîne valides lors de l'appel de la fonction new Date().
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 l’impression que JavaScript n’avait pas d’API intégrée pour formater un objet de date en chaîne.
Note de l'éditeur: L'approche suivante est la tentative du demandeur qui a fonctionné sur un navigateur particulier mais qui non fonctionne 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 toString() sur l'objet de date et, étonnamment, 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 qui répertorie les spécificateurs de format pris en charge par l'objet Date()?
J'aime 10 façons de formater l'heure et la date à l'aide de JavaScript et Utilisation de 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);Il s’agit d’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à 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, datepicker ne formate que les dates et ne peut pas formater les heures.
Jetez un coup d’œil à jQuery UI datepicker formatDate , les exemples.
Où se trouve la documentation qui répertorie les spécificateurs de format pris en charge par l'objet
Date()?
Je suis tombé sur cela aujourd'hui et étais assez surpris que personne n'a pris le temps de répondre à cette question simple. 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.
Autant que je sache, JavaScript pur ne prend pas en charge les spécificateurs de format la façon dont 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 référence à l’objet Date que j’utilise le plus souvent se trouve sur le site Web w3schools.com (mais une recherche rapide dans Google en révélera beaucoup d’autres qui pourraient mieux répondre à vos besoins).
Notez également que la section Date Object Properties fournit un lien vers prototype , qui illustre certaines manières d'étendre l'objet Date à l'aide de méthodes personnalisées. Au fil des ans, il y a eu un débat dans la communauté JavaScript, sur le point de savoir s'il s'agit ou non d'une bonne pratique, et je ne préconise ni pour ni contre elle, mais simplement pour souligner son existence.
Fonction de formatage personnalisé:
Pour les formats fixes, une fonction simple fait 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: Cependant, il n'est généralement pas conseillé 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 le fait. Certaines autres réponses les énumèrent déjà. Mais les dépendances croissantes ont aussi leur contrepartie.
Fonctions de formatage ECMAScript standard:
Depuis les versions les 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: 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 paramètres régionaux.
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 de paramètres régionaux.
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 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’existe pas de documentation "universelle" à 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, 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 une deuxième norme définie par IETF que les navigateurs ont tendance à suivre, ce qui correspond à 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 ce qui devrait être n'est pas ce qui est intrinsèquement. Je vais cependant approfondir un peu cette procédure, car il semble que trois personnes seulement aient réellement répondu à la question (Scott, goofballLogic, et peller notamment), ce qui, à mon avis, suggère que la plupart des gens ne savent pas ce qui se passe réellement créer un objet Date.
La longue réponse
Où se trouve la documentation qui répertorie les spécificateurs de format pris en charge par l'objet Date ()?
Pour répondre à la question, ou généralement même chercher la réponse à cette question, vous devez savoir que javascript n'est pas un nouveau langage. C’est en fait une implémentation d’ECMAScript, qui respecte les normes ECMAScript (mais notez que javascript est également antérieur à ces normes; les normes EMCAScript sont conçues à 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 2009), la norme é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) c’est une implémentation d’une norme donnée, b) toutes les implémentations d’une norme ne sont pas puritaines, et c) les fonctionnalités ne sont pas publiées en synchronisation avec un nouvelle norme comme d) une mise en œuvre est un travail constant
En gros, s’agissant de javascript, il s’agit d’un dérivé (javascript spécifique au navigateur) d’une implémentation (javascript lui-même). La version 8 de Google, par exemple, implémente ECMAScript 5.0, mais le langage JScript d’Internet Explorer ne tente pas de se conformer à une norme ECMAScript, mais Internet Explorer 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 utilisé est le suivant:
new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )
Ces deux fonctions devraient sembler familières, mais cela ne répond pas immédiatement à votre question et ce qui est considéré comme un "format de date" acceptable 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 code conditionnel.) déclaration dans une seule fonction) pour nouvelle Date (valeur) avec votre chaîne comme argument pour le paramètre "valeur". Cette fonction va d'abord vérifier 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
Nous pouvons en 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 peut être trouvée ici:
http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2
Et nous pouvons également en déduire que les dates devraient être dans un format étendu modifié 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 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 l'utilisation de 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 examiner l’implémentation javascript de Google, V8; veuillez noter que je ne suggère pas qu'il s'agisse du "meilleur" moteur javascript (comment définir le "meilleur" ou même le "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 répondent aux attentes modernes.
V8, date.js, DateConstructor de Google
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 devons trouver la fonction DateParse; Toutefois, notez que "année" n'est pas l'année réelle et constitue uniquement une référence au paramètre "année".
V8, date.js, DateParse de Google
https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#27
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:
V8, runtime.cc,% DateParseString de Google
https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559
L’appel de fonction qui nous concerne 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:
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.
- Le texte entre parenthèses est ignoré.
- Les nombres non signés suivis de ":" sont interprétés comme une "composante temporelle".
- Les nombres non signés suivis de "." Sont interprétés comme une "composante de temps" et doivent être suivis de millisecondes.
- Les 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.
- Lorsque vous déclarez l'heure et les minutes, vous pouvez utiliser “hh: mm” ou “hhmm”.
- Les mots qui indiquent un fuseau horaire sont interprétés comme un fuseau horaire.
- Tous les autres nombres sont interprétés comme des "composants de date".
- 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: “hh: mm” ou “hhmm”.
- Les symboles tels que “+”, “-“ et “sans correspondance” ne sont pas autorisés après le traitement d'un nombre.
- Les éléments correspondant à plusieurs formats (par exemple, 1970-01-01) sont traités en tant que chaîne conforme à la norme EMCAScript 5.0 ISO 8601.
Cela devrait donc suffire à vous donner une idée de base de ce à quoi s'attendre lorsqu'il s'agit de passer une chaîne à un objet Date. Vous pouvez approfondir cette question en consultant la spécification suivante indiquée par Mozilla sur le réseau de développeurs Mozilla (conforme aux horodatages IETF RFC 2822):
Le réseau de développeurs Microsoft mentionne en outre une norme supplémentaire pour l'objet Date: ECMA-402, spécification API d'internationalisation ECMAScript, complémentaire de la norme ECMAScript 5.1 (et des futures). Cela peut être trouvé ici:
Dans tous les cas, cela devrait aider à souligner qu’il n’existe pas de "documentation" qui représente universellement toutes les implémentations de javascript, mais qu’il existe 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#27
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 commander Datejs lorsque vous traitez avec des dates en JavaScript. C'est assez impressionnant et bien documenté comme vous pouvez le voir avec la fonction toString .
EDIT: Tyler Forsythe fait remarquer que datejs est obsolète. Je l'utilise dans mon projet actuel et je n'ai eu aucun problème avec ce dernier. Cependant, vous devez en être conscient et envisager des alternatives.
Vous pouvez simplement développer l'objet Date avec une nouvelle méthode format comme indiqué par meizz , le code fourni par l'auteur est ci-dessous. Ethere est 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 tous 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 de la prise en charge 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 é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 la 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())
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 recommanderais cette BEAUCOUP de bibliothèque plus simple (format de date JavaScript) que je préfère simplement parce qu’elle ne contient 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 d'objet de date, qui est plus petite que n'importe quelle bibliothèque et qui peut facilement être étendue pour supporter 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 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;
}
N'ayant pu 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 différents 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]/[Numéro de date] - Le mois peut être soit le nombre avec ou sans un zéro au début, soit le nom du mois en format court ou long, et le numéro de la date peut être avec ou sans le début. zéro.
- 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 soit le numéro avec ou sans un zéro au début, soit le nom du mois en format court ou long, et le numéro de la date peut être avec ou sans le début. zéro.
- 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 la 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.
- 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é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 non significatifs (il s'agit du format utilisé par le type MySQL Date utilise)
- 2013-08-09
Utilisation des noms de mois:
Il est intéressant de noter que lors de l’utilisation des noms de mois, j’ai découvert que seuls les trois 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');
La bibliothèque sugar.js a quelques fonctionnalités intéressantes 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 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 comme "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"
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 auxiliaire.
La bibliothèque javascript XDate par Adam Shaw existe depuis mi-2011 et est toujours en cours de développement. 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:
"13:45:20"
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 objetDate - Utilisez
.getDate(),.getMonth()et.getFullYear()pour obtenir respectivement le jour, le mois et l'année - 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 this Fiddle ).
Navigateurs modernes seulement
Vous pouvez également utiliser la méthode .toLocaleDateString intégrée 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, 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 this Fiddle ).
(*)Selon le MDN , "navigateurs modernes" signifie Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ et 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 mathématique de la date (ajout/soustraction d'éléments de date), la comparaison de date, l'analyse de la date, etc. Il est généreusement ouvert.
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.
utiliser ces fonctions
toTimeString() and toLocaleDateString()
voir le lien ci-dessous pour plus de détails https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date
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);
La manière correcte de formater une date pour renvoyer "2012-12-29" est avec le script de JavaScript Date Format:
var d1 = new Date();
return d1.format("dd-m-yy");
Ce code ne fonctionne pas:
var d1 = new Date();
d1.toString('yyyy-MM-dd');
JsSimpleDateFormat est une bibliothèque qui peut formater l'objet date et analyser la chaîne mise en forme dans 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 , 2/8/2013, page 173), toString La fonction 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 pourraient être utilisées pour effectuer 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, parce que j'utilise à la fois PHP et jQuery/javascript, 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 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 1000 de l'horodatage javascript est due au fait qu'un horodatage javascript est exprimé en millisecondes mais qu'un horodatage PHP est en secondes.
La réponse spécifique à cette question se trouve dans ces deux lignes ci-dessous:
//pull the last two digits of the year
console.log(new Date().getFullYear().toString().substr(2,2));Exemple de formatage de date et heure complète (MMddyy): jsFiddle
JavaScript:
//A function for formatting a date to MMddyy
function formatDate(d)
{
//get the month
var month = d.getMonth();
//get the day
var day = d.getDate();
//get the year
var year = d.getFullYear();
//pull the last two digits of the year
year = year.toString().substr(2,2);
//increment month by 1 since it is 0 indexed
month = month + 1;
//converts month to a string
month = month + "";
//if month is 1-9 pad right with a 0 for two digits
if (month.length == 1)
{
month = "0" + month;
}
//convert day to string
day = day + "";
//if day is between 1-9 pad right with a 0 for two digits
if (day.length == 1)
{
day = "0" + day;
}
//return the string "MMddyy"
return month + day + year;
}
var d = new Date();
console.log(formatDate(d));d = Date.now();
d = new Date(d);
d = (d.getMonth()+1)+'/'+d.getDate()+'/'+d.getFullYear()+' '+(d.getHours() > 12 ? d.getHours() - 12 : d.getHours())+':'+d.getMinutes()+' '+(d.getHours() >= 12 ? "PM" : "AM");
console.log(d);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 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")
Voir dtmFRM.js . Si vous connaissez la chaîne de format de date et d'heure personnalisée de C #, cette bibliothèque devrait faire exactement la même chose.
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>");