yyyy - string format to date javascript




Onde posso encontrar documentação sobre a formatação de uma data em JavaScript? (20)

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

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

AFAIK, JavaScript puro não suporta especificadores de formato da maneira que você indicou que gostaria de usá-los . Mas suporta métodos para formatar datas e / ou horas, como .toLocaleDateString() , .toLocaleTimeString() e .toUTCString() .

A referência do objeto Date que uso com mais freqüência está no w3schools.com/jsref/jsref_obj_date.asp (mas uma pesquisa rápida no Google revelará muitos mais que podem atender melhor às suas necessidades).

Observe também que a seção Date Object Properties fornece um link para prototype , que ilustra algumas maneiras de estender o objeto Date com métodos personalizados. Tem havido algum debate na comunidade JavaScript ao longo dos anos sobre se esta é ou não a melhor prática, e eu não estou defendendo a favor ou contra, apenas apontando a sua existência.

Notei que a new Date() função new Date() 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 seqüência de caracteres válidos ao chamar a new Date() função new Date() .

Isto é para converter uma string para uma data. Se olharmos para o lado oposto, ou seja, convertendo um objeto de data em uma string, até agora eu estava com a impressão de que o JavaScript não tem 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 determinado navegador, mas não funciona em geral; veja as respostas nesta página para ver algumas soluções reais.

Hoje, eu joguei com o toString() no objeto date e, surpreendentemente, ele serve ao propósito de formatar data para 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 consegui encontrar nenhuma documentação sobre todas as maneiras como podemos formatar o objeto de data em uma string.

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


A resposta curta

Não há documentação "universal" que o javascript atenda; Cada navegador que tem javascript é realmente uma implementação. No entanto, existe um padrão que os navegadores mais modernos tendem a seguir, e esse é o padrão EMCAScript; as seqüências padrão ECMAScript levariam, no mínimo, uma implementação modificada da definição da ISO 8601.

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

A partir disso, você pode esperar funcionalidade básica, mas o que “deveria ser” não é inerentemente o que “é”. Eu vou um pouco mais a fundo com isso, no entanto, como parece, apenas três pessoas realmente responderam à pergunta (Scott, Googball, e peller), o que, para mim, sugere que a maioria das pessoas não sabe o que realmente acontece quando você crie um objeto Date.

A longa resposta

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


Para responder à pergunta, ou normalmente até 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 note que o javascript também antecedeu esses padrões; os padrões do EMCAScript são construídos a partir da implementação inicial do LiveScript / JavaScript). O padrão atual do ECMAScript é o 5.1 (2011); no momento em que a pergunta foi originalmente feita (junho de 2009), a norma era 3 (4 foi abandonada), mas 5 foram liberados logo após o post no final de 2009. Isso deve delinear um problema; o padrão que uma implementação de javascript pode seguir, pode não refletir o que está realmente 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 ec) a funcionalidade não é liberada em sincronização com um novo padrão como d) uma implementação é um trabalho constante em andamento

Essencialmente, ao lidar com o javascript, você está lidando com um derivativo (javascript específico para o navegador) de uma implementação (o próprio javascript). O V8 do Google, por exemplo, implementa o ECMAScript 5.0, mas o JScript do Internet Explorer não está em conformidade com nenhum padrão 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 explicações adicionais. Quando você passa uma string para a nova Date (), ela chama o protótipo (note que estou usando a palavra protótipo livremente; as versões podem ser funções individuais ou podem ser parte de uma instrução condicional em uma única função) para new Date (value) com sua string como argumento para o parâmetro “value”. 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 disso, podemos deduzir que, para obter a formatação da cadeia permitida para a nova Data (valor), temos que observar 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

Além disso, podemos inferir 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 (imposta pela existência dessa questão em primeiro lugar), e isso é bom porque o ECMAScript permite formatos específicos de implementação. No entanto, isso ainda não responde à pergunta sobre qual documentação está disponível nos formatos disponíveis, nem quais formatos são realmente permitidos. Vamos ver a implementação do JavaScript do Google, o V8; Por favor, note que eu não estou sugerindo que este é o "melhor" motor javascript (como pode definir "melhor" ou mesmo "bom") e não se pode assumir que os formatos permitidos no V8 representam todos os formatos disponíveis hoje, mas eu acho que é justo supor 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

