JavaScript: Welche Browser unterstützen das Parsen von ISO-8601 Date String mit Date.parse

Ich Fehler beim Parsen ein ISO-8601-Datum "2011-04-26T13:16:50Z" auf IE8 und Safari 5, aber es funktionierte auf Chrome 10, FF4. Die Unterstützung scheint zu sein, ziemlich gemischt?

Kennt jemand den aktuellen status, die Browser Parsen können dieses format? Ich nehme an, IE6 und 7 fehl auch.

var d = Date.parse("2011-04-26T13:16:50Z");

Kommentar zu dem Problem

Wahrscheinlich können wir diese Figur ein, weil ECMAScript-262v5 Unterstützung wird nicht veröffentlicht. Nützliche links: Mozilla Docs, W3 datetime Kommentarautor: cat

InformationsquelleAutor der Frage cat | 2011-04-27

17

Ich hatte dieses Problem heute. Ich fand momentjs war eine gute Möglichkeit, das Parsen von ISO-8601-Datumsangaben in einer cross-browser-manor.

momentjs kann auch verwendet werden, um die Ausgabe des Datum in einem anderen format.

InformationsquelleAutor der Antwort asgeo1

Ich sagen shim es nur, wenn nötig über ein paar tests,

hier, habe ich bereits geschrieben:

(function() {

var d = window.Date,
    regexIso8601 = /^(\d{4}|\+\d{6})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})\.(\d{1,3})(?:Z|([\-+])(\d{2}):(\d{2}))?)?)?)?$/;

if (d.parse('2011-11-29T15:52:30.5') !== 1322581950500 ||
    d.parse('2011-11-29T15:52:30.52') !== 1322581950520 ||
    d.parse('2011-11-29T15:52:18.867') !== 1322581938867 ||
    d.parse('2011-11-29T15:52:18.867Z') !== 1322581938867 ||
    d.parse('2011-11-29T15:52:18.867-03:30') !== 1322594538867 ||
    d.parse('2011-11-29') !== 1322524800000 ||
    d.parse('2011-11') !== 1320105600000 ||
    d.parse('2011') !== 1293840000000) {

    d.__parse = d.parse;

    d.parse = function(v) {

        var m = regexIso8601.exec(v);

        if (m) {
            return Date.UTC(
                m[1],
                (m[2] || 1) - 1,
                m[3] || 1,
                m[4] - (m[8] ? m[8] + m[9] : 0) || 0,
                m[5] - (m[8] ? m[8] + m[10] : 0) || 0,
                m[6] || 0,
                ((m[7] || 0) + '00').substr(0, 3)
            );
        }

        return d.__parse.apply(this, arguments);

    };
}

d.__fromString = d.fromString;

d.fromString = function(v) {

    if (!d.__fromString || regexIso8601.test(v)) {
        return new d(d.parse(v));
    }

    return d.__fromString.apply(this, arguments);
};

})();

in seinem code nur verwenden Sie immer Date.fromString(...) statt new Date(...)

test in einem browser zu sehen, ob der shim wird verwendet:

http://jsbin.com/efivib/1/edit

funktioniert in allen gängigen Browsern, verwendet diese Verweise:

http://dev.w3.org/html5/spec/common-microsyntaxes.html

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

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

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

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

!- microsoft connect erfordert ein log-in zur Ansicht:

IE9 wurde nicht auf Millisekunden mit Ziffer zählt andere als 3: (behoben in IE10)
https://connect.microsoft.com/IE/feedback/details/723740/date-parse-and-new-date-fail-on-valid-formats

IE10 ist immer noch (1/17/2013) zu Versagen, wenn die Zeitzone weggelassen wird (nach ECMA, dies sollte defalt bis Z oder UTC, nicht Ortszeit):
https://connect.microsoft.com/IE/feedback/details/776783/date-parse-and-new-date-fail-on-valid-formats

-- Lesen Sie dies, wenn Sie sich kümmern, wo der standard ist jetzt /in die Zukunft gehen und warum kann ich nicht bekommen, das IE-team, zu erkennen, dass Ihre IE10 Umsetzung ist technisch falsch:

