Moment.js

il s'agit d'une bibliothèque de date (légère)* JavaScript pour analyser, manipuler et formater les 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é + gzippé 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 lecteur de données ne formate que les dates, et ne peut pas formater les heures.

regarder jQuery UI datepicker formatDate , les exemples.

Où est la documentation qui liste les spécificateurs de format supportés par l'objet Date() ?

je suis tombé sur ce aujourd'hui et j'ai été très surpris que personne n'ait pris le temps de répondre à cette simple question. Il est vrai qu'il existe de nombreuses bibliothèques pour aider à manipuler les dates. Certains sont meilleurs que d'autres. Mais ce n'était pas la question posée.

AFAIK, pur JavaScript ne supporte pas le format spécifiez de la façon dont vous avez indiqué que vous souhaitez les utiliser . Mais il supporte 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 est sur le w3schools.com site web (mais une recherche rapide de Google révélera beaucoup plus qui pourraient mieux répondre à vos besoins).

Also notez que la section Date Object Properties fournit un lien vers prototype , ce qui illustre certaines façons dont vous pouvez étendre l'objet Date avec des méthodes personnalisées. Il y a eu un certain débat dans la communauté JavaScript au cours des années sur la question de savoir si c'est ou non une bonne pratique, et je ne plaide pas pour ou contre, simplement en soulignant son existence.

fonction de formatage personnalisé:

pour les formats fixes, une fonction simple fait le travail. Exemple suivant générer le format international AAAA-MM - JJ:

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

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

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

si écrire une fonction de mise en forme est trop long, il ya beaucoup de bibliothèques autour de qui le fait. D'autres réponses les énumèrent déjà. Mais l'augmentation des dépendances a également contre-partie.

Standard ECMAScript fonctions de mise en forme:

depuis les versions plus récentes D'ECMAscript, la classe Date a des fonctions de formatage spécifiques:

toDateString : implémentation dependent, show only the 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 : indiquer 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 : implémentation dependent, a date in locale format.

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

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

toLocaleString : implémentation dependent, a date&time in locale format.

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 : implémentation dependent, a time in locale format.

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

Note: 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" pour javascript; 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, minimalement, une mise en œuvre modifiée de la définition ISO 8601.

en plus de cela, il y a une deuxième norme IETF que les navigateurs ont tendance à suivre également, ce qui est la définition pour les horodateurs fabriqués dans le RFC 2822. La documentation actuelle se trouve dans la liste des références au bas de la page.

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

La Réponse Longue

Où est la documentation qui liste les spécificateurs de format supportés par L'objet Date ()?

pour répondre À la question, ou généralement même chercher la réponse à cette question, vous devez pour savoir que javascript n'est pas un langage nouveau; il s'agit en fait d'une implémentation D'ECMAScript, et suit les normes D'ECMAScript (mais notez, javascript aussi réellement pré-datée de ces normes; Normes Emascript sont construits à partir de la mise en œuvre 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 3 (4 a été abandonné), mais 5 a été libéré peu de temps après le post à la fin de 2009. Ce devrait souligner un problème; Quelle norme une implémentation javascript peut suivre, peut ne pas refléter ce qui est réellement en place, parce que a) c'est une implémentation d'une norme donnée, b) Toutes les implémentations d'une norme ne sont pas puritaines, et c) la fonctionnalité n'est pas libérée en synchronisation avec une nouvelle norme car d) une implémentation est un travail constant en cours

essentiellement, lorsque vous traitez avec javascript, vous traitez avec un dérivé (javascript spécifique à la navigateur) d'une implémentation (javascript lui-même). Le V8 de Google, par exemple, implémente ECMAScript 5.0, mais le JScript D'Internet Explorer ne tente pas de se conformer à une norme ECMAScript, alors Qu'Internet Explorer 9 se conforme à ECMAScript 5.0.

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

new Date(value)

lorsque deux arguments ou plus sont passés à new Date (), il jette cette fonction prototype:

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 quantifié comme un "format de date" acceptable nécessite des explications supplémentaires. Lorsque vous passez une chaîne à new Date (), elle appellera le prototype (notez que j'utilise le mot prototype vaguement; les versions peuvent être des fonctions individuelles, ou il peut faire partie d'une déclaration conditionnelle dans une seule fonction) pour nouvelle Date (Valeur) avec votre chaîne de caractères comme argument pour le paramètre "valeur". Cette fonction va d'abord vérifier si c'est un nombre ou 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

