Como faço para formatar uma data Microsoft JSON?

StackOverflow https://stackoverflow.com/questions/206384

  •  03-07-2019
  •  | 
  •  

Pergunta

Eu estou tomando minha primeira rachadura em Ajax com jQuery. Eu estou recebendo meus dados para a minha página, mas eu estou tendo alguns problemas com os dados JSON que é retornado para tipos de dados Data. Basicamente, eu estou recebendo um back seqüência parecida com esta: 

/Date(1224043200000)/

De alguém totalmente novo para JSON - Como faço para formatar isso para um curto formato de data? este deve ser tratado em algum lugar no código jQuery? Eu tentei o jQuery.UI.datepicker plugin usando $.datepicker.formatDate() sem qualquer sucesso.

FYI: Aqui está a solução que eu vim com usando uma combinação das respostas aqui: 

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

Esta solução tem meu objeto do método de retorno e exibidas as datas na página corretamente usando a biblioteca formato de data.

Foi útil?

Solução

eval() não é necessário. Este trabalho será bem: 

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

A função substr() tira a parte /Date(, ea função parseInt() recebe o inteiro e ignora o )/ no final. O número resultante é passado para o construtor Date.

Eu intencionalmente deixado de fora a raiz (o 2º argumento para parseInt); consulte meu comentário abaixo .

Além disso, eu concordo completamente com de Rory comentário : ISO-8601 datas são preferidos sobre este formato antigo - de modo que este formato geralmente não deve ser usado para o desenvolvimento de novos. Veja a biblioteca Json.NET excelente para uma excelente alternativa que serializa datas usando o formato ISO-8601.

Para ISO-8601 datas JSON formatados, basta passar a string para o construtor Date: 

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

Outras dicas

Você pode usar isso para obter uma data de JSON: 

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

E, em seguida, você pode usar um script Formato de data JavaScript (1,2 KB quando minified e compactado) para exibi-lo como quiser.

Para aqueles que usam Newtonsoft Json.NET , ler sobre como fazê-lo através de nativo JSON no IE8, Firefox 3.5, mais Json.NET .

Além disso, a documentação sobre como alterar o formato das datas escritas por Json.NET é útil: Serializando datas com Json.NET

Para aqueles que são preguiçosos demais, aqui estão os passos rápidos. Como JSON tem uma implementação DateTime solto, você precisa usar o IsoDateTimeConverter(). Note-se que desde Json.NET 4.5 o formato de data padrão é ISO para que o código abaixo não é necessário. 

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

O JSON virá através como 

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

Finalmente, alguns JavaScript para converter a data ISO para uma 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;
}

Eu usei-o como este 

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

O exemplo original: 

/Date(1224043200000)/

não reflete o formato usado pelo WCF ao enviar datas via WCF REST usando a serialização embutida JSON. (Pelo menos em .NET 3.5, SP1)

Eu encontrei a resposta aqui útil, mas é necessária uma ligeira edição da regex, como parece que o fuso horário GMT está sendo anexada para o número retornado (desde 1970) em WCF JSON.

Em um serviço WCF eu tenho: 

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

ApptVisitLinkInfo é definido simplesmente: 

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

Quando "campo2" é retornada como Json do serviço o valor é: 

/Date(1224043200000-0600)/

Observe o deslocamento de fuso horário incluído como parte do valor.

O regex modificado: 

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

É um pouco mais ansioso e pega tudo entre os parênteses, não apenas o primeiro número. O sinze resultando tempo 1970, além de deslocamento de fuso horário podem ser alimentados no eval para obter um objeto data.

A linha resultante de JavaScript para o substituir é: 

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

Não se repita - conversão de data automatizar usando $.parseJSON()

As respostas a seu cargo fornecer conversão de data manual para datas JavaScript. Eu estendida $.parseJSON() do jQuery apenas um pouco, por isso é capaz de datas automaticamente de análise quando você instruí-lo a. Ele processa ASP.NET formatado datas (/Date(12348721342)/), bem como ISO formatado datas (2010-01-01T12.34.56.789Z) que são suportados por funções JSON nativa em navegadores (e bibliotecas como json2.js).

De qualquer forma. Se você não quer repetir o seu código de conversão de data e outra vez eu sugiro que você leia este post e obter o código que irá tornar sua vida um pouco mais fácil.