Olhando para 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 é realmente uma referência de função de tempo de execução para uma função de 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 (); Ignorar a lógica que envolve essas chamadas de função, estas são apenas verificações para se conformar 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 ela aceita. Essencialmente, ele verifica o padrão EMCAScript 5.0 ISO 8601 e, se não for compatível com os padrões, ele tentará construir a data com base nos formatos herdados. Alguns pontos-chave baseados nos comentários:

  1. Palavras antes do primeiro número que são desconhecidas para o analisador são ignoradas.
  2. Texto parênteses são ignorados.
  3. Os números não assinados seguidos de “:” são interpretados como um “componente de tempo”.
  4. Os números não assinados seguidos de "." São interpretados como um "componente de tempo" e devem ser seguidos por milissegundos.
  5. Números assinados seguidos de hora ou hora (por exemplo, +5: 15 ou +0515) são interpretados como o fuso horário.
  6. Ao declarar a hora e o minuto, 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 de 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 inigualá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 lhe dar uma ideia 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 para a qual o Mozilla aponta na Mozilla Developer Network (compatível com os timestamps da IETF RFC 2822):

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

A Microsoft Developer Network também menciona um padrão adicional para o objeto Date: ECMA-402, a Especificação da API de Internacionalização 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/

Em qualquer caso, isso deve ajudar a destacar que não há "documentação" que represente universalmente todas as implementações do javascript, mas ainda há documentação suficiente disponível para fazer sentido em quais strings são aceitáveis ​​para um objeto Date. Muito 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

developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

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


Todos os navegadores

A maneira mais confiável de formatar uma data com o formato de origem que você está usando é aplicar 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 os pedaços juntos de acordo com o formato de destino

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 o local adequado e as opções 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 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ e Safari noturno


A funcionalidade que você cita não é JavaScript padrão, provavelmente não será portável entre os navegadores e, portanto, não é uma boa prática. A especificação do ECMAScript 3 deixa os formatos de análise e saída funcionar até a implementação de Javascript. O ECMAScript 5 adiciona um subconjunto do suporte ISO8601. Eu acredito que a função toString () que você menciona é uma inovação em um navegador (Mozilla?)

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


Eu amo 10 maneiras de formatar a hora e data usando JavaScript e trabalhando com datas .

Basicamente, você tem três métodos e você tem que combinar as strings para 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);


Se você já estiver usando o jQuery UI em seu projeto, poderá usar o método interno do datepicker para formatar seu objeto 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 no jQuery UI datepicker formatDate , os exemplos.


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

momentjs

É uma biblioteca de data 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 reduzido + gzipado na menor configuração possível (fev 2014)


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"

Eu fiz este formatador muito simples, é cortado / n / pastável (Atualizado com 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/


Não consegui encontrar nenhuma documentação definitiva em 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

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

[Ano completo] / [Mês] / [Número da data] - O mês pode ser o número com ou sem um zero inicial ou o nome do mês no formato curto ou longo e o número da data pode ser com ou sem um zero à esquerda.

  • 2013/08/09
  • 2013/08/9
  • 2013/8/09
  • 2013/8/9
  • 2013 / agosto / 09
  • 2013 / agosto / 9
  • 2013 / ago / 09
  • 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 no formato curto ou longo e o número da data pode ser com ou sem um zero à esquerda.

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

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

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

[Ano completo] - [Número do mês] - [Número da data] - O número do mês e da data deve incluir zeros à esquerda (esse é o formato usado pelo tipo de data do MySQL )

  • 2013-08-09

Usando nomes de mês:
Curiosamente, ao usar nomes de meses, descobri que apenas os 3 primeiros caracteres do nome do mês são usados, portanto, todos os itens a seguir 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');

Só para continuar a resposta sólida do 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;
}

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 mais antigos, então você pode precisar implementar o polyfill a partir do link fornecido.

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


A maneira correta de formatar uma data para retornar "2012-12-29" é com o script do 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');      

A resposta é "lugar nenhum" já que a formatação de 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 ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, página 173), a função toString é documentada da seguinte forma :

"O conteúdo da cadeia 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");
}

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

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

Link para alterar as strings de localidade: https://gist.github.com/1221376


Muitas estruturas (que você já pode estar usando) têm formatação de data que você pode não estar ciente. O jQueryUI já foi mencionado, mas outros frameworks como o Kendo UI (Globalization) , o Yahoo UI (Util) eo 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")

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

Usando uma biblioteca que usa o mesmo formato de strings como algo que eu já sei que é mais fácil para mim, e o manual contendo todas as possibilidades de string de formato para a função de data é claro online no php.net

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

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

Você pode usar d1.getTime () ao invés de valueOf () se você quiser, eles fazem a mesma coisa.

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


Se você não precisa de todos os recursos que uma biblioteca como o momentjs fornece, então você pode usar meu port 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 da funcionalidade 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://.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





time-format