Ho notato che la new Date()funzione JavaScript è molto intelligente nell'accettare date in diversi formati.

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

Non sono riuscito a trovare documentazione da nessuna parte che mostra tutti i formati di stringa validi durante la chiamata alla new Date()funzione.

Questo serve per convertire una stringa in una data. Se osserviamo il lato opposto, ovvero la conversione di un oggetto data in una stringa, fino ad ora avevo l'impressione che JavaScript non avesse un'API integrata per formattare un oggetto data in una stringa.

Nota del redattore: il seguente approccio è il tentativo del richiedente che ha funzionato su un browser particolare ma non funziona in generale; vedere le risposte in questa pagina per vedere alcune soluzioni reali.

Oggi ho giocato con il toString()metodo sull'oggetto date e sorprendentemente ha lo scopo di formattare la data in stringhe.

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

Anche qui non sono riuscito a trovare alcuna documentazione su tutti i modi in cui possiamo formattare l'oggetto data in una stringa.

Dov'è la documentazione che elenca gli identificatori di formato supportati Date()dall'oggetto?

Adoro 10 modi per formattare data e ora utilizzando JavaScript e Lavorare con le date .

Fondamentalmente, hai tre metodi e devi combinare le stringhe per te:

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

Esempio:

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

È una libreria di date (leggera) * JavaScript per l'analisi, la manipolazione e la formattazione delle date.

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"

(*) significato leggero 9.3 KB minificati + compressi con gzip nella configurazione più piccola possibile (febbraio 2014)

Se stai già utilizzando l' interfaccia utente jQuery nel tuo progetto, puoi utilizzare il metodo datepicker incorporato per formattare l'oggetto data:

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

Tuttavia, il datepicker formatta solo le date e non può formattare le ore.

Dai un'occhiata al formato datepicker dell'interfaccia utente jQueryData , gli esempi.

Dov'è la documentazione che elenca gli identificatori di formato supportati Date()dall'oggetto?

Mi sono imbattuto in questo oggi e sono rimasto piuttosto sorpreso dal fatto che nessuno abbia avuto il tempo di rispondere a questa semplice domanda. È vero, ci sono molte librerie là fuori per aiutare con la manipolazione della data. Alcuni sono migliori di altri. Ma non era questa la domanda.

AFAIK, JavaScript puro non supporta gli identificatori di formato nel modo in cui hai indicato che desideri utilizzarli . Ma lo fa metodi di supporto per la formattazione delle date e / o orari, ad esempio .toLocaleDateString(), .toLocaleTimeString()e .toUTCString().

Il Dateriferimento all'oggetto che utilizzo più frequentemente si trova sul sito Web w3schools.com (ma una rapida ricerca su Google rivelerà molti altri che potrebbero soddisfare meglio le tue esigenze).

Si noti inoltre che la sezione Proprietà oggetto data fornisce un collegamento a prototype, che illustra alcuni modi in cui è possibile estendere l'oggetto Date con metodi personalizzati. Nel corso degli anni c'è stato un certo dibattito nella comunità JavaScript sull'opportunità o meno di questa è la migliore pratica, e non sto sostenendo a favore o contro di essa, solo sottolineando la sua esistenza.

Funzione di formattazione personalizzata:

Per formati fissi, una semplice funzione rende il lavoro. L'esempio seguente genera il formato internazionale AAAA-MM-GG:

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: di solito non è una buona idea estendere le librerie standard di Javascript (ad es. Aggiungendo questa funzione al prototipo di Date).

Una funzione più avanzata potrebbe generare un output configurabile basato su un parametro di formato. Ci sono un paio di buoni esempi in questa stessa pagina.

Se scrivere una funzione di formattazione è troppo lungo, ci sono molte librerie attorno alle quali lo fa. Alcune altre risposte li elencano già. Ma anche le crescenti dipendenze hanno una controparte.

Funzioni di formattazione ECMAScript standard:

Dalle versioni più recenti di ECMAscript, la Dateclasse ha alcune funzioni di formattazione specifiche:

toDateString : a seconda dell'implementazione , mostra solo la 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 data e ora 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 per 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 : dipende dall'implementazione , una data in formato locale.

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

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

toLocaleString : dipende dall'implementazione , una data e ora in formato locale.

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 : dipende dall'implementazione , un'ora nel formato locale.

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

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

