Wo finde ich eine Dokumentation zum Formatieren eines Datums in JavaScript?

Moment.js

Es ist eine (leichte) * JavaScript-Datumsbibliothek zum Analysieren, Bearbeiten und Formatieren von Datumsangaben.

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"

(*) leichte Bedeutung: 9,3 KB Minimiert + Gezippt im kleinsten möglichen Setup (Februar 2014)} 

Wenn Sie in Ihrem Projekt bereits jQuery UI verwenden, können Sie die integrierte Methode datepicker zum Formatieren Ihres Datumsobjekts verwenden:

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

Der Datepicker formatiert jedoch nur Datumsangaben und kann keine Zeiten formatieren.

Schauen Sie sich die jQuery UI datepicker formatDate an, die Beispiele.

Wo ist die Dokumentation, in der die Formatspezifizierer aufgelistet sind, die vom Date()-Objekt unterstützt werden?

Ich bin heute darüber gestolpert und war ziemlich überrascht, dass sich niemand die Zeit nahm, um diese einfache Frage zu beantworten. Es stimmt, es gibt viele Bibliotheken, die bei der Datumsmanipulation helfen. Einige sind besser als andere. Aber das war nicht die gestellte Frage.

AFAIK, reines JavaScript unterstützt keine Formatangaben die Art und Weise, wie Sie angegeben haben, dass Sie sie verwenden möchten. Es werden jedoch Methoden zum Formatieren von Datumsangaben und/oder -zeiten unterstützt, z. B. .toLocaleDateString(), .toLocaleTimeString() und .toUTCString().

Die Date-Objektreferenz, die ich am häufigsten verwende, befindet sich auf der w3schools.com-Website (aber eine schnelle Google-Suche wird viele weitere enthüllen, die Ihren Anforderungen möglicherweise besser entsprechen.

Beachten Sie auch, dass der Abschnitt Date Object Properties einen Link zu prototype enthält, der einige Möglichkeiten veranschaulicht, wie Sie das Date-Objekt mit benutzerdefinierten Methoden erweitern können. In der JavaScript-Community gab es im Laufe der Jahre einige Debatten darüber, ob dies die beste Praxis ist oder nicht, und ich befürworte nicht oder lehne es ab, sondern weise nur auf seine Existenz hin.

Benutzerdefinierte Formatierungsfunktion:

Bei festen Formaten erledigen Sie eine einfache Funktion. Folgendes Beispiel erzeugt das internationale Format JJJJ-MM-TT:

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

Hinweis: Es ist jedoch normalerweise keine gute Idee, die Javascript-Standardbibliotheken zu erweitern (z. B. durch Hinzufügen dieser Funktion zum Prototyp von Date). 

Eine erweiterte Funktion könnte auf Basis eines Formatparameters eine konfigurierbare Ausgabe generieren. Es gibt einige gute Beispiele auf dieser Seite.

Wenn eine Formatierungsfunktion zu lang ist, gibt es viele Bibliotheken, um die es geht. Einige andere Antworten listen sie bereits auf. Zunehmende Abhängigkeiten haben aber auch einen Gegenpart.

Standard-ECMAScript-Formatierungsfunktionen:

Seit neueren Versionen von ECMAscript verfügt die Date-Klasse über bestimmte Formatierungsfunktionen:

toDateString: Implementierungsabhängig, nur das Datum anzeigen.

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: Zeigt Datum und Uhrzeit von ISO 8601 an.

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: Zeichenfolge für 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: Implementierungsabhängig, ein Datum im Gebietsschemaformat.

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

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

toLocaleString: Implementierungsabhängig, Datum und Uhrzeit im Gebietsschemaformat.

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: Implementierungsabhängig, eine Zeit im Gebietsschemaformat.

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: Generisches toString für Datum.

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

Hinweis: Es ist möglich, aus diesen Formatierungsfunktionen eine benutzerdefinierte Ausgabe zu generieren:

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

Die kurze Antwort

Es gibt keine "universelle" Dokumentation, für die Javascript ausgelegt ist. Jeder Browser, der Javascript hat, ist wirklich eine Implementierung. Es gibt jedoch einen Standard, dem die meisten modernen Browser tendenziell folgen, und das ist der EMCAScript-Standard. Die ECMAScript-Standardzeichenfolgen würden eine modifizierte Implementierung der ISO 8601-Definition erfordern.

Darüber hinaus gibt es einen zweiten Standard, der durch IETF festgelegt wird und dem auch die Browser folgen. Dies ist die Definition für Zeitstempel, die im RFC 2822 erstellt wurden. Die tatsächliche Dokumentation finden Sie in die referenzliste unten.

Hiervon können Sie grundlegende Funktionen erwarten, aber was „sein sollte“, ist nicht von Natur aus das, was „ist“. Ich werde mich jedoch etwas eingehender mit diesem Verfahren befassen, da anscheinend nur drei Personen die Frage beantwortet haben (Scott, goofballLogic und Peller), was für mich nahelegt, dass die meisten Menschen nicht wissen, was bei Ihnen tatsächlich passiert Erstellen Sie ein Date-Objekt.

Die lange Antwort

Wo befindet sich die Dokumentation, in der die vom Date () - Objekt unterstützten Formatbezeichner aufgelistet sind?

Um die Frage zu beantworten oder in der Regel nach Antworten auf diese Frage zu suchen, müssen Sie wissen, dass Javascript keine neuartige Sprache ist. Tatsächlich handelt es sich um eine Implementierung von ECMAScript, die den ECMAScript-Standards folgt (Beachten Sie jedoch, dass Javascript auch tatsächlich vor diesen Standards erstellt wurde; EMCAScript-Standards basieren auf der frühen Implementierung von LiveScript/JavaScript). Der aktuelle ECMAScript-Standard ist 5.1 (2011); Zu dem Zeitpunkt, als die Frage ursprünglich gestellt wurde (Juni 2009), war der Standard 3 (4 wurde aufgegeben), 5 wurde jedoch kurz nach der Veröffentlichung Ende 2009 veröffentlicht. Welchem ​​Standard eine Javascript-Implementierung folgen kann, gibt möglicherweise nicht wieder, was tatsächlich vorhanden ist, da a) dies eine Implementierung eines bestimmten Standards ist, b) nicht alle Implementierungen eines Standards puritanisch sind und c) die Funktionalität nicht synchron mit a freigegeben ist neuer standard als d) eine umsetzung ist ein ständiger arbeitsaufwand

