Puede usar esto para obtener una fecha de JSON:

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

Y luego puede usar un script con formato de fecha JavaScript (1.2 KB cuando se minifica y se comprime) para mostrarlo como desee.

Para aquellos que utilizan Newtonsoft Json.NET, lee sobre cómo hacerlo a través de JSON Nativo en IE8, Firefox 3.5 plus Json.NET.

También la documentación sobre el cambio de formato de fechas escrita por Json.NET es útil: Serialización de Fechas con Json.NET

Para aquellos que son demasiado perezosos, aquí están los pasos rápidos. Como JSON tiene una implementación de DateTime suelta, debe usar IsoDateTimeConverter(). Tenga en cuenta que desde Json.NET 4.5 las el formato de fecha predeterminado es ISO, por lo que no es necesario el siguiente código.

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

El JSON vendrá como

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

Finalmente, algunos JavaScript para convertir la fecha ISO a una fecha 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;
}

Lo usé así {[16]]}

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

El ejemplo original:

/Date(1224043200000)/  

No refleja el formato utilizado por WCF al enviar fechas a través de WCF REST utilizando la serialización JSON integrada. (al menos en. NET 3.5, SP1)

Encontré útil la respuesta aquí, pero se requiere una ligera edición de la expresión regular, ya que parece que el desplazamiento GMT de la zona horaria se está agregando al número devuelto (desde 1970) en WCF JSON.

En un servicio WCF tengo:

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

ApptVisitLinkInfo está definido simplemente:

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

Cuando "Field2" se devuelve como Json desde el servicio, el valor es:

/Date(1224043200000-0600)/

Observe el desplazamiento de zona horaria incluido como parte del valor.

La expresión regular modificada:

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

Es un poco más ansioso y agarra todo entre paréntesis, no solo el primer número. El tiempo resultante sinze 1970, más el desplazamiento de zona horaria se pueden introducir en la evaluación para obtener un objeto de fecha.

La línea resultante de JavaScript para el reemplazo es:

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

No te repitas - automatiza la conversión de fecha usando $.parseJSON()

Las respuestas a su publicación proporcionan conversión manual de fechas a fechas JavaScript. He ampliado jQuery $.parseJSON() solo un poco, por lo que es capaz de analizar automáticamente las fechas cuando se le indique. Procesos de ti ASP.NET fechas con formato (/Date(12348721342)/), así como fechas con formato ISO (2010-01-01T12.34.56.789Z) que son compatibles con funciones JSON nativas en navegadores (y bibliotecas como json2.js).

De todos modos. Si no quieres repetir tu cita código de conversión una y otra vez Te sugiero que leas esta entrada de blog y obtengas el código que te hará la vida un poco más fácil.

Si se dice en JavaScript,

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

Verá que es la fecha correcta, y puede usarla en cualquier lugar del código JavaScript con cualquier framework.

Haga clic aquí para ver 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();

Resultado - "10/15/2008"

Actualizado

Tenemos una biblioteca de interfaz de usuario interna que tiene que hacer frente a ambos Microsoft ASP.NET el formato JSON incorporado, como /Date(msecs)/, preguntó por aquí originalmente, y la mayoría del formato de fecha de JSON incluye JSON.NET ' s, como 2014-06-22T00:00:00.0. Además tenemos que hacer frente a La incapacidad de oldIE para hacer frente a cualquier cosa menos 3 decimales .

Primero detectamos qué tipo de fecha estamos consumiendo, la analizamos en un objeto normal de JavaScript Date, luego formateamos eso.

1) Detectar Formato de fecha de Microsoft

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

2) Detectar el formato de fecha 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) Analizar el formato de fecha de MS:

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

4) Analizar el formato de fecha ISO.

Al menos tenemos una manera de estar seguros de que estamos tratando con fechas ISO estándar o fechas ISO modificadas para tener siempre tres lugares milisegundos ( ver arriba), por lo que el código es diferente dependiendo del entorno.