ECMAScript-262 v6.0 ist sich zu bewegen, die etwas mehr nach ISO8601-konforme version von "wenn es die Zeit zone Indikator weggelassen wird, übernehmen die local time"... so gibt es jetzt eine Diskrepanz, diese Umsetzung, chrome, mobile safari und opera Folgen alle ECMAScript-262 v5.1, in der Erwägung, dass IE10, firefox, desktop-safari alle zu sein scheinen nach dem mehr nach ISO8601-konformen ECMAScript-262 v6.0-Spezifikation... das ist verwirrend, gelinde gesagt. Wenn chrome oder mobile safari ziehen Sie den Auslöser und bewegen Sie den ES6 Umsetzung, ich denke, diese Umsetzung sollte mit ihm gehen verlassen ES5.1 in der Minderheit. Ich habe gelesen, dass diese im aufgeführt ist die "errata" in der version 5.1 aber ich habe es nicht gefunden. Ich bin eher der Meinung, dass es ein bisschen früh ist, ziehen Sie den Auslöser auf ES6 gerade noch, aber ich bin auch der Meinung, dass code muss praktisch, nicht ideal und zu bewegen, um, wo die browser-Macher bewegen. Das heißt, es scheint eine 50/50 Entscheidung, gerade jetzt, so unten ist der "future" version von diesem code...

Ich sollte auch erwähnen, dass eine der beiden Versionen wird der code normalisieren "nicht-konforme" Browser mit dem Verhalten des anderen, da es ist, was shims tun 😉

HIER IST EINE ANGEPASSTE VERSION KOMPATIBEL MIT der ECMAScript-262 v6.0 (JavaScript-Zukunft)

siehe entsprechende Abschnitte hier: (dies ist das einzige online-html-version die spec, die ich finden konnte) http://people.mozilla.org/~jorendorff/es6-Entwurf.html#sec-15.9.1.15

(function() {

    var d = window.Date,
        regexIso8601 = /^(\d{4}|\+\d{6})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})\.(\d{1,})(Z|([\-+])(\d{2}):(\d{2}))?)?)?)?$/,
        lOff, lHrs, lMin;

    if (d.parse('2011-11-29T15:52:30.5') !== 1322599950500 ||
        d.parse('2011-11-29T15:52:30.52') !== 1322599950520 ||
        d.parse('2011-11-29T15:52:18.867') !== 1322599938867 ||
        d.parse('2011-11-29T15:52:18.867Z') !== 1322581938867 ||
        d.parse('2011-11-29T15:52:18.867-03:30') !== 1322594538867 ||
        d.parse('2011-11-29') !== 1322524800000 ||
        d.parse('2011-11') !== 1320105600000 ||
        d.parse('2011') !== 1293840000000) {

        d.__parse = d.parse;

        lOff = -(new Date().getTimezoneOffset());
        lHrs = Math.floor(lOff / 60);
        lMin = lOff % 60;

        d.parse = function(v) {

            var m = regexIso8601.exec(v);

            if (m) {
                return Date.UTC(
                    m[1],
                    (m[2] || 1) - 1,
                    m[3] || 1,
                    m[4] - (m[8] ? m[9] ? m[9] + m[10] : 0 : lHrs) || 0,
                    m[5] - (m[8] ? m[9] ? m[9] + m[11] : 0 : lMin) || 0,
                    m[6] || 0,
                    ((m[7] || 0) + '00').substr(0, 3)
                );
            }

            return d.__parse.apply(this, arguments);

        };
    }

    d.__fromString = d.fromString;

    d.fromString = function(v) {

        if (!d.__fromString || regexIso8601.test(v)) {
            return new d(d.parse(v));
        }

        return d.__fromString.apply(this, arguments);
    };

})();

hoffe, das hilft -ck

InformationsquelleAutor der Antwort ckozl

Einfache Funktion zum analysieren nach ISO8601 Datumsformat in jedem browser:

function dateFromISO8601(isoDateString) {
  var parts = isoDateString.match(/\d+/g);
  var isoTime = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4], parts[5]);
  var isoDate = new Date(isoTime);

  return isoDate;
}

InformationsquelleAutor der Antwort Alex Tsurika

6

Ja, Datum.analysieren ist nicht konsistent für die verschiedenen Browser. Sie könnten:
- Verwenden Datum.UTC statt, die zu Brüchen in der Datum-string in separate Eingänge
- Verwendung einer wrapper-Bibliothek, wie jQuery parseDate
InformationsquelleAutor der Antwort Vik David

Einigen älteren Browsern Rückkehr der falsch Datum (und nicht NaN), wenn Sie analysieren eine ISO-konforme Datums-Zeichenfolge.

Verwenden Sie Ihre eigene Methode für alle Browser, oder verwenden Sie Datum.analysieren, wenn es richtig umgesetzt wird-
prüfen Sie eine bekannte timestamp.

Date.fromISO= (function(){
    var diso= Date.parse('2011-04-26T13:16:50Z');
    if(diso=== 1303823810000) return function(s){
        return new Date(Date.parse(s));
    }
    else return function(s){
        var day, tz, 
        rx= /^(\d{4}\-\d\d\-\d\d([tT][\d:\.]*)?)([zZ]|([+\-])(\d\d):(\d\d))?$/, 
        p= rx.exec(s) || [];
        if(p[1]){
            day= p[1].split(/\D/).map(function(itm){
                return parseInt(itm, 10) || 0;
            });
            day[1]-= 1;
            day= new Date(Date.UTC.apply(Date, day));
            if(!day.getDate()) return NaN;
            if(p[5]){
                tz= parseInt(p[5], 10)*60;
                if(p[6]) tz += parseInt(p[6], 10);
                if(p[4]== "+") tz*= -1;
                if(tz) day.setUTCMinutes(day.getUTCMinutes()+ tz);
            }
            return day;
        }
        return NaN;
    }
})()

InformationsquelleAutor der Antwort kennebec

4

Den ES5 Skillung weicht von der nach ISO8601 spec, vor allem, wenn es um die Behandlung von Daten ohne eine Zeitzone-Anzeige /offset. Es ist ein bug-ticket bei https://bugs.ecmascript.org/show_bug.cgi?id=112 die das problem beschreiben, und es sieht aus wie es wird behoben werden in ES6.

Für jetzt, ich empfehlen, sich auf https://github.com/csnover/js-iso8601 für eine cross-browser-Implementierung. Ich benutze https://github.com/csnover/js-iso8601/tree/lax, die nicht konform zu den ES5 spec, hat aber eine bessere Interoperabilität mit anderen JSON serialisieren Bibliotheken wie JSON.NET.

InformationsquelleAutor der Antwort Will Holley
2

Fand ich ckozl Antwort wirklich nützlich und interessant, aber der regexp ist nicht perfekt, und es funktionierte nicht in meinem Fall.

Abgesehen von der Tatsache, dass die Termine ohne Minuten, Sekunden oder milisecs werden nicht geparst, ISO 8501 spec sagt, dass die '-' und': '- Trennzeichen sind optional, also "2013-12-27" und "20131227" sind beide gültig. In meinem Fall ist das wichtig, weil ich bin einrichten des server-Datum und Zeit in eine JavaScript-variable von PHP:
```
var serverDate = new Date(Date.parse("<?php date(DateTime::ISO8601); ?>"));
```
Erzeugt der code so etwas wie dieses:
```
<script>
var serverDate = new Date(Date.parse("2013-12-27T15:27:34+0100"));
</script>
```
Wichtig ist nur die time zone designator "+0100" wo die ':' fehlt. Obwohl Firefox analysiert die Zeichenfolge korrekt, IE (11) fehlschlägt (wenn der ':' ist Hinzugefügt, dann wird IE auch funktioniert). Die Kopfschmerzen, über die zonetime und die ECMAScript-Spezifikationen beschrieben ckozl ist unwichtig in meinem Fall, da PHP immer den time zone designator.