: generico per la 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: è possibile generare output personalizzati da quelle funzioni di formattazione:

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

La risposta breve

Non esiste una documentazione "universale" a cui si rivolge javascript; ogni browser che ha JavaScript è davvero un'implementazione. Tuttavia, esiste uno standard che la maggior parte dei browser moderni tende a seguire, e questo è lo standard EMCAScript; le stringhe standard ECMAScript richiederebbero, come minimo, un'implementazione modificata della definizione ISO 8601.

Oltre a ciò, esiste un secondo standard stabilito dall'IETF che i browser tendono a seguire, che è la definizione per i timestamp realizzati nella RFC 2822. La documentazione effettiva è disponibile nell'elenco dei riferimenti in fondo.

Da questo ci si può aspettare funzionalità di base, ma ciò che "dovrebbe" essere non è intrinsecamente ciò che "è". Ho intenzione di approfondire un po 'questa procedura proceduralmente, poiché sembra che solo tre persone abbiano effettivamente risposto alla domanda (Scott, goofballLogic e peller) che, per me, suggerisce che la maggior parte delle persone non sono consapevoli di ciò che accade realmente quando creare un oggetto Date.

La lunga risposta

Dov'è la documentazione che elenca gli identificatori di formato supportati dall'oggetto Date ()?

Per rispondere alla domanda, o in genere anche cercare la risposta a questa domanda, devi sapere che javascript non è un linguaggio inedito; è in realtà un'implementazione di ECMAScript e segue gli standard ECMAScript (ma nota, anche javascript ha effettivamente preceduto quegli standard; gli standard EMCAScript sono basati sull'implementazione anticipata di LiveScript / JavaScript). L'attuale standard ECMAScript è 5.1 (2011); al momento in cui la domanda era stata inizialmente posta (giugno '09), lo standard era 3 (4 è stato abbandonato), ma 5 è stato rilasciato poco dopo il post alla fine del 2009. Ciò dovrebbe evidenziare un problema; quale standard può seguire un'implementazione javascript, potrebbe non riflettere ciò che è effettivamente in atto, perché a) è un'implementazione di un determinato standard, b) non tutte le implementazioni di uno standard sono puritane,

In sostanza, quando si ha a che fare con javascript, si ha a che fare con una derivata (javascript specifica per il browser) di un'implementazione (javascript stesso). Google V8, ad esempio, implementa ECMAScript 5.0, ma JScript di Internet Explorer non tenta di conformarsi a nessuno standard ECMAScript, tuttavia Internet Explorer 9 è conforme a ECMAScript 5.0.

Quando un singolo argomento viene passato a new Date (), lancia questo prototipo di funzione:

new Date(value)

Quando due o più argomenti vengono passati alla nuova data (), viene lanciato questo prototipo di funzione:

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

Entrambe queste funzioni dovrebbero sembrare familiari, ma ciò non risponde immediatamente alla tua domanda e ciò che si quantifica come un "formato data" accettabile richiede ulteriori spiegazioni. Quando passi una stringa a new Date (), chiamerà il prototipo (nota che sto usando vagamente la parola prototipo ; le versioni possono essere singole funzioni o possono far parte di un'istruzione condizionale in una singola funzione) per nuova data (valore) con la stringa come argomento per il parametro "valore". Questa funzione verificherà innanzitutto se si tratta di un numero o una stringa. La documentazione per questa funzione è disponibile qui:

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

Da questo, possiamo dedurre che per ottenere la formattazione della stringa consentita per la nuova Data (valore), dobbiamo guardare al metodo Date.parse (stringa). La documentazione per questo metodo è disponibile qui:

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

E possiamo ulteriormente dedurre che le date dovrebbero essere in un formato esteso ISO 8601 modificato, come specificato qui:

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

Tuttavia, possiamo riconoscere per esperienza che l'oggetto Date di javascript accetta altri formati (imposto dall'esistenza di questa domanda in primo luogo), e questo va bene perché ECMAScript consente l'implementazione di formati specifici. Tuttavia, ciò non risponde ancora alla domanda su quale documentazione sia disponibile sui formati disponibili, né quali formati siano effettivamente consentiti. Vedremo l'implementazione javascript di Google, V8; si prega di notare che non sto suggerendo che questo sia il "migliore" motore javascript (come si può definire "migliore" o addirittura "buono") e non si può presumere che i formati consentiti in V8 rappresentino tutti i formati disponibili oggi, ma penso che sia giusto supporre che seguano le aspettative moderne.

