Percebi que a new Date()função do JavaScript é muito inteligente em aceitar datas em vários formatos.

Xmas95 = new Date("25 Dec, 1995 23:15:00")
Xmas95 = new Date("2009 06 12,12:52:39")
Xmas95 = new Date("20 09 2006,12:52:39")

Não consegui encontrar documentação em nenhum lugar mostrando todos os formatos de string válidos ao chamar a new Date()função.

Isto é para converter uma string em uma data. Se olharmos para o lado oposto, isto é, converter um objeto de data em uma string, até agora eu estava com a impressão de que o JavaScript não tinha uma API interna para formatar um objeto de data em uma string.

Nota do editor: A abordagem a seguir é a tentativa do solicitante que trabalhou em um navegador específico, mas não funciona em geral; veja as respostas nesta página para ver algumas soluções reais.

Hoje, eu brinquei com o toString()método no objeto date e, surpreendentemente, serve ao propósito de formatar a data em strings.

var d1 = new Date();
d1.toString('yyyy-MM-dd');       //Returns "2009-06-29" in Internet Explorer, but not Firefox or Chrome
d1.toString('dddd, MMMM ,yyyy')  //Returns "Monday, June 29,2009" in Internet Explorer, but not Firefox or Chrome

Também aqui não encontrei nenhuma documentação sobre todas as maneiras pelas quais podemos formatar o objeto de data em uma string.

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

Adoro 10 maneiras de formatar data e hora usando JavaScript e Trabalhando com Datas .

Basicamente, você tem três métodos e precisa combinar as strings por si mesmo:

getDate() // Returns the date
getMonth() // Returns the month
getFullYear() // Returns the year

Exemplo:

var d = new Date();
var curr_date = d.getDate();
var curr_month = d.getMonth() + 1; //Months are zero based
var curr_year = d.getFullYear();
console.log(curr_date + "-" + curr_month + "-" + curr_year);

Moment.js

É uma biblioteca de datas JavaScript (leve) * para analisar, manipular e formatar datas.

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"

(*) significado leve 9,3KB minificado + compactado com gz na menor configuração possível (fevereiro de 2014)

Se você já estiver usando a interface do usuário do jQuery em seu projeto, poderá usar o método datepicker interno para formatar seu objeto de data:

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

No entanto, o selecionador de data formata apenas datas e não pode formatar horas.

Dê uma olhada no jQuery UI datepicker formatDate , os exemplos.

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

Eu me deparei com isso hoje e fiquei bastante surpreso que ninguém teve tempo para responder a essa pergunta simples. É verdade que existem muitas bibliotecas disponíveis para ajudar na manipulação de datas. Alguns são melhores que outros. Mas essa não foi a pergunta.

AFAIK, JavaScript puro não suporta especificadores de formato da maneira que você indicou que gostaria de usá-los . Mas ele faz métodos de apoio para a formatação de datas e / ou horários, tais como .toLocaleDateString(), .toLocaleTimeString(), e .toUTCString().

A Datereferência de objeto que eu uso com mais freqüência está no site w3schools.com (mas uma pesquisa rápida no Google revelará muitos outros que podem atender melhor às suas necessidades).

Observe também que a seção Propriedades do objeto Date fornece um link para prototype, que ilustra algumas maneiras pelas quais você pode estender o objeto Date com métodos personalizados. Ao longo dos anos, houve um debate na comunidade JavaScript sobre se essa é uma prática recomendada ou não, e não estou defendendo a favor ou contra, apenas apontando sua existência.

Função de formatação personalizada:

Para formatos fixos, uma função simples faz o trabalho. O exemplo a seguir gera 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: No entanto, geralmente não é uma boa idéia estender as bibliotecas padrão do Javascript (por exemplo, adicionando esta função ao protótipo de Data).

Uma função mais avançada pode gerar uma saída configurável com base em um parâmetro de formato. Existem alguns bons exemplos nesta mesma página.

Se a gravação de uma função de formatação for muito longa, há muitas bibliotecas em torno delas. Algumas outras respostas já as enumeram. Mas o aumento de dependências também tem sua contrapartida.

Funções de formatação padrão do ECMAScript:

Desde versões mais recentes do ECMAscript, a Dateclasse possui algumas funções de formatação específicas:

toDateString : depende da implementação, mostra 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 da 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 no formato de localidade.

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

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

toLocaleString : depende da implementação, uma data e hora no formato de localidade.

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, uma hora no formato de localidade.

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 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 a partir dessas funções de formatação:

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

A resposta curta

