Dove posso trovare la documentazione sulla formattazione di una data in JavaScript? [chiuso]


1398

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?


165
i tuoi esempi in realtà non funzionano come pensi che facciano: jsfiddle.net/edelman/WDNVk/1
Jason

27
Spiacenti, il passaggio delle stringhe di formato in ToString funziona in .NET e potrebbe funzionare in Java, ma come ha sottolineato Jason, in realtà non funziona in Javascript.
Joshua Carmody,

12
La gente ricorda: le domande, per quanto canoniche, devono rimanere domande . Si prega di astenersi da qualsiasi modifica che trasforma questa domanda in una risposta, affinare e mantenere invece le risposte . Grazie :)
Tim Post

1
Ho usato il codice in questo link msdn.microsoft.com/en-us/library/ie/ff743760(v=vs.94).aspx - (date.toLocaleDateString ("en-US"));
Khaled Annajar,

Se i futuri visitatori di questa pagina sono confusi dal modo in cui la maggior parte delle risposte si riferiscono alla domanda, suggerisco di leggere le revisioni della domanda , in particolare (se diverse da quelle sopra) revisione 15 @ Eric Muyser - I per uno sono stato confuso dalla mancanza dell'invalido Data # a Utilizzo della stringa.
user66001

Risposte:


1063

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


27
Entrambi questi siti hanno licenze restrittive. Quindi, se usi il codice (senza permesso), sarai in violazione. Momentjs ( stackoverflow.com/a/10119138/278976 ) appare come un modo scelta migliore ed è licenza MIT.
Homer6

4
@peller Questa risposta risponde alla domanda "Come posso formattare le date in javascript?" che è effettivamente il titolo della domanda. Nel corpo della domanda è abbastanza fuorviante. E, a tuo avviso, questa risposta non parla di formattazione di stringhe usando librerie casuali non standard o non menzionate. Ma quella parte della domanda è stata posta in modo errato, come sottolinea il commento n. 1 sulla domanda. Quindi, questo risponde alla vera domanda, ma non alle stringhe di formato che in realtà non esistono.
McKay,

3
@McKay; non era questa la domanda. Penso che tu o fraintenda ciò che il peller chiede o sia ottuso nel tuo ragionamento.
codeinthehole,

10
@codeinthehole "Formattare le date in Javascript" è la domanda. "fino ad ora avevo l'impressione che JavaScript non avesse un'API integrata per formattare un oggetto data in una stringa." ma poi parla del comportamento, che credo che pensi sia nativo in JavaScript. Senza sapere a quale libreria fa erroneamente riferimento, penso che la migliore ipotesi sia che stia ponendo la domanda "Come posso formattare le date in javascript?" e non credo di fare passi da gigante.
McKay,

5
MM significa 01-12, non 1-12: 2013-04-17 => OK 2013-4-17 => BAD
Adrian Maire

678

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)


7
Ciò fornisce anche un motivo decorativo attorno all'oggetto Data anziché scimmiottare con la scimmia l'oggetto principale, quindi è meno probabile che si verifichino conflitti lungo la strada.
Gabe Martin-Dempesy,

120
Si prega di smettere di abusare della parola "leggero". Anche 5kb è ridicolmente grande per tale funzionalità e, come oggi, quella dimensione è aumentata a 19kb.
user123444555621

27
@ Pumbaa80 Non sono d'accordo sul fatto che "Anche 5kb è ridicolmente grande per tale funzionalità". Hai visto i documenti? È una libreria estremamente utile per gestire le date in JS. Comprendo che avere una libreria superiore a un paio di KB per un singolo utilizzo di un formato di base come "D / M / Y" può essere un po 'eccessivo, tuttavia differenze di pochi KB stanno diventando trascurabili per la facilità d'uso fornita dalla libreria . Il codice mantenibile è una buona cosa per il bene di pochi KB. Se fosse + 100 KB minimizzato, sarei comunque d'accordo.
Turnerj

15
@Tumerj sostenendo che è utile non fa nulla per affrontare la preoccupazione di essere leggeri. I due non sono correlati.
JoshJordan,

9
Non puoi rendere un aereo jet più leggero rimuovendo il motore perché diventa un aliante e non un jet. Leggero significa che qualcosa ha solo la funzionalità necessaria per eseguire una funzione specificata. Ergo, questa è una soluzione leggera.
Bon

425

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.


come dirlo per usare l'ora locale o Zulu?
Ustaman Sangat

7
preferisco usare questa soluzione in grado di ottenere il tempo senza alcuna libreria: new Date (). toTimeString (). match (/ ^ ([0-9] {2}: [0-9] {2}: [0-9 ] {2}) /) [0] FYI
markcial

C'è un modo per fare questo. $ .datepicker.formatDate ('yy-mm-dd', new Date ("txtAdvDate" .Val ()); o qualcosa del genere
Pomster

@Pomster - cosa ti farebbe pensare che la stringa "txtAdvDate" avrebbe un metodo val su di essa? Intendi $ ('# txtAdvDate'). Val ()? Supponendo che si adatti a uno dei costruttori (vedi qui w3schools.com/jsref/jsref_obj_date.asp ), allora funzionerebbe bene.
Vbullinger,

@Pomster - prova ad usare questo: document.getElementById (id) .value = $ .datepicker.formatDate ('yy-mm-dd', new Date ());
sig

219

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.



