Um momento.js

It is a (lightweight) * JavaScript date library for parsing, manipulating, and formatting dates.

var a = moment([2010, 1, 14, 15, 25, 50, 125]);
a.format("dddd, MMMM Do YYYY, h:mm:ss a"); // "Sunday, February 14th 2010, 3:25:50 pm"
a.format("ddd, hA");                       // "Sun, 3PM"

(*) lightweight meaning 9.3 KB minified + gzipped in the smallest possible setup (Fev 2014)

Se já estiver a utilizar jQuery UI no seu projecto, poderá usar o método incorporado para formatar o seu objecto de data:

$.datepicker.formatDate('yy-mm-dd', new Date(2007, 1 - 1, 26));

No entanto, o datepicker apenas Formata datas, e não pode formatar horas.

Dê uma olhada em jQuery UI datepicker formatDate , Os exemplos.

Onde está a documentação que lista os especificadores de formato suportados pelo objecto Date()?

AFAIK, o JavaScript puro não suporta os especificadores de formato da forma como indicou que gostaria de use-os. Mas ele suporta Métodos de formatação de datas e / ou horas, tais como .toLocaleDateString(), .toLocaleTimeString(), e .toUTCString()

A referência do objecto que uso mais frequentemente está no w3schools.com o site (mas uma pesquisa rápida no Google irá revelar muito mais que possa satisfazer melhor as suas necessidades).

Note também que a secção Date Object Properties fornece uma ligação para prototype, o que ilustra algumas formas de extender o objecto da data com o personalizado meios. Tem havido algum debate na comunidade JavaScript ao longo dos anos sobre se isto é ou não uma boa prática, e eu não estou defendendo ou contra isso, apenas apontando a sua existência.

Função de formatação personalizada:

Para formatos fixos, uma função simples faz o trabalho. A seguir, gerar o formato internacional AAAA-MM-DD:

function dateToYMD(date) {
    var d = date.getDate();
    var m = date.getMonth() + 1;
    var y = date.getFullYear();
    return '' + y + '-' + (m<=9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
}

Nota: normalmente não é boa ideia estender as bibliotecas padrão Javascript (por exemplo, adicionando esta função ao protótipo da data).

Uma função mais avançada poderia gerar uma saída configurável com base num parâmetro de formato. Há alguns bons exemplos neste mesmo pagina.

Se escrever uma função de formatação é muito longa, existem muitas bibliotecas ao redor das quais isso acontece. Algumas outras respostas já as enumeram. Mas o aumento das dependências também tem contra-parte.

Funções normais de formatação ECMAScript:

Desde as versões mais recentes do ECMAscript, a classe Date tem algumas funções de formatação específicas:

ToDateString : dependente da implementação, mostrar apenas a data.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.todatestring

new Date().toDateString(); // e.g. "Fri Nov 11 2016"

ToISOString : mostra a data e hora ISO 8601.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.toisostring

new Date().toISOString(); // e.g. "2016-11-21T08:00:00.000Z"

ToJSON : Stringifier para JSON.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tojson

new Date().toJSON(); // e.g. "2016-11-21T08:00:00.000Z"

ToLocaleDateString : dependente da implementação, uma data em formato local.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaledatestring

new Date().toLocaleDateString(); // e.g. "21/11/2016"

ToLocaleString : dependente da implementação, uma data e hora no formato local.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocalestring

new Date().toLocaleString(); // e.g. "21/11/2016, 08:00:00 AM"

ToLocaleTimeString : dependente da implementação, um tempo em formato local.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tolocaletimestring

new Date().toLocaleTimeString(); // e.g. "08:00:00 AM"

ToString : toString genérico para a data.

Http://www.ecma-international.org/ecma-262/7.0/index.html#sec-date.prototype.tostring

new Date().toString(); // e.g. "Fri Nov 11 2016 08:00:00 GMT+0100 (W. Europe Standard Time)"

Nota: é possível gerar uma saída personalizada dessas funções de formatação:

new Date().toISOString().slice(0,10); // By @Image72, return YYYY-MM-DD

A Resposta Curta

Não existe nenhuma documentação "universal" que javascript atende; cada navegador que tem javascript é realmente uma implementação. No entanto, há um padrão que a maioria dos navegadores modernos tendem a seguir, e que é o padrão EMCAScript; as strings padrão ECMAScript levaria, minimamente, uma implementação modificada da definição ISO 8601.

Além disso, existe um segundo padrão estabelecido pela IETF {[9] } que os navegadores tendem a follow as well, which is the definition for timestamps made in the RFC 2822. A documentação real pode ser encontrada na lista de referências no fundo.

A partir disto você pode esperar funcionalidade básica, mas o que" deve "ser não é inerentemente o que"é". Eu vou ir um pouco em profundidade com este procedimento, porém, como parece que apenas três pessoas realmente responderam à pergunta (Scott, goofballogic, e peller nomeadamente) que, para mim, sugere que a maioria das pessoas não estão cientes do que realmente acontece quando se cria um objecto de data.

A Resposta Longa

Onde está a documentação que lista os especificadores de formato suportados pelo objecto Date ()?

Para responder à pergunta, ou normalmente até mesmo procurar a resposta para esta pergunta, você precisa saber que javascript não é uma linguagem nova; é na verdade uma implementação de ECMAScript, e segue os padrões ECMAScript (mas note, javascript também realmente pré-datado aqueles padrões; padrões EMCAScript são construídos a partir da implementação inicial do LiveScript/JavaScript). O padrão ECMAScript atual é 5.1 (2011); na época em que a pergunta foi originalmente feita (junho de 2009), o padrão era 3 (4 foi abandonado), mas 5 foi lançado pouco depois do post no final de 2009. Isto deve delinear um problema; que padrão uma implementação javascript pode seguir, pode não refletir o que está realmente no lugar, porque a) é uma implementação de um dado padrão, b) nem todas as implementações de um padrão são puritanas, e C) a funcionalidade não é liberada em sincronização com um novo padrão como d) uma implementação é um trabalho constante em progresso

