Format de date ASP.NET MVC JsonResult

J'ai une action de contrôleur qui renvoie simplement un JsonResult de mon modèle. Donc, dans ma méthode, j'ai quelque chose comme ceci:

return new JsonResult(myModel);

Cela fonctionne bien, sauf pour un problème. Il y a une propriété date dans le modèle et cela semble être retourné dans le résultat Json comme ceci:

"\/Date(1239018869048)\/"

Comment dois-je traiter les dates pour qu'elles soient retournées dans le format dont j'ai besoin? Ou comment gérer ce format ci-dessus dans le script?

Juste pour développer la réponse de casperOne .

La spécification JSON ne prend pas en compte les valeurs de date. MS a dû faire un appel, et le chemin qu'ils ont choisi était d'exploiter une petite astuce dans la représentation javascript des chaînes: le littéral de chaîne "/" est le même que "\ /", et un littéral de chaîne ne sera jamais sérialisé en " \ / "(même" \ / "doit être mappé sur" \\ / ").

Voir http://msdn.microsoft.com/en-us/library/bb299886.aspx#intro_to_json_topic2 pour une meilleure explication (faites défiler jusqu'à "Des littéraux JavaScript vers JSON")

L'un des points sensibles de JSON est l'absence d'un littéral date / heure. Beaucoup de gens sont surpris et déçus d'apprendre cela lors de leur première rencontre avec JSON. L'explication simple (consolante ou non) de l'absence d'un littéral date / heure est que JavaScript n'en a jamais eu non plus: la prise en charge des valeurs de date et d'heure en JavaScript est entièrement fournie via l'objet Date. Par conséquent, la plupart des applications utilisant JSON comme format de données ont généralement tendance à utiliser une chaîne ou un nombre pour exprimer les valeurs de date et d'heure. Si une chaîne est utilisée, vous pouvez généralement vous attendre à ce qu'elle soit au format ISO 8601. Si un nombre est utilisé à la place, la valeur est généralement considérée comme le nombre de millisecondes en temps universel coordonné (UTC) depuis l'époque, où l'époque est définie comme minuit le 1er janvier 1970 (UTC). Encore, il s'agit d'une simple convention et ne fait pas partie de la norme JSON. Si vous échangez des données avec une autre application, vous devrez vérifier sa documentation pour voir comment elle code les valeurs de date et d'heure dans un littéral JSON. Par exemple, ASP.NET AJAX de Microsoft n'utilise aucune des conventions décrites. Au lieu de cela, il code les valeurs .NET DateTime sous la forme d'une chaîne JSON, où le contenu de la chaîne est / Date (ticks) / et où ticks représente les millisecondes depuis epoch (UTC). Ainsi, le 29 novembre 1989, 4:55:30 AM, en UTC est codé comme "\ / Date (628318530718) \ /". NET AJAX n'utilise aucune des conventions décrites. Au lieu de cela, il code les valeurs .NET DateTime sous forme de chaîne JSON, où le contenu de la chaîne est / Date (ticks) / et où ticks représente les millisecondes depuis epoch (UTC). Ainsi, le 29 novembre 1989, 4:55:30 AM, en UTC est codé comme "\ / Date (628318530718) \ /". NET AJAX n'utilise aucune des conventions décrites. Au lieu de cela, il code les valeurs .NET DateTime sous forme de chaîne JSON, où le contenu de la chaîne est / Date (ticks) / et où ticks représente les millisecondes depuis epoch (UTC). Ainsi, le 29 novembre 1989, 4:55:30 AM, en UTC est codé comme "\ / Date (628318530718) \ /".

Une solution serait de simplement analyser:

value = new Date(parseInt(value.replace("/Date(", "").replace(")/",""), 10));

Cependant, j'ai entendu dire qu'il y avait un paramètre quelque part pour que le sérialiseur génère des DateTimeobjets avec la new Date(xxx)syntaxe. Je vais essayer de creuser ça.

Le deuxième paramètre de JSON.parse()accepte une reviverfonction où prescrit comment la valeur produite à l'origine par, avant d'être renvoyée.

Voici un exemple de date:

var parsed = JSON.parse(data, function(key, value) {
  if (typeof value === 'string') {
    var d = /\/Date\((\d*)\)\//.exec(value);
    return (d) ? new Date(+d[1]) : value;
  }
  return value;
});

Voir les documents de JSON.parse ()

Voici ma solution en Javascript - un peu comme JPot, mais plus courte (et peut-être un tout petit peu plus rapide):

value = new Date(parseInt(value.substr(6)));

"value.substr (6)" supprime la partie "/ Date (", et la fonction parseInt ignore les caractères non numériques qui se produisent à la fin.

EDIT: J'ai intentionnellement laissé de côté le radix (le deuxième argument à analyser); voir mon commentaire ci-dessous . Veuillez également noter que les dates ISO-8601 sont préférées à cet ancien format - donc ce format ne devrait 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 en utilisant le format ISO-8601.

Pour les dates JSON au format ISO-8601, passez simplement la chaîne dans le constructeur Date:

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

Il y a pas mal de réponses pour le gérer côté client, mais vous pouvez changer le côté serveur de sortie si vous le souhaitez.

Il y a plusieurs façons d'aborder cela, je vais commencer par les bases. Vous devrez sous-classer la classe JsonResult et remplacer la méthode ExecuteResult. À partir de là, vous pouvez adopter différentes approches pour modifier la sérialisation.

Approche 1: l' implémentation par défaut utilise JsonScriptSerializer . Si vous jetez un œil à la documentation, vous pouvez utiliser la méthode RegisterConverters pour ajouter des JavaScriptConverters personnalisés . Il y a cependant quelques problèmes: Le JavaScriptConverter sérialise dans un dictionnaire, c'est-à-dire qu'il prend un objet et sérialise dans un dictionnaire Json. Pour que l'objet soit sérialisé en chaîne, il faut un peu de piratage, voir l' article . Ce hack particulier échappera également à la chaîne.

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            // Use your custom JavaScriptConverter subclass here.
            serializer.RegisterConverters(new JavascriptConverter[] { new CustomConverter });

            response.Write(serializer.Serialize(Data));
        }
    }
}

Approche 2 (recommandée): La deuxième approche consiste à commencer par le JsonResult remplacé et à aller avec un autre sérialiseur Json, dans mon cas le sérialiseur Json.NET . Cela ne nécessite pas le piratage de l'approche 1. Voici mon implémentation de la sous-classe JsonResult:

public class CustomJsonResult : JsonResult
{
    private const string _dateFormat = "yyyy-MM-dd HH:mm:ss";

    public override void ExecuteResult(ControllerContext context)
    {
        if (context == null)
        {
            throw new ArgumentNullException("context");
        }

        HttpResponseBase response = context.HttpContext.Response;

        if (!String.IsNullOrEmpty(ContentType))
        {
            response.ContentType = ContentType;
        }
        else
        {
            response.ContentType = "application/json";
        }
        if (ContentEncoding != null)
        {
            response.ContentEncoding = ContentEncoding;
        }
        if (Data != null)
        {
            // Using Json.NET serializer
            var isoConvert = new IsoDateTimeConverter();
            isoConvert.DateTimeFormat = _dateFormat;
            response.Write(JsonConvert.SerializeObject(Data, isoConvert));
        }
    }
}

Exemple d'utilisation:

[HttpGet]
public ActionResult Index() {
    return new CustomJsonResult { Data = new { users=db.Users.ToList(); } };
}

Crédits supplémentaires: James Newton-King

Moment.js est une bibliothèque de datetime étendue qui prend également en charge cela. http://momentjs.com/docs/#/parsing/asp-net-json-dates/

ex: moment ("/ Date (1198908717056-0700) /")

Ça pourrait aider. sortie plongeur

J'ai trouvé que créer un nouveau JsonResultet revenir qui n'est pas satisfaisant - devoir remplacer tous les appels à return Json(obj)avec return new MyJsonResult { Data = obj }est une douleur.

J'ai donc pensé, pourquoi ne pas simplement détourner l' JsonResultutilisation d'un ActionFilter:

public class JsonNetFilterAttribute : ActionFilterAttribute
{
    public override void OnActionExecuted(ActionExecutedContext filterContext)
    {
        if (filterContext.Result is JsonResult == false)
        {
            return;
        }

        filterContext.Result = new JsonNetResult(
            (JsonResult)filterContext.Result);
    }

    private class JsonNetResult : JsonResult
    {
        public JsonNetResult(JsonResult jsonResult)
        {
            this.ContentEncoding = jsonResult.ContentEncoding;
            this.ContentType = jsonResult.ContentType;
            this.Data = jsonResult.Data;
            this.JsonRequestBehavior = jsonResult.JsonRequestBehavior;
            this.MaxJsonLength = jsonResult.MaxJsonLength;
            this.RecursionLimit = jsonResult.RecursionLimit;
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var isMethodGet = string.Equals(
                context.HttpContext.Request.HttpMethod, 
                "GET", 
                StringComparison.OrdinalIgnoreCase);

            if (this.JsonRequestBehavior == JsonRequestBehavior.DenyGet
                && isMethodGet)
            {
                throw new InvalidOperationException(
                    "GET not allowed! Change JsonRequestBehavior to AllowGet.");
            }

            var response = context.HttpContext.Response;

            response.ContentType = string.IsNullOrEmpty(this.ContentType) 
                ? "application/json" 
                : this.ContentType;

            if (this.ContentEncoding != null)
            {
                response.ContentEncoding = this.ContentEncoding;
            }

            if (this.Data != null)
            {
                response.Write(JsonConvert.SerializeObject(this.Data));
            }
        }
    }
}

Cela peut être appliqué à toute méthode renvoyant un JsonResultpour utiliser JSON.Net à la place:

[JsonNetFilter]
public ActionResult GetJson()
{
    return Json(new { hello = new Date(2015, 03, 09) }, JsonRequestBehavior.AllowGet)
}

qui répondra avec

{"hello":"2015-03-09T00:00:00+00:00"}

comme voulu!

Vous pouvez, si cela ne vous dérange pas appeler la iscomparaison à chaque demande, l'ajouter à votre FilterConfig:

// ...
filters.Add(new JsonNetFilterAttribute());

et tout votre JSON sera désormais sérialisé avec JSON.Net au lieu du intégré JavaScriptSerializer.

Utiliser jQuery pour convertir automatiquement des dates avec $.parseJSON

Remarque : cette réponse fournit une extension jQuery qui ajoute la prise en charge automatique des formats de date ISO et .net.

Puisque vous utilisez Asp.net MVC, je soupçonne que vous utilisez jQuery du côté client. Je vous suggère de lire cet article de blog contenant du code sur la façon d'utiliser$.parseJSON pour convertir automatiquement les dates pour vous.

Le code prend en charge les dates au format Asp.net comme celles que vous avez mentionnées ainsi que les dates au format ISO. Toutes les dates seront automatiquement formatées pour vous en utilisant $.parseJSON().

La communication Ajax entre le client et le serveur implique souvent des données au format JSON. Bien que JSON fonctionne bien pour les chaînes, les nombres et les booléens, il peut poser quelques difficultés pour les dates en raison de la façon dont ASP.NET les sérialise. Comme il n'a pas de représentation spéciale pour les dates, elles sont sérialisées en chaînes simples. Comme solution, le mécanisme de sérialisation par défaut des formulaires Web ASP.NET et MVC sérialise les dates sous une forme spéciale - / Date (ticks) / - où ticks est le nombre de millisecondes depuis le 1er janvier 1970.

Ce problème peut être résolu de 2 manières:

côté client

Convertissez la chaîne de date reçue en nombre et créez un objet date en utilisant le constructeur de la classe de date avec les ticks comme paramètre.

function ToJavaScriptDate(value) {
  var pattern = /Date\(([^)]+)\)/;
  var results = pattern.exec(value);
  var dt = new Date(parseFloat(results[1]));
  return (dt.getMonth() + 1) + "/" + dt.getDate() + "/" + dt.getFullYear();
}

du côté serveur

La solution précédente utilise un script côté client pour convertir la date en un objet Date JavaScript. Vous pouvez également utiliser du code côté serveur qui sérialise les instances .NET DateTime au format de votre choix. Pour accomplir cette tâche, vous devez créer votre propre ActionResult, puis sérialiser les données comme vous le souhaitez.