Se você diz em JavaScript, 

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

Você vai ver que é a data correta, e você pode usar isso em qualquer lugar no código JavaScript com qualquer estrutura.

Clique aqui para conferir a demonstração

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"

Atualização

Nós temos uma biblioteca de interface do usuário interna que tem de lidar com ASP.NET tanto da Microsoft embutido no formato JSON, como /Date(msecs)/, questionado sobre aqui originalmente, e mais formato de data do JSON incluindo JSON.NET de, como 2014-06-22T00:00:00.0. Além disso, precisamos lidar com a incapacidade de oldIE para lidar com qualquer coisa, mas 3 casas decimais .

Em primeiro lugar, detectar que tipo de data que está consumindo, analisá-lo em um objeto normal de Date JavaScript, em seguida, formatar isso.

1) Detectar Data formato Microsoft 

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

2) Detectar formato de 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) Parse MS formato de data: 

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

4) formato Parse ISO data.

Nós fazemos, pelo menos, ter uma maneira de ter certeza de que estamos lidando com datas norma ISO ou datas ISO modificados para ter sempre três milissegundo lugares ( veja acima ), para que o código é diferente, dependendo do ambiente.

4a) Formato da data Parse padrão ISO, lidar com questões 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) formato Parse ISO com um fixo três milissegundo casas decimais - muito mais fácil: 

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

5) Formate-lo: 

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) unir tudo isso: 

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

    return formatDate(d);
}

A seguir velha resposta é útil para amarrar esta data formatação na própria análise JSON jQuery para que você obtenha Data objetos em vez de cordas, ou se você ainda está preso em jQuery <1,5 alguma forma.

Resposta Old

Se você estiver usando jQuery função Ajax 1.4 de com ASP.NET MVC, você pode transformar todas as propriedades de data e hora em objetos de data com: 

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

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

Em jQuery 1.5 você pode evitar substituindo o método parseJSON globalmente usando a opção conversores na chamada Ajax.

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

Infelizmente você tem que mudar para a rota eval mais velhos, a fim de obter datas para analisar globalmente no local -. Caso contrário, você precisa convertê-los em um caso-a-caso base pós-parse mais

Eu também tive que procurar uma solução para este problema e, eventualmente, me deparei com moment.js que é uma biblioteca agradável que pode analisar esse formato de data e muito mais. 

var d = moment(yourdatestring)

Ele salvou algumas dores de cabeça para mim, então eu pensei em compartilhar com você. :)
Você pode encontrar mais algumas informações sobre ele aqui: http://momentjs.com/

Não há construído em tipo de data no JSON . Este parece ser o número de segundos / milissegundos de alguma época. Se você sabe a época você pode criar a data, adicionando a quantidade certa de tempo.

acabei adicionando os "personagens em expressão regular de Panos para se livrar dos gerados pela serializer Microsoft para ao escrever objetos em um script embutido:

Então, se você tem uma propriedade em sua C # code-behind isso é algo como 

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

E no seu aspx você tem 

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

Você deseja obter algo como 

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

Observe as aspas duplas.

Para obter este em uma forma que eval irá desserializar corretamente, eu usei: 

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

Eu uso Prototype e usá-lo eu adicionei 

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

Em jQuery 1.5, contanto que você tem json2.js para cobrir os navegadores mais antigos, você pode desserializar todas as datas provenientes do Ajax da seguinte forma: 

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

Eu incluí lógica que assume que você envie todas as datas a partir do servidor como UTC (que você deve); o consumidor, em seguida, obtém um objeto Date JavaScript que tem o valor carrapatos adequada para refletir isso. Isto é, chamando getUTCHours(), etc. na data retornará o mesmo valor como o fez no servidor, e chamando getHours() irá retornar o valor no fuso horário local do usuário, conforme determinado pelo seu browser.

Isto não leva em conta WCF formato com deslocamentos de fuso horário, no entanto, que seria relativamente fácil a acrescentar.

Não excesso de pensar isso. Como temos feito há décadas, passar um deslocamento a partir da época de-facto padrão de 01 janeiro de 1970 à meia-noite GMT / UTC / & c em número de segundos (ou milissegundos) desde essa época numérico. JavaScript gosta, Java gosta, C gosta, e da Internet gosta.