Essencialmente, ao lidar com javascript, você está lidando com um derivado (javascript específico para o navegador) de uma implementação (javascript em si). O V8 do Google, por exemplo, implementa o ECMAScript 5.0, mas o Jscript do Internet Explorer não tenta conformar-se com qualquer padrão ECMAScript, ainda O Internet Explorer 9 está em conformidade com o ECMAScript 5.0.

Quando um único argumento é passado para uma nova data (), ele lança este protótipo de função:

new Date(value)

Quando dois ou mais argumentos são passados para nova data (), ele lança este protótipo de função:

new Date (year, month [, date [, hours [, minutes [, seconds [, ms ] ] ] ] ] )

Ambas as funções devem parecer familiares, mas isso não responde imediatamente à sua pergunta e o que quantifica como um "formato de data" aceitável requer uma explicação adicional. Quando você passar uma string para a nova data (), ela irá chamada de protótipo (note que estou usando a palavra protótipo livremente; as versões podem ser funções individuais, ou pode ser parte de uma instrução condicional em uma única função) nova Data(valor), com a sua string como argumento para o "valor de parâmetro". Esta função irá primeiro verificar se é um número ou uma string. A documentação para esta função pode ser encontrada aqui:

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

A partir disto, podemos deduzir que para obter a formatação de string permitida para nova data(valor), temos que olhar para a data do método.parse (string). A documentação para este método pode ser encontrada aqui:

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

E podemos ainda inferir que as datas devem estar num formato alargado ISO 8601 modificado, como indicado aqui:

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

No entanto, podemos reconhecer a partir da experiência que o objeto Data do javascript Aceita outros formatos (forçado pela existência desta questão em primeiro lugar), e isso é ok porque o ECMAScript permite a implementação de formatos específicos. No entanto, isso ainda não responde à questão de que documentação está disponível nos formatos disponíveis, nem que formatos são na verdade, é permitido. Nós vamos olhar para a implementação javascript do Google, V8; por favor, note que eu não estou sugerindo que este é o "melhor" motor javascript (como se pode definir "melhor" ou mesmo "bom") e não se pode assumir que os formatos permitidos em V8 representam todos os formatos disponíveis hoje, mas eu acho que é justo assumir que eles seguem as expectativas modernas.

Data do Google v8.js, DateConstructor

Https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

Olhando para a função Dateconstrutor, podemos deduzir que precisamos encontrar a função DateParse; no entanto, note que" ano "não é o ano real e é apenas uma referência ao parâmetro" ano".