V8 di Google, date.js, DateConstructor

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

Osservando la funzione DateConstructor, possiamo dedurre che dobbiamo trovare la funzione DateParse; tuttavia, si noti che "anno" non è l'anno effettivo ed è solo un riferimento al parametro "anno".

V8 di Google, date.js, DateParse

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

Ciò chiama% DateParseString, che in realtà è un riferimento di funzione di runtime per una funzione C ++. Si riferisce al seguente codice:

V8 di Google, runtime.cc,% DateParseString

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

La chiamata di funzione di cui ci occupiamo in questa funzione è per DateParser :: Parse (); ignora la logica che circonda quelle chiamate di funzione, questi sono solo controlli per conformarsi al tipo di codifica (ASCII e UC16). DateParser :: Parse è definito qui:

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

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

Questa è la funzione che definisce effettivamente quali formati accetta. In sostanza, verifica lo standard EMCAScript 5.0 ISO 8601 e se non è conforme agli standard, tenterà quindi di costruire la data in base a formati legacy. Alcuni punti chiave basati sui commenti:

1. Le parole prima del primo numero sconosciute al parser vengono ignorate.
2. Il testo tra parentesi viene ignorato.
3. I numeri senza segno seguiti da “:” sono interpretati come “componenti temporali”.
4. Numeri non firmati seguiti da "." sono interpretati come un "componente temporale" e devono essere seguiti da millisecondi.
5. I numeri firmati seguiti dall'ora o dall'ora (ad esempio +5: 15 o +0515) vengono interpretati come fuso orario.
6. Quando si dichiarano l'ora e i minuti, è possibile utilizzare “hh: mm” o “hhmm”.
7. Le parole che indicano un fuso orario vengono interpretate come fuso orario.
8. Tutti gli altri numeri vengono interpretati come "componenti data".
9. Tutte le parole che iniziano con le prime tre cifre di un mese vengono interpretate come il mese.
10. È possibile definire minuti e ore insieme in uno dei due formati: "hh: mm" o "hhmm".
11. Simboli come "+", "-" e non corrispondente ")" non sono consentiti dopo l'elaborazione di un numero.
12. Gli articoli che corrispondono a più formati (ad es. 1970-01-01) vengono elaborati come una stringa ISO 8601 conforme allo standard EMCAScript 5.0.

Quindi, questo dovrebbe essere sufficiente per darti un'idea di base su cosa aspettarti quando si tratta di passare una stringa in un oggetto Date. Puoi approfondire ulteriormente questo aspetto osservando le seguenti specifiche a cui Mozilla fa riferimento sulla Mozilla Developer Network (conforme ai timestamp IETF RFC 2822):

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

Microsoft Developer Network menziona inoltre uno standard aggiuntivo per l'oggetto Date: ECMA-402, la specifica dell'API per l'internazionalizzazione di ECMAScript, complementare allo standard ECMAScript 5.1 (e quelli futuri). Questo può essere trovato qui:

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

In ogni caso, ciò dovrebbe essere d'aiuto nell'evidenziare che non esiste una "documentazione" che rappresenti universalmente tutte le implementazioni di javascript, ma c'è ancora abbastanza documentazione disponibile per dare un ragionevole senso di quali stringhe sono accettabili per un oggetto Date. Piuttosto la domanda carica quando ci pensi, sì? : P

Riferimenti

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

risorse

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

Assicurati di controllare Datejs quando gestisci le date in JavaScript. È piuttosto impressionante e ben documentato come puoi vedere nel caso della funzione toString .

EDIT : Tyler Forsythe sottolinea che datejs è obsoleto. Lo uso nel mio progetto attuale e non ho avuto problemi con esso, tuttavia dovresti essere consapevole di questo e considerare delle alternative.

Puoi semplicemente espandere l' Dateoggetto con un nuovo formatmetodo come notato da meizz , di seguito è riportato il codice fornito dall'autore. Ed ecco un 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"));