référence: http://www.developer.com/net/dealing-with-json-dates-in-asp.net-mvc.html

J'ai eu le même problème et au lieu de renvoyer la valeur de date réelle, je viens d'utiliser ToString ("jj MMM aaaa") dessus. Puis, dans mon javascript, j'ai utilisé une nouvelle date (datevalue), où datevalue peut être "01 jan 2009".

Voir ce fil:

http://forums.asp.net/p/1038457/1441866.aspx#1441866

Fondamentalement, bien que le Date()format soit du javascript valide, ce n'est PAS du JSON valide (il y a une différence). Si vous voulez l'ancien format, vous devrez probablement créer une façade et transformer la valeur vous-même, ou trouver un moyen d'obtenir le sérialiseur pour votre type dans le JsonResultet de lui faire utiliser un format personnalisé pour les dates.

Pas la manière la plus élégante mais cela a fonctionné pour moi:

var ms = date.substring(6, date.length - 2);
var newDate = formatDate(ms);


function formatDate(ms) {

    var date = new Date(parseInt(ms));
    var hour = date.getHours();
    var mins = date.getMinutes() + '';
    var time = "AM";

    // find time 
    if (hour >= 12) {
        time = "PM";
    }
    // fix hours format
    if (hour > 12) {
        hour -= 12;
    }
    else if (hour == 0) {
        hour = 12;
    }
    // fix minutes format
    if (mins.length == 1) {
        mins = "0" + mins;
    }
    // return formatted date time string
    return date.getMonth() + 1 + "/" + date.getDate() + "/" + date.getFullYear() + " " + hour + ":" + mins + " " + time;
}

J'ai travaillé sur une solution à ce problème car aucune des réponses ci-dessus ne m'a vraiment aidé. Je travaille avec le calendrier de la semaine jquery et j'avais besoin de mes dates pour avoir des informations de fuseau horaire sur le serveur et localement sur la page. Après avoir longuement fouillé, j'ai trouvé une solution qui pourrait aider les autres.

J'utilise asp.net 3.5, vs 2008, asp.net MVC 2 et le calendrier de la semaine jquery,

Tout d'abord, j'utilise une bibliothèque écrite par Steven Levithan qui aide à gérer les dates côté client, la bibliothèque de dates de Steven Levithan . Le format isoUtcDateTime est parfait pour ce dont j'avais besoin. Dans mon appel AJAX jquery, j'utilise la fonction de format fournie avec la bibliothèque au format isoUtcDateTime et lorsque l'appel ajax atteint ma méthode d'action, le type datetime est défini sur local et reflète l'heure du serveur.

Lorsque j'envoie des dates sur ma page via AJAX, je les envoie sous forme de chaînes de texte en formatant les dates en utilisant "jjj, jj MMM aaaa HH ':' mm ':' ss 'GMT'zzzz". Ce format est facilement convertible côté client en utilisant

var myDate = new Date(myReceivedDate);

Voici ma solution complète moins la source de Steve Levithan, que vous pouvez télécharger:

Manette:

public class HomeController : Controller
{
    public const string DATE_FORMAT = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'zzzz";

    public ActionResult Index()
    {
        ViewData["Message"] = "Welcome to ASP.NET MVC!";

        return View();
    }

    public ActionResult About()
    {
        return View();
    }


    public JsonResult GetData()
    {
        DateTime myDate = DateTime.Now.ToLocalTime();

        return new JsonResult { Data = new { myDate = myDate.ToString(DATE_FORMAT) } };
    }

    public JsonResult ReceiveData(DateTime myDate)
    {
        return new JsonResult { Data = new { myDate = myDate.ToString(DATE_FORMAT) } };
    }
}

Javascript:

<script type="text/javascript">

function getData() {
    $.ajax({
        url: "/Home/GetData",
        type: "POST",
        cache: "false",
        dataType: "json",
        success: function(data) {
            alert(data.myDate);
            var newDate = cleanDate(data.myDate);
            alert(newDate);
            sendData(newDate);
        }
    });
} 