Usando o datepicker jQuery UI - realmente só faz sentido se você já está incluindo jQuery UI: 

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

saída:

15 de outubro de 2008

Todos destas respostas tem uma coisa em comum:. Eles todas as datas loja como um único valor (geralmente uma string)

Outra opção é aproveitar a estrutura inerente de JSON, e representam uma data lista de números como: 

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

É claro, você tem que ter certeza ambas as extremidades da conversa chegar a acordo sobre o formato (ano, mês, dia), e quais campos são destinadas a ser datas, ... mas tem a vantagem de evitar completamente o emissão de conversão de data-to-string. É todos os números - sem cordas em tudo. Além disso, usando a ordem:. Ano, mês, dia também permite triagem adequada por data

Apenas pensar fora da caixa aqui -. Uma data JSON não tem que ser armazenado como uma string

Outro bônus para fazê-lo desta maneira é que você pode facilmente (e eficiente) selecionar todos os registros para um determinado ano ou mês, aproveitando a maneira CouchDB alças consultas sobre valores da matriz.

Posting in thread incrível: 

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 uma outra opção sem usar a biblioteca jQuery?

Tenho a data como esta: 

"/Date(1276290000000+0300)/"

Em alguns exemplos da data está em um pouco diferentes formatos: 

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

etc.

Então, eu vim com o seguinte RegExp: 

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

eo código final é: 

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

Hope isso ajuda.

Update: Eu encontrei este link da Microsoft: Como Datas I Serialize com JSON?

Esta parece ser a que estamos todos à procura de. 

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

A seguir é uma solução muito simples para analisar datas JSON. Use o abaixo funções como por sua exigência. Você só precisa passar o formato JSON Data buscado como um parâmetro para as funções abaixo: 

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

Isto pode também pode ajudá-lo. 

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

Verifique se o padrão de data ISO; tipo de como isto: 

yyyy.MM.ddThh:mm

Torna-se 2008.11.20T22:18.

Este é frustrante. Minha solução foi analisar o "/ e /" a partir do valor gerado pelo JavaScriptSerializer do ASP.NET para que, embora JSON não pode ter um literal data, ainda é interpretado pelo navegador como uma data, que é o que tudo o que eu realmente quer: {"myDate":Date(123456789)}

JavaScriptConverter personalizado para DateTime?

Devo enfatizar a exatidão do comentário de Roy Tinker. Este não é JSON legal. É um sujo, truque sujo no servidor para remover o problema antes que se torne um problema para JavaScript. Ele vai sufocar um analisador JSON. Usei-o para sair do chão, mas eu não uso isso mais. No entanto, eu ainda sinto as melhores mentiras resposta com a mudança de como o servidor formata a data, por exemplo, ISO como mencionado em outro lugar.

Adicione o jQuery UI plugin na sua página: 

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

Você também pode usar a biblioteca JavaScript moment.js , que vem a calhar quando você planeja fazer lidar com diferentes localizada formatos e executar outras operações com valores datas: 

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

Configuração de localização é tão fácil como adicionar arquivos de configuração (você levá-los a momentjs.com) ao seu projeto e configurar o idioma: 

moment.lang('de');

Um post atrasado, mas para aqueles que procurou este post.

Imagine o seguinte: 

    [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 você pode ver, eu estou utilizando recurso C # 3.0 é para criar o "Auto" Genéricos. É um pouco preguiçoso, mas eu gosto dele e ele funciona. Apenas uma nota:. Perfil é uma classe personalizada que criei para o meu projeto de aplicação Web

solução Mootools: 

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

Requer mootools-mais. Testadas usando mootools-1.2.3.1-mais no Firefox 3.6.3 e IE 7.0.5730.13

FYI, para qualquer um usando Python no lado do servidor:. Datetime.datetime () ctime () retorna uma cadeia que é nativamente parsable por "new Date ()". Isto é, se você criar uma nova instância datetime.datetime (como com datetime.datetime.now), a corda pode ser incluída na string JSON, em seguida, essa seqüência pode ser passado como o primeiro argumento para o construtor Data. Eu ainda não encontraram quaisquer excepções, mas eu não testei muito rigorosamente, quer.

E se .NET retorna ... 

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

E, em seguida, em JavaScript ... 

var x = new Date("2013-09-17 15:18:53Z");
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top