Data do Google v8.js, DateParse

Https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

Isto chama %DateParseString, que é na verdade uma referência de função em tempo de execução para uma função C++. Refere-se ao seguinte código:

O V8 do Google, runtime.cc, % DateParseString

Https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

A chamada de função com que estamos preocupados nesta função é para DateParser::Parse(); ignorar a lógica em torno dessas chamadas de função, estes são apenas verificações para se conformar com o tipo de codificação (ASCII e UC16). DateParser:: o processamento é definido aqui:

Google ' s V8, dateparser-inl.h, DateParser:: Parse

Https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Esta é a função que realmente define os formatos que aceita. Essencialmente, ele verifica para a norma EMCASCRIPT 5.0 ISO 8601 e se não é compatível com normas, então ele vai tentar construir a data com base em formatos legados. Alguns pontos - chave com base na observações:

1. as palavras antes do primeiro número que são desconhecidas para o analisador são ignoradas.
O texto entre parênteses é ignorado.
2. números Sem sinal seguidos de": "são interpretados como um"componente Temporal".
3. números não assinados, seguidos de"."são interpretados como um" componente de tempo", e devem ser seguidos por milisegundos.
4. os números assinados, seguidos da hora ou hora minuto (por exemplo, + 5: 15 ou + 0515), são interpretados como o fuso.
Ao declarar a hora e o minuto, pode usar "HH: mm "ou"hhmm". Palavras que indicam um fuso horário são interpretadas como Fuso horário.
5. todos os outros números são interpretados como"componentes de data".
6. todas as palavras que começam com os três primeiros dígitos de um mês são interpretadas como o mês.
7. você pode definir minutos e horas juntos em qualquer um dos dois formatos: "hh: mm "ou"hhmm".
8. símbolos como"+", " - " e não são permitidos ")" não compensados depois de um número ter sido processado.
9. Os itens que correspondem a múltiplos formatos (por exemplo, 1970-01-01) são processados como um padrão emcascript 5.0 ISO 8601 string.

Então Isto deve ser suficiente para lhe dar uma ideia básica do que esperar quando se trata de passar uma string para um objecto de data. Você pode expandir ainda mais sobre isso, olhando para a seguinte especificação que o Mozilla aponta para a rede de desenvolvedores Mozilla (compatível com o IETF RFC 2822 timestamps):

Http://tools.ietf.org/html/rfc2822#page-14

A Microsoft Developer Network menciona adicionalmente uma norma adicional para o objecto Date: ECMA-402, A especificação API de internacionalização ECMAScript, que é complementar à norma ECMAScript 5.1 (e futuras). Isso pode ser encontrado aqui:

Http://www.ecma-international.org/ecma-402/1.0/

Em qualquer caso, isto deve ajuda em destacar que não há "documentação" que represente universalmente todas as implementações de javascript, mas ainda há documentação suficiente disponível para fazer um sentido razoável de quais strings são aceitáveis para um objeto de data. É uma grande pergunta quando pensas nisso, não é? : P

Referências

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.3.2

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.4.2

Http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15

Http://tools.ietf.org/html/rfc2822#page-14

Http://www.ecma-international.org/ecma-402/1.0/

Https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#141

Https://code.google.com/p/v8/source/browse/trunk/src/date.js?r=18400#270

Https://code.google.com/p/v8/source/browse/trunk/src/runtime.cc?r=18400#9559

Https://code.google.com/p/v8/source/browse/trunk/src/dateparser-inl.h?r=18400#36

Recursos

Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Http://msdn.microsoft.com/en-us/library/ff743760(v=vs 94).aspx

Certifique-se de obter Datejs ao lidar com datas em JavaScript. É bastante impressionante e bem documentado como você pode ver no caso da função toString .

EDIT : Tyler Forsythe aponta, que datejs está desactualizado. Eu uso - o no meu projeto atual e não tive nenhum problema com ele, no entanto você deve estar ciente disso e considerar alternativas.

Você pode simplesmente expandir o objeto Date com um novo método format Como observado por meiz , abaixo está o código dado pelo autor. E aqui está um jsfiddle.

