web-dev-qa-db-de.com

Wie formatiere ich ein Microsoft JSON-Datum?

Ich mache meinen ersten Riss bei Ajax mit jQuery. Ich erhalte meine Daten auf meiner Seite, habe jedoch einige Probleme mit den JSON-Daten, die für Datumsdatentypen zurückgegeben werden. Im Grunde bekomme ich eine Zeichenfolge zurück, die so aussieht:

/Date(1224043200000)/

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

Zu Ihrer Information: Hier ist die Lösung, die ich mithilfe einer Kombination der folgenden Antworten 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 Rückrufmethode erhalten und die Daten auf der Seite mithilfe der Datumsformatbibliothek ordnungsgemäß angezeigt.

1930
Mark Struzinski

eval() ist nicht erforderlich. Das wird gut funktionieren:

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

Die substr() -Funktion entfernt den /Date( -Teil und die parseInt() -Funktion erhält die Ganzzahl und ignoriert den )/ am Ende. Die resultierende Nummer wird an den Konstruktor Date übergeben.


Ich habe das Radix absichtlich weggelassen (das zweite Argument für parseInt); siehe mein Kommentar unten .

Außerdem stimme ich voll und ganz zu Rorys Kommentar : ISO-8601-Daten werden diesem alten Format vorgezogen - daher sollte dieses Format im Allgemeinen nicht für Neuentwicklungen verwendet werden. In der Bibliothek excellent Json.NET finden Sie eine großartige Alternative zur Serialisierung von Daten im ISO-8601-Format.

Übergeben Sie für JSON-Daten im ISO-8601-Format die Zeichenfolge einfach an den Konstruktor Date:

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

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

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

Anschließend können Sie das Skript ein JavaScript-Datumsformat (1,2 KB, wenn es minimiert und komprimiert ist) verwenden, um es wie gewünscht anzuzeigen.

126
Panos

Für Benutzer von Newtonsoft Json.NET lesen Sie bitte - Natives JSON in IE8, Firefox 3.5 und Json.NET .

Auch die Dokumentation zum Ändern des von Json.NET geschriebenen Datumsformats ist nützlich: Serialisieren von Daten mit Json.NET

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

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

Der JSON kommt durch als

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

Zum Schluss noch etwas JavaScript, um das ISO-Datum in ein JavaScript-Datum umzuwandeln:

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);
94
Jason Jong

Das ursprüngliche Beispiel:

/Date(1224043200000)/  

spiegelt nicht die Formatierung wider, die von WCF beim Senden von Daten über WCF REST unter Verwendung der integrierten JSON-Serialisierung verwendet wird. (zumindest unter .NET 3.5, SP1)

Ich fand die Antwort hier hilfreich, aber es ist eine leichte Änderung des regulären Ausdrucks erforderlich, da der GMT-Versatz der Zeitzone an die in WCF JSON zurückgegebene Zahl (seit 1970) angehängt wird.

In einem WCF-Dienst habe ich:

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

ApptVisitLinkInfo wird einfach definiert:

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

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

/Date(1224043200000-0600)/

Beachten Sie den Zeitzonenversatz, der im Wert enthalten ist.

Der modifizierte reguläre Ausdruck:

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

Es ist etwas eifriger und packt alles zwischen den Eltern, nicht nur die erste Zahl. Die resultierende Zeit sinze 1970 plus Zeitzonenoffset kann alle in die Auswertung eingespeist werden, um ein Datumsobjekt zu erhalten.

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

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

Wiederholen Sie sich nicht - automatisieren Sie die Datumskonvertierung mit $.parseJSON()

Antworten auf Ihren Beitrag ermöglichen die manuelle Konvertierung von Datumsangaben in JavaScript-Datumsangaben. Ich habe jQueries $.parseJSON() nur ein bisschen erweitert, damit es automatisch Daten parsen kann, wenn Sie es anweisen. Es verarbeitet ASP.NET-formatierte Daten (/Date(12348721342)/) sowie ISO-formatierte Daten (2010-01-01T12.34.56.789Z), die von systemeigenen JSON-Funktionen in Browsern (und Bibliotheken wie json2.js) unterstützt werden.