2
La mia risposta ha tentato di rispondere anche a questa domanda. Credo che i browser Firefox o Mozilla fornissero una volta un metodo Date.toString () che utilizzava una tale stringa di formattazione. Sfortunatamente, non trovo traccia della vecchia documentazione. Non fa più parte dello standard e non sembra più essere supportato da nessuna parte, nemmeno in Firefox.
Peller,

214

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

10
Dovrebbe essere accettata la risposta, perché fornisce il formato richiesto (01-01-2000, non 1-1-2000)
Danubian Sailor

6
nuova data (). toISOString (). slice (0,10) // "2015-04-27"
immagine72

2
Sarebbe molto utile non avere l'esempio dell'11 settembre, quindi sarebbe chiaro in quale posizione sono rappresentati il ​​giorno e il mese.
Karl Adler,

1
@abimelex fatto. Spero sia più chiaro ora.
Adrian Maire,


125

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


92

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.


2
Non sono riuscito a trovare un modo per alimentare datejs con millisecondi per creare una data. In questo modo: var dateTime = new Date (); dateTime.setTime (millisecondi);
Arne Evertsson,

14
25k? Solo per le date? Ahia.
Ben Lesh,

13
Datejs è una libreria obsoleta che non ha visto uno sviluppo attivo da circa 5 anni. La loro fonte è su Github e Google Code ed entrambi hanno le ultime date aggiornate del 2008 (è il 2013). Per motivi di sanità mentale, scegli XDate o Moment.js.
Tyler Forsythe,

3
@TylerForsythe Ho aggiunto un suggerimento / avvertimento al riguardo.
Tim Büthe

2
lol lo script della data non è aggiornato ...
rtpHarry il

69

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

Migliorato un po 'per i miei scopi di supportare AM / PM - vedi sotto
Michael Angstadt

@WHK Ma mi piacciono ancora di più i momentjs : D
gongzhitaao,

Problemi con il mese di acquisizione: new Date ((new Date ()). Format ('yyyy-MM-dd')) restituisce maggio ma ora è giugno: - / che usi il fuso orario nella stringa di analisi?
e-info128,

1
@WHK Questo è in realtà un parser di date molto primitivo. Nel caso in cui non si debba rovinare troppo la data. Se hai davvero bisogno di far fronte a vari formati di date, consiglierei una libreria indipendente come momentjs. : D
gongzhitaao,

1
@WHK Perché console.log(new Date('2014-06-01')) -> Maypenso che abbia qualcosa a che fare con il fuso orario: D
gongzhitaao,

37

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 .


5
Tentare di rispondere effettivamente alla domanda non ti farà ottenere molti voti. Nomina una libreria popolare e vedi volare il tuo punteggio !!
RobG,

30

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/


4
Mi piace questa classe ma penso che dovrebbe essere una classe "statica". Non c'è bisogno di istanziarlo più di una volta. (Non dovrebbe essere necessario new DateFmt())
Cheeso

1
Cheeso: E se volessi formattare 10 date diverse su una pagina in 3 modi diversi, ciascuno? In tal caso sarebbe utile avere tre istanze di questo formattatore. È un caso d'uso perfettamente valido che ciò precluderebbe. L'OP ha progettato questo correttamente. Inoltre, la specifica di un formato in fase di costruzione consente di risparmiare la duplicazione del codice specificando un formato ogni volta che è necessario formattarlo in un determinato modo.
hsanders,

29

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"

è questo browser? e cross locale?
Iftah,

Sì. Mostra l'ora nel fuso orario locale (dell'utente del browser).
John Williams,


18

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

2
le operazioni di sostituzione non sono veramente efficienti, quindi è una buona pratica prevenirlo.
mrzmyr,

cosa succede se scrivo, cosa succederà? console.log ("La data è:" + dateFormat (nuova data (), "GG / MM / AA"));
Hakan,

1
Questo stamperà il testo "La data è: 12/11 / AA", perché quanto sopra non gestisce le date a 2 cifre. Se avete bisogno di questo, si potrebbe aggiungere il seguente immediatamente prima l'istruzione return: format = format.replace("YY", (""+date.getFullYear()).substring(2));. Questo sta diventando brutto però - probabilmente vorrai scendere lungo la rotta RegEx o simile.
Ollie Bennett,

1
@mrzmyr Pensi davvero che le date di formattazione saranno un collo di bottiglia nelle prestazioni? Dai.
Doug65536,

11

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

1
buona risposta, ma penso che dovresti cambiare la funzione zp2 come: var zp2 = function (val) {return val <= 9? '00' + val: (val <= 99? '0' + val: '' + val); }
Eric Wang del

1
c'è un'eccezione, quando il valore della parte ms è 0, non è lo stesso, nella tua funzione il risultato è '00', ma non '000'.
Eric Wang,

9

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

8

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

Ottima soluzione! var a = nuova data (); a.format ( 'AAAA-MM-d'); // Ritorno 16-08-2013.
Adrian Maire,

this.getMonth (); non riesce in iOS
N20084753

7

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

6

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


6

Codice di esempio:

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

Produzione:

"13:45:20"


2
vale la pena notare con toISOString (); genera UTC. Quindi new Date();// = Fri Nov 22 2013 17:48:22 GMT+0100, se , l'output con il codice sopra sarà"16:48:22"
Tewr,

6

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"

4

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


3

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à.



2

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


1

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

1

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

1

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


0

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

3
è necessario lo script collegato "Formato data JavaScript" collegato sopra
Sebastian Viereck,

0

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.


0

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")
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.