Date.prototype.format = function(format) //author: meizz
{
  var o = {
    "M+" : this.getMonth()+1, //month
    "d+" : this.getDate(),    //day
    "h+" : this.getHours(),   //hour
    "m+" : this.getMinutes(), //minute
    "s+" : this.getSeconds(), //second
    "q+" : Math.floor((this.getMonth()+3)/3),  //quarter
    "S" : this.getMilliseconds() //millisecond
  }

  if(/(y+)/.test(format)) format=format.replace(RegExp.$1,
    (this.getFullYear()+"").substr(4 - RegExp.$1.length));
  for(var k in o)if(new RegExp("("+ k +")").test(format))
    format = format.replace(RegExp.$1,
      RegExp.$1.length==1 ? o[k] :
        ("00"+ o[k]).substr((""+ o[k]).length));
  return format;
}

alert(new Date().format("yyyy-MM-dd"));
alert(new Date("january 12 2008 11:12:30").format("yyyy-MM-dd h:mm:ss"));

A funcionalidade que você cita não é padrão Javascript, não é provável que seja portátil entre navegadores e, portanto, não é boa prática. O ECMAScript 3 spec deixa a função de formatos de processamento e saída até a implementação Javascript. o ECMAScript 5 adiciona um subconjunto do suporte ISO8601. Eu acredito que a função toString() que você mencionou é uma inovação em um navegador (Mozilla?)

Fiz este formatador muito simples, é cortado/n / pastável (actualizado com a versão mais limpa):

function DateFmt(fstr) {
  this.formatString = fstr

  var mthNames = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
  var dayNames = ["Sun","Mon","Tue","Wed","Thu","Fri","Sat"];
  var zeroPad = function(number) {
     return ("0"+number).substr(-2,2);
  }

  var dateMarkers = {
    d:['getDate',function(v) { return zeroPad(v)}],
    m:['getMonth',function(v) { return zeroPad(v+1)}],
    n:['getMonth',function(v) { return mthNames[v]; }],
    w:['getDay',function(v) { return dayNames[v]; }],
    y:['getFullYear'],
    H:['getHours',function(v) { return zeroPad(v)}],
    M:['getMinutes',function(v) { return zeroPad(v)}],
    S:['getSeconds',function(v) { return zeroPad(v)}],
    i:['toISOString']
  };

  this.format = function(date) {
    var dateTxt = this.formatString.replace(/%(.)/g, function(m, p) {
      var rv = date[(dateMarkers[p])[0]]()

      if ( dateMarkers[p][1] != null ) rv = dateMarkers[p][1](rv)

      return rv

    });

    return dateTxt
  }

}

fmt = new DateFmt("%w %d:%n:%y - %H:%M:%S  %i")
v = fmt.format(new Date())

Http://snipplr.com/view/66968.82825/

Framework free, limited but light

var d = (new Date()+'').split(' ');
// ["Tue", "Sep", "03", "2013", "21:54:52", "GMT-0500", "(Central", "Daylight", "Time)"]

[d[3], d[1], d[2], d[4]].join(' ');
// "2013 Sep 03 21:58:03"

DateJS é certamente completo, mas eu recomendaria este muito mais simples lib (formato de data JavaScript) que eu prefiro simplesmente porque é apenas 120 linhas ou assim.

/**
* Format date as a string
* @param date - a date object (usually "new Date();")
* @param format - a string format, eg. "DD-MM-YYYY"
*/
function dateFormat(date, format) {
    // Calculate date parts and replace instances in format string accordingly
    format = format.replace("DD", (date.getDate() < 10 ? '0' : '') + date.getDate()); // Pad with '0' if needed
    format = format.replace("MM", (date.getMonth() < 9 ? '0' : '') + (date.getMonth() + 1)); // Months are zero-based
    format = format.replace("YYYY", date.getFullYear());
    return format;
}

Uso de exemplo:

console.log("The date is: " + dateFormat(new Date(), "DD/MM/YYYY"));

function date_and_time() {
    var date = new Date();
    //zero-pad a single zero if needed
    var zp = function (val){
        return (val <= 9 ? '0' + val : '' + val);
    }

    //zero-pad up to two zeroes if needed
    var zp2 = function(val){
        return val <= 99? (val <=9? '00' + val : '0' + val) : ('' + val ) ;
    }

    var d = date.getDate();
    var m = date.getMonth() + 1;
    var y = date.getFullYear();
    var h = date.getHours();
    var min = date.getMinutes();
    var s = date.getSeconds();
    var ms = date.getMilliseconds();
    return '' + y + '-' + zp(m) + '-' + zp(d) + ' ' + zp(h) + ':' + zp(min) + ':' + zp(s) + '.' + zp2(ms);
}