Sowieso. Wenn Sie Ihren Datumskonvertierungscode nicht immer und immer wieder wiederholen möchten, empfehlen wir Ihnen, diesen Blog-Beitrag zu lesen und den Code zu erhalten, der Ihnen das Leben ein wenig erleichtert.

62
Robert Koritnik

Wenn Sie in JavaScript sagen,

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

sie werden sehen, dass es das richtige Datum ist, und Sie können es überall in JavaScript-Code mit jedem Framework verwenden.

60
John Boker

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"

59
user2007801

Aktualisiert

Wir haben eine interne UI-Bibliothek, die sowohl das in ASP.NET integrierte JSON-Format von Microsoft wie /Date(msecs)/, das ursprünglich hier abgefragt wurde, als auch das Datumsformat der meisten JSONs einschließlich JSON.NETs wie 2014-06-22T00:00:00.0 verarbeiten muss. . Außerdem müssen wir mit der Unfähigkeit von oldIE fertig werden, mit etwas anderem als 3 Dezimalstellen fertig zu werden.

Wir erkennen zuerst, welche Art von Datum wir verbrauchen, analysieren es in ein normales JavaScript Date -Objekt und formatieren es dann aus.

1) Ermitteln Sie das Microsoft-Datumsformat

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

2) Ermitteln Sie 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) MS-Datumsformat analysieren:

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

4) Analysieren Sie das ISO-Datumsformat.

Wir können zumindest sicherstellen, dass es sich um Standard-ISO-Daten oder ISO-Daten handelt, die so geändert wurden, dass sie immer drei Millisekunden haben ( siehe oben ), daher ist der Code je nach Umgebung unterschiedlich.

4a) Analysieren Sie das standardmäßige ISO-Datumsformat, um die Probleme von oldIE zu lösen:

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) Analysieren Sie das ISO-Format mit einer festen Drei-Millisekunden-Dezimalstelle - viel einfacher:

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

5) Formatieren Sie 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) Alles zusammenbinden:

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 unten stehende alte Antwort ist nützlich, um diese Datumsformatierung in das JSON-Parsing von jQuery zu integrieren, sodass Sie Datumsobjekte anstelle von Zeichenfolgen erhalten oder wenn Sie immer noch in jQuery <1.5 festsitzen.

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:

// 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 verhindern, dass die Methode parseJSON global überschrieben wird, indem Sie die Option converters im Ajax-Aufruf verwenden.

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

Leider müssen Sie auf die ältere Auswertungsroute wechseln, um die Daten global zu analysieren. Andernfalls müssen Sie sie nach dem Parsen von Fall zu Fall konvertieren.

37
Chris Moschini

Ich musste auch nach einer Lösung für dieses Problem suchen und bin schließlich auf moment.js gestoßen, eine nette Bibliothek, die dieses Datumsformat und vieles mehr analysieren kann.

var d = moment(yourdatestring)

Es ersparte mir Kopfschmerzen und ich dachte, ich würde es mit dir teilen. :)
Weitere Informationen dazu finden Sie hier: http://momentjs.com/

24
Venemo

Es gibt keinen eingebauten Datumstyp in JSON . Dies sieht aus wie die Anzahl der Sekunden/Millisekunden aus einer bestimmten Epoche. Wenn Sie die Epoche kennen, können Sie das Datum erstellen, indem Sie die richtige Zeit hinzufügen.

23
johnstok

Am Ende habe ich die "Zeichen in den regulären Ausdruck von Panos eingefügt, um die Zeichen zu entfernen, die vom Microsoft-Serializer beim Schreiben von Objekten in ein Inline-Skript generiert wurden:

Also, wenn Sie eine Eigenschaft in Ihrem C # haben Code-Behind das ist so etwas wie

protected string JsonObject { get { return jsSerialiser.Serialize(_myObject); }}

Und in deinem Aspx hast du

<script type="text/javascript">
    var myObject = '<%= JsonObject %>';
</script>

Sie würden so etwas bekommen

var myObject = '{"StartDate":"\/Date(1255131630400)\/"}';

Beachten Sie die doppelten Anführungszeichen.

Um dies in eine Form zu bringen, die eval korrekt deserialisiert, habe ich Folgendes verwendet:

myObject = myObject.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');