Im Wesentlichen handelt es sich beim Umgang mit Javascript um ein Derivat (browserspezifisches Javascript) einer Implementierung (Javascript selbst). In Google V8 wird beispielsweise ECMAScript 5.0 implementiert, Internet Explorer JScript versucht jedoch nicht, ECMAScript-Standards zu erfüllen, Internet Explorer 9 entspricht jedoch ECMAScript 5.0.

Wenn ein einzelnes Argument an new Date () übergeben wird, wird der folgende Funktionsprototyp umgewandelt:

new Date(value)

Wenn zwei oder mehr Argumente an new Date () übergeben werden, wird der folgende Funktionsprototyp umgewandelt:

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

Diese beiden Funktionen sollten vertraut aussehen, aber dies beantwortet Ihre Frage nicht sofort und was als akzeptables „Datumsformat“ quantifiziert wird, bedarf einer weiteren Erläuterung. Wenn Sie eine Zeichenfolge an new Date () übergeben, wird der Prototyp aufgerufen (beachten Sie, dass ich den Word-Prototyp lose verwende; die Versionen können einzelne Funktionen sein oder es kann sein Teil einer bedingten Anweisung in einer einzigen Funktion sein) für neues Datum (Wert) mit Ihrer Zeichenfolge als Argument für den Parameter "value". Diese Funktion prüft zunächst, ob es sich um eine Zahl oder eine Zeichenfolge handelt. Die Dokumentation zu dieser Funktion finden Sie hier:

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

Daraus können wir schließen, dass wir uns die Methode Date.parse (string) ansehen müssen, um die für das neue Datum (value) zulässige Formatierung der Zeichenfolge zu erhalten. Die Dokumentation zu dieser Methode finden Sie hier:

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