Poderá achar útil esta modificação do objecto date, que é menor do que qualquer biblioteca e é facilmente extensível para suportar diferentes formatos:

Nota:

• ele usa objecto.keys () que não está definido nos navegadores mais antigos, por isso poderá precisar de implementar o polifill a partir da ligação indicada.

Código

Date.prototype.format = function(format) {
    // set default format if function argument not provided
    format = format || 'YYYY-MM-DD hh:mm';

    var zeropad = function(number, length) {
            number = number.toString();
            length = length || 2;
            while(number.length < length)
                number = '0' + number;
            return number;
        },
        // here you can define your formats
        formats = {
            YYYY: this.getFullYear(),
            MM: zeropad(this.getMonth() + 1),
            DD: zeropad(this.getDate()),
            hh: zeropad(this.getHours()),
            mm: zeropad(this.getMinutes())
        },
        pattern = '(' + Object.keys(formats).join(')|(') + ')';

    return format.replace(new RegExp(pattern, 'g'), function(match) {
        return formats[match];
    });
};

UTILIZAÇÃO

var now = new Date;
console.log(now.format());
// outputs: 2015-02-09 11:47
var yesterday = new Date('2015-02-08');
console.log(yesterday.format('hh:mm YYYY/MM/DD'));
// outputs: 00:00 2015/02/08

 Date.prototype.format = function (format) //author: meizz
{
    var hours = this.getHours();
    var ttime = "AM";
    if(format.indexOf("t") > -1 && hours > 12)
    {
        hours = hours - 12;
        ttime = "PM";
     }

var o = {
    "M+": this.getMonth() + 1, //month
    "d+": this.getDate(),    //day
    "h+": hours,   //hour
    "m+": this.getMinutes(), //minute
    "s+": this.getSeconds(), //second
    "q+": Math.floor((this.getMonth() + 3) / 3),  //quarter
    "S": this.getMilliseconds(), //millisecond,
    "t+": ttime
}

if (/(y+)/.test(format)) format = format.replace(RegExp.$1,
  (this.getFullYear() + "").substr(4 - RegExp.$1.length));
for (var k in o) if (new RegExp("(" + k + ")").test(format))
    format = format.replace(RegExp.$1,
      RegExp.$1.length == 1 ? o[k] :
        ("00" + o[k]).substr(("" + o[k]).length));
return format;
}

Não consegui encontrar nenhuma documentação definitiva sobre formatos de data válidos, por isso escrevi o meu próprio teste para ver o que é suportado em vários navegadores.

Http://blarg.co.uk/blog/javascript-date-formats

Os meus resultados concluíram que os seguintes formatos são válidos em todos os navegadores que testei (os exemplos usam a data "9 de agosto de 2013"):

[ano completo]/[mês] / [Número de data] - Mês pode ser o número com ou sem um zero inicial ou o nome do mês em formato curto ou longo, e o número de data pode ser com ou sem um zero inicial.

• 2013/08/09
• 2013/08/9
• 2013/8/09
• 2013/8/9
[15]}2013 / agosto / 09 [15]}2013 / agosto / 9
• 2013/ago / 09
[15]}2013 / ago / 9

[Mês]/[Ano Completo] / [Número da data] - o mês pode ser o número com ou sem um zero inicial ou o nome do mês em formato curto ou longo, e o número da data pode ser com ou sem um líder zero.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• agosto / 2013 / 09
• agosto / 2013 / 9
• Ago / 2013 / 09
• Ago / 2013 / 9

Qualquer combinação de [Ano Completo], [nome do mês] e [número da data] separada por espaços - o nome do mês pode ser em formato curto ou longo, e o número da data pode ser com ou sem um zero inicial.

[15]}2013 agosto 09 Agosto de 2013 09
• 09 Agosto de 2013
2013 ago 09 9 de Agosto de 2013 [15]}2013 9 Ago
• etc...