function cleanDate(d) {
    if (typeof d == 'string') {
        return new Date(d) || Date.parse(d) || new Date(parseInt(d));
    }
    if (typeof d == 'number') {
        return new Date(d);
    }
    return d;
}

function sendData(newDate) {
    $.ajax({
        url: "/Home/ReceiveData",
        type: "POST",
        cache: "false",
        dataType: "json",
        data:
        {
            myDate: newDate.format("isoUtcDateTime")
        },
        success: function(data) {
            alert(data.myDate);
            var newDate = cleanDate(data.myDate);
            alert(newDate);
        }
    });
}

// bind myButton click event to call getData
$(document).ready(function() {
    $('input#myButton').bind('click', getData);
});
</script>

J'espère que cet exemple rapide aide les autres dans la même situation que celle dans laquelle je me trouvais. À l'heure actuelle, il semble très bien fonctionner avec la sérialisation Microsoft JSON et conserve mes dates correctes sur tous les fuseaux horaires.

La meilleure façon de gérer les dates dans knockoutjs est d'utiliser la bibliothèque de moments et de gérer les dates comme boss. Vous pouvez facilement gérer des dates telles que / Date (-62135578800000) /. Pas besoin de se soucier de la façon dont votre date de sérialisation dans le contrôleur.

function jsonToDate(date,format) {
   return moment(date).format(format);
}

l'utiliser comme

var formattedDate = jsonToDate(date,'MM/DD/YYYY')

momentjs prend en charge de nombreux formats de date et d'heure et des fonctions utilitaires sur les dates.

Formatez la date dans la requête.

var _myModel = from _m in model.ModelSearch(word)
    select new { date = ((DateTime)_m.Date).ToShortDateString() };

Le seul problème avec cette solution est que vous n'obtiendrez aucun résultat si TOUTES les valeurs de date sont nulles. Pour contourner ce problème, vous pouvez soit placer des instructions conditionnelles dans votre requête AVANT de sélectionner la date qui ignore les nulls de date, soit configurer une requête pour obtenir tous les résultats, puis parcourir toutes ces informations à l'aide d'une boucle foreach et attribuer une valeur à toutes les dates qui sont nulles AVANT de faire votre SELECT nouveau.

Exemple des deux:

var _test = from _t in adc.ItemSearchTest(word)
                        where _t.Date != null
                        select new { date = ((DateTime)_t.Date).ToShortDateString() };

La deuxième option nécessite une autre requête entièrement afin que vous puissiez attribuer des valeurs à tous les null. Cela et la boucle foreach devraient être AVANT votre requête qui sélectionne les valeurs.

var _testA = from _t in adc.ItemSearchTest(word)
                         select _i;

            foreach (var detail in _testA)
            {
                if (detail.Date== null)
                {
                    detail.Date= Convert.ToDateTime("1/1/0001");
                }
            }

Juste une idée que j'ai trouvée plus facile que tous les exemples javascript.

Vous pouvez utiliser cette méthode:

String.prototype.jsonToDate = function(){
    try{
        var date;
        eval(("date = new " + this).replace(/\//g,''));
        return date;
    } 
    catch(e){
        return new Date(0);
    }
};

0

Dans votre cshtml,

<tr ng-repeat="value in Results">                
 <td>{{value.FileReceivedOn | mydate | date : 'dd-MM-yyyy'}} </td>
</tr>

Dans votre fichier JS, peut-être app.js,

En dehors de app.controller, ajoutez le filtre ci-dessous.

Ici, "mydate" est la fonction que vous appelez pour analyser la date. Ici, "l'application" est la variable qui contient le module angulaire.

app.filter("mydate", function () {
    var re = /\/Date\(([0-9]*)\)\//;
    return function (x) {
        var m = x.match(re);
        if (m) return new Date(parseInt(m[1]));
        else return null;
    };
});

ajoutez le plugin jquery ui dans votre page.

function JsonDateFormate(dateFormate, jsonDateTime) {
    return $.datepicker.formatDate(dateFormate, eval('new ' + jsonDateTime.slice(1, -1)));
};

Pas pour rien, mais il existe un autre moyen. Commencez par construire votre requête LINQ. Ensuite, créez une requête du résultat énuméré et appliquez le type de mise en forme qui vous convient.

var query = from t in db.Table select new { t.DateField };
var result = from c in query.AsEnumerable() select new { c.DateField.toString("dd MMM yyy") };

Je dois dire que l'étape supplémentaire est ennuyeuse, mais cela fonctionne bien.

Ce qui a fonctionné pour moi a été de créer un modèle de vue contenant la propriété date sous forme de chaîne. Affecter la propriété DateTime à partir du modèle de domaine et appeler le .ToString () sur la propriété date lors de l'attribution de la valeur au viewmodel.

Un résultat JSON d'une méthode d'action MVC renverra la date dans un format compatible avec la vue.

Voir le modèle

public class TransactionsViewModel
{
    public string DateInitiated { get; set; }
    public string DateCompleted { get; set; }
}

Modèle de domaine

public class Transaction{
   public DateTime? DateInitiated {get; set;}
   public DateTime? DateCompleted {get; set;}
}

Méthode d'action du contrôleur

public JsonResult GetTransactions(){

var transactions = _transactionsRepository.All;
        var model = new List<TransactionsViewModel>();

        foreach (var transaction in transactions)
        {
            var item = new TransactionsViewModel
            {
                ...............
                DateInitiated = transaction.DateInitiated.ToString(),
                DateCompleted = transaction.DateCompleted.ToString(),
            };

            model.Add(item);
        }
        return Json(model, JsonRequestBehavior.AllowGet);
}

Remplacez les contrôleurs Json / JsonResult pour renvoyer JSON.Net:

Cela fonctionne un régal

Ennuyeux, non?

Ma solution a été de changer mon service WCF pour qu'il retourne DateTimes dans un format plus lisible (non Microsoft). Remarquez ci-dessous, le " UpdateDateOriginal", qui est le format par défaut des dates de WCF, et mon " UpdateDate", qui est formaté pour quelque chose de plus lisible.

Voici comment procéder:

Modification du format de date WCF

J'espère que cela t'aides.

J'ai trouvé que c'était le moyen le plus simple de le changer côté serveur.

using System.Collections.Generic;
using System.Web.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;

namespace Website
{
    /// <summary>
    /// This is like MVC5's JsonResult but it uses CamelCase and date formatting.
    /// </summary>
    public class MyJsonResult : ContentResult
    {
        private static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver(),
            Converters = new List<JsonConverter> { new StringEnumConverter() }
        };

        public FindersJsonResult(object obj)
        {
            this.Content = JsonConvert.SerializeObject(obj, Settings);
            this.ContentType = "application/json";
        }
    }
}

J'ai eu un certain nombre de problèmes avec les dates JSON et j'ai décidé de me débarrasser du problème en résolvant le problème de date dans SQL. Changer le format de date en un format de chaîne

select flddate from tblName

select flddate, convert(varchar(12), flddate, 113) as fldDateStr from tblName

En utilisant fldDateStr, le problème a disparu et je pouvais toujours utiliser le champ de date pour le tri ou à d'autres fins.

Il renvoie le format de date du serveur. Vous devez définir votre propre fonction.

function jsonDateFormat(jsonDate) {
  // Changed data format;
  return (new Date(parseInt(jsonDate.substr(6)))).format("mm-dd-yyyy / h:MM tt");
};

Voici un code JavaScript que j'ai écrit qui définit une <input type="date">valeur à partir d'une date transmise par ASP.NET MVC.

var setDate = function(id, d) {
  if (d !== undefined && d !== null) {
    var date = new Date(parseInt(d.replace("/Date(", "").replace(")/", ""), 10));
    var day = ('0' + date.getDate()).slice(-2);
    var month = ('0' + (date.getMonth() + 1)).slice(-2);
    var parsedDate = date.getFullYear() + "-" + (month) + "-" + (day);
    $(id).val(parsedDate);
  }
};

Vous appelez cette fonction comme ceci:

setDate('#productCommissionStartDate', data.commissionStartDate);

Où commissionStartDateest la date JSON passée par MVC.

Le plus simple:

var milisegundos = parseInt (data.replace ("/ Date (", "") .replace (") /", ""));
Var newDate = nouvelle date (milisegundos). toLocaleDateString ("en-UE");