4a) Analizar el formato de fecha ISO estándar, hacer frente a los problemas 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) Analizar Formato ISO con un decimal fijo de tres milisegundos-mucho más fácil:

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

5) Formatearlo:

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) Atar todo junto:

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 respuesta anterior a continuación es útil para vincular este formato de fecha en el propio análisis JSON de jQuery para obtener objetos de fecha en lugar de cadenas, o si todavía está atascado en jQuery

Antigua respuesta

Si está utilizando la función Ajax de jQuery 1.4 con ASP.NET MVC, puede convertir todas las propiedades DateTime en Fecha objetos con:

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

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

En jQuery 1.5 puede evitar sobrescribir el método parseJSON globalmente usando la opción convertidores en la llamada Ajax.

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

Desafortunadamente tiene que cambiar a la ruta de evaluación anterior para obtener Fechas para analizar globalmente en su lugar; de lo contrario, debe convertirlas caso por caso después del análisis.

También tuve que buscar una solución a este problema y finalmente me encontré con moment.js, que es una buena biblioteca que puede analizar este formato de fecha y muchos más.

var d = moment(yourdatestring)

Me ahorró un poco de dolor de cabeza, así que pensé en compartirlo contigo. :)
Puede encontrar más información al respecto aquí: http://momentjs.com /

Terminé agregando los " caracteres en la expresión regular de Panos para deshacerse de los generados por el serializador de Microsoft para cuando se escriben objetos en un script en línea:

Así que si tienes una propiedad en tu código de C# -detrás de eso es algo así como

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

Y en tu aspx tienes

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

Obtendrías algo como

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

Observe las comillas dobles.

Para conseguir esto en una forma que eval correctamente deserializar, me usado:

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

Utilizo Prototipo y para usarlo agregué

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

No hay un tipo de fecha incorporado en JSON. Esto parece el número de segundos / milisegundos de alguna época. Si conoce la época, puede crear la fecha agregando la cantidad de tiempo correcta.

En jQuery 1.5, siempre y cuando tenga json2.js para cubrir los navegadores más antiguos, puede deserializar todas las fechas procedentes de Ajax de la siguiente manera:

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

He incluido la lógica que asume que envía todas las fechas desde el servidor como UTC (que debería); el consumidor obtiene un objeto JavaScript Date que tiene el valor de ticks adecuado para reflejar esto. Es decir, llamando getUTCHours(), etc. en la fecha devolverá el mismo valor que en el servidor, y llamando a getHours() devolverá el valor en el zona horaria local del usuario determinada por su navegador.

Esto no tiene en cuenta el formato WCF con compensaciones de zona horaria, aunque eso sería relativamente fácil de agregar.

No lo pienses demasiado. Como hemos hecho durante décadas, pase un desplazamiento numérico de la época estándar de facto del 1 de enero de 1970 medianoche GMT / UTC/ & c en número de segundos (o milisegundos) desde esta época. A JavaScript le gusta, a Java le gusta, a C le gusta y a Internet le gusta.

Usando el datepicker de jQuery UI-realmente solo tiene sentido si ya está incluyendo jQuery UI:

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

Salida:

15 de octubre de 2008

Todas estas respuestas tienen una cosa en común: todas almacenan fechas como un solo valor (generalmente una cadena).

Otra opción es aprovechar la estructura inherente de JSON, y representar una fecha como lista de números:

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

Por supuesto, usted tendría que asegurarse de que ambos extremos de la conversación de acuerdo en el formato (año, mes, día), y que los campos están destinados a ser fechas,... pero tiene la ventaja de evitar completamente el problema de la conversión de fecha a cadena. Son todos números no sin ataduras. Además, el uso del orden: año, mes, día también permite una clasificación adecuada por fecha.

Simplemente pensando fuera de la caja aquí a una fecha JSON no tiene que ser almacenada como una cadena.

Otra ventaja de hacerlo de esta manera es que puede seleccionar fácilmente (y eficientemente) todos los registros para un año o mes determinado aprovechando la forma en que CouchDB maneja las consultas sobre los valores de la matriz.

Publicando en impresionante hilo:

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