Ich benutze Prototype und fügte hinzu, um es zu verwenden

String.prototype.evalJSONWithDates = function() {
    var jsonWithDates = this.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');
    return jsonWithDates.evalJSON(true);
}
23
Chris Woodward

In jQuery 1.5 können Sie, solange Sie json2.js haben, um ältere Browser abzudecken, alle von Ajax kommenden Daten wie folgt deserialisieren:

(function () {
    var DATE_START = "/Date(";
    var DATE_START_LENGTH = DATE_START.length;

    function isDateString(x) {
        return typeof x === "string" && x.startsWith(DATE_START);
    }

    function deserializeDateString(dateString) {
        var dateOffsetByLocalTime = new Date(parseInt(dateString.substr(DATE_START_LENGTH)));
        var utcDate = new Date(dateOffsetByLocalTime.getTime() - dateOffsetByLocalTime.getTimezoneOffset() * 60 * 1000);
        return utcDate;
    }

    function convertJSONDates(key, value) {
      if (isDateString(value)) {
        return deserializeDateString(value);
      }
      return value;
    }

    window.jQuery.ajaxSetup({
      converters: {
        "text json": function(data) {
          return window.JSON.parse(data, convertJSONDates);
        }
      }
    });
}());

Ich habe eine Logik eingefügt, die davon ausgeht, dass Sie alle Daten vom Server als UTC senden (was Sie tun sollten). Der Verbraucher erhält dann ein JavaScript Date -Objekt, das den richtigen Tick-Wert aufweist, um dies widerzuspiegeln. Das heißt, wenn Sie am Datum getUTCHours() usw. aufrufen, wird derselbe Wert wie auf dem Server zurückgegeben, und wenn Sie getHours() aufrufen, wird der Wert in der lokalen Zeitzone des Benutzers zurückgegeben, wie vom Browser festgelegt.

Dies berücksichtigt nicht das Format WCF mit Zeitzonenversätzen, obwohl dies relativ einfach hinzuzufügen wäre.

21
Domenic

Überdenken Sie das nicht. Übergeben Sie wie seit Jahrzehnten einen numerischen Versatz von der De-facto-Standard-Epoche vom 1. Januar 1970 um Mitternacht (GMT/UTC/& c) in Sekunden (oder Millisekunden) seit dieser Epoche. JavaScript mag es, Java mag es, C mag es und das Internet mag es.

19
Jé Queue

Verwenden des Datepickers für die jQuery-Benutzeroberfläche - ist nur dann sinnvoll, wenn Sie bereits die jQuery-Benutzeroberfläche einbinden:

$.datepicker.formatDate('MM d, yy', new Date(parseInt('/Date(1224043200000)/'.substr(6)))); 

ausgabe:

15. Oktober 2008

19
dominic

Alle diese Antworten haben eines gemeinsam: Sie speichern Datumsangaben als einen einzigen Wert (normalerweise als Zeichenfolge).

Eine andere Möglichkeit besteht darin, die inhärente Struktur von JSON zu nutzen und ein Datum als Liste von Zahlen darzustellen:

{ "name":"Nick",
  "birthdate":[1968,6,9] }

Natürlich müssten Sie sicherstellen, dass sich beide Gesprächsenden auf das Format (Jahr, Monat, Tag) einigen und festlegen, welche Felder Datumsangaben sein sollen. Dies hat jedoch den Vorteil, dass die Ausgabe von Datumsangaben vollständig vermieden wird -to-String-Konvertierung. Es sind alles Zahlen - überhaupt keine Schnüre. Wenn Sie die Reihenfolge Jahr, Monat und Tag verwenden, können Sie auch nach Datum sortieren.

Denken Sie hier einfach über den Tellerrand hinaus - ein JSON-Datum muss nicht als Zeichenfolge gespeichert werden.

Ein weiterer Vorteil dieser Methode besteht darin, dass Sie alle Datensätze für ein bestimmtes Jahr oder einen bestimmten Monat einfach (und effizient) auswählen können, indem Sie die Methode CouchDB verwenden, um Abfragen zu Array-Werten zu verarbeiten.

18
Nick Perkins

Posting in einem tollen Thread:

var d = new Date(parseInt('/Date(1224043200000)/'.slice(6, -2)));
alert('' + (1 + d.getMonth()) + '/' + d.getDate() + '/' + d.getFullYear().toString().slice(-2));
16
Dan Beam
var newDate = dateFormat(jsonDate, "mm/dd/yyyy"); 

Gibt es eine andere Option, ohne die jQuery-Bibliothek zu verwenden?

15
Bilgin Kılıç

Um hier einen weiteren Ansatz hinzuzufügen, der "Ticks-Ansatz", der WCF verwendet, ist anfällig für Probleme mit Zeitzonen, wenn Sie nicht besonders vorsichtig sind, wie in hier und in beschrieben andere Plätze. Daher verwende ich jetzt das ISO 8601-Format, das sowohl .NET als auch JavaScript ordnungsgemäß unterstützen und das Zeitzonen-Offsets enthält. Unten sind die Details:

In WCF/.NET:

wobei CreationDate ein System.DateTime ist; ToString ("o") verwendet .NETs Round-Trip-Formatbezeichner , der eine ISO 8601-kompatible Datumszeichenfolge generiert

new MyInfo {
    CreationDate = r.CreationDate.ToString("o"),
};

In JavaScript

Unmittelbar nach dem Abrufen des JSON werden die Daten mit dem Date-Konstruktor, der eine ISO 8601-Datumszeichenfolge akzeptiert, als JavaSript-Datumsobjekte festgelegt ...

$.getJSON(
    "MyRestService.svc/myinfo",
    function (data) {
        $.each(data.myinfos, function (r) {
            this.CreatedOn = new Date(this.CreationDate);
        });
        // Now each myinfo object in the myinfos collection has a CreatedOn field that is a real JavaScript date (with timezone intact).
       alert(data.myinfos[0].CreationDate.toLocaleString());
    }
)

Sobald Sie ein JavaScript-Datum haben, können Sie alle praktischen und zuverlässigen Datumsmethoden wie toDateString , toLocaleString usw. verwenden.

15
Scott Willeke

Dies kann Ihnen auch helfen.

 function ToJavaScriptDate(value) { //To Parse Date from the Returned Parsed Date
        var pattern = /Date\(([^)]+)\)/;
        var results = pattern.exec(value);
        var dt = new Date(parseFloat(results[1]));
        return (dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear();
    }
10
Ravi Mehta

Ich bekomme das Datum so:

"/Date(1276290000000+0300)/"

In einigen Beispielen liegt das Datum in leicht unterschiedlichen Formaten vor:

"/Date(12762900000000300)/"
"Date(1276290000000-0300)"

usw.

Also habe ich mir folgenden RegExp ausgedacht:

/\/+Date\(([\d+]+)\)\/+/

und der endgültige Code lautet:

var myDate = new Date(parseInt(jsonWcfDate.replace(/\/+Date\(([\d+-]+)\)\/+/, '$1')));

Ich hoffe es hilft.

Update: Ich habe diesen Link von Microsoft gefunden: Wie serialisiere ich Daten mit JSON?

Dies scheint die zu sein, nach der wir alle suchen.

9

Sie können auch die JavaScript-Bibliothek moment.js verwenden, die nützlich ist, wenn Sie verschiedene lokalisierte Formate bearbeiten und andere Operationen mit Datumswerten ausführen möchten:

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

    function (result) {
        $("#AuthMerchId").text(result.AuthorizationMerchantId);
        $("#SttlMerchId").text(result.SettlementMerchantId);
        $("#CreateDate").text(moment(result.AppendDts).format("L"));
        $("#ExpireDate").text(moment(result.ExpiresDts).format("L"));
        $("#LastUpdate").text(moment(result.LastUpdateDts).format("L"));
        $("#LastUpdatedBy").text(result.LastUpdateNt);
        $("#ProcessIn").text(result.ProcessIn);
    }
    );
    return false;
}

Das Einrichten der Lokalisierung ist so einfach wie das Hinzufügen von Konfigurationsdateien (diese erhalten Sie bei momentjs.com) zu Ihrem Projekt und das Konfigurieren der Sprache:

moment.lang('de');
9
martinoss

