Sto prendendo il mio primo crack all'Ajax con jQuery. Ricevo i miei dati sulla mia pagina, ma ho dei problemi con i dati JSON restituiti per i tipi di dati Date. Fondamentalmente, sto recuperando una stringa simile a questa:

/Date(1224043200000)/

Da qualcuno totalmente nuovo a JSON - Come posso formattarlo in un formato data breve? Questo dovrebbe essere gestito da qualche parte nel codice jQuery? Ho provato il jQuery.UI.datepickerplugin usando $.datepicker.formatDate()senza successo.

Cordiali saluti: Ecco la soluzione che mi è venuta in mente usando una combinazione delle risposte qui:

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

Questa soluzione ha ottenuto il mio oggetto dal metodo callback e ha visualizzato correttamente le date sulla pagina utilizzando la libreria del formato della data.

eval()non è necessario. Questo funzionerà benissimo:

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

La substr()funzione estrae la /Date(parte e la parseInt()funzione ottiene il numero intero e ignora il )/alla fine. Il numero risultante viene passato al Datecostruttore.

Ho intenzionalmente escluso il radix (il secondo argomento a parseInt); vedi il mio commento qui sotto .

Inoltre, sono completamente d'accordo con il commento di Rory : le date ISO-8601 sono preferite rispetto a questo vecchio formato - quindi questo formato generalmente non dovrebbe essere usato per nuovi sviluppi. Guarda l'eccellente libreria Json.NET per un'ottima alternativa che serializza le date usando il formato ISO-8601.

Per le date JSON formattate ISO-8601, basta passare la stringa nel Datecostruttore:

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

Puoi usarlo per ottenere una data da JSON:

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

Quindi puoi utilizzare uno script JavaScript Date Format (1,2 KB quando minimizzato e compresso) per visualizzarlo come desideri.

Per coloro che utilizzano Newtonsoft Json.NET , leggi come farlo tramite Native JSON in IE8, Firefox 3.5 e Json.NET .

Anche la documentazione sulla modifica del formato delle date scritta da Json.NET è utile: Serializzare le date con Json.NET

Per quelli che sono troppo pigri, ecco i passaggi rapidi. Poiché JSON ha un'implementazione DateTime libera, è necessario utilizzare il IsoDateTimeConverter(). Si noti che a partire da Json.NET 4.5 il formato data predefinito è ISO, quindi il codice seguente non è necessario.

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

Il JSON verrà come

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

Infine, alcuni JavaScript per convertire la data ISO in una data 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;
}

L'ho usato così

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

L'esempio originale:

/Date(1224043200000)/  

non riflette la formattazione utilizzata da WCF durante l'invio di date tramite WCF REST utilizzando la serializzazione JSON integrata. (almeno su .NET 3.5, SP1)

Ho trovato utile la risposta qui, ma è necessaria una leggera modifica alla regex, poiché sembra che l'offset GMT del fuso orario sia stato aggiunto al numero restituito (dal 1970) in WCF JSON.

In un servizio WCF ho:

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

ApptVisitLinkInfo è definito semplicemente:

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

Quando "Field2" viene restituito come Json dal servizio, il valore è:

/Date(1224043200000-0600)/

Notare l'offset del fuso orario incluso come parte del valore.

La regex modificata:

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

È leggermente più desideroso e afferra tutto tra le parentesi, non solo il primo numero. Il tempo risultante sinze 1970, oltre all'offset del fuso orario, possono essere inseriti nell'Eval per ottenere un oggetto data.

La riga risultante di JavaScript per la sostituzione è:

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

Non ripetere te stesso: automatizza la conversione della data utilizzando $.parseJSON()

Le risposte al tuo post forniscono la conversione manuale della data in date JavaScript. Ho esteso $.parseJSON()un po 'di jQuery , quindi è in grado di analizzare automaticamente le date quando te lo ordini. Elabora le date in formato ASP.NET ( /Date(12348721342)/) e le date in formato ISO ( 2010-01-01T12.34.56.789Z) supportate dalle funzioni native JSON nei browser (e librerie come json2.js).

Comunque. Se non vuoi ripetere più volte il codice di conversione della data, ti suggerisco di leggere questo post sul blog e ottenere il codice che ti renderà la vita un po 'più semplice.

Se dici in JavaScript,

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

vedrai che è la data corretta e puoi usarla ovunque nel codice JavaScript con qualsiasi framework.

Fai clic qui per controllare la 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();

Risultato - "15/10/2008"

aggiornato

Abbiamo una libreria UI interna che deve far fronte sia al formato JSON incorporato ASP.NET di Microsoft, come /Date(msecs)/, chiesto qui in origine, sia alla maggior parte del formato data di JSON incluso JSON.NET, come 2014-06-22T00:00:00.0. Inoltre, dobbiamo far fronte all'incapacità di oldIE di far fronte a qualsiasi cifra tranne 3 decimali .

Per prima cosa rileviamo quale tipo di data stiamo consumando, analizziamo in un normale Dateoggetto JavaScript , quindi formattiamo.

1) Rileva il formato Microsoft Date

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

2) Rileva il formato data 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) Formato data MS MS:

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

4) Formato data ISO analizzato.

Abbiamo almeno un modo per essere sicuri di avere a che fare con date ISO standard o date ISO modificate per avere sempre tre millisecondi ( vedi sopra ), quindi il codice è diverso a seconda dell'ambiente.

4a) Analizzare il formato della data ISO standard, far fronte ai problemi di 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) Formato ISO di analisi con decimali fissi di tre millisecondi - molto più semplice:

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

5) Formattalo:

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) Legalo tutto insieme:

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

    return formatDate(d);
}

La vecchia risposta di seguito è utile per associare questa formattazione della data all'analisi JSON di jQuery in modo da ottenere oggetti Date anziché stringhe o se in qualche modo sei ancora bloccato in jQuery <1.5.

Vecchia risposta

Se si utilizza la funzione Ajax di jQuery 1.4 con ASP.NET MVC, è possibile trasformare tutte le proprietà DateTime in oggetti Date con:

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

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

In jQuery 1.5 puoi evitare di ignorare il parseJSONmetodo a livello globale usando l'opzione convertitori nella chiamata Ajax.

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

Sfortunatamente devi passare al vecchio percorso di valutazione per far sì che le Date analizzino globalmente sul posto, altrimenti dovrai convertirle caso per caso più post-analisi.

Non esiste un tipo di data incorporato in JSON . Questo sembra il numero di secondi / millisecondi di qualche epoca. Se conosci l'epoca puoi creare la data aggiungendo la giusta quantità di tempo.

Ho anche dovuto cercare una soluzione a questo problema e alla fine mi sono imbattuto in moment.js che è una bella libreria in grado di analizzare questo formato di data e molti altri.

var d = moment(yourdatestring)

Mi ha risparmiato un po 'di mal di testa, quindi ho pensato di condividerlo con te. :)
Puoi trovare qualche informazione in più qui: http://momentjs.com/

Ho finito per aggiungere i "caratteri nell'espressione regolare di Panos per sbarazzarmi di quelli generati dal serializzatore Microsoft per quando si scrivono oggetti in uno script incorporato:

Quindi se hai una proprietà nel tuo codice C # dietro è qualcosa di simile

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

E nel tuo aspx hai

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

Otterresti qualcosa del genere

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

Nota le doppie virgolette.

Per ottenere questo in una forma che eval diserializzerà correttamente, ho usato:

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

Uso Prototype e per usarlo ho aggiunto

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

In jQuery 1.5, purché tu abbia json2.js da coprire per i browser più vecchi, puoi deserializzare tutte le date provenienti da Ajax come segue:

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

Ho incluso la logica che presuppone che tu invii tutte le date dal server come UTC (che dovresti); il consumatore ottiene quindi un Dateoggetto JavaScript con il valore di tick corretto per riflettere questo. Cioè, la chiamata getUTCHours(), ecc. getHours()Alla data restituirà lo stesso valore che aveva sul server e la chiamata restituirà il valore nel fuso orario locale dell'utente determinato dal loro browser.

Questo non tiene conto del formato WCF con gli offset del fuso orario, anche se sarebbe relativamente facile da aggiungere.

Usando il datepicker dell'interfaccia utente jQuery - ha davvero senso solo se stai già includendo l'interfaccia utente jQuery:

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

produzione:

15 ottobre 2008

Non pensarci troppo. Come abbiamo fatto per decenni, passare un offset numerico dall'epoca standard di fatto del 1 ° gennaio 1970 mezzanotte GMT / UTC / ecc in numero di secondi (o millisecondi) da questa epoca. Piace a JavaScript, Piace a Java, Piace a C e Piace a Internet.

Ognuna di queste risposte ha una cosa in comune: memorizzano tutte le date come un singolo valore (di solito una stringa).

Un'altra opzione è quella di sfruttare la struttura intrinseca di JSON e rappresentare una data come elenco di numeri:

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

Ovviamente, dovresti assicurarti che entrambe le estremità della conversazione concordino sul formato (anno, mese, giorno) e quali campi debbano essere date, ... ma ha il vantaggio di evitare completamente l'emissione della data conversione da stringa. Sono tutti numeri, niente stringhe. Inoltre, utilizzando l'ordine: anno, mese, giorno consente anche un corretto ordinamento per data.

Solo pensando fuori dagli schemi qui - una data JSON non deve essere memorizzata come una stringa.

Un altro vantaggio nel farlo in questo modo è che puoi selezionare facilmente (ed efficientemente) tutti i record per un dato anno o mese sfruttando il modo in cui CouchDB gestisce le query sui valori dell'array.

Pubblicare in thread fantastici:

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

Solo per aggiungere un altro approccio qui, l'approccio "ticks" adottato da WCF è soggetto a problemi con i fusi orari se non si è estremamente attenti come descritto qui e in altri luoghi. Quindi ora sto usando il formato ISO 8601 che sia .NET che JavaScript supportano debitamente che include gli offset del fuso orario. Di seguito sono riportati i dettagli:

In WCF / .NET:

Dove CreationDate è un System.DateTime; ToString ("o") utilizza l'identificatore di formato Round-trip di .NET che genera una stringa di data conforme a ISO 8601

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

In JavaScript

Subito dopo aver recuperato JSON vado a sistemare le date come oggetti Date JavaSript usando il costruttore Date che accetta una stringa di date 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());
    }
)

Una volta che hai una data JavaScript puoi usare tutti i metodi Date convenienti e affidabili come toDateString , toLocaleString , ecc.

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

Esiste un'altra opzione senza utilizzare la libreria jQuery?

Questo può anche aiutarti.

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

Di seguito è una soluzione piuttosto semplice per l'analisi delle date JSON. Utilizzare le funzioni seguenti secondo le proprie esigenze. Devi solo passare il formato JSON Data recuperato come parametro alle funzioni seguenti:

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

Puoi anche utilizzare la libreria JavaScript moment.js , utile quando pianifichi di gestire diversi formati localizzati ed eseguire altre operazioni con valori di date:

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

Impostare la localizzazione è facile come aggiungere file di configurazione (li trovi su momentjs.com) al tuo progetto e configurare la lingua:

moment.lang('de');

Ricevo la data in questo modo:

"/Date(1276290000000+0300)/"

In alcuni esempi la data è in formati leggermente diversi:

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

eccetera.

Quindi ho ideato il seguente RegExp:

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

e il codice finale è:

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

Spero che sia d'aiuto.

Aggiornamento: ho trovato questo collegamento da Microsoft: come posso serializzare le date con JSON?

Sembra quello che stiamo tutti cercando.

Controlla la data ISO standard; un po 'così:

yyyy.MM.ddThh:mm

Diventa 2008.11.20T22:18.

Questo è frustrante. La mia soluzione è stata quella di analizzare "/ e /" dal valore generato dal JavaScriptSerializer di ASP.NET in modo che, sebbene JSON non abbia una data letterale, venga comunque interpretato dal browser come una data, che è tutto ciò che realmente volere:{"myDate":Date(123456789)}

JavaScriptConverter personalizzato per DateTime?

Devo sottolineare l'accuratezza del commento di Roy Tinker. Questo non è JSON legale. È un trucco sporco e sporco sul server per rimuovere il problema prima che diventi un problema per JavaScript. Soffocerà un parser JSON. L'ho usato per scendere da terra, ma non lo uso più. Tuttavia, ritengo che la risposta migliore risieda nel cambiare il modo in cui il server formatta la data, ad esempio ISO, come menzionato altrove.

Un post in ritardo, ma per chi ha cercato questo post.

Immagina questo:

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

Come puoi vedere, sto usando la funzione di C # 3.0 per creare i generici "Auto". È un po 'pigro, ma mi piace e funziona. Solo una nota: il profilo è una classe personalizzata che ho creato per il mio progetto di applicazione web.

Cordiali saluti, per chiunque usi Python sul lato server: datetime.datetime (). Ctime () restituisce una stringa che può essere analizzata in modo nativo da "new Date ()". Cioè, se si crea una nuova istanza di datetime.datetime (come con datetime.datetime.now), la stringa può essere inclusa nella stringa JSON e quindi quella stringa può essere passata come primo argomento al costruttore Date. Non ho ancora trovato eccezioni, ma non l'ho nemmeno provato troppo rigorosamente.

Soluzione Mootools:

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

Richiede mootools-altro. Testato usando mootools-1.2.3.1-more su Firefox 3.6.3 e IE 7.0.5730.13

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

Aggiungi il plug-in dell'interfaccia utente jQuery nella tua pagina:

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

Cosa succede se .NET ritorna ...

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

E poi in JavaScript ...

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