La funzionalità che citi non è Javascript standard, non è probabile che sia portatile su tutti i browser e quindi non è una buona pratica. La specifica ECMAScript 3 lascia i formati di analisi e di output fino all'implementazione di Javascript. ECMAScript 5 aggiunge un sottoinsieme del supporto ISO8601. Credo che la funzione toString () di cui parli sia un'innovazione in un browser (Mozilla?)

Diverse librerie forniscono routine per la parametrizzazione, alcune con un ampio supporto di localizzazione. Puoi anche controllare i metodi in dojo.date.locale .

Ho creato questo formatter molto semplice, è tagliato / n / pastable (aggiornato con la versione più ordinata):

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/

Quadro libero, limitato ma leggero

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 è sicuramente completo, ma consiglierei questo MOLTO più semplice lib (JavaScript Date Format) che preferisco semplicemente perché ha solo 120 righe o giù di lì.

Dopo aver esaminato alcune delle opzioni fornite in altre risposte, ho deciso di scrivere la mia soluzione limitata ma semplice che altri potrebbero trovare utili.

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

Esempio di utilizzo:

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

Ecco una funzione che uso molto. Il risultato è aaaa-mm-gg 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);
}

Potresti trovare utile questa modifica dell'oggetto Date, che è più piccola di qualsiasi libreria ed è facilmente estensibile per supportare diversi formati:

NOTA:

• Usa Object.keys () che non è definito nei browser più vecchi, quindi potrebbe essere necessario implementare il polyfill da un determinato link.

CODICE

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

USO

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

Giusto per continuare la solida risposta di gongzhitaao: questo gestisce 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;
}

Non sono stato in grado di trovare alcuna documentazione definitiva su formati di data validi, quindi ho scritto il mio test per vedere cosa è supportato in vari browser.

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

I miei risultati hanno concluso che i seguenti formati sono validi in tutti i browser che ho testato (gli esempi usano la data "9 agosto 2013"):

[Anno completo] / [Mese] / [Numero data] - Il mese può essere il numero con o senza uno zero iniziale o il nome del mese in formato breve o lungo e il numero della data può essere con o senza uno zero iniziale.

• 2013/08/09
• 2013/08/09
• 2013/08/09
• 2013/08/09
• 2013 / Agosto / 09
• 2013 / Agosto / 9
• 2013 / Aug / 09
• 2013 / Aug / 9

[Mese] / [Anno completo] / [Numero data] - Il mese può essere il numero con o senza uno zero iniziale o il nome del mese in formato breve o lungo e il numero della data può essere con o senza uno zero iniziale.

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

Qualsiasi combinazione di [Anno completo], [Nome mese] e [Numero data] separati da spazi : il nome del mese può essere in formato breve o lungo e il numero della data può essere con o senza zero iniziale.

• 09 agosto 2013
• Agosto 2013 09
• 09 agosto 2013
• 09 ago 2013
• 9 agosto 2013
• 2013 9 agosto
• eccetera...

Valido anche nei "browser moderni" (o in altri termini tutti i browser tranne IE9 e precedenti)

[Anno completo] - [Numero mese] - [Numero data] - Il numero mese e data deve includere zeri iniziali (questo è il formato utilizzato dal tipo di data MySQL )

• 2013/08/09

Uso dei nomi dei mesi:
È interessante notare che, usando i nomi dei mesi, ho scoperto che vengono utilizzati solo i primi 3 caratteri del nome del mese, quindi tutti i seguenti sono perfettamente validi:

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

La formattazione e in particolare l'analisi delle date in JavaScript può essere un po 'un mal di testa. Non tutti i browser gestiscono le date allo stesso modo. Quindi, mentre è utile conoscere i metodi di base, è più pratico usare una libreria di helper.

La libreria javascript XDate di Adam Shaw è in circolazione da metà 2011 ed è ancora in fase di sviluppo attivo. Ha una documentazione fantastica, una grande API, formattazione, cerca di rimanere retrocompatibile e supporta persino stringhe localizzate.

Link per modificare le stringhe delle impostazioni internazionali: https://gist.github.com/1221376

Codice di esempio:

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

Produzione:

"13:45:20"

La libreria sugar.js ha alcune ottime funzionalità per lavorare con le date in JavaScript. Ed è molto ben documentato .