Das ist frustrierend. Meine Lösung bestand darin, das "/ und /" aus dem von ASP.NETs JavaScriptSerializer generierten Wert herauszusuchen, damit JSON zwar kein Datumsliteral hat, aber dennoch vom Browser als Datum interpretiert wird wollen: {"myDate":Date(123456789)}

Benutzerdefinierter JavaScriptConverter für DateTime?

Ich muss die Richtigkeit von Roy Tinkers Kommentar betonen. Dies ist kein legaler JSON. Es ist ein schmutziger, schmutziger Hack auf dem Server, um das Problem zu beheben, bevor es zu einem Problem für JavaScript wird. Es wird ein JSON-Parser ersticken. Ich habe es benutzt, um auf die Beine zu kommen, aber ich benutze es nicht mehr. Ich bin jedoch der Meinung, dass die beste Antwort darin besteht, zu ändern, wie der Server das Datum formatiert, z. B. ISO, wie an anderer Stelle erwähnt.

9
StarTrekRedneck

Prüfen Sie den ISO-Standard für das Datum. Art wie folgt aus:

yyyy.MM.ddThh:mm

Es wird 2008.11.20T22:18.

9
Thomas Hansen
var obj = eval('(' + "{Date: \/Date(1278903921551)\/}".replace(/\/Date\((\d+)\)\//gi, "new Date($1)") + ')');
var dateValue = obj["Date"];
9
在路上

Im Folgenden finden Sie eine ziemlich einfache Lösung zum Parsen von JSON-Daten. Verwenden Sie die folgenden Funktionen gemäß Ihrer Anforderung. Sie müssen lediglich das als Parameter abgerufene JSON-Format Datum an die folgenden Funktionen übergeben:

function JSONDate(dateStr) {
    var m, day;
    jsonDate = dateStr;
    var d = new Date(parseInt(jsonDate.substr(6)));
    m = d.getMonth() + 1;
    if (m < 10)
        m = '0' + m
    if (d.getDate() < 10)
        day = '0' + d.getDate()
    else
        day = d.getDate();
    return (m + '/' + day + '/' + d.getFullYear())
}

function JSONDateWithTime(dateStr) {
    jsonDate = dateStr;
    var d = new Date(parseInt(jsonDate.substr(6)));
    var m, day;
    m = d.getMonth() + 1;
    if (m < 10)
        m = '0' + m
    if (d.getDate() < 10)
        day = '0' + d.getDate()
    else
        day = d.getDate();
    var formattedDate = m + "/" + day + "/" + d.getFullYear();
    var hours = (d.getHours() < 10) ? "0" + d.getHours() : d.getHours();
    var minutes = (d.getMinutes() < 10) ? "0" + d.getMinutes() : d.getMinutes();
    var formattedTime = hours + ":" + minutes + ":" + d.getSeconds();
    formattedDate = formattedDate + " " + formattedTime;
    return formattedDate;
}
9
Umar Malik

Fügen Sie das jQuery UI Plugin in Ihre Seite ein:

function DateFormate(dateConvert) {
    return $.datepicker.formatDate("dd/MM/yyyy", eval('new ' + dateConvert.slice(1, -1)));
};
9
Thulasiram

Ein später Beitrag, aber für diejenigen, die diesen Beitrag gesucht haben.

Stell dir das vor:

    [Authorize(Roles = "Administrator")]
    [Authorize(Roles = "Director")]
    [Authorize(Roles = "Human Resources")]
    [HttpGet]
    public ActionResult GetUserData(string UserIdGuidKey)
    {
        if (UserIdGuidKey!= null)
        {
            var guidUserId = new Guid(UserIdGuidKey);
            var memuser = Membership.GetUser(guidUserId);
            var profileuser = Profile.GetUserProfile(memuser.UserName);
            var list = new {
                              UserName = memuser.UserName,
                              Email = memuser.Email ,
                              IsApproved = memuser.IsApproved.ToString() ,
                              IsLockedOut = memuser.IsLockedOut.ToString() ,
                              LastLockoutDate = memuser.LastLockoutDate.ToString() ,
                              CreationDate = memuser.CreationDate.ToString() ,
                              LastLoginDate = memuser.LastLoginDate.ToString() ,
                              LastActivityDate = memuser.LastActivityDate.ToString() ,
                              LastPasswordChangedDate = memuser.LastPasswordChangedDate.ToString() ,
                              IsOnline = memuser.IsOnline.ToString() ,
                              FirstName = profileuser.FirstName ,
                              LastName = profileuser.LastName ,
                              NickName = profileuser.NickName ,
                              BirthDate = profileuser.BirthDate.ToString() ,
            };
            return Json(list, JsonRequestBehavior.AllowGet);
        }
        return Redirect("Index");
    }

Wie Sie sehen, verwende ich die Funktion von C # 3.0 zum Erstellen der "automatischen" Generics. Es ist ein bisschen faul, aber ich mag es und es funktioniert. Nur eine Anmerkung: Profil ist eine benutzerdefinierte Klasse, die ich für mein Webanwendungsprojekt erstellt habe.

8
Ray Linder

Mootools Lösung:

new Date(Date(result.AppendDts)).format('%x')

Benötigt mootools-more. Getestet mit mootools-1.2.3.1-more unter Firefox 3.6.3 und IE 7.0.5730.13

8
Midhat

Zu Ihrer Information, für alle, die Python auf der Serverseite verwenden: datetime.datetime (). Ctime () gibt eine Zeichenfolge zurück, die von Haus aus mit "new Date ()" syntaktisch analysiert werden kann. Wenn Sie also eine neue datetime.datetime-Instanz erstellen (z. B. mit datetime.datetime.now), kann die Zeichenfolge in die JSON-Zeichenfolge eingeschlossen werden, und diese Zeichenfolge kann dann als erstes Argument an den Date-Konstruktor übergeben werden. Ich habe noch keine Ausnahmen gefunden, aber ich habe es auch nicht zu streng getestet.

7
Kyle Alan Hale

Was ist, wenn . NET zurückgibt ...

return DateTime.Now.ToString("u"); //"2013-09-17 15:18:53Z"

Und dann in JavaScript ...

var x = new Date("2013-09-17 15:18:53Z");
7

Im folgenden Code. ich habe

1. Der Zeitstempel wurde aus der Datumszeichenfolge abgerufen.

2. Und zerlegte es in Int

. Endlich ein Date damit erstellt.

var dateString = "/Date(1224043200000)/";
var seconds = parseInt(dateString.replace(/\/Date\(([0-9]+)[^+]\//i, "$1"));
var date = new Date(seconds);
console.log(date);
5

Nebenbei bemerkt, unterstützt KendoUI die Konvertierung von Microsoft JSON-Datumsangaben. Wenn Ihr Projekt den Verweis auf "KendoUI" hat, können Sie einfach verwenden

var newDate = kendo.parseDate(jsonDate);
2
Safeer Hussain

Dies verwendet ein regulärer Ausdruck und es funktioniert auch:

var date = new Date(parseInt(/^\/Date\((.*?)\)\/$/.exec(jsonDate)[1], 10));
2
Vlad Bezden

Der einfachste Weg, den ich vorschlagen kann, ist die Verwendung von Regex für JS als:

//Only use [0] if you are sure that the string matches the pattern
//Otherwise, verify if 'match' returns something
"/Date(1512488018202)/".match(/\d+/)[0] 
2
Reuel Ribeiro

Ein weiteres Beispiel für Regex, das Sie verwenden können:

var mydate = json.date
var date = new Date(parseInt(mydate.replace(/\/Date\((-?\d+)\)\//, '$1');
mydate = date.getMonth() + 1 + '/' + date.getDate() + '/' + date.getFullYear();

date.getMonth() gibt eine Ganzzahl von 0 bis 11 zurück, daher müssen wir 1 addieren, um die richtige Monatszahl zu erhalten

2
Luminous

Versuche dies...

function formatJSONDate(jsonDate) {
            var date = jsonDate;
            var parsedDate = new Date(parseInt(date.toString().substring(6)));
            var newDate = new Date(parsedDate);
            var getMonth = newDate.getMonth() + 1;
            var getDay = newDate.getDay();
            var getYear = newDate.getFullYear(); 

            var standardDate = (getMonth<10 ? '0' : '') + getMonth + '/' + (getDay<10 ? '0' : '') + getDay + '/' + getYear;
            return standardDate;
        }

getYear () gibt das Jahr zurück - 1900, Dies ist seit einiger Zeit veraltet. Verwenden Sie am besten getFullYear ().

2
Noor All Safaet

Ich benutze diese einfache Funktion, um das Datum von Microsoft JSON Date zu erhalten

function getDateValue(dateVal) {
    return new Date(parseInt(dateVal.replace(/\D+/g, '')));
};

replace(/\D+/g, '') entfernt alle Zeichen außer Zahlen

parseInt konvertiert den String in eine Zahl

Verwendungszweck

$scope.ReturnDate = getDateValue(result.JSONDateVariable)
1

Es ist einfach, ein JSON-Datum in ein JavaScript-Datum umzuwandeln:

var s = Response.StartDate;     
s = s.replace('/Date(', '');

s = s.replace(')/', '');

var expDate = new Date(parseInt(s));
1
user1814380

TLDR: Sie können diesen Nur-Datum-Wert nicht zuverlässig konvertieren, sondern stattdessen eine Zeichenfolge senden ...

... oder zumindest sollten fast alle diese Antworten so beginnen.

Es gibt eine Reihe von Konvertierungsproblemen, die hier auftreten.

Dies ist ein Datum ohne Zeit

Offenbar fehlt allen, wie viele nachgestellte Nullen es in der Frage gibt - es wird mit ziemlicher Sicherheit als Datum ohne Zeit begonnen:

/Date(1224043200000)/

Bei Ausführung über eine Javascript-Konsole als neues Datum (Grundlage vieler Antworten)

new Date(1224043200000)

Du kriegst:

enter image description here

Der ursprüngliche Fragesteller war wahrscheinlich in EST und hatte ein reines Datum (sql) oder eine DateTime (nicht DateTimeOffset) mit Mitternacht.

Mit anderen Worten ist hier beabsichtigt, dass der Zeitanteil bedeutungslos ist. Wenn der Browser dies jedoch in derselben Zeitzone ausführt wie der Server, auf dem es erstellt wurde, spielt es keine Rolle, und die meisten Antworten funktionieren.

Bit By Timezone

Wenn Sie den obigen Code jedoch auf einem Computer mit einer anderen Zeitzone ausführen (z. B. PST):

enter image description here

Sie werden feststellen, dass wir in dieser anderen Zeitzone jetzt einen Tag hinter liegen. Dies wird nicht durch Ändern des Serializers behoben (der weiterhin die Zeitzone im ISO-Format enthält).

Das Problem

Date (sql) und DateTime (.net) haben keine Zeitzone, aber sobald Sie sie in etwas konvertieren, das dies bewirkt (in diesem Fall wird Javascript durch json abgeleitet), ist die Standardaktion in .net, die aktuelle Zeitzone anzunehmen .

Die Nummer, die die Serialisierung erstellt, ist Millisekunden seit Unix Epoch oder:

(DateTimeOffset.Parse("10/15/2008 00:00:00Z") - DateTimeOffset.Parse("1/1/1970 00:00:00Z")).TotalMilliseconds;

Welches ist etwas, das new Date () in Javascript als Parameter nimmt. Die Epoche ist von UTC, also haben Sie jetzt Zeitzoneninformationen, ob Sie es wollten oder nicht.

Mögliche Lösungen:

Es ist möglicherweise sicherer, eine Zeichenfolge-Eigenschaft für Ihr serialisiertes Objekt zu erstellen, die NUR das Datum darstellt. Eine Zeichenfolge mit "15.10.2008" wird wahrscheinlich niemanden mit diesem Durcheinander verwechseln. Auch dort müssen Sie beim Parsen vorsichtig sein: https://stackoverflow.com/a/31732581

Im Geiste der Beantwortung der gestellten Frage gilt jedoch Folgendes:

function adjustToLocalMidnight(serverMidnight){ 
  var serverOffset=-240; //injected from model? <-- DateTimeOffset.Now.Offset.TotalMinutes
  var localOffset=-(new Date()).getTimezoneOffset(); 
  return new Date(date.getTime() + (serverOffset-localOffset) * 60 * 1000)
}

var localMidnightDate = adjustToLocalMidnight(new Date(parseInt(jsonDate.substr(6))));
1
b_levitt