Frage Wie formatiere ich ein Microsoft JSON-Datum?


Ich mache meinen ersten Fehler Ajax mit jQuery. Ich erhalte meine Daten auf meiner Seite, aber ich habe Probleme mit den JSON-Daten, die für die Datentypen "Datum" zurückgegeben werden. Im Grunde genommen bekomme ich eine Schnur zurück, die so aussieht:

/Date(1224043200000)/

Von jemandem, der JSON völlig neu ist - Wie formatiere ich das in ein kurzes Datumsformat? Sollte dies irgendwo im jQuery-Code behandelt werden? Ich habe es versucht jQuery.UI.datepicker Plugin verwenden $.datepicker.formatDate() ohne Erfolg.

FYI: Hier ist die Lösung, die ich mit einer Kombination der Antworten hier gefunden habe:

function getMismatch(id) {
  $.getJSON("Main.aspx?Callback=GetMismatch",
    { MismatchId: id },

    function (result) {
      $("#AuthMerchId").text(result.AuthorizationMerchantId);
      $("#SttlMerchId").text(result.SettlementMerchantId);
      $("#CreateDate").text(formatJSONDate(Date(result.AppendDts)));
      $("#ExpireDate").text(formatJSONDate(Date(result.ExpiresDts)));
      $("#LastUpdate").text(formatJSONDate(Date(result.LastUpdateDts)));
      $("#LastUpdatedBy").text(result.LastUpdateNt);
      $("#ProcessIn").text(result.ProcessIn);
    }
  );

  return false;
}

function formatJSONDate(jsonDate) {
  var newDate = dateFormat(jsonDate, "mm/dd/yyyy");
  return newDate;
}

Diese Lösung hat mein Objekt von der Callback-Methode erhalten und die Daten auf der Seite korrekt mit der Date-Format-Bibliothek angezeigt.


1788


Ursprung


Antworten:


Eval ist nicht notwendig. Das wird gut funktionieren:

var date = new Date(parseInt(jsonDate.substr(6)));

Die Funktion substr entnimmt den Teil "/ Date (", und die Funktion parseInt erhält die Ganzzahl und ignoriert am Ende das Zeichen ") /". Die resultierende Zahl wird an den Date-Konstruktor übergeben.

EDIT: Ich habe absichtlich das Radix (das zweite Argument zu ParseInt); sehen mein Kommentar unten. Auch stimme ich völlig zu Rorys Kommentar: ISO-8601-Daten werden gegenüber diesem alten Format bevorzugt - daher sollte dieses Format generell nicht für Neuentwicklungen verwendet werden. Sehen Sie das ausgezeichnete Json.NET Bibliothek für eine großartige Alternative, die Daten im ISO-8601-Format serialisiert.

Bei ISO-8601-formatierten JSON-Daten übergeben Sie die Zeichenfolge einfach an den Date-Konstruktor:

var date = new Date(jsonDate); //no ugly parsing needed; full timezone support

1565



Sie können dies verwenden, um ein Datum von JSON zu erhalten:

var date = eval(jsonDate.replace(/\/Date\((\d+)\)\//gi, "new Date($1)"));

Und dann kannst du verwenden ein JavaScript Datumsformat Skript (1,2 KB, wenn minimiert und gezippt), um es anzuzeigen, wie Sie möchten.


115



Für diejenigen, die Newtonsoft verwenden Json.NET, lesen Sie, wie es geht über Natives JSON in IE8, Firefox 3.5 und Json.NET.

Auch die Dokumentation zum Ändern des Datumsformats von Json.NET ist hilfreich: Serialisierung von Daten mit Json.NET

Für diejenigen, die zu faul sind, hier sind die schnellen Schritte. Da JSON über eine lose DateTime-Implementierung verfügt, müssen Sie die IsoDateTimeConverter(). Beachten Sie, dass seit Json.NET 4.5 das Standard-Datumsformat ISO ist, daher wird der folgende Code nicht benötigt.

string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());

Der JSON wird als durchkommen

"fieldName": "2009-04-12T20:44:55"

Zum Schluss noch ein wenig JavaScript, um das ISO-Datum in ein JavaScript-Datum zu konvertieren:

function isoDateReviver(value) {
  if (typeof value === 'string') {
    var a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)(?:([\+-])(\d{2})\:(\d{2}))?Z?$/.exec(value);
      if (a) {
        var utcMilliseconds = Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6]);
        return new Date(utcMilliseconds);
      }
  }
  return value;
}