Também válido em " navegadores modernos "(ou, por outras palavras, todos os navegadores excepto IE9 e Abaixo)

[Ano Completo] - [Número do mês]-[Número da data] - o mês e o número da data devem incluir os zeros iniciais (este é o formato que o MySQL Date type usa)

• 2013-08-09

Usar os nomes dos meses:
Curiosamente, ao usar nomes dos meses eu descobri que apenas os primeiros 3 caracteres do nome do mês são usados para que todos os seguintes são perfeitamente válidos:

new Date('9 August 2013');
new Date('9 Aug 2013');
new Date('9 Augu 2013');
new Date('9 Augustagfsdgsd 2013');

A formatação e especialmente a análise das datas em JavaScript podem ser uma dor de cabeça. Nem todos os navegadores lidam com datas da mesma forma. Então, embora seja útil conhecer os métodos de base, é mais prático usar uma biblioteca auxiliar.

A Biblioteca xdate javascript por Adam Shaw existe desde meados de 2011 e ainda está em desenvolvimento activo. Ele tem uma documentação fantástica, uma grande API, formatação, tenta permanecer para trás-compatível e até mesmo suporta localizado cadeia.

Ligação para alterar as cadeias de caracteres locais: https://gist.github.com/1221376

Código de exemplo:

var d = new Date();
var time = d.toISOString().replace(/.*?T(\d+:\d+:\d+).*/, "$1");

Resultado:

"13:45:20"

A biblioteca açúcar.o js tem uma grande funcionalidade para trabalhar com datas em JavaScript. E está muito bem documentado.

O açúcar dá muito amor à classe de datas a partir da data.criar método que pode compreender as datas em praticamente qualquer formato em 15 major línguas, incluindo formatos relativos como "1 hour ago". As datas podem também ser saída em qualquer formato ou linguagem usando uma fácil de entender sintaxe, com atalhos para a data normalmente usada formato. Data complexa a comparação também é possível com métodos como is, que entendem qualquer formatar e aplicar construído com precisão.

Alguns exemplos:

Date.create('July 4, 1776')  -> July 4, 1776
Date.create(-446806800000)   -> November 5, 1955
Date.create(1776, 6, 4)      -> July 4, 1776
Date.create('1776年07月04日', 'ja') -> July 4, 1776
Date.utc.create('July 4, 1776', 'en')  -> July 4, 1776

Date.create().format('{Weekday} {d} {Month}, {yyyy}')    -> Monday July 4, 2003
Date.create().format('{hh}:{mm}')                        -> 15:57
Date.create().format('{12hr}:{mm}{tt}')                  -> 3:57pm
Date.create().format(Date.ISO8601_DATETIME)              -> 2011-07-05 12:24:55.528Z

Date.create().is('the 7th of June') -> false
Date.create().addMonths(2); ->"Sunday, June 15, 2014 13:39"

Apenas outra opção, que eu escrevi:

Biblioteca Dp_ Dateextensions

Suporta a formatação data/hora, matemática de datas (adicionar / subtrair partes de datas), comparação de datas, processamento de datas, etc. É de fonte aberta.

Não há razão para considerá-lo se já estiver a usar um framework (todos eles são capazes), mas se precisar de adicionar data rapidamente manipular um projecto dá-lhe uma oportunidade.

Todos os navegadores

A forma mais fiável de formatar uma data com o formato de origem que está a usar é aplicar os seguintes passos:

1. usar new Date() para criar um objectoDate
2. uso .getDate(), .getMonth() e .getFullYear() para obter, respectivamente, o dia, o mês e o ano
3. colar as peças em conjunto de acordo com o seu formato alvo

Exemplo:

var date = '2015-11-09T10:46:15.097Z';

function format(input) {
    var date = new Date(input);
    return [
       ("0" + date.getDate()).slice(-2),
       ("0" + (date.getMonth()+1)).slice(-2),
       date.getFullYear()
    ].join('/');
}

document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

Isto Violino).

Você também pode usar o método built-in .toLocaleDateString para fazer a formatação para você. Você só precisa passar ao longo do local adequado e opções para corresponder ao formato certo, que infelizmente só é suportado por navegadores modernos (*) :

var date = '2015-11-09T10:46:15.097Z';

function format(input) {
    return new Date(input).toLocaleDateString('en-GB', {
        year: 'numeric',
        month: '2-digit',
        day: '2-digit'
    });
}