Die RegExp, die ich verwende, statt dass man von ckozl ist:
```
var regexIso8601 = /^(\d{4}|\+\d{6})(?:-?(\d{2})(?:-?(\d{2})(?:T(\d{2})(?::?(\d{2})(?::?(\d{2})(?:(?:\.|,)(\d{1,}))?)?)?(Z|([\-+])(\d{2})(?::?(\d{2}))?)?)?)?)?$/;
```
Beachten Sie, dass diese regexp ist nicht perfekt. ISO 8501 ermöglicht Woche-Spezifikation (2007-W01-1 für Montag, 1 Jan 2007), oder Dezimalzahlen in Stunden und Minuten (18.50 18:30:00 oder 18:30.25 18:30:15). Aber Sie sind ziemlich ungewöhnlich.

P. D. Diese Antwort sollte ich mir vorstellen, einen Kommentar zu die original-chozl Antwort, aber ich habe nicht genug Ruf 🙁

InformationsquelleAutor der Antwort Googol

Wie schon zuvor erwähnt, ISO-8601-Stil Termine wurden Hinzugefügt, die in ECMAScript version 5, wo die Implementierung nicht konsistent ist, und nicht in allen Browsern verfügbar. Es gibt eine Anzahl von Skript stubs zur Verfügung, aber möchten Sie vielleicht fügen Sie einfach Ihr eigenes Datum.analysieren* die Methode.

(function() {
  //ISO-8601 Date Matching
  var reIsoDate = /^(\d{4})-(\d{2})-(\d{2})((T)(\d{2}):(\d{2})(:(\d{2})(\.\d*)?)?)?(Z|[+-]00(\:00)?)?$/;
  Date.parseISO = function(val) {
    var m;

    m = typeof val === 'string' && val.match(reIsoDate);
    if (m) return new Date(Date.UTC(+m[1], +m[2] - 1, +m[3], +m[6] || 0, +m[7] || 0, +m[9] || 0, parseInt((+m[10]) * 1000) || 0));

    return null;
  }

  //MS-Ajax Date Matching
  var reMsAjaxDate = /^\\?\/Date\((\-?\d+)\)\\?\/$/;
  Date.parseAjax = function(val) {
    var m;

    m = typeof val === 'string' && val.match(reMsAjaxDate);
    if (m) return new Date(+m[1]);

    return null;
  }
}();

Verwende ich die oben beschriebene Methode für JSON.analysieren Hydratation der Termine...

JSON.parse(text, function(key, val) {
  return Date.parseISO(val) || Date.parseAjax(val) || val;
});

InformationsquelleAutor der Antwort Tracker1

1

ISO 8601 Datum-Formate wurden Hinzugefügt, ECMAScript-262 v5. Wenn also der browser ist nicht v5-kompatibel, Sie können einfach nicht erwarten werden in der Lage Umgang mit ISO-8601-Formate.

Browser nicht v5-kompatibel, kann eine allfällige Umsetzung bestimmtes Datum-Formate, die Sie wollen. Die meisten von Ihnen machen zumindest RFC822/RFC1123 Datum-Formate, aber. Beispiel:
```
var d = Date.parse("Wed, 26 Apr 2011 13:16:50 GMT+0200");
```
InformationsquelleAutor der Antwort Jürgen Thelen
0

Microsoft Sharepoint 2013 ist AUCH die Verwendung einer anderen notation z.B. "2013-04-30T22:00:00Z"

Wenn Sie möchten, verwenden Sie die REST-Dienste von sharepoint 2013 im zusammenspiel mit Internet Explorer 8 ( IE8 ) , dann ist die Lösung von ckozl NICHT funktioniert.
Youll erhalten die NaN

änderung der regex-Zeile:
```
regexIso8601 = /^(\d{4}|\+\d{6})(?:-(\d{2})(?:-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(\.(\d{1,3}))?(?:Z|([\-+])(\d{2}):(\d{2}))?)?)?)?$/;
```
damit werden die Mikrosekunden bit optional !

cheerio, Leo

InformationsquelleAutor der Antwort leo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.