Ich habe es so benutzt

$("<span />").text(isoDateReviver(item.fieldName).toLocaleString()).appendTo("#" + divName);

84



Das ursprüngliche Beispiel:

/Date(1224043200000)/  

spiegelt nicht die von WCF verwendete Formatierung wider, wenn Daten über WCF-REST mithilfe der integrierten JSON-Serialisierung gesendet werden. (mindestens auf .NET 3.5, SP1)

Ich fand die Antwort hier hilfreich, aber eine geringfügige Bearbeitung der Regex ist erforderlich, da es scheint, dass der Zeitzonen-GMT-Offset an die Zahl angehängt wird, die seit 1970 in WCF JSON zurückgegeben wird.

In einem WCF-Dienst habe ich:

[OperationContract]
[WebInvoke(
    RequestFormat = WebMessageFormat.Json,
    ResponseFormat = WebMessageFormat.Json,
    BodyStyle = WebMessageBodyStyle.WrappedRequest
    )]
ApptVisitLinkInfo GetCurrentLinkInfo( int appointmentsId );

ApptVisitLinkInfo ist einfach definiert:

public class ApptVisitLinkInfo {
    string Field1 { get; set; }
    DateTime Field2 { get; set; }
    ...
}

Wenn "Field2" als Json vom Dienst zurückgegeben wird, lautet der Wert:

/Date(1224043200000-0600)/

Beachten Sie, dass der Zeitzonenoffset als Teil des Werts enthalten ist.

Die modifizierte Regex:

/\/Date\((.*?)\)\//gi

Es ist etwas eifriger und packt alles zwischen den Parens, nicht nur die erste Nummer. Die daraus resultierende Zeit sinze 1970 plus Zeitzonen-Offset können alle in das Eval eingegeben werden, um ein Datumsobjekt zu erhalten.

Die resultierende JavaScript-Zeile für das Ersetzen lautet:

replace(/\/Date\((.*?)\)\//gi, "new Date($1)");

57



Wiederhole dich nicht - automatisiere die Datumsumwandlung mit $.parseJSON()

Antworten auf Ihren Post bieten eine manuelle Datumskonvertierung für JavaScript-Daten. Ich habe jQuery erweitert $.parseJSON() nur ein kleines bisschen, so ist es in der Lage, automatisch Daten zu analysieren, wenn Sie es anweisen. Es verarbeitet ASP.NET-formatierte Daten (/Date(12348721342)/) sowie ISO-formatierte Daten (2010-01-01T12.34.56.789Z), die von nativen JSON-Funktionen in Browsern (und Bibliotheken wie json2.js) unterstützt werden.

Sowieso. Wenn Sie Ihren Datumsumwandlungscode nicht immer wieder wiederholen möchten, empfehle ich Ihnen, zu lesen dieser Blogbeitrag und erhalte den Code, der dir das Leben ein wenig erleichtern wird.


53



Wenn Sie in JavaScript sagen,

var thedate = new Date(1224043200000);
alert(thedate);

Sie werden feststellen, dass es sich um das richtige Datum handelt, und Sie können dies überall in JavaScript-Code mit einem beliebigen Framework verwenden.


50



Klicken Sie hier, um die Demo zu sehen

JavaScript / jQuery

var = MyDate_String_Value = "/Date(1224043200000)/"
var value = new Date
            (
                 parseInt(MyDate_String_Value.replace(/(^.*\()|([+-].*$)/g, ''))
            );
var dat = value.getMonth() +
                         1 +
                       "/" +
           value.getDate() +
                       "/" +
       value.getFullYear();

Ergebnis - "15.10.2008"


46



Aktualisiert

Wir haben eine interne UI-Bibliothek, die sowohl mit dem integrierten ASP.NET-JSON-Format von Microsoft als auch mit Microsoft umgehen kann /Date(msecs)/, fragte hier ursprünglich, und die meisten JSON-Datumsformat einschließlich JSON.NET, wie 2014-06-22T00:00:00.0. Darüber hinaus müssen wir damit umgehen oldIEs Unfähigkeit, mit nur 3 Nachkommastellen fertig zu werden.

Wir erkennen zuerst, welche Art von Datum wir verbrauchen, parsen Sie es in ein normales JavaScript Date Objekt, dann formatieren Sie das aus.

1) Erkenne Microsoft Datumsformat

// Handling of Microsoft AJAX Dates, formatted like '/Date(01238329348239)/'
function looksLikeMSDate(s) {
    return /^\/Date\(/.test(s);
}

2) Erkenne das ISO-Datumsformat

var isoDateRegex = /^(\d\d\d\d)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(\.\d\d?\d?)?([\+-]\d\d:\d\d|Z)?$/;

function looksLikeIsoDate(s) {
    return isoDateRegex.test(s);
}

3) Parse MS Datumsformat:

function parseMSDate(s) {
    // Jump forward past the /Date(, parseInt handles the rest
    return new Date(parseInt(s.substr(6)));
}

4) Parse ISO Datumsformat.

Wir haben zumindest einen Weg, um sicher zu sein, dass wir uns mit Standard-ISO-Daten oder ISO-Daten befassen, die so modifiziert wurden, dass sie immer drei Millisekunden haben (siehe oben), daher ist der Code abhängig von der Umgebung unterschiedlich.

4a) Parse Standard-ISO-Datumsformat, bewältigen Sie die Probleme von OldIE:

function parseIsoDate(s) {
    var m = isoDateRegex.exec(s);

    // Is this UTC, offset, or undefined? Treat undefined as UTC.
    if (m.length == 7 ||                // Just the y-m-dTh:m:s, no ms, no tz offset - assume UTC
        (m.length > 7 && (
            !m[7] ||                    // Array came back length 9 with undefined for 7 and 8
            m[7].charAt(0) != '.' ||    // ms portion, no tz offset, or no ms portion, Z
            !m[8] ||                    // ms portion, no tz offset
            m[8] == 'Z'))) {            // ms portion and Z
        // JavaScript's weirdo date handling expects just the months to be 0-based, as in 0-11, not 1-12 - the rest are as you expect in dates.
        var d = new Date(Date.UTC(m[1], m[2]-1, m[3], m[4], m[5], m[6]));
    } else {
        // local
        var d = new Date(m[1], m[2]-1, m[3], m[4], m[5], m[6]);
    }

    return d;
}

4b) Parse ISO-Format mit einer festen drei Millisekunden Dezimalstellen - viel einfacher:

function parseIsoDate(s) {
    return new Date(s);
}

5) Formatiere es:

function hasTime(d) {
    return !!(d.getUTCHours() || d.getUTCMinutes() || d.getUTCSeconds());
}

function zeroFill(n) {
    if ((n + '').length == 1)
        return '0' + n;

    return n;
}

function formatDate(d) {
    if (hasTime(d)) {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
        s += ' ' + d.getHours() + ':' + zeroFill(d.getMinutes()) + ':' + zeroFill(d.getSeconds());
    } else {
        var s = (d.getMonth() + 1) + '/' + d.getDate() + '/' + d.getFullYear();
    }

    return s;
}

6) Binde alles zusammen:

function parseDate(s) {
    var d;
    if (looksLikeMSDate(s))
        d = parseMSDate(s);
    else if (looksLikeIsoDate(s))
        d = parseIsoDate(s);
    else
        return null;

    return formatDate(d);
}

Die folgende alte Antwort ist nützlich, um diese Datumsformatierung in jQuerys JSON-Parsing zu binden, so dass Sie Date-Objekte anstelle von Strings erhalten oder wenn Sie immer noch in jQuery <1.5 stecken bleiben.

Alte Antwort

Wenn Sie die Ajax-Funktion von jQuery 1.4 mit ASP.NET MVC verwenden, können Sie alle DateTime-Eigenschaften in Date-Objekte umwandeln mit:

// Once
jQuery.parseJSON = function(d) {return eval('(' + d + ')');};

$.ajax({
    ...
    dataFilter: function(d) {
        return d.replace(/"\\\/(Date\(-?\d+\))\\\/"/g, 'new $1');
    },
    ...
});

In jQuery 1.5 können Sie das Überschreiben vermeiden parseJSON Methode global, indem Sie die Option converters im Ajax-Aufruf verwenden.

http://api.jquery.com/jQuery.ajax/

Leider müssen Sie zu der älteren Eval-Route wechseln, um Daten zu erhalten, die global in-place analysiert werden. Andernfalls müssen Sie sie im Einzelfall nach der Analyse konvertieren.


31