Sugar dà alla classe Date molto amore a partire dal metodo Date.create che può comprendere le date in quasi tutti i formati in 15 lingue principali, compresi i formati relativi come "1 ora fa". Le date possono anche essere emesse in qualsiasi formato o lingua usando una sintassi di facile comprensione, con collegamenti a formati di data comunemente usati. Un confronto complesso delle date è anche possibile con metodi come is, che comprendono qualsiasi formato e applicano una precisione integrata.

Alcuni esempi:

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"

Tutti i browser

Il modo più affidabile per formattare una data con il formato di origine che stai utilizzando è applicare i seguenti passaggi:

1. Utilizzare new Date()per creare un Dateoggetto
2. Usa .getDate(), .getMonth()e .getFullYear()per ottenere, rispettivamente, il giorno, mese e anno
3. Incolla i pezzi insieme in base al formato target

Esempio :

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

(Vedi anche questo violino ).

Solo browser moderni

Puoi anche utilizzare il .toLocaleDateStringmetodo integrato per eseguire la formattazione. Devi solo passare le impostazioni locali e le opzioni appropriate per abbinare il formato giusto, che purtroppo è supportato solo dai browser moderni (*) :

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

(Vedi anche questo violino ).

(*) Secondo MDN , "Browser moderni" indica Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ e Safari nightly build

Solo un'altra opzione, che ho scritto:

DP_DateExtensions Library

Non sono sicuro che possa aiutare, ma l'ho trovato utile in diversi progetti - sembra che farà ciò di cui hai bisogno.

Supporta la formattazione di data / ora, la matematica della data (aggiungi / sottrai parti della data), il confronto delle date, l'analisi della data, ecc. È liberamente disponibile.

Nessun motivo per considerarlo se stai già utilizzando un framework (sono tutti in grado), ma se hai solo bisogno di aggiungere rapidamente la manipolazione della data a un progetto, dagli una possibilità.

Se vuoi mostrare solo il tempo con due cifre, questo può aiutarti:

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

usa questa funzione

toTimeString() and toLocaleDateString()

fare riferimento al link seguente per maggiori dettagli https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat è una libreria che può formattare l'oggetto data e analizzare nuovamente la stringa formattata nell'oggetto Date. Utilizza il formato Java (classe SimpleDateFormat). Il nome di mesi e giorni può essere localizzato.

Esempio:

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

La risposta è "da nessuna parte" poiché la formattazione della data è funzionalità proprietaria. Non credo che le funzioni toString siano destinate a conformarsi a un formato specifico. ad es. nelle specifiche ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, pagina 173), la funzione toString è documentata come segue :

"Il contenuto della stringa dipende dall'implementazione"

Funzioni come i seguenti esempi potrebbero essere utilizzate per eseguire la formattazione abbastanza facilmente.

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 non hai bisogno di tutte le funzionalità fornite da una libreria come Moment.js , puoi usare il mio port of strftime . È leggero (1,35 KB contro 54,9 KB ridotto rispetto a Moment.js 2.15.0) e offre la maggior parte delle funzionalità di 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;
  });
}

Esempio di utilizzo:

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"

L'ultimo codice è disponibile qui: https://github.com/thdoan/strftime

Il modo corretto di formattare una data per restituire "2012-12-29" è con lo script dal formato data JavaScript :

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

Questo codice NON funziona:

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

Personalmente, poiché utilizzo PHP e jQuery / javascript in egual misura, utilizzo la funzione di data da php.js http://phpjs.org/functions/date/

L'uso di una libreria che utilizza le stesse stringhe di formato di qualcosa che già conosco è più semplice per me e il manuale contenente tutte le possibilità di stringa di formato per la funzione di data è ovviamente online su php.net

Devi semplicemente includere il file date.js nel tuo HTML usando il tuo metodo preferito, quindi chiamarlo così:

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

Puoi usare d1.getTime () invece di valueOf () se vuoi, fanno la stessa cosa.

La divisione per 1000 del timestamp javascript è dovuta al fatto che un timestamp javascript è in millisecondi, ma un timestamp PHP è in secondi.

Molti framework (che potresti già utilizzare) hanno una formattazione della data di cui potresti non essere a conoscenza. jQueryUI è già stato menzionato, ma anche altri framework come Kendo UI (Globalization) , Yahoo UI (Util) e AngularJS ne hanno.

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

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