Pierwszy raz robię crack w Ajaxie z jQuery. Dostaję moje dane na moją stronę, ale mam problemy z danymi JSON zwracanymi dla typów danych Date. Zasadniczo otrzymuję ciąg znaków, który wygląda następująco:

/Date(1224043200000)/

Od kogoś zupełnie nowego do JSON - Jak sformatować to na krótki termin? Czy należy to rozwiązać gdzieś w kodzie jQuery? Próbowałem jQuery.UI.datepickerużywać wtyczki $.datepicker.formatDate()bez powodzenia.

FYI: Oto rozwiązanie, które wymyśliłem, używając kombinacji odpowiedzi tutaj:

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

To rozwiązanie pobrało mój obiekt z metody wywołania zwrotnego i poprawnie wyświetlało daty na stronie przy użyciu biblioteki formatu daty.

eval()to nie jest konieczne. To zadziała dobrze:

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

substr()Funkcja wyjmuje /Date(część oraz parseInt()funkcja pobiera całkowitą i ignoruje )/na końcu. Wynikowa liczba jest przekazywana do Datekonstruktora.

Celowo pominąłem podstawkę (drugi argument do parseInt); zobacz mój komentarz poniżej .

Ponadto całkowicie zgadzam się z komentarzem Rory'ego : daty ISO-8601 są preferowane w stosunku do tego starego formatu - więc ten format zasadniczo nie powinien być używany do nowego programowania. Zobacz doskonałą bibliotekę Json.NET, która stanowi doskonałą alternatywę szeregowania dat przy użyciu formatu ISO-8601.

W przypadku dat JSON sformatowanych według ISO-8601 wystarczy przekazać ciąg do Datekonstruktora:

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

Możesz użyć tego, aby uzyskać datę z JSON:

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

Następnie możesz użyć skryptu formatu daty JavaScript (1,2 KB po zminimalizowaniu i spakowaniu gzip), aby wyświetlić go tak, jak chcesz.

Dla tych, którzy używają Newtonsoft Json.NET , przeczytaj, jak to zrobić przez Native JSON w IE8, Firefox 3.5 oraz Json.NET .

Przydatna jest również dokumentacja dotycząca zmiany formatu dat napisana przez Json.NET: Serializacja dat w Json.NET

Dla tych, którzy są zbyt leniwi, oto krótkie kroki. Ponieważ JSON ma luźną implementację DateTime, musisz użyć IsoDateTimeConverter(). Zauważ, że od Json.NET 4.5 domyślnym formatem daty jest ISO, więc poniższy kod nie jest potrzebny.

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

JSON przejdzie jako

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

Na koniec niektóre JavaScript do konwersji daty ISO na datę JavaScript:

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

Użyłem tego w ten sposób

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

Oryginalny przykład:

/Date(1224043200000)/  

nie odzwierciedla formatowania używanego przez WCF podczas wysyłania dat przez REST WCF przy użyciu wbudowanej serializacji JSON. (przynajmniej w .NET 3.5, SP1)

Uznałem, że odpowiedź tutaj jest pomocna, ale wymagana jest niewielka modyfikacja wyrażenia regularnego, ponieważ wydaje się, że przesunięcie strefy czasowej GMT jest dołączane do liczby zwracanej (od 1970 r.) W WCF JSON.

W serwisie WCF mam:

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

ApptVisitLinkInfo definiuje się po prostu:

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

Gdy „Field2” jest zwracane jako Json z usługi, wartość wynosi:

/Date(1224043200000-0600)/

Zwróć uwagę na przesunięcie strefy czasowej uwzględnione jako część wartości.

Zmodyfikowane wyrażenie regularne:

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

Jest nieco bardziej chętny i chwyta wszystko między parens, nie tylko pierwszą liczbę. Wynikowy czas sinze 1970 plus przesunięcie strefy czasowej można wprowadzić do eval, aby uzyskać obiekt daty.

Wynikowa linia JavaScript do zamiany to:

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