Außerdem können wir daraus schließen, dass die Daten voraussichtlich in einem modifizierten erweiterten ISO 8601-Format vorliegen werden, wie hier angegeben:

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

Aus Erfahrung können wir jedoch erkennen, dass das Datumsobjekt von Javascript andere Formate akzeptiert (was in erster Linie durch das Vorhandensein dieser Frage erzwungen wird), und dies ist in Ordnung, da ECMAScript die Implementierung spezifischer Formate ermöglicht. Dies beantwortet jedoch immer noch nicht die Frage, welche Dokumentation zu den verfügbaren Formaten verfügbar ist oder welche Formate tatsächlich zulässig sind. Wir werden uns Googles Javascript-Implementierung V8 ansehen. Bitte beachten Sie, dass ich nicht vorschlage, dass dies die "beste" Javascript-Engine ist (wie kann man "beste" oder sogar "gute" definieren), und man kann nicht davon ausgehen, dass die in V8 zulässigen Formate alle heute verfügbaren Formate darstellen, aber ich denke, es ist fair davon auszugehen, dass sie modernen Erwartungen entsprechen.

Googles V8, date.js, DateConstructor

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

Wenn wir uns die DateConstructor-Funktion ansehen, können wir daraus schließen, dass wir die DateParse-Funktion finden müssen. Beachten Sie jedoch, dass „Jahr“ nicht das tatsächliche Jahr ist und nur auf den Parameter „Jahr“ verweist.

Googles V8, date.js, DateParse

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

Das ruft% DateParseString auf, das tatsächlich eine Laufzeitfunktionsreferenz für eine C++ - Funktion ist. Es bezieht sich auf den folgenden Code:

Googles V8, runtime.cc,% DateParseString

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

Der Funktionsaufruf, um den es in dieser Funktion geht, gilt für DateParser :: Parse (). Ignorieren Sie die Logik, die diese Funktionsaufrufe umgibt. Dies sind nur Überprüfungen, um den Codierungstyp (ASCII und UC16) zu erfüllen. DateParser :: Parse wird hier definiert:

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

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

Dies ist die Funktion, die tatsächlich definiert, welche Formate akzeptiert werden. Im Wesentlichen wird nach dem Standard EMCAScript 5.0 ISO 8601 gesucht. Wenn der Standard nicht mit den Standards übereinstimmt, wird versucht, das Datum auf der Grundlage älterer Formate zu erstellen. Ein paar wichtige Punkte basierend auf den Kommentaren:

1. Wörter vor der ersten Zahl, die dem Parser unbekannt sind, werden ignoriert.
2. Eingeklammerter Text wird ignoriert.
3. Zahlen ohne Vorzeichen, gefolgt von „:“, werden als „Zeitkomponente“ interpretiert.
4. Zahlen ohne Vorzeichen, gefolgt von „.“, Werden als „Zeitkomponente“ interpretiert und müssen von Millisekunden gefolgt werden.
5. Vorzeichen, gefolgt von der Stunde oder Stunde (z. B. +5: 15 oder +0515), werden als Zeitzone interpretiert.
6. Bei der Angabe von Stunde und Minute können Sie entweder "hh: mm" oder "hhmm" verwenden.
7. Wörter, die eine Zeitzone angeben, werden als Zeitzone interpretiert.
8. Alle anderen Zahlen werden als "Datumskomponenten" interpretiert.
9. Alle Wörter, die mit den ersten drei Ziffern eines Monats beginnen, werden als Monat interpretiert.
10. Sie können Minuten und Stunden zusammen in einem der beiden Formate definieren: "hh: mm" oder "hhmm".
11. Symbole wie „+“, „-“ und nicht übereinstimmendes „)“ sind nach der Verarbeitung einer Nummer nicht zulässig.
12. Elemente, die mehreren Formaten entsprechen (z. B. 1970-01-01), werden als standardkonforme EMCAScript 5.0 ISO 8601-Zeichenfolge verarbeitet.

Dies sollte also ausreichen, um Ihnen eine grundlegende Vorstellung davon zu geben, was Sie beim Übergeben einer Zeichenfolge an ein Date-Objekt erwarten können. Sie können dies weiter ausbauen, indem Sie sich die folgende Spezifikation ansehen, auf die Mozilla im Mozilla Developer Network verweist (gemäß den IETF RFC 2822-Zeitstempeln):

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

