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

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

A następnie możesz użyć skryptu JavaScript Date Format (1,2 KB, gdy minified i gzipped), aby wyświetlić go jak chcesz.

Dla osób korzystających z Newtonsoft Json.NET, przeczytaj Jak to zrobić poprzez natywny JSON w IE8, Firefox 3.5 plus Json.NET.

Również dokumentacja dotycząca zmiany formatu dat pisanych przez Json.NET jest przydatna: serializacja dat z Json.NET

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

JSON przejdzie jako

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

Wreszcie, niektóre JavaScript, aby przekonwertować datę ISO do daty 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 go tak

$("<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 WCF REST przy użyciu wbudowanej serializacji JSON. (przynajmniej na. Net 3.5, SP1)

Znalazłem tutaj pomocną odpowiedź, ale wymagana jest niewielka edycja regex, ponieważ wydaje się, że przesunięcie strefy czasowej GMT jest dodawane do liczby zwracanej (od 1970 roku) w WCF JSON.

W usłudze WCF mam:

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

Apptvisitlinkinfo jest zdefiniowane 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 zawarte jako część wartości.

Zmodyfikowany regex:

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

Wynikowa linia JavaScript dla replace to:

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

Nie powtarzaj się - automatyzuj konwersję daty za pomocą $.parseJSON()

Odpowiedzi na twój post zapewniają ręczną konwersję daty Na daty JavaScript. Rozszerzyłem jQuery $.parseJSON() tylko trochę, więc jest w stanie automatycznie parsować daty, gdy go polecisz. Procesy It ASP.NET formatowane daty (/Date(12348721342)/) oraz daty sformatowane ISO (2010-01-01T12.34.56.789Z), które są obsługiwane przez natywne funkcje JSON w przeglądarkach (i bibliotekach takich jak json2.js).

Jeśli powiesz w JavaScript,

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

Zobaczysz, że jest to prawidłowa data i możesz jej użyć w dowolnym miejscu w kodzie JavaScript z dowolnym frameworkiem.

Kliknij tutaj, aby sprawdzić 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 Microsoft ASP.NET wbudowany format JSON, jak /Date(msecs)/, pytany o tutaj pierwotnie, a większość formatu daty JSON, w tym JSON.NET ' s, jak 2014-06-22T00:00:00.0. Ponadto musimy poradzić sobie z niezdolnością starego do radzenia sobie z czymkolwiek poza 3 miejscami po przecinku.

Najpierw wykrywamy, jaką datę konsumujemy, analizujemy ją do normalnego obiektu JavaScript Date, a następnie formatujemy ją.

1) Wykryj Microsoft Date format

// 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) Parse MS Date format:

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

4) Parse ISO date format.

Mamy przynajmniej sposób, aby mieć pewność, że mamy do czynienia ze standardowymi datami ISO lub datami ISO zmodyfikowanymi tak, aby zawsze miały trzy milisekundy (patrz wyżej ), więc kod jest różny w zależności od środowiska.

4a) Parse standard ISO date format, radzić sobie ze starymi problemami:

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 Format ISO z ustalonymi trzema milisekundami miejsc dziesiętnych-znacznie łatwiejszy:

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

5) sformatuj go:

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żej stara odpowiedź jest przydatna do wiązania tego formatowania daty z własnym parsowaniem jQuery JSON, aby uzyskać obiekty daty zamiast łańcuchów, lub jeśli nadal tkwisz w jQuery

Stara Odpowiedź

Jeśli używasz funkcji Ajax jQuery 1.4 z ASP.NET MVC, możesz zamienić wszystkie właściwości DateTime na Data obiektów z:

// 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żna uniknąć nadpisywania metody parseJSON globalnie, używając opcji konwertery w wywołaniu Ajax.

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

Niestety musisz przełączyć się na starszą trasę eval, aby uzyskać daty do parsowania globalnie na miejscu - w przeciwnym razie musisz przekonwertować je na podstawie bardziej indywidualnych przypadków po parsowaniu.

Musiałem też szukać rozwiązania tego problemu i w końcu natrafiłem na moment.js, która jest ładną biblioteką, która może analizować ten format daty i wiele innych.

var d = moment(yourdatestring)

W końcu dodałem "znaki do wyrażenia regularnego Panos, aby pozbyć się tych generowanych przez serializer Microsoft podczas pisania obiektów do skryptu wbudowanego:

Więc jeśli masz właściwość w kodzie C# - za to coś w stylu

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

A w Twoim aspx masz

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

Dostaniesz coś takiego

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

Zwróć uwagę na podwójne cudzysłowy.

Aby uzyskać to w formie, która eval poprawnie deserializuje, I użyte:

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

Używam Prototype i aby go użyć dodałem

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

Nie ma wbudowanego typu daty w JSON . Wygląda to jak liczba sekund / milisekund z jakiejś epoki. Jeśli znasz epokę, możesz utworzyć datę, dodając odpowiednią ilość czasu.

W jQuery 1.5, o ile masz json2.js aby pokryć starsze przeglądarki, możesz deserializować wszystkie daty pochodzące 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);
        }
      }
    });
}());

Dodałem logikę, która zakłada, że wszystkie daty są wysyłane z serwera jako UTC (co powinieneś); konsument otrzymuje wtedy obiekt JavaScript Date, który ma odpowiednią wartość wskazów, aby to odzwierciedlić. Czyli wywołanie getUTCHours() itp. w dniu zwróci taką samą wartość jak na serwerze, a wywołanie getHours() zwróci wartość w lokalna Strefa czasowa użytkownika określona przez przeglądarkę.

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