Nie powtarzaj się - zautomatyzuj konwersję dat za pomocą $.parseJSON()

Odpowiedzi na Twój post zapewniają ręczną konwersję dat na daty JavaScript. Rozszerzyłem jQuery $.parseJSON()tylko trochę, więc jest w stanie automatycznie parsować daty, kiedy go poinstruujesz. Przetwarza daty w formacie ASP.NET ( /Date(12348721342)/) oraz daty w formacie ISO ( 2010-01-01T12.34.56.789Z), które są obsługiwane przez rodzime funkcje JSON w przeglądarkach (i bibliotekach takich jak json2.js).

Tak czy siak. Jeśli nie chcesz powtarzać kodu konwersji daty w kółko, sugeruję przeczytanie tego postu na blogu i uzyskanie kodu, który ułatwi ci życie.

Jeśli powiesz w JavaScript,

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

zobaczysz, że jest to poprawna data i możesz jej użyć w dowolnym miejscu w kodzie JavaScript z dowolnym frameworkiem.

Kliknij tutaj, aby sprawdzić wersję demo

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

Wynik - „10/15/2008”

Zaktualizowano

Mamy wewnętrzną bibliotekę interfejsu użytkownika, która musi poradzić sobie zarówno z wbudowanym formatem JSON Microsoft.NET.NET firmy Microsoft, jak /Date(msecs)/pierwotnie zapytano o nią, jak i z większością formatu daty JSON, w tym JSON.NET 2014-06-22T00:00:00.0. Ponadto musimy poradzić sobie z niezdolnością oldIE do radzenia sobie z czymkolwiek innym niż 3 miejsca dziesiętne .

Najpierw wykrywamy, jaką datę zużywamy, analizujemy w zwykły Dateobiekt JavaScript , a następnie formatujemy.

1) Wykryj format daty Microsoft

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

2) Wykryj format daty ISO

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) Format daty parsowania MS:

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

4) Analizuj format daty ISO.

Mamy przynajmniej sposób na upewnienie się, że mamy do czynienia ze standardowymi datami ISO lub datami ISO zmodyfikowanymi tak, aby zawsze miały trzy milisekundowe miejsca ( patrz wyżej ), więc kod różni się w zależności od środowiska.

4a) Analizować standardowy format daty ISO, radzić sobie z problemami 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) Parsuj format ISO ze stałymi miejscami dziesiętnymi milisekund - znacznie łatwiej:

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

5) Sformatuj:

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) Zwiąż wszystko razem:

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

    return formatDate(d);
}

Poniższa stara odpowiedź jest przydatna do powiązania formatowania daty z własnym parsowaniem JSON jQuery, aby uzyskać obiekty Date zamiast ciągów, lub jeśli nadal utkniesz w jQuery <1.5.

Stara odpowiedź

Jeśli używasz funkcji Ajax jQuery 1.4 z ASP.NET MVC, możesz przekształcić wszystkie właściwości DateTime w obiekty Date za pomocą:

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

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

W jQuery 1.5 możesz uniknąć parseJSONglobalnego zastąpienia metody, używając opcji konwerterów w wywołaniu Ajax.

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

Niestety musisz przełączyć się na starszą ścieżkę ewaluacyjną, aby Daty mogły parsować globalnie w miejscu - w przeciwnym razie musisz je przekonwertować po analizie poszczególnych przypadków.

W JSON nie ma wbudowanego typu daty . Wygląda to na liczbę sekund / milisekund z pewnej epoki. Jeśli znasz epokę, możesz utworzyć datę, dodając odpowiednią ilość czasu.

Musiałem także znaleźć rozwiązanie tego problemu i ostatecznie natknąłem się na moment.js, która jest fajną biblioteką, która może analizować ten format daty i wiele innych.

var d = moment(yourdatestring)

Oszczędzało mi to bólu głowy, więc pomyślałem, że podzielę się tym z tobą. :)
Więcej informacji na ten temat można znaleźć tutaj: http://momentjs.com/