Das Microsoft Developer Network erwähnt zusätzlich einen zusätzlichen Standard für das Date-Objekt: ECMA-402, die ECMAScript Internationalization API-Spezifikation, die den ECMAScript 5.1-Standard (und zukünftige) ergänzt. Das gibt es hier:

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

In jedem Fall sollte dies dazu beitragen, zu verdeutlichen, dass es keine "Dokumentation" gibt, die alle Implementierungen von Javascript allgemein darstellt, aber dennoch genügend Dokumentation zur Verfügung steht, um einen vernünftigen Sinn dafür zu ergeben, welche Zeichenfolgen für ein Date-Objekt akzeptabel sind. Ziemlich die geladene Frage, wenn Sie darüber nachdenken, ja? : P

Referenzen

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

Ressourcen

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

Stellen Sie sicher, dass Sie Datejs auschecken, wenn Sie mit Datumsangaben in JavaScript arbeiten. Es ist ziemlich beeindruckend und gut dokumentiert, wie Sie im Fall der toString-Funktion sehen können.

EDIT: Tyler Forsythe weist darauf hin, dass datejs veraltet ist. Ich verwende es in meinem aktuellen Projekt und hatte keine Probleme damit, aber Sie sollten sich dessen bewusst sein und Alternativen in Betracht ziehen.

Sie können das Date-Objekt einfach mit einer neuen format-Methode erweitern, wie von meizz angegeben. UndEs gibt eine 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"));

Bei der von Ihnen genannten Funktionalität handelt es sich nicht um Standard-Javascript. Sie ist wahrscheinlich nicht für alle Browser portierbar und daher nicht empfehlenswert. Die ECMAScript 3-Spezifikation überlässt die Analyse- und Ausgabeformate bis zur Javascript-Implementierung. ECMAScript 5 fügt eine Teilmenge der ISO8601-Unterstützung hinzu. Ich glaube, die von Ihnen erwähnte toString () - Funktion ist eine Innovation in einem Browser (Mozilla?).

Mehrere Bibliotheken stellen Routinen zur Verfügung, um dies zu parametrieren, einige davon mit umfassender Lokalisierungsunterstützung. Sie können die Methoden auch in dojo.date.locale auschecken.

Ich habe dieses sehr einfache Formatierungsprogramm erstellt, es ist geschnitten/n/pastierbar (Mit sauberer Version aktualisiert):

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/

Rahmen frei, begrenzt aber leicht

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 ist sicherlich voll funktionsfähig, aber ich würde diese VIEL einfachere lib (JavaScript Date Format) empfehlen.

Nachdem ich einige der Optionen in anderen Antworten durchgesehen hatte, entschied ich mich, meine eigene begrenzte, aber einfache Lösung zu schreiben, die auch für andere nützlich sein könnte.

