it-swarm.it

Come si formatta una data Microsoft JSON?

Sto prendendo il mio primo crack a Ajax con jQuery. Inserisco i miei dati nella mia pagina, ma sto riscontrando dei problemi con i dati JSON restituiti per i tipi di dati Date. Fondamentalmente, sto ottenendo una stringa che assomiglia a questo:

/Date(1224043200000)/

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

A proposito: ecco la soluzione che ho trovato 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 di callback e ha visualizzato correttamente le date sulla pagina utilizzando la libreria del formato della data.

1908
Mark Struzinski

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

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

La funzione substr() elimina la parte /Date( e la funzione parseInt() ottiene l'intero e ignora )/ alla fine. Il numero risultante viene passato al costruttore Date.


Ho intenzionalmente omesso la radice (il secondo argomento per 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 un nuovo sviluppo . Vedere la libreria eccellente Json.NET per un'ottima alternativa che serializza le date utilizzando il formato ISO-8601.

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

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

Puoi usarlo per ottenere una data da JSON:

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

E poi puoi usare uno script JavaScript (Format) (1,2 KB se minified e gzip) per visualizzarlo come vuoi.

124
Panos

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

È utile anche la documentazione sulla modifica del formato delle date scritte da Json.NET: Serializzare le date con Json.NET

Per quelli che sono troppo pigri, ecco i passi veloci. Poiché JSON ha un'implementazione DateTime libera, è necessario utilizzare IsoDateTimeConverter(). Si noti che dal momento che Json.NET 4.5 il formato di data predefinito è ISO, quindi il codice sottostante non è necessario.

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

Il JSON passerà 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);
93
Jason Jong

L'esempio originale:

/Date(1224043200000)/  

non riflette la formattazione utilizzata da WCF quando si inviano le date tramite WCF REST utilizzando la serializzazione JSON incorporata. (almeno su .NET 3.5, SP1)

Ho trovato la risposta qui utile, 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)/

Si noti l'offset del fuso orario incluso come parte del valore.

La regex modificata:

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

È leggermente più impaziente e afferra tutto tra i paren, non solo il primo numero. Il risultante tempo del 1970, oltre allo sfasamento del fuso orario, può essere inserito nell'eval per ottenere un oggetto data.

La riga risultante di JavaScript per la sostituzione è:

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

Non ripeterti: automatizza la conversione della data utilizzando $.parseJSON()

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

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

60
Robert Koritnik

Se dici in JavaScript,

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

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

59
John Boker

Clicca qui per verificare 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"

55
user2007801

Aggiornato

Abbiamo una libreria UI interna che deve far fronte al formato JSON di Microsoft ASP.NET, come /Date(msecs)/, ha chiesto informazioni su qui in origine, e la maggior parte del formato di data di JSON incluso JSON.NET, come 2014-06-22T00:00:00.0. Inoltre, dobbiamo affrontare l'incapacità di oldie di far fronte a qualsiasi cosa tranne 3 posizioni decimali .

Prima rileviamo quale tipo di data stiamo consumando, lo analizziamo in un normale oggetto JavaScript Date, quindi lo formattiamo.

1) Rileva il formato della data di Microsoft

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

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

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

4) Formato della data ISO Parse.

Almeno abbiamo un modo per essere sicuri che abbiamo 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) Formato standard per la data ISO standard, per 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 Parse ISO con cifre decimali fisse 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) Lega 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 precedente risposta è utile per legare questa formattazione della data al parsing JSON di jQuery in modo da ottenere oggetti Date invece di stringhe o se in qualche modo sei ancora bloccato in jQuery <1.5.

Vecchia risposta

Se stai utilizzando la funzione Ajax di jQuery 1.4 con ASP.NET MVC, puoi 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 è possibile evitare di eseguire l'override del metodo parseJSON a livello globale utilizzando l'opzione convertitori nella chiamata Ajax.

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

Sfortunatamente devi passare alla vecchia eval route per far sì che le date possano essere analizzate globalmente sul posto, altrimenti è necessario convertirle in base al caso dopo l'analisi caso per caso.

36
Chris Moschini

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 data e molti altri.

var d = moment(yourdatestring)

Mi ha salvato un po 'di mal di testa quindi ho pensato di condividerlo con te. :)
Puoi trovare ulteriori informazioni a riguardo qui: http://momentjs.com/

24
Venemo

Non esiste un tipo di data incorporato in JSON . Sembra il numero di secondi/millisecondi di qualche epoca. Se conosci l'Epoca puoi creare la data aggiungendo il giusto tempo.

23
johnstok

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

Quindi se hai una proprietà nel tuo C # code-behind è 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 di simile

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

Notare le doppie virgolette.

Per ottenere questo in una forma che la valutazione ha correttamente deserializzato, ho usato:

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

Io 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);
}
23
Chris Woodward

In jQuery 1.5, finché hai json2.js per coprire 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 oggetto JavaScript Datecon il valore di zecche appropriato per riflettere questo. Cioè, chiamando getUTCHours(), ecc. Alla data restituirà lo stesso valore che ha sul server, e chiamando getHours() restituirà il valore nel fuso orario locale dell'utente come determinato dal proprio browser.

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

21
Domenic

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

19
Jé Queue

L'uso del Datepicker dell'interfaccia utente jQuery - ha davvero senso solo se stai già includendo l'interfaccia utente di jQuery:

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

produzione:

15 ottobre 2008

19
dominic

Ognuna di queste risposte ha una cosa in comune: tutte memorizzano 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] }

Certo, dovresti assicurarti che entrambi i capi della conversazione concordino sul formato (anno, mese, giorno) e quali campi debbano essere date, ... ma ha il vantaggio di evitare completamente il problema della data conversione a stringa. Sono tutti numeri - niente corde. Inoltre, l'utilizzo dell'ordine: anno, mese, giorno consente anche l'ordinamento corretto per data.

Basta pensare fuori dagli schemi - una data JSON non deve essere memorizzata come stringa.

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

18
Nick Perkins

Pubblicare nel thread fantastico:

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

C'è un'altra opzione senza usare la libreria jQuery?

15
Bilgin Kılıç

Solo per aggiungere un altro approccio qui, l'approccio "ticks" che WCF prende è soggetto a problemi con i fusi orari se non sei estremamente attento come descritto qui e in altri posti. Così ora sto usando il formato ISO 8601 che sia .NET che JavaScript supportano regolarmente che include offset del fuso orario. Di seguito sono 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 ISO 8601

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

In JavaScript

Subito dopo aver recuperato il JSON, vado a correggere le date per essere oggetti JavaSript Date utilizzando il costruttore Date che accetta una stringa di data 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 di Date convenienti e affidabili come toDateString , toLocaleString , ecc.

15
Scott Willeke

Ho ricevuto la data in questo modo:

"/Date(1276290000000+0300)/"

In alcuni esempi la data è in formati leggermente diversi:

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

eccetera.

Quindi sono arrivato con 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?

Questo sembra quello che stiamo cercando.

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

Di seguito è una soluzione piuttosto semplice per l'analisi delle date JSON. Usa le seguenti funzioni secondo i tuoi requisiti. Devi solo passare il formato JSON Data recuperata come parametro per le seguenti funzioni:

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

È inoltre possibile utilizzare la libreria JavaScript moment.js , che risulta utile quando si pianifica di trattare formati diversi 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;
}

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

moment.lang('de');
8
martinoss

Questo è frustrante. La mia soluzione era di analizzare "/ e /" dal valore generato dal JavaScriptSerializer di ASP.NET in modo che, anche se JSON potrebbe non avere un valore letterale per la data, viene comunque interpretato dal browser come una data, il che è tutto ciò che veramente desiderare: {"myDate":Date(123456789)}

JavaScriptConverter personalizzato per DateTime?

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

8
StarTrekRedneck

Controlla la data ISO standard; un po 'come questo:

yyyy.MM.ddThh:mm

Diventa 2008.11.20T22:18.

8
Thomas Hansen

Aggiungi il jQuery UI plug-in nella tua pagina:

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

Un post in ritardo, ma per coloro che hanno 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 utilizzando la funzione di C # 3.0 per la creazione di Generics "Auto". È un po 'pigro, ma mi piace e funziona. Solo una nota: Profile è una classe personalizzata che ho creato per il mio progetto di applicazione web.

7
Ray Linder

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

Soluzione di Mootools:

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

Richiede mootools-di più. Testato usando mootools-1.2.3.1-more su Firefox 3.6.3 e IE 7.0.5730.13

7
Midhat

Cordiali saluti, per chiunque usi Python sul lato server: datetime.datetime (). Ctime () restituisce una stringa che è in origine parsabile da "new Date ()". Cioè, se si crea una nuova istanza 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 ancora testato rigorosamente.

6
Kyle Alan Hale

Cosa succede se . NET restituisce ...

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");
6

Nel seguente codice io ho

1. Recupera il timestamp dalla stringa della data.

2. E analizzato in Int

3. Finalmente creato un Date che lo usa.

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

Come nota a margine, KendoUI supporta la conversione della data di Microsoft JSON. Quindi, se il tuo progetto ha il riferimento a "KendoUI", puoi semplicemente usarlo

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

Questo usa un'espressione regolare , e funziona altrettanto bene:

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

Il modo più semplice che posso suggerire è usare regex su JS come:

//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

Un altro esempio di regex che puoi provare usando:

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

date.getMonth() restituisce un intero da 0 a 11, quindi dobbiamo aggiungere 1 per ottenere il giusto numero di mese

2
Luminous

Prova questo...

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 () restituisce l'anno - 1900, Questo è stato deprecato per un po 'di tempo, è meglio usare getFullYear ()

2
Noor All Safaet

Io uso questa semplice funzione per ottenere la data da Microsoft JSON Date

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

replace(/\D+/g, '') rimuoverà tutti i caratteri tranne i numeri

parseInt convertirà la stringa in numero

Uso

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

È facile convertire la data JSON in una data JavaScript:

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

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

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

TLDR: non puoi convertire in modo affidabile quel valore di sola data, invia invece una stringa ...

... o almeno è come quasi tutte queste risposte dovrebbero iniziare.

C'è un numero di problemi di conversione che stanno accadendo qui.

Questa è una data senza tempo

Qualcosa sembra che tutti manchino è quanti zeri finali ci sono nella domanda - è quasi certamente iniziato come una data senza tempo:

/Date(1224043200000)/

Quando si esegue questo da una console javascript come una nuova data (la base di molte risposte)

new Date(1224043200000)

Ottieni:

enter image description here

Il richiedente originale era probabilmente in EST e aveva una data pura (sql) o un DateTime (non DateTimeOffset) con mezzanotte.

In altre parole, l'intenzione qui è che la porzione temporale non ha senso. Tuttavia, se il browser esegue questo nello stesso fuso orario del server che lo ha generato, non ha importanza e la maggior parte delle risposte funziona.

Bit per fuso orario

Ma, se si esegue il codice sopra su una macchina con un fuso orario diverso (ad esempio PST):

enter image description here

Noterai che ora siamo un giorno indietro in questo altro fuso orario. Questo problema non verrà risolto cambiando il serializzatore (che includerà comunque il fuso orario nel formato iso)

Il problema

Date (sql) e DateTime (.net) non hanno il fuso orario su di loro, ma non appena li converti in qualcosa che fa (javascript inferred thru json in questo caso), l'azione predefinita in .net è assumere il fuso orario corrente .

Il numero che la serializzazione sta creando è millisecondo poiché unix Epoch o:

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

Qualcosa che il nuovo Date () in javascript assume come parametro. Epoch è di UTC, quindi ora hai informazioni sul fuso orario se lo vuoi o no.

Possibili soluzioni:

Potrebbe essere più sicuro creare una proprietà stringa sull'oggetto serializzato che rappresenta SOLO la data: una stringa con "10/15/2008" non è in grado di confondere chiunque altro con questo problema. Sebbene anche lì devi stare attento sul lato dell'analisi: https://stackoverflow.com/a/31732581

Tuttavia, nello spirito di fornire una risposta alla domanda posta, come è:

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))));
0
b_levitt