nous pouvons en déduire que pour obtenir le formatage de chaîne autorisé pour la nouvelle Date (Valeur), nous devons regardez la méthode Date.parse (string). La documentation pour 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 sont attendues 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 (mis en application par l'existence de cette question en premier lieu), et ce n'est pas grave car ECMAScript permet des formats spécifiques d'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 en fait permettre. Nous allons examiner l'implémentation javascript de Google, V8; veuillez noter que je ne suggère pas que c'est le "meilleur" moteur javascript (comment peut-on définir "meilleur" ou même "bon") et on ne peut pas supposer que les formats autorisés dans V8 représentent tous les formats disponibles aujourd'hui, mais je pense qu'il est juste de 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 en déduire que nous avons besoin de 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 %Dateparstring, qui est en fait une référence de fonction d'exécution pour une fonction C++. Il se réfère au code suivant:

Google V8, runtime.cc, % Dateparstring

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(); ignorez la logique entourant ces appels de fonction, ce sont juste des vérifications pour se conformer au type d'encodage (ASCII et UC16). DateParser:: Parse est défini ici:

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

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

c'est la fonction qui définit en fait les formats qu'elle accepte. Essentiellement, il vérifie pour la norme EMCAScript 5.0 ISO 8601 et si elle n'est pas conforme aux normes, alors il tentera de construire la date basée sur les formats hérités. Quelques points clés basés sur les commentaires:

1. les mots avant le premier numéro qui sont inconnus de l'analyseur sont ignorés.
2. texte entre parenthèses sont ignorés.
3. Unsigned chiffres suivi de ":" sont interprétés comme un "composant".
4. Unsigned numéros de suivi par "le."est interprété comme une" composante temporelle", et doit être suivi de millisecondes.
Les numéros signés
5. suivis de l'heure ou de la minute de l'heure (par exemple +5:15 ou +0515) sont interprétés comme le fuseau horaire.
6. en déclarant l'heure et la minute, Vous pouvez utiliser soit "hh:mm" ou "hhmm".
7. les mots qui indiquent un fuseau horaire sont interprétés comme un fuseau horaire.
8. tous les autres numéros sont interprétés comme des"éléments de date".
9. Tous les mots qui commencent avec les trois premiers chiffres d'un mois sont interprétées 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 unmatched ") " ne sont pas autorisé après qu'un numéro a été traité.
12. les articles qui correspondent à plusieurs formats (par exemple 1970-01-01) sont traités comme une chaîne de caractères conforme à la norme Emcastrip 5.0 ISO 8601.

cela devrait donc suffire à vous donner une idée de base de ce qu'il faut attendre quand il s'agit de passer une chaîne dans un objet Date. Vous pouvez vous étendre sur ceci en regardant la spécification suivante que Mozilla pointe sur le réseau de développeur Mozilla (conforme à la RFC 2822 de L'IETF):

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

le réseau de développeurs de Microsoft mentionne en outre une norme supplémentaire pour L'objet Date: ECMA-402, la spécification de L'API D'internationalisation D'ECMAScript, qui est complémentaire à la norme ECMAScript 5.1 (et les suivantes). Que l'on peut trouver 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 assez de documentation disponible pour donner un sens raisonnable aux chaînes qui sont acceptables pour un objet Date. C'est une question chargée quand on y pense, non? : 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=94).151980920"

assurez-vous de vérifier Datejs lors de la gestion des dates en JavaScript. C'est assez impressionnant et bien documenté comme vous pouvez le voir dans le cas de la fonction toString .

EDIT : Tyler Forsythe fait remarquer que datejs est périmé. Je l'utilise dans mon projet actuel et n'ai pas eu de problème avec elle, cependant vous devriez être au courant de cela et envisager des alternatives.

vous pouvez simplement étendre L'objet Date avec une nouvelle méthode format comme noté 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.,
    (this.getFullYear()+"").substr(4 - RegExp..length));
  for(var k in o)if(new RegExp("("+ k +")").test(format))
    format = format.replace(RegExp.,
      RegExp..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 Javascript standard, pas susceptible d'être portable à travers les navigateurs et donc pas une bonne pratique. Le ECMAScript 3 spec laisse la fonction formats parse et output à L'implémentation Javascript. ECMAScript 5 ajoute un sous-ensemble de support ISO8601. Je crois que la fonction toString () que vous mentionnez est une innovation dans un seul navigateur (Mozilla?)

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

j'ai fait ce formater très simple, c'est cut/n/pastable (mis à jour avec la version plus nette):

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 la lumière

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 recommande cette lib beaucoup plus simple (Format Date JavaScript) que je préfère simplement parce que c'est seulement 120 lignes ou ainsi.

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 peuvent également trouver utiles.

/**
* 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'usage:

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 petit que n'importe quelle bibliothèque et est facilement extensible pour supporter différents formats:

NOTE:

• Il utilise des Objet.keys () qui n'est pas défini dans les navigateurs plus anciens, donc vous pouvez avoir besoin d'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];
    });
};

UTILISER

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 gongzhitaao de réponse solide - c'poignées 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.,
  (this.getFullYear() + "").substr(4 - RegExp..length));
for (var k in o) if (new RegExp("(" + k + ")").test(format))
    format = format.replace(RegExp.,
      RegExp..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, donc j'ai é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 valides dans tous les navigateurs que j'ai testés (les exemples utilisent la date "9th August 2013"):

[année complète] / [mois] / [Numéro de Date] Mois peut être soit le nombre avec ou sans zéro ou le nom du mois en format court ou long, la date et le numéro peut être avec ou sans 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]/[Date] Mois peut être soit le nombre avec ou sans zéro ou le nom du mois en format court ou long, la date et le numéro peut être avec ou sans zéro.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• August / 2013 / 09
• August / 2013 / 9
• Aug / 2013 / 09
• Aug / 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 court ou long, et le numéro de date peut être avec ou sans zéro.

• 2013 août 09
• août 2013 09
• 09 Août 2013
• 2013 Août 09
• 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 de mois] - [Numéro de Date] - le numéro de mois et de Date doit inclure des zéros en tête (c'est le format que le type de date MySQL utilise)

• 2013-08-09

utilisant les noms de mois:

Il est intéressant de noter qu'en utilisant des noms de mois, j'ai découvert que seuls les 3 premiers caractères du nom de mois sont jamais utilisés de sorte que tous les 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 surtout l'analyse des dates en JavaScript peuvent être un peu casse-tête. Tous les navigateurs ne gèrent pas les dates de la même façon. Donc, bien qu'il soit utile de connaître les méthodes de base, il est plus pratique d'utiliser une bibliothèque helper.

la XDate javascript library par Adam Shaw existe depuis le milieu de l'année 2011 et est encore en développement. Il a de la documentation fantastique, une grande API, le formatage, tente de rester rétro-compatible et supporte même les chaînes localisées.

lien vers changer les chaînes de caractères locales: https://gist.github.com/1221376

exemple de code:

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

sortie:

"13:45:20"

La bibliothèque de sucre.js a quelques fonctionnalités excellentes pour travailler avec les dates en JavaScript. Et il est très bien documentée .

sucre donne la classe de Date beaucoup d'amour à partir de la Date.créer méthode qui peut comprendre les dates dans à peu près n'importe quel format en 15 majeur langues, y compris les formats relatifs comme "il y a une heure". Les Dates peuvent aussi ê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. Complexe de la date la comparaison est également possible avec des méthodes comme l'is, qui comprennent toute formater et appliquer construit avec précision.

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"

juste une autre option, que j'ai écrit:

DP_DateExtensions Library

Je ne suis pas sûr que cela vous aidera, mais je l'ai trouvé utile dans plusieurs projets - on dirait qu'il fera ce dont vous avez besoin.

prend en charge le formatage date/heure, le calcul de date (ajouter/soustraire des parties de date), la comparaison de date, l'analyse de date, etc. Il est généreusement open source.

aucune raison de l'envisager si vous utilisez déjà un cadre (ils sont tous capables), mais si vous avez juste besoin d'ajouter rapidement la manipulation de date à un projet donner une chance.

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. utiliser new Date() pour créer un Date objet
2. utilisez .getDate() , .getMonth() et .getFullYear() pour obtenir respectivement le jour, le mois et l'année
3. coller 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 seulement

vous pouvez également utiliser la méthode intégrée .toLocaleDateString pour faire le formatage pour vous. Vous avez juste besoin de passer le long de la locale appropriée et des options pour correspondre au bon format, qui est malheureusement seulement pris en charge par moderne les navigateurs (*) :

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+ & Safari construction nocturne

la façon correcte de formater une date de retour "2012-12-29" est avec le script de Format 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 voulez montrer seulement le temps 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()

voir le 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 analyser la chaîne formatée 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");

Si vous n'avez pas besoin de toutes les fonctionnalités qu'une bibliothèque comme Moment.js fournit, alors vous pouvez utiliser mon port de strftime . Il est léger (1,35 Ko vs. 57,9 Ko minimisé par rapport au 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:
 * /q/javascript-calculate-the-day-of-the-year-1-366-50744/"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 réponse est" nulle part " puisque le formatage de 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 L'ECMAScript 5.1 spec ( 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 est fonction de la mise en œuvre"

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

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

utilisant une bibliothèque qui utilise les mêmes chaînes de format que quelque chose 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 date est bien sûr en ligne à php.net

vous incluez simplement la date.fichier js dans votre HTML en utilisant votre méthode préférée puis l'appeler 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 voulez, ils font la même chose.

la division par 1000 de l'horodatage javascript est parce qu'un horodatage javascript est en millisecondes mais un horodatage PHP est en secondes.

de nombreux cadres (que vous pourriez déjà utiliser) 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 (mondialisation) , Yahoo UI (Util) et AngularJS les ont aussi.

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

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