Não há documentação "universal" que o javascript atenda; todo navegador que possui javascript é realmente uma implementação. No entanto, existe um padrão que a maioria dos navegadores modernos costuma seguir, e esse é o padrão EMCAScript; as seqüências padrão ECMAScript precisariam, no mínimo, de uma implementação modificada da definição da ISO 8601.

Além disso, há um segundo padrão estabelecido pela IETF que os navegadores também tendem a seguir, que é a definição de carimbos de data e hora feita no RFC 2822. A documentação real pode ser encontrada na lista de referências na parte inferior.

Com isso, você pode esperar funcionalidades básicas, mas o que "deveria" ser não é inerentemente o que "é". No entanto, vou me aprofundar um pouco nisso, pois parece que apenas três pessoas responderam à pergunta (Scott, goofballLogic e peller, a saber) que, para mim, sugere que a maioria das pessoas não sabe o que realmente acontece quando você crie um objeto Date.

A resposta longa

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

Para responder à pergunta, ou até mesmo procurar a resposta para essa pergunta, você precisa saber que o javascript não é uma linguagem nova; na verdade, é uma implementação do ECMAScript e segue os padrões do ECMAScript (mas observe, o javascript também na verdade antecede esses padrões; os padrões do EMCAScript são criados a partir da implementação inicial do LiveScript / JavaScript). O padrão atual do ECMAScript é 5.1 (2011); no momento em que a pergunta foi feita originalmente (junho de 2009), o padrão era 3 (4 foi abandonado), mas 5 foi lançado logo após o cargo no final de 2009. Isso deve descrever um problema; qual padrão uma implementação de javascript pode seguir, pode não refletir o que realmente está em vigor, porque a) é uma implementação de um determinado padrão; b) nem todas as implementações de um padrão são puritanas,

Essencialmente, ao lidar com javascript, você está lidando com um derivado (javascript específico para o navegador) de uma implementação (o próprio javascript). A V8 do Google, por exemplo, implementa o ECMAScript 5.0, mas o JScript do Internet Explorer não tenta se adaptar a nenhum padrão do ECMAScript, mas o Internet Explorer 9 está em conformidade com o ECMAScript 5.0.

Quando um único argumento é passado para o novo Date (), ele lança esse protótipo de função:

new Date(value)

Quando dois ou mais argumentos são passados ​​para o novo Date (), ele lança esse 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 mais explicações. Quando você passa uma string para o novo Date (), ele chama o protótipo (observe que estou usando a palavra protótipo livremente; as versões podem ser funções individuais ou podem fazer parte de uma instrução condicional em uma única função) para nova data (valor) com sua string como argumento para o parâmetro "value". Esta função primeiro verifica 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 disso, podemos deduzir que, para obter a formatação de string permitida para a nova data (valor), precisamos examinar o método Date.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 inferir ainda mais que as datas devem estar em um formato estendido ISO 8601 modificado, conforme especificado aqui:

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

No entanto, podemos reconhecer por experiência que o objeto Date do javascript aceita outros formatos (imposto pela existência dessa pergunta em primeiro lugar), e isso é bom porque o ECMAScript permite a implementação de formatos específicos. No entanto, isso ainda não responde à pergunta de qual documentação está disponível nos formatos disponíveis, nem de quais formatos são realmente permitidos. Vamos dar uma olhada na implementação javascript do Google, V8; observe que não estou sugerindo que este é o melhor mecanismo javascript (como definir "melhor" ou até "bom") e não se pode presumir que os formatos permitidos na V8 representam todos os formatos disponíveis hoje, mas acho justo assumir que eles seguem as expectativas modernas.

V8 do Google, date.js, DateConstructor

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

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

V8 do Google, date.js, DateParse

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

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

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 a qual estamos preocupados nessa função é para DateParser :: Parse (); Se você ignorar a lógica em torno dessas chamadas de função, essas são apenas verificações para se adequar ao tipo de codificação (ASCII e UC16). DateParser :: Parse é definido aqui:

V8 do Google, dateparser-inl.h, DateParser :: Parse

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

Essa é a função que realmente define quais formatos ele aceita. Essencialmente, ele verifica o padrão EMCAScript 5.0 ISO 8601 e, se não for compatível com os padrões, tentará criar a data com base nos formatos herdados. Alguns pontos-chave com base nos comentários:

1. Palavras antes do primeiro número que são desconhecidas para o analisador são ignoradas.
2. O texto entre parênteses é ignorado.
3. Os números não assinados seguidos de ":" são interpretados como um "componente de tempo".
4. Números não assinados seguidos de "." são interpretados como um "componente de tempo" e devem ser seguidos por milissegundos.
5. Os números assinados seguidos pela hora ou hora minuto (por exemplo, +5: 15 ou +0515) são interpretados como o fuso horário.
6. Ao declarar a hora e os minutos, você pode usar “hh: mm” ou “hhmm”.
7. Palavras que indicam um fuso horário são interpretadas como um fuso horário.
8. Todos os outros números são interpretados como "componentes da data".
9. Todas as palavras que começam com os três primeiros dígitos de um mês são interpretadas como o mês.
10. Você pode definir minutos e horas juntos em um dos dois formatos: "hh: mm" ou "hhmm".
11. Símbolos como “+”, “-“ e incomparável “)” não são permitidos após o processamento de um número.
12. Os itens que correspondem a vários formatos (por exemplo, 1970-01-01) são processados ​​como uma sequência EMCAScript 5.0 ISO 8601 compatível com o padrão.

Portanto, isso deve ser suficiente para fornecer uma idéia básica do que esperar quando se trata de passar uma string para um objeto Date. Você pode expandir ainda mais isso observando a seguinte especificação que o Mozilla aponta na Mozilla Developer Network (compatível com os carimbos de data e hora da IETF RFC 2822):

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

A Microsoft Developer Network menciona adicionalmente um padrão adicional para o objeto Date: ECMA-402, a Especificação da API de Internacionalização da ECMAScript, que é complementar ao padrão ECMAScript 5.1 (e futuros). Isso pode ser encontrado aqui:

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

De qualquer forma, isso deve ajudar a 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 compreender com precisão quais seqüências de caracteres são aceitáveis ​​para um objeto Date. Quite a pergunta carregada quando você pensa sobre isso, sim? : 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

Verifique o Datejs ao lidar com datas em JavaScript. É bastante impressionante e bem documentado, como você pode ver no caso da função toString .

Edição : Tyler Forsythe ressalta, que datejs está desatualizado. Eu o uso 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 DateObjeto com um novo formatmétodo, conforme observado por meizz , abaixo é o código fornecido pelo autor. E aqui está um violão .

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 é Javascript padrão, provavelmente não é portátil em navegadores e, portanto, não é uma boa prática. A especificação do ECMAScript 3 deixa a função de análise e formatos de saída até a implementação do Javascript. O ECMAScript 5 adiciona um subconjunto do suporte ISO8601. Acredito que a função toString () mencionada é uma inovação em um navegador (Mozilla?)

Várias bibliotecas fornecem rotinas para parametrizar isso, algumas com amplo suporte à localização. Você também pode verificar os métodos em dojo.date.locale .

Eu criei este formatador muito simples, é recortado / n / colável (atualizado 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/

Estrutura livre, limitada, mas leve

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"

O DateJS certamente possui todos os recursos, mas eu recomendaria essa lib muito mais simples (JavaScript Date Format), que eu prefiro simplesmente porque são apenas 120 linhas.

Tendo examinado várias das opções fornecidas em outras respostas, decidi escrever minha própria solução limitada, mas simples, que outras pessoas também podem achar útil.

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

Exemplo de uso:

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

Aqui está uma função que eu uso muito. O resultado é aaaa-mm-dd hh: mm: ss.nnn.

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

Você pode achar útil essa modificação do objeto de data, que é menor que qualquer biblioteca e é facilmente extensível para suportar diferentes formatos:

NOTA:

• Ele usa Object.keys (), que é indefinido em navegadores antigos, portanto, você pode precisar implementar o polyfill a partir de um determinado link.

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

USAR

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

Apenas para continuar a sólida resposta de gongzhitaao - isso lida com AM / PM

 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 os formatos de data válidos, então escrevi meu próprio teste para ver o que é suportado em vários navegadores.

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

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 inteiro] / [Mês] / [Número da data] - O mês pode ser o número com ou sem zero inicial ou o nome do mês em formato curto ou longo, e o número da data pode ser com ou sem zero inicial.

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

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

• 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 inteiro], [Nome do mês] e [Número da data] separados por espaços - o nome do mês pode estar em formato curto ou longo e o número da data pode estar com ou sem um zero à esquerda.

• 2013 09 de agosto
• Agosto de 2013 09
• 09 de agosto de 2013
• 2013 09 de agosto
• 9 de agosto de 2013
• 2013 9 ago
• etc ...

Também é válido em "navegadores modernos" (ou em todos os navegadores, exceto IE9 e abaixo)

[Ano inteiro] - [Número do mês] - [Número da data] - O mês e o número da data devem incluir zeros à esquerda (este é o formato que o tipo de data do MySQL usa)

• 09/08/2013

Usando nomes de mês:
Curiosamente, ao usar nomes de mês, descobri que apenas os 3 primeiros caracteres do nome do mês são usados ​​para que todos os itens a seguir sejam perfeitamente válidos:

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