Nie przesadzaj. Tak jak robiliśmy przez dziesięciolecia, przesunięcie numeryczne od standardowej epoki 1 stycznia 1970 o północy GMT / UTC/&C w liczbie sekund (lub milisekund) od tej epoki. JavaScript to lubi, Java to lubi, C to lubi, a Internet to lubi.

Korzystanie z jQuery UI datepicker - naprawdę ma sens tylko wtedy, gdy już włączasz jQuery UI:

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

Wyjście:

15 października 2008

Każda z tych Odpowiedzi ma jedną wspólną cechę: wszystkie przechowują daty jako jedną wartość (zwykle łańcuch).

Inną opcją jest skorzystanie z nieodłącznej struktury JSON i reprezentowanie daty jako listy liczb:

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

Oczywiście musisz upewnić się, że oba końce rozmowy są zgodne co do formatu (Rok, Miesiąc, Dzień) i które pola mają być datami,... ale ma tę zaletę, że całkowicie unikamy problemu konwersji daty na ciąg znaków. To same liczby, żadnych zobowiązań. Ponadto użycie kolejności: Rok, Miesiąc, Dzień pozwala również na prawidłowe sortowanie według daty.

Myślę nieszablonowo -- Data JSON nie musi być przechowywana jako ciąg znaków.

Kolejną zaletą tego sposobu jest to, że możesz łatwo (i efektywnie) wybrać wszystkie rekordy dla danego roku lub miesiąca, wykorzystując sposób, w jaki CouchDB obsługuje zapytania dotyczące wartości tablicy.

Posting in awesome thread:

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

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

Czy jest inna opcja bez użycia biblioteki jQuery?

Aby dodać jeszcze jedno podejście tutaj, "podejście kleszczy", które WCF przyjmuje jest podatne na problemy z strefami czasowymi, jeśli nie jesteś bardzo ostrożny, jak opisano TUTAJ i w innych miejscach. Więc teraz używam formatu ISO 8601, który obsługuje zarówno. NET, jak i JavaScript, który obejmuje przesunięcia stref czasowych. Poniżej znajdują się szczegóły:

W WCF/. NET:

gdzie CreationDate jest systemem.DateTime; ToString ("o") używa formatu. NET w obie strony Specyfikacja generująca łańcuch daty zgodny z ISO 8601

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

W JavaScript

zaraz po pobraniu JSON idę naprawić daty jako obiekty daty JavaSript używając konstruktora daty, który akceptuje ciąg daty 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 datę JavaScript, możesz użyć wszystkich wygodnych i niezawodnych metod datowania, takich jak toDateString, toLocaleString , itd.

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

Sprawdź datę ISO standard; coś w tym stylu:

yyyy.MM.ddThh:mm

Staje się 2008.11.20T22:18.

I get the date like this:

"/Date(1276290000000+0300)/"

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

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

Itd.

Więc wymyśliłem następujące wyrażenie regularne:

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

A końcowy kod to:

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

Update: Znalazłem ten link od Microsoftu: jak serializować daty z JSON?

To frustrujące. Moim rozwiązaniem było parsowanie "/ i / " z wartości Wygenerowanej Przez ASP.NET JavaScriptSerializer tak, że chociaż JSON może nie mieć dosłownej daty, to nadal jest interpretowany przez przeglądarkę jako Data, co jest tym, czego naprawdę chcę: {"myDate":Date(123456789)}

Custom JavaScriptConverter for DateTime?

Dodaj jQuery UI plugin na swojej stronie:

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

Poniżej jest dość proste rozwiązanie do parsowania dat JSON. Użyj poniższych funkcji zgodnie z wymaganiami. Wystarczy przekazać datę w formacie JSON pobraną jako parametr do funkcji poniżej:

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

Ostatni post, ale dla tych, którzy przeszukali ten post.

Wyobraź sobie to:

    [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 widzisz, używam funkcji C# 3.0 do tworzenia generycznych "Auto". Jest trochę leniwy, ale podoba mi się i działa. Tylko uwaga: profil to niestandardowa klasa, którą stworzyłem dla mojego projektu aplikacji internetowej.

Rozwiązanie Mootools:

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

Wymaga mootools-więcej. Testowane przy użyciu mootools-1.2.3.1-więcej na Firefox 3.6.3 i IE 7.0.5730.13

Możesz również użyć biblioteki JavaScript moment.js , który przydaje się, gdy planujesz zajmować się różnymi miejscowymi formatami i wykonywać inne operacje o wartościach 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;
}

Konfiguracja lokalizacji jest tak prosta jak dodawanie plików konfiguracyjnych (dostajesz je w momentjs.com) do projektu i konfiguracji języka:

moment.lang('de');

Dla wszystkich, którzy używają Pythona po stronie serwera: datetime.datetime ().ctime () zwraca łańcuch, który jest natywnie parsowalny przez"new Date ()". Oznacza to, że jeśli utworzysz nowy datetime.instancja datetime (np. z datetime.datetime.teraz), łańcuch może być zawarty w łańcuchu JSON, a następnie ten łańcuch może być przekazany jako pierwszy argument do konstruktora Date. Nie znalazłem jeszcze żadnych WYJĄTKÓW, ale nie testowałem go zbyt rygorystycznie.

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

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

A następnie w JavaScript...

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

Może Ci też 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();
    }