¿Hay otra opción sin usar la biblioteca jQuery?

Solo para agregar otro enfoque aquí, el "enfoque de garrapatas" que WCF toma es propenso a problemas con las zonas horarias si no eres extremadamente cuidadoso, como se describe aquí y en otros lugares. Así que ahora estoy usando el formato ISO 8601 que tanto. NET como JavaScript soportan debidamente que incluye compensaciones de zona horaria. A continuación se presentan los detalles:

En WCF/. NET:

Donde creationDate es un Sistema.DateTime; toString ("o") está usando el formato de ida y vuelta de. NET especificador que genera una cadena de fecha conforme a ISO 8601

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

En JavaScript

Justo después de recuperar el JSON, voy a arreglar las fechas para que sean objetos de fecha JavaScript usando el constructor de fecha que acepta una cadena de fecha 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 vez que tenga una fecha JavaScript, puede usar todos los métodos de fecha convenientes y confiables como toDateString, toLocaleString, etc.

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

Verifique la fecha del estándar ISO; algo así:

yyyy.MM.ddThh:mm

Se convierte en 2008.11.20T22:18.

Obtengo la fecha así:

"/Date(1276290000000+0300)/"

En algunos ejemplos la fecha está en formatos ligeramente diferentes:

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

Etc.

Así que se me ocurrió la siguiente expresión regular:

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

Y el código final es:

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

Espero que ayude.

Actualizar: He encontrado este enlace de Microsoft: ¿Cómo Serializo las Fechas con JSON?

Este parece el que todos estamos buscando.

Esto es frustrante. Mi solución fue analizar el "/ y / " del valor generado por ASP.NET JavaScriptSerializer para que, aunque JSON no tenga una fecha literal, el navegador lo interprete como una fecha, que es lo que realmente quiero: {"myDate":Date(123456789)}

JavaScriptConverter personalizado para DateTime?

Debo enfatizar la precisión del comentario de Roy Tinker. Esto no es JSON legal. Es un truco sucio, sucio en el servidor para eliminar el problema antes de que se convierta un problema para JavaScript. Estrangulará un analizador JSON. Lo usé para despegar, pero ya no uso esto. Sin embargo, todavía creo que la mejor respuesta radica en cambiar la forma en que el servidor formatea la fecha, por ejemplo, ISO como se mencionó en otro lugar.

Añade el plugin jQuery UI en tu página:

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

A continuación se muestra una solución bastante simple para analizar fechas JSON. Utilice las funciones siguientes según su requisito. Solo necesita pasar la fecha de formato JSON obtenida como parámetro a las siguientes funciones:

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

Un post tardío, pero para aquellos que buscaron este post.

Imagina esto:

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

Como puede ver, estoy utilizando la función de C# 3.0 para crear los genéricos "Automáticos". Es un poco perezoso, pero me gusta y funciona. Solo una nota: Profile es una clase personalizada que he creado para mi proyecto de aplicación web.

Solución de Mootools:

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

Requiere mootools-más. Probado usando mootools-1.2.3.1 - más en Firefox 3.6.3 e IE 7.0.5730.13

También puede usar la biblioteca JavaScript moment.js, que es muy útil cuando planea hacer frente a diferentes formatos localizados y realizar otras operaciones con valores de fechas:

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

Configurar la localización es tan fácil como agregar archivos de configuración (los obtienes en momentjs.com) a su proyecto y configurando el idioma:

moment.lang('de');

Para su información, para cualquiera que use Python en el lado del servidor: datetime.datetime().ctime () devuelve una cadena que es nativamente parsable por "new Date ()". Es decir, si crea una nueva fecha y hora.instancia de datetime (como con datetime.datetime.ahora), la cadena se puede incluir en la cadena JSON, y luego esa cadena se puede pasar como primer argumento al constructor Date. Todavía no he encontrado ninguna excepción, pero tampoco la he probado demasiado rigurosamente.

Y si . NET devuelve...

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

Y luego en JavaScript...

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

Este mayo también puede ayudarte.

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