/**
* 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;
}

Verwendungsbeispiel:

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

Hier ist eine Funktion, die ich häufig benutze. Das Ergebnis ist jjjj-mm-tt 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);
}

Diese Änderung des Date-Objekts kann nützlich sein, da sie kleiner ist als jede Bibliothek und leicht erweiterbar ist, um verschiedene Formate zu unterstützen:

HINWEIS:

• Es verwendet Object.keys () , das in älteren Browsern undefiniert ist, so dass Sie möglicherweise Polyfill von einem angegebenen Link aus implementieren müssen.

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

BENUTZEN

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

Um die solide Antwort von gongzhitaao fortzusetzen, werden AM/PM erledigt

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

Ich konnte keine gültige Dokumentation zu gültigen Datumsformaten finden. Deshalb habe ich meinen eigenen Test geschrieben, um zu sehen, was in verschiedenen Browsern unterstützt wird.

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

Nach meinen Ergebnissen sind die folgenden Formate in allen von mir getesteten Browsern gültig (Beispiele verwenden das Datum "9. August 2013"):

[Ganzes Jahr]/[Monat]/[Datumsnummer] - Monat kann entweder die Zahl mit oder ohne führende Null oder der Monatsname im Kurz- oder Langformat sein, und die Datumsnummer kann mit oder ohne führende sein Null.

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

[Monat]/[ganzes Jahr]/[Datumsnummer] - Monat kann entweder die Zahl mit oder ohne führende Null oder der Monatsname im Kurz- oder Langformat sein, und die Datumsnummer kann mit oder ohne führende Nummer sein Null. 

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

Jede Kombination von [Ganzes Jahr], [Monatsname] und [Datumsnummer] getrennt durch Leerzeichen - Der Monatsname kann entweder kurz oder lang sein und die Datumsnummer kann mit oder ohne führende Null sein. 

• 2013 August 09
• August 2013 09
• 09. August 2013
• 2013 Aug 09
• 9. August 2013
• 2013 9 Aug
• usw...

Gilt auch für "moderne Browser" (oder anders ausgedrückt für alle Browser außer IE9 und darunter).

[Ganzes Jahr] - [Monatsnummer] - [Datumsnummer] - Monat und Datumsnummer müssen führende Nullen enthalten (dies ist das Format, das der MySQL-Datentyp verwendet). 

• 2013-08-09

Verwenden von Monatsnamen:
Interessanterweise habe ich bei der Verwendung von Monatsnamen festgestellt, dass nur die ersten drei Zeichen des Monatsnamens verwendet werden, sodass alle der folgenden Punkte vollkommen gültig sind:

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

Die Bibliothek sugar.js verfügt über einige großartige Funktionen zum Arbeiten mit Datumsangaben in JavaScript. Und es ist sehr gut dokumentiert .

Zucker verleiht der Date-Klasse viel Liebe, beginnend mit dem Date.create Methode, die Daten in fast jedem Format in 15 Dur verstehen kann. Sprachen, einschließlich relativer Formate wie "vor 1 Stunde". Termine können Sie können auch in einem beliebigen Format oder in einer beliebigen Sprache ausgegeben werden. Syntax mit Verknüpfungen zu häufig verwendeten Datumsformaten. Komplexes Datum Vergleiche sind auch mit Methoden möglich, die beliebige .__ verstehen. Formatieren und Anwenden von Präzision.

Einige Beispiele:

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"

Das Formatieren und insbesondere das Analysieren von Datumsangaben in JavaScript kann Kopfschmerzen verursachen. Nicht alle Browser behandeln Daten auf dieselbe Weise. Obwohl es nützlich ist, die Basismethoden zu kennen, ist es praktischer, eine Helper-Bibliothek zu verwenden.

Die XDate-Javascript-Bibliothek by Adam Shaw gibt es seit Mitte 2011 und befindet sich noch in der aktiven Entwicklung. Es hat eine fantastische Dokumentation, eine großartige API, Formatierung, versucht rückwärtskompatibel zu bleiben und unterstützt sogar lokalisierte Zeichenketten.

Link zum Ändern der lokalen Zeichenfolgen: https://Gist.github.com/1221376

Beispielcode:

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

Ausgabe:

"13:45:20"

Alle Browser

Die zuverlässigste Methode, ein Datum mit dem von Ihnen verwendeten Quellformat zu formatieren, besteht in der Anwendung der folgenden Schritte:

1. Verwenden Sie new Date(), um ein Date-Objekt zu erstellen
2. Verwenden Sie .getDate(), .getMonth() und .getFullYear(), um Tag, Monat und Jahr zu erhalten
3. Fügen Sie die Stücke gemäß Ihrem Zielformat zusammen ein

Beispiel:

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

(Siehe auch this Fiddle ).

Nur moderne Browser

Sie können auch die integrierte .toLocaleDateString-Methode verwenden, um die Formatierung für Sie vorzunehmen. Sie müssen lediglich das richtige Gebietsschema und die entsprechenden Optionen übergeben, um das richtige Format zu finden, das leider nur von modernen Browsern unterstützt wird (*):

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

(Siehe auch this Fiddle ).

(*)Laut MDN bedeutet "moderne Browser" Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ und Safari nightly build.

Nur eine weitere Option, die ich geschrieben habe:

DP_DateExtensions Library

Nicht sicher, ob es helfen wird, aber ich habe es in mehreren Projekten als nützlich erachtet - es sieht so aus, als würde es das tun, was Sie brauchen.

Unterstützt Datums-/Zeitformatierung, Datumsberechnung (Datumsteile hinzufügen/subtrahieren), Datumsvergleich, Datumsanalyse, usw. Es ist reichlich Open Source.

Es gibt keinen Grund, darüber nachzudenken, wenn Sie bereits ein Framework verwenden (sie sind alle in der Lage), aber wenn Sie einem Projekt schnell eine Datumsänderung hinzufügen müssen, geben Sie ihm eine Chance.

verwenden Sie diese Funktionen

toTimeString() and toLocaleDateString()

weitere Informationen finden Sie unter dem Link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Wenn Sie nur Zeit mit zwei Ziffern anzeigen möchten, kann dies Ihnen helfen:

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

Der korrekte Weg, ein Datum zu formatieren, um "2012-12-29" zurückzugeben, ist mit dem Skript aus JavaScript Date Format: 

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

Dieser Code funktioniert NICHT:

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

JsSimpleDateFormat ist eine Bibliothek, die das Date-Objekt formatieren und die formatierte Zeichenfolge wieder im Date-Objekt analysieren kann. Es verwendet das Java-Format (SimpleDateFormat-Klasse). Der Name von Monaten und Tagen kann lokalisiert werden.

Beispiel:

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

Die Antwort lautet "nirgendwo", da die Datumsformatierung proprietäre Funktionalität ist. Ich denke nicht, dass die toString-Funktionen einem bestimmten Format entsprechen sollen. z.B. in der ECMAScript 5.1-Spezifikation ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, Seite 173) der toString Die Funktion ist wie folgt dokumentiert:

"Der Inhalt des Strings ist implementierungsabhängig"

Funktionen wie die folgenden Beispiele können verwendet werden, um die Formatierung relativ einfach durchzuführen.

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

Wenn Sie nicht alle Funktionen benötigen, die eine Bibliothek wie Moment.js bietet, können Sie meinen Port von strftime verwenden. Es ist leicht (1,35 KB vs. 57,9 KB gegenüber Moment.js 2.15.0) und bietet die meisten Funktionen von 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;
  });
}

Verwendungsbeispiel:

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"

Der neueste Code ist hier verfügbar: https://github.com/thdoan/strftime

Da ich sowohl PHP als auch jQuery/javascript gleichermaßen benutze, verwende ich die Datumsfunktion von php.js http://phpjs.org/functions/date/

Es ist für mich einfacher, eine Bibliothek zu verwenden, die dieselben Formatzeichenfolgen als etwas verwendet, das ich bereits kenne. Das Handbuch, das alle Formatzeichenfolgenmöglichkeiten für die Datumsfunktion enthält, ist natürlich online auf php.net

Fügen Sie die date.js-Datei einfach mit Ihrer bevorzugten Methode in Ihren HTML-Code ein und rufen Sie sie wie folgt auf:

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

Sie können d1.getTime () anstelle von valueOf () verwenden, wenn Sie möchten, tun sie dasselbe.

Die Division des Javascript-Zeitstempels durch 1000 ist darauf zurückzuführen, dass ein JavaScript-Zeitstempel in Millisekunden angegeben wird, ein PHP -Zeitstempel jedoch in Sekunden.

Die konkrete Antwort auf diese Frage finden Sie in den folgenden beiden Zeilen:

//pull the last two digits of the year
console.log(new Date().getFullYear().toString().substr(2,2));

Beispiel für das Formatieren der vollständigen Datumszeit (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));

Viele Frameworks (die Sie möglicherweise bereits verwenden) haben eine Datumsformatierung, die Sie möglicherweise nicht kennen. jQueryUI wurde bereits erwähnt, aber andere Frameworks wie Kendo UI (Globalisierung) , Yahoo UI (Util) und AngularJS haben sie ebenfalls.

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

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

Siehe dtmFRM.js . Wenn Sie mit der benutzerdefinierten Datums- und Uhrzeitformat-Zeichenfolge von C # vertraut sind, sollte diese Bibliothek dasselbe tun.

DEMO :

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

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

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

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

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