Formatar e, especialmente, analisar datas em JavaScript pode ser um pouco difícil. Nem todos os navegadores lidam com datas da mesma maneira. Portanto, embora seja útil conhecer os métodos básicos, é mais prático usar uma biblioteca auxiliar.

A biblioteca javascript do XDate de Adam Shaw existe desde meados de 2011 e ainda está em desenvolvimento ativo. Possui documentação fantástica, uma ótima API, formatação, tenta permanecer compatível com versões anteriores e até suporta seqüências localizadas.

Link para alterar as cadeias de código de idioma: 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 sugar.js possui ótimas funcionalidades para trabalhar com datas em JavaScript. E está muito bem documentado .

O Sugar dá muito amor à classe Date, começando com o método Date.create, que pode entender datas em praticamente qualquer formato em 15 idiomas principais, incluindo formatos relativos como "1 hora atrás". As datas também podem ser exibidas em qualquer formato ou idioma, usando uma sintaxe fácil de entender, com atalhos para os formatos de data mais usados. A comparação complexa de datas também é possível com métodos como o is, que entendem qualquer formato e se aplicam 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"

Todos os navegadores

A maneira mais confiável de formatar uma data com o formato de origem que você está usando é aplicando as seguintes etapas:

1. Use new Date()para criar um Dateobjeto
2. Use .getDate(), .getMonth()e .getFullYear()para obter respectivamente o dia, mês e ano
3. Cole as peças de acordo com o formato desejado

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

(Veja também este violino ).

Apenas navegadores modernos

Você também pode usar o .toLocaleDateStringmétodo interno para fazer a formatação para você. Você só precisa passar a localidade e as opções adequadas para corresponder ao formato correto, que infelizmente é suportado apenas pelos 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

(Veja também este violino ).

(*) De acordo com o MDN , "Navegadores modernos" significa Chrome noturno, Firefox 29+, IE11, Edge12 +, Opera 15+ e Safari noturno

Apenas outra opção, que escrevi:

Biblioteca DP_DateExtensions

Não tenho certeza se isso ajudará, mas achei útil em vários projetos - parece que ele fará o que você precisa.

Suporta formatação de data / hora, matemática da data (adicionar / subtrair partes da data), comparação de datas, análise de datas, etc. É de código aberto.

Não há razão para considerá-lo se você já estiver usando uma estrutura (todos eles são capazes), mas se você precisar adicionar rapidamente a manipulação de datas a um projeto, dê uma chance.

Se você deseja mostrar apenas o tempo com dois dígitos, isso 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);

use estas funções

toTimeString() and toLocaleDateString()

consulte o link abaixo para obter mais detalhes https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat é uma biblioteca que pode formatar o objeto de data e analisar a sequência de caracteres formatada de volta ao objeto Date. Ele usa o formato Java (classe SimpleDateFormat). O nome dos 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");

A resposta é "lugar nenhum", pois a formatação da data é uma funcionalidade proprietária. Eu não acho que as funções toString se destinam a estar em conformidade com um formato específico. por exemplo, na especificação do ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 8/2/2013, página 173), a função toString está documentada da seguinte forma :

"O conteúdo da String depende da implementação"

Funções como as amostras abaixo podem ser usadas 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");
}

Se você não precisar de todos os recursos fornecidos por uma biblioteca como o Moment.js , poderá usar minha porta de strftime . É leve (1,35 KB vs. 57,9 KB minificado em comparação com Moment.js 2.15.0) e fornece a maior parte das funcionalidades do 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;
  });
}

Uso 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 código mais recente está disponível aqui: https://github.com/thdoan/strftime

A maneira correta de formatar uma data para retornar "2012-12-29" é com o script do JavaScript Date Format :

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

Pessoalmente, como uso PHP e jQuery / javascript em medidas iguais, uso a função date em php.js http://phpjs.org/functions/date/

Usar uma biblioteca que usa as mesmas strings de formato de algo que eu já sei é mais fácil para mim, e o manual que contém todas as possibilidades de strings de formato para a função date está obviamente online no php.net

Você simplesmente inclui o arquivo date.js. no seu HTML usando o método preferido e o chama assim:

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

Você pode usar d1.getTime () em vez de valueOf () se desejar, eles fazem a mesma coisa.

A divisão por 1000 do registro de data e hora do javascript ocorre porque o registro de data e hora do javascript está em milissegundos, mas o registro de data e hora do PHP está em segundos.

Muitas estruturas (que você já pode estar usando) possuem formatação de data que você pode não estar ciente. O jQueryUI já foi mencionado, mas outras estruturas, como Kendo UI (Globalização) , Yahoo UI (Util) e AngularJS, também os possuem.

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

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