document.body.innerHTML = format(date); // OUTPUT : 09/11/2015

Este Violino).

(*) de acordo com a MDN, "Browsers modernos" significa Chrome 24+, Firefox 29+, IE11, Edge12+, Opera 15+ & Safari construir todas as noites

A forma correcta de formatar uma data para retornar "2012-12-29" é com o script de formato de data JavaScript:

var d1 = new Date();
return d1.format("dd-m-yy");

Este código não funciona:

var d1 = new Date();
d1.toString('yyyy-MM-dd');      

Se quiser mostrar apenas o tempo com dois dígitos, isto pode ajudá-lo:

var now = new Date();
var cHour = now.getHours();
var cMinuts = now.getMinutes();
var cSeconds = now.getSeconds();

var outStr = (cHour <= 0 ? ('0' + cHour) : cHour) + ':' + (cMinuts <= 9 ? ('0' + cMinuts) : cMinuts) + ':' + (cSeconds <= 9 ? '0' + cSeconds : cSeconds);

Usar estas funções

toTimeString() and toLocaleDateString()

Ver abaixo a ligação para mais detalhes https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

Jssimpledatformat é uma biblioteca que pode formatar o objeto de data e processar o texto formatado de volta ao objeto de data. Ele usa o formato Java (Classe Simpledatformat). O nome de meses e dias pode ser localizado.

Exemplo:

var sdf = new JsSimpleDateFormat("EEEE, MMMM dd, yyyy");
var formattedString = sdf.format(new Date());
var dateObject = sdf.parse("Monday, June 29, 2009");

Se você não precisa de todas as características que uma biblioteca como momento.js fornece, então você pode usar o meu porto de strftime . É leve (1,35 KB vs. 57,9 KB minificado em comparação com o momento.js 2.15.0) e fornece a maior parte da funcionalidade de strftime().

/* Port of strftime(). Compatibility notes:
 *
 * %c - formatted string is slightly different
 * %D - not implemented (use "%m/%d/%y" or "%d/%m/%y")
 * %e - space is not added
 * %E - not implemented
 * %h - not implemented (use "%b")
 * %k - space is not added
 * %n - not implemented (use "\n")
 * %O - not implemented
 * %r - not implemented (use "%I:%M:%S %p")
 * %R - not implemented (use "%H:%M")
 * %t - not implemented (use "\t")
 * %T - not implemented (use "%H:%M:%S")
 * %U - not implemented
 * %W - not implemented
 * %+ - not implemented
 * %% - not implemented (use "%")
 *
 * strftime() reference:
 * http://man7.org/linux/man-pages/man3/strftime.3.html
 *
 * Day of year (%j) code based on Joe Orost's answer:
 * http://stackoverflow.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
 *
 * Week number (%V) code based on Taco van den Broek's prototype:
 * http://techblog.procurios.nl/k/news/view/33796/14863/calculate-iso-8601-week-and-year-in-javascript.html
 */
function strftime(sFormat, date) {
  if (!(date instanceof Date)) date = new Date();
  var nDay = date.getDay(),
    nDate = date.getDate(),
    nMonth = date.getMonth(),
    nYear = date.getFullYear(),
    nHour = date.getHours(),
    aDays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
    aMonths = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
    aDayCount = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334],
    isLeapYear = function() {
      if (nYear&3!==0) return false;
      return nYear%100!==0 || year%400===0;
    },
    getThursday = function() {
      var target = new Date(date);
      target.setDate(nDate - ((nDay+6)%7) + 3);
      return target;
    },
    zeroPad = function(nNum, nPad) {
      return ('' + (Math.pow(10, nPad) + nNum)).slice(1);
    };
  return sFormat.replace(/%[a-z]/gi, function(sMatch) {
    return {
      '%a': aDays[nDay].slice(0,3),
      '%A': aDays[nDay],
      '%b': aMonths[nMonth].slice(0,3),
      '%B': aMonths[nMonth],
      '%c': date.toUTCString(),
      '%C': Math.floor(nYear/100),
      '%d': zeroPad(nDate, 2),
      '%e': nDate,
      '%F': date.toISOString().slice(0,10),
      '%G': getThursday().getFullYear(),
      '%g': ('' + getThursday().getFullYear()).slice(2),
      '%H': zeroPad(nHour, 2),
      '%I': zeroPad((nHour+11)%12 + 1, 2),
      '%j': zeroPad(aDayCount[nMonth] + nDate + ((nMonth>1 && isLeapYear()) ? 1 : 0), 3),
      '%k': '' + nHour,
      '%l': (nHour+11)%12 + 1,
      '%m': zeroPad(nMonth + 1, 2),
      '%M': zeroPad(date.getMinutes(), 2),
      '%p': (nHour<12) ? 'AM' : 'PM',
      '%P': (nHour<12) ? 'am' : 'pm',
      '%s': Math.round(date.getTime()/1000),
      '%S': zeroPad(date.getSeconds(), 2),
      '%u': nDay || 7,
      '%V': (function() {
              var target = getThursday(),
                n1stThu = target.valueOf();
              target.setMonth(0, 1);
              var nJan1 = target.getDay();
              if (nJan1!==4) target.setMonth(0, 1 + ((4-nJan1)+7)%7);
              return zeroPad(1 + Math.ceil((n1stThu-target)/604800000), 2);
            })(),
      '%w': '' + nDay,
      '%x': date.toLocaleDateString(),
      '%X': date.toLocaleTimeString(),
      '%y': ('' + nYear).slice(2),
      '%Y': nYear,
      '%z': date.toTimeString().replace(/.+GMT([+-]\d+).+/, '$1'),
      '%Z': date.toTimeString().replace(/.+\((.+?)\)$/, '$1')
    }[sMatch] || sMatch;
  });
}

Utilização da amostra:

strftime('%F'); // Returns "2016-09-15"
strftime('%A, %B %e, %Y'); // Returns "Thursday, September 15, 2016"

// You can optionally pass it a Date object...

strftime('%x %X', new Date('1/1/2016')); // Returns "1/1/2016 12:00:00 AM"

O último código está disponível aqui: https://github.com/thdoan/strftime

A resposta é "em lado Nenhum", uma vez que a formatação da data é uma funcionalidade proprietária. Eu não acho que as funções de toString são destinadas a conformar-se a um formato específico. por exemplo, no ECMAScript 5.1 spec ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, página 173), a função toString está documentada do seguinte modo:

"o conteúdo do texto depende da implementação"

Funções como as amostras abaixo pode ser usado para realizar a formatação com bastante facilidade.

function pad(toPad, padWith) {
    return (String(padWith) + String(toPad)).slice(-1 * padWith.length);
}

function dateAsInputValue(toFormat) {
    if(!(toFormat instanceof Date)) return null;
    return toFormat.getFullYear() + "-" + pad(toFormat.getMonth() + 1, "00") + "-" + pad(toFormat.getDate(), "00");
}

function timeAsInputValue(toFormat) {
    if(!(toFormat instanceof Date)) return null;        
    return pad(toFormat.getHours(), "00") + ":" + pad(toFormat.getMinutes(), "00") + ":" + pad(toFormat.getSeconds(), "00");
}

Pessoalmente, porque eu uso PHP e jquery / javascript em medidas iguais, Eu uso a função de data de php.js http://phpjs.org/functions/date/

Usar uma biblioteca que usa os mesmos caracteres de formato que algo que eu já sei é mais fácil para mim, e o manual que contém todas as possibilidades de formatação para a função de data é, naturalmente, online em php.net

Você simplesmente inclui a data.ficheiro js em seu HTML usando o seu método preferido, em seguida, chamá-lo como isto:

var d1=new Date();
var datestring = date('Y-m-d', d1.valueOf()/1000);

Pode usar o d1.getTime() em vez de value of () Se você quiser, eles fazem a mesma coisa.

A divisão por 1000 do tempo de javascript é porque um tempo de javascript é em milisegundos, mas um tempo de PHP é em segundos.

Muitos frameworks (que você pode já estar usando) têm formatação de data que você pode não estar ciente. jQueryUI já foi mencionado, mas outras estruturas, como Kendo UI (Globalização), Yahoo UI (Util) e AngularJS tê-los bem.

// 11/6/2000
kendo.toString(new Date(value), "d")

// Monday, November 06, 2000
kendo.toString(new Date(2000, 10, 6), "D")