Skończyło się na dodawaniu „znaków do wyrażenia regularnego Panos, aby pozbyć się tych generowanych przez serializator Microsoft podczas pisania obiektów w skrypcie wbudowanym:

Więc jeśli masz właściwość w swoim C # za kodem , to coś takiego

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

A w aspx masz

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

Dostałbyś coś takiego

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

Zwróć uwagę na podwójne cytaty.

Aby przekształcić to w postać, która eval poprawnie poprawi deserializację, użyłem:

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

Używam Prototypu i do tego dodałem

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

W jQuery 1.5, o ile masz plik json2.js na starsze przeglądarki, możesz dokonać deserializacji wszystkich dat pochodzących z Ajax w następujący sposób:

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

Podałem logikę, która zakłada, że ​​wysyłasz wszystkie daty z serwera jako UTC (co powinieneś); konsument otrzymuje następnie Dateobiekt JavaScript, który ma odpowiednią wartość tików, aby to odzwierciedlić. Oznacza to, że wywołanie getUTCHours()itp. W dniu zwróci tę samą wartość, co na serwerze, a wywołanie getHours()zwróci wartość w lokalnej strefie czasowej użytkownika określonej przez przeglądarkę.

Nie bierze to pod uwagę formatu WCF z przesunięciami stref czasowych, chociaż byłoby to stosunkowo łatwe do dodania.

Korzystanie z datepicker interfejsu użytkownika jQuery - naprawdę ma sens tylko wtedy, gdy już dołączasz interfejs użytkownika jQuery:

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

wynik:

15 października 2008 r

Nie przesadzaj z tym. Tak jak robiliśmy to od dziesięcioleci, podaj liczbowe przesunięcie w stosunku do faktycznej standardowej epoki 1 stycznia 1970 r. O północy GMT / UTC / cw liczbie sekund (lub milisekund) od tej epoki. JavaScript to lubi, Java to lubi, C to lubi, a Internet to lubi.

Każda z tych odpowiedzi ma jedną wspólną cechę: wszystkie przechowują daty jako jedną wartość (zwykle ciąg znaków).

Inną opcją jest skorzystanie z wbudowanej struktury JSON i przedstawienie daty jako listy liczb:

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

Oczywiście musisz upewnić się, że oba końce rozmowy zgadzają się co do formatu (rok, miesiąc, dzień) i które pola mają być datami, ale ma tę zaletę, że całkowicie omija problem daty konwersja na ciąg znaków. To wszystkie liczby - bez żadnych ciągów. Ponadto, korzystając z zamówienia: rok, miesiąc, dzień, można również prawidłowo sortować według daty.

Po prostu myślę tutaj nieszablonowo - data JSON nie musi być przechowywana jako ciąg.

Kolejną zaletą robienia tego w ten sposób jest to, że możesz łatwo (i wydajnie) wybierać wszystkie rekordy dla danego roku lub miesiąca, wykorzystując sposób, w jaki CouchDB obsługuje zapytania o wartości macierzy.

Publikowanie w niesamowitym wątku:

var d = new Date(parseInt('/Date(1224043200000)/'.slice(6, -2)));
alert('' + (1 + d.getMonth()) + '/' + d.getDate() + '/' + d.getFullYear().toString().slice(-2));

Aby dodać tutaj inne podejście, „podejście tykania”, które stosuje WCF, jest podatne na problemy ze strefami czasowymi, jeśli nie jesteś wyjątkowo ostrożny, jak opisano tutaj i w innych miejscach. Teraz używam formatu ISO 8601, który odpowiednio obsługuje .NET i JavaScript, który obejmuje przesunięcia stref czasowych. Poniżej znajdują się szczegóły:

W WCF / .NET:

Gdzie CreationDate jest System.DateTime; ToString („o”) używa specyfikatora formatu .NET w obie strony, który generuje ciąg daty zgodny z ISO 8601

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

W JavaScript

Zaraz po pobraniu JSON idę ustawić daty na obiekty JavaSript Date za pomocą konstruktora Date, który akceptuje ciąg dat ISO 8601 ...

$.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());
    }
)

Gdy masz już datę JavaScript, możesz użyć wszystkich wygodnych i niezawodnych metod Date, takich jak toDateString , toLocaleString itp.

var newDate = dateFormat(jsonDate, "mm/dd/yyyy"); 

Czy istnieje inna opcja bez korzystania z biblioteki jQuery?

To może ci również pomóc.

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

Poniżej znajduje się dość proste rozwiązanie do analizowania dat JSON. Skorzystaj z poniższych funkcji zgodnie z wymaganiami. Musisz tylko przekazać datę JSON formatu pobranego jako parametr do poniższych funkcji:

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

Możesz także skorzystać z biblioteki JavaScript moment.js , która jest przydatna, gdy planujesz radzić sobie z różnymi zlokalizowanymi formatami i wykonywać inne operacje z wartościami dat:

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

Konfigurowanie lokalizacji jest tak proste, jak dodawanie plików konfiguracyjnych (otrzymujesz je na momentjs.com) do projektu i konfigurowanie języka:

moment.lang('de');

Mam taką datę:

"/Date(1276290000000+0300)/"

W niektórych przykładach data jest w nieco innych formatach:

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

itp.

Więc wymyśliłem następujący RegExp:

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

a końcowy kod to:

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

Mam nadzieję, że to pomoże.

Aktualizacja: Znalazłem ten link od Microsoft: Jak mogę serializować daty w JSON?

Wygląda na to, że wszyscy tego szukamy.

Sprawdź datę normy ISO; coś takiego:

yyyy.MM.ddThh:mm

Staje się 2008.11.20T22:18.

To jest frustrujące. Moim rozwiązaniem było przeanalizowanie „/ i /” z wartości wygenerowanej przez JavaScriptSerializer ASP.NET, aby chociaż JSON mógł nie mieć literału daty, nadal jest interpretowany przez przeglądarkę jako data, i tak naprawdę wszystko chcieć:{"myDate":Date(123456789)}

Niestandardowy konwerter JavaScript dla DateTime?

Muszę podkreślić trafność komentarza Roya Tinkera. To nie jest legalne JSON. Jest to brudny, brudny hack na serwerze, aby usunąć problem, zanim stanie się problemem dla JavaScript. Udusi parser JSON. Użyłem go do zejścia z ziemi, ale już go nie używam. Jednak nadal uważam, że najlepszą odpowiedzią jest zmiana sposobu formatowania daty przez serwer, na przykład ISO, jak wspomniano w innym miejscu.

Późny post, ale dla tych, którzy szukali tego postu.

Wyobraź to sobie:

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

Jak widać, używam funkcji C # 3.0 do tworzenia generycznych „Auto”. To trochę leniwe, ale podoba mi się i działa. Tylko uwaga: Profile to niestandardowa klasa, którą stworzyłem dla mojego projektu aplikacji internetowej.

Do Twojej wiadomości dla każdego, kto używa Pythona po stronie serwera: datetime.datetime (). Ctime () zwraca ciąg, który można natywnie przetwarzać przez „new Date ()”. Oznacza to, że jeśli utworzysz nową instancję datetime.datetime (na przykład z datetime.datetime.now), ciąg może zostać zawarty w ciągu JSON, a następnie ten ciąg może zostać przekazany jako pierwszy argument do konstruktora Date. Nie znalazłem jeszcze żadnych wyjątków, ale też nie testowałem tego zbyt rygorystycznie.

Rozwiązanie Mootools:

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

Wymaga mootools-more. Testowane przy użyciu mootools-1.2.3.1-more w Firefox 3.6.3 i IE 7.0.5730.13

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

Dodaj wtyczkę interfejsu użytkownika jQuery na swojej stronie:

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

Co jeśli .NET zwróci ...

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

A potem w JavaScript ...

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