Comment formater une date JSON Microsoft?
Je prends ma première fissure à Ajax avec jQuery. Mes données apparaissent sur ma page, mais je rencontre des problèmes avec les données JSON renvoyées pour les types de données Date. Fondamentalement, je reçois une chaîne qui ressemble à ceci:
/Date(1224043200000)/
De quelqu'un totalement nouveau à JSON - Comment formater cela en un format de date court? Cela devrait-il être géré quelque part dans le code jQuery? J'ai essayé le plugin jQuery.UI.datepicker en utilisant $.datepicker.formatDate() sans succès.
FYI: Voici la solution que j'ai trouvée en utilisant une combinaison de réponses ici:
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;
}
Cette solution a obtenu mon objet de la méthode de rappel et a affiché correctement les dates sur la page à l'aide de la bibliothèque de format de date.
eval() n'est pas nécessaire. Cela fonctionnera bien:
var date = new Date(parseInt(jsonDate.substr(6)));
La fonction substr() extrait la partie /Date( et la fonction parseInt() obtient le nombre entier et ignore le )/ à la fin. Le nombre résultant est passé dans le constructeur Date.
J'ai volontairement laissé de côté la base (le deuxième argument de parseInt); voir mon commentaire ci-dessous .
De plus, je suis tout à fait d'accord avec commentaire de Rory : les dates ISO-8601 sont préférées à cet ancien format - ce format ne devrait donc généralement pas être utilisé pour de nouveaux développements. Voir l'excellente bibliothèque Json.NET pour une excellente alternative qui sérialise les dates à l'aide du format ISO-8601.
Pour les dates JSON formatées ISO-8601, il suffit de passer la chaîne dans le constructeur Date:
var date = new Date(jsonDate); //no ugly parsing needed; full timezone support
Vous pouvez utiliser ceci pour obtenir une date de JSON:
var date = eval(jsonDate.replace(/\/Date\((\d+)\)\//gi, "new Date($1)"));
Et ensuite, vous pouvez utiliser le script format de date JavaScript (1,2 Ko lorsque minifié et gzippé) pour l'afficher à votre guise.
Pour ceux qui utilisent Newtonsoft Json.NET , découvrez comment le faire via - JSON natif dans IE8, Firefox 3.5 plus Json.NET .
La documentation sur la modification du format des dates écrites par Json.NET est également utile: Sérialisation des dates avec Json.NET
Pour ceux qui sont trop paresseux, voici les étapes rapides. Comme JSON a une implémentation lâche de DateTime, vous devez utiliser IsoDateTimeConverter(). Notez que depuis Json.NET 4.5, le format de date par défaut est ISO, le code ci-dessous n’est donc pas nécessaire.
string jsonText = JsonConvert.SerializeObject(p, new IsoDateTimeConverter());
Le JSON arrivera comme
"fieldName": "2009-04-12T20:44:55"
Enfin, quelques JavaScript pour convertir la date ISO en une date 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;
}
Je l'ai utilisé comme ça
$("<span />").text(isoDateReviver(item.fieldName).toLocaleString()).appendTo("#" + divName);
L'exemple original:
/Date(1224043200000)/
ne reflète pas le formatage utilisé par WCF lors de l'envoi de dates via WCF REST à l'aide de la sérialisation JSON intégrée. (au moins sur .NET 3.5, SP1)
J'ai trouvé la réponse utile, mais une légère modification de l'expression rationnelle est requise, car il semble que l'offset GMT du fuseau horaire soit ajouté au nombre renvoyé (depuis 1970) dans JSON WCF.
Dans un service WCF, j'ai:
[OperationContract]
[WebInvoke(
RequestFormat = WebMessageFormat.Json,
ResponseFormat = WebMessageFormat.Json,
BodyStyle = WebMessageBodyStyle.WrappedRequest
)]
ApptVisitLinkInfo GetCurrentLinkInfo( int appointmentsId );
ApptVisitLinkInfo est défini simplement:
public class ApptVisitLinkInfo {
string Field1 { get; set; }
DateTime Field2 { get; set; }
...
}
Lorsque "Field2" est renvoyé en tant que Json du service, la valeur est:
/Date(1224043200000-0600)/
Notez le décalage de fuseau horaire inclus dans la valeur.
La regex modifiée:
/\/Date\((.*?)\)\//gi
Il est légèrement plus impatient et saisit tout entre les parens, pas seulement le premier chiffre. Le temps résultant 1970, plus le décalage horaire, peuvent tous être introduits dans l’évaluation pour obtenir un objet de date.
La ligne résultante de JavaScript pour le remplacement est la suivante:
replace(/\/Date\((.*?)\)\//gi, "new Date($1)");
Ne vous répétez pas - automatisez la conversion de date à l'aide de $.parseJSON()
Les réponses à votre message fournissent une conversion manuelle des dates en dates JavaScript. J'ai étendu un peu la $.parseJSON() de jQuery, afin qu'il puisse automatiquement analyser les dates lorsque vous le lui demandez. Il traite les dates au format ASP.NET (/Date(12348721342)/) ainsi que les dates au format ISO (2010-01-01T12.34.56.789Z) prises en charge par les fonctions JSON natives des navigateurs (et des bibliothèques comme json2.js).
En tous cas. Si vous ne voulez pas répéter votre code de conversion de date encore et encore, je vous suggère de lire cet article de blog et d'obtenir le code qui vous facilitera la vie.
Si vous dites en JavaScript,
var thedate = new Date(1224043200000);
alert(thedate);
vous verrez que c'est la date correcte et que vous pouvez l'utiliser n'importe où dans le code JavaScript avec n'importe quel framework.
Cliquez ici pour voir la démo
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();
Résultat - "10/15/2008"
Mis à jour
Nous avons une bibliothèque d'interface utilisateur interne qui doit gérer à la fois le format JSON intégré de Microsoft ASP.NET, tel que /Date(msecs)/, interrogé ici à l'origine, et la plupart du format de date JSON, y compris celui de JSON.NET, tel que 2014-06-22T00:00:00.0. . En outre, nous devons faire face à incapacité de oldIE à faire face à autre chose que 3 décimales .
Nous détectons d’abord le type de date que nous consommons, l’analysons dans un objet JavaScript Date normal, puis nous le formaterons.
1) Détecter le format de date Microsoft
// Handling of Microsoft AJAX Dates, formatted like '/Date(01238329348239)/'
function looksLikeMSDate(s) {
return /^\/Date\(/.test(s);
}
2) Détecter le format de date 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) Analyser le format de date MS:
function parseMSDate(s) {
// Jump forward past the /Date(, parseInt handles the rest
return new Date(parseInt(s.substr(6)));
}
4) Analyser le format de date ISO.
Nous avons au moins un moyen de nous assurer que nous traitons avec des dates ISO standard ou des dates ISO modifiées pour toujours avoir trois millisecondes ( voir ci-dessus ), de sorte que le code est différent selon l'environnement. .
4a) Analyser le format de date ISO standard, faire face aux problèmes de 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) Analyser le format ISO avec une décimale fixe de trois millisecondes - beaucoup plus facile:
function parseIsoDate(s) {
return new Date(s);
}
5) le formater:
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) Nouez le tout:
function parseDate(s) {
var d;
if (looksLikeMSDate(s))
d = parseMSDate(s);
else if (looksLikeIsoDate(s))
d = parseIsoDate(s);
else
return null;
return formatDate(d);
}
L'ancienne réponse ci-dessous est utile pour lier cette mise en forme de date à l'analyse JSON de jQuery afin d'obtenir des objets Date au lieu de chaînes, ou si vous êtes toujours bloqué dans jQuery d'une manière ou d'une autre.
Ancienne réponse
Si vous utilisez la fonction Ajax de jQuery 1.4 avec ASP.NET MVC, vous pouvez transformer toutes les propriétés DateTime en objets Date avec:
// Once
jQuery.parseJSON = function(d) {return eval('(' + d + ')');};
$.ajax({
...
dataFilter: function(d) {
return d.replace(/"\\\/(Date\(-?\d+\))\\\/"/g, 'new $1');
},
...
});
Dans jQuery 1.5, vous pouvez éviter de remplacer la méthode parseJSON globalement en utilisant l'option converters dans l'appel Ajax.
http://api.jquery.com/jQuery.ajax/
Malheureusement, vous devez passer à l'ancienne route d'évaluation pour que les dates soient globalement analysées, sinon vous devrez les convertir au cas par cas, après analyse.
Je devais aussi chercher une solution à ce problème et finalement je suis tombé sur moment.js, une bibliothèque de Nice capable d’analyser ce format de date et bien d’autres.
var d = moment(yourdatestring)
Cela m'a évité des maux de tête, alors j'ai pensé le partager avec vous. :)
Vous trouverez plus d’informations à ce sujet ici: http://momentjs.com/
Il n'y a pas de type de date intégré dans JSON . Cela ressemble au nombre de secondes/millisecondes de certaines époques. Si vous connaissez l’époque, vous pouvez créer la date en ajoutant le temps voulu.
J'ai fini par ajouter les "caractères" dans l'expression régulière de Panos pour supprimer ceux générés par le sérialiseur Microsoft lors de l'écriture d'objets dans un script en ligne:
Donc, si vous avez une propriété dans votre C # code-behind c'est quelque chose comme
protected string JsonObject { get { return jsSerialiser.Serialize(_myObject); }}
Et dans ton aspx tu as
<script type="text/javascript">
var myObject = '<%= JsonObject %>';
</script>
Vous auriez quelque chose comme
var myObject = '{"StartDate":"\/Date(1255131630400)\/"}';
Notez les guillemets doubles.
Pour obtenir cela dans un formulaire qui eval sera correctement désérialisé, j'ai utilisé:
myObject = myObject.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');
J'utilise Prototype et pour l'utiliser, j'ai ajouté
String.prototype.evalJSONWithDates = function() {
var jsonWithDates = this.replace(/"\/Date\((\d+)\)\/"/g, 'new Date($1)');
return jsonWithDates.evalJSON(true);
}
Dans jQuery 1.5, tant que vous avez json2.js pour couvrir les navigateurs plus anciens, vous pouvez désérialiser toutes les dates en provenance d'Ajax comme suit:
(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);
}
}
});
}());
J'ai inclus la logique qui suppose que vous envoyez toutes les dates du serveur au format UTC (ce que vous devriez); le consommateur obtient alors un objet JavaScript Date qui a la valeur de ticks appropriée pour refléter cela. C'est-à-dire que l'appel de getUTCHours(), etc. à la date renverra la même valeur que sur le serveur et que l'appel de getHours() renverra la valeur dans le fuseau horaire local de l'utilisateur, tel que déterminé par son navigateur.
Cela ne prend pas en compte le format WCF avec les décalages de fuseau horaire, bien que ce soit relativement facile à ajouter.
Ne réfléchissez pas trop. Comme nous le faisons depuis des décennies, transmettez un décalage numérique par rapport à l’époque standard de facto du 1er janvier 1970 à minuit GMT/UTC/& c en nombre de secondes (ou millisecondes) depuis cette époque. JavaScript l'aime, Java l'aime, C l'aime et Internet l'aime.
Utiliser datepicker de l'interface utilisateur jQuery - cela n'a de sens que si vous incluez déjà l'interface utilisateur jQuery:
$.datepicker.formatDate('MM d, yy', new Date(parseInt('/Date(1224043200000)/'.substr(6))));
sortie:
15 octobre 2008
Chacune de ces réponses a une chose en commun: elles stockent toutes les dates sous forme de valeur unique (généralement une chaîne).
Une autre option consiste à tirer parti de la structure inhérente de JSON et à représenter une date sous forme de liste de nombres:
{ "name":"Nick",
"birthdate":[1968,6,9] }
Bien sûr, vous devez vous assurer que les deux bouts de la conversation s’accordent sur le format (année, mois, jour) et sur les champs censés être des dates, mais cela présente l’avantage d’éviter complètement la question de la date. -to-chaîne de conversion. Ce sont tous des chiffres - pas de ficelle du tout. En outre, l'utilisation de l'ordre: année, mois et jour permet également un tri correct par date.
En dehors des sentiers battus, une date JSON ne doit pas nécessairement être stockée sous forme de chaîne.
Un autre avantage à le faire de cette façon est que vous pouvez facilement (et efficacement) sélectionner tous les enregistrements pour une année ou un mois donné en utilisant la méthode CouchDB traite les requêtes sur les valeurs de tableau.
Poster dans un fil génial:
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");
Existe-t-il une autre option sans utiliser la bibliothèque jQuery?
Juste pour ajouter une autre approche ici, la "méthode des ticks" que WCF est sujette aux problèmes de fuseaux horaires si vous n'êtes pas extrêmement prudent, comme décrit ici et dans d'autres lieux. J'utilise donc maintenant le format ISO 8601 que .NET et JavaScript prennent dûment en charge, ce qui inclut les décalages de fuseau horaire. Voici les détails:
Dans WCF/.NET:
Où CreationDate est un System.DateTime; ToString ("o") utilise le spécificateur de format aller-retour de .NET qui génère une chaîne de date conforme à ISO 8601 .
new MyInfo {
CreationDate = r.CreationDate.ToString("o"),
};
En JavaScript
Juste après avoir récupéré le JSON, je corrige les dates pour qu'elles soient des objets Date JavaSript à l'aide du constructeur Date qui accepte une chaîne de 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());
}
)
Une fois que vous avez une date JavaScript, vous pouvez utiliser toutes les méthodes Date pratiques et fiables telles que toDateString , toLocaleString , etc.
Cela peut aussi vous aider.
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();
}
Je reçois la date comme ceci:
"/Date(1276290000000+0300)/"
Dans certains exemples, la date est dans des formats légèrement différents:
"/Date(12762900000000300)/"
"Date(1276290000000-0300)"
etc.
Alors je suis venu avec le RegExp suivant:
/\/+Date\(([\d+]+)\)\/+/
et le code final est:
var myDate = new Date(parseInt(jsonWcfDate.replace(/\/+Date\(([\d+-]+)\)\/+/, '$1')));
J'espère que ça aide.
Mise à jour: J'ai trouvé ce lien de Microsoft: Comment sérialiser des dates avec JSON?
Cela semble être celui que nous recherchons tous.
Vous pouvez également utiliser la bibliothèque JavaScript moment.js , très utile lorsque vous prévoyez de traiter avec différents formats localisés et d'effectuer d'autres opérations avec des valeurs de dates:
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;
}
La configuration de la localisation est aussi simple que l’ajout de fichiers de configuration (vous les obtenez sur momentjs.com) à votre projet et la configuration de la langue:
moment.lang('de');
C'est frustrant. Ma solution consistait à analyser les "/ et /" à partir de la valeur générée par JavaScriptSerializer d’ASP.NET afin que, même si JSON n’ait pas de date littérale, il reste interprété par le navigateur comme une date, ce que j’ai vraiment voulu faire. veux: {"myDate":Date(123456789)}
JavaScriptConverter personnalisé pour DateTime?
Je dois souligner la précision du commentaire de Roy Tinker. Ce n'est pas légal JSON. Il est difficile de supprimer le problème avant que cela ne devienne un problème pour JavaScript. Cela étouffera un analyseur JSON. Je l'ai utilisé pour décoller, mais je ne l'utilise plus. Cependant, je pense toujours que la meilleure solution consiste à changer la façon dont le serveur formate la date, par exemple, ISO, comme mentionné ailleurs.
Vérifiez la date ISO standard; un peu comme ça:
yyyy.MM.ddThh:mm
Cela devient 2008.11.20T22:18.
var obj = eval('(' + "{Date: \/Date(1278903921551)\/}".replace(/\/Date\((\d+)\)\//gi, "new Date($1)") + ')');
var dateValue = obj["Date"];
Vous trouverez ci-dessous une solution assez simple pour analyser les dates JSON. Utilisez les fonctions ci-dessous selon vos besoins. Il vous suffit de passer le format JSON Date récupéré en tant que paramètre des fonctions ci-dessous:
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;
}
Ajoutez le plugin jQuery UI dans votre page:
function DateFormate(dateConvert) {
return $.datepicker.formatDate("dd/MM/yyyy", eval('new ' + dateConvert.slice(1, -1)));
};
Un post tardif, mais pour ceux qui ont cherché ce post.
Imagine ça:
[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");
}
Comme vous pouvez le constater, j'utilise la fonctionnalité de C # 3.0 pour créer les génériques "automatiques". C'est un peu paresseux, mais j'aime ça et ça marche. Juste une remarque: Profile est une classe personnalisée que j'ai créée pour mon projet d'application Web.
Solution Mootools:
new Date(Date(result.AppendDts)).format('%x')
Nécessite mootools-more. Testé en utilisant mootools-1.2.3.1-more sur Firefox 3.6.3 et IE 7.0.5730.13
Pour votre information, si vous utilisez Python du côté du serveur: datetime.datetime (). Ctime () renvoie une chaîne analysable en mode natif par "new Date ()". Autrement dit, si vous créez une nouvelle instance datetime.datetime (telle que datetime.datetime.now), la chaîne peut être incluse dans la chaîne JSON, puis cette chaîne peut être transmise en tant que premier argument au constructeur Date. Je n'ai pas encore trouvé d'exceptions, mais je ne l'ai pas testé de manière rigoureuse non plus.
Et si . NET renvoie ...
return DateTime.Now.ToString("u"); //"2013-09-17 15:18:53Z"
Et puis en JavaScript ...
var x = new Date("2013-09-17 15:18:53Z");
Dans le code suivant. j'ai
1. Récupéré l'horodatage de la chaîne de date.
2. Et l’analyser dans Int
. Finalement créé une Date en l'utilisant.
var dateString = "/Date(1224043200000)/";
var seconds = parseInt(dateString.replace(/\/Date\(([0-9]+)[^+]\//i, "$1"));
var date = new Date(seconds);
console.log(date);En guise de remarque, KendoUI prend en charge la conversion de la date JSON Microsoft. Donc, si votre projet a la référence à "KendoUI", vous pouvez simplement utiliser
var newDate = kendo.parseDate(jsonDate);
Ceci utilise un expression régulière , et cela fonctionne aussi:
var date = new Date(parseInt(/^\/Date\((.*?)\)\/$/.exec(jsonDate)[1], 10));
Le moyen le plus simple que je puisse suggérer consiste à utiliser regex sur JS comme:
//Only use [0] if you are sure that the string matches the pattern
//Otherwise, verify if 'match' returns something
"/Date(1512488018202)/".match(/\d+/)[0]
Un autre exemple de regex que vous pouvez essayer d’utiliser:
var mydate = json.date
var date = new Date(parseInt(mydate.replace(/\/Date\((-?\d+)\)\//, '$1');
mydate = date.getMonth() + 1 + '/' + date.getDate() + '/' + date.getFullYear();
date.getMonth() renvoie un entier compris entre 0 et 11, il faut donc ajouter 1 pour obtenir le bon numéro de mois
Essaye ça...
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 () renvoie l'année 1900, elle est obsolète depuis un moment, il est préférable d'utiliser getFullYear ().
J'utilise cette fonction simple pour obtenir la date de Microsoft JSON Date
function getDateValue(dateVal) {
return new Date(parseInt(dateVal.replace(/\D+/g, '')));
};
replace(/\D+/g, '') supprimera tous les caractères autres que des chiffres
parseInt convertira la chaîne en nombre
Usage
$scope.ReturnDate = getDateValue(result.JSONDateVariable)
Il est facile de convertir une date JSON en une date JavaScript:
var s = Response.StartDate;
s = s.replace('/Date(', '');
s = s.replace(')/', '');
var expDate = new Date(parseInt(s));
TLDR: Vous ne pouvez pas convertir de manière fiable cette valeur de date uniquement, envoyez plutôt une chaîne ...
... ou du moins c'est comme cela que toutes ces réponses devraient commencer.
Un certain nombre de problèmes de conversion se produisent ici.
C'est une date sans heure
Tout le monde semble manquer, c'est le nombre de zéros à la fin de la question - il s'agit presque certainement d'une date sans date:
/Date(1224043200000)/
Lors de l’exécution à partir d’une console javascript comme nouvelle date (base de nombreuses réponses)
new Date(1224043200000)
Vous obtenez:
Le demandeur d'origine était probablement en EST et avait une date pure (sql) ou un DateTime (pas DateTimeOffset) avec minuit.
En d’autres termes, l’intention ici est que la partie temps n’ait pas de sens. Cependant, si le navigateur l'exécute dans le même fuseau horaire que le serveur qui l'a généré, cela n'a pas d'importance et la plupart des réponses fonctionnent.
Bit par fuseau horaire
Mais si vous exécutez le code ci-dessus sur une machine ayant un fuseau horaire différent (PST par exemple):
Vous noterez que nous avons maintenant un jour de retard dans cet autre fuseau horaire. Cela ne sera pas corrigé en modifiant le sérialiseur (qui inclura toujours le fuseau horaire au format iso)
Le problème
Date (sql) et DateTime (.net) n'ont pas de fuseau horaire, mais dès que vous les convertissez en quelque chose qui le fait (javascript inféré par json dans ce cas), l'action par défaut dans .net est d'assumer le fuseau horaire actuel. .
Le nombre que la sérialisation est en train de créer est en millisecondes depuis unix Epoch ou:
(DateTimeOffset.Parse("10/15/2008 00:00:00Z") - DateTimeOffset.Parse("1/1/1970 00:00:00Z")).TotalMilliseconds;
C'est quelque chose que new Date () en javascript prend comme paramètre. Epoch provient de l'UTC, vous avez donc maintenant les informations de fuseau horaire, que vous le vouliez ou non.
Solutions possibles:
Il pourrait être plus sûr de créer une propriété de chaîne sur votre objet sérialisé qui représente la date UNIQUEMENT - une chaîne avec "10/15/2008" ne risque pas de confondre qui que ce soit avec ce désordre. Même si, même là, vous devez être prudent du côté de l'analyse: https://stackoverflow.com/a/31732581
Cependant, dans l’esprit de fournir une réponse à la question posée, telle quelle:
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))));