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

https://stackoverflow.com/questions/1056728

20-08-2019
|

Domanda

Ho notato che la funzione new Date() di 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 della funzione toString().

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 dell'editore: il seguente approccio è il tentativo del richiedente che ha funzionato su un browser particolare ma non funziona in generale; vedi le risposte in questa pagina per vedere alcune soluzioni reali.

Oggi ho giocato con il metodo Date() sull'oggetto data e sorprendentemente serve allo 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 dall'oggetto <=>?

Soluzione

I love 10 modi per formattare ora e data utilizzando JavaScript e Lavorare con 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);

Altri suggerimenti

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"

(*) peso leggero che significa 9,3 KB minificati + compressi con gzip nella configurazione più piccola possibile (febbraio 2014)

Se stai già utilizzando UI jQuery nel tuo progetto, puoi utilizzare il built-in metodo datepicker 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 a jQuery UI datepicker formatDate , gli esempi.

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

Oggi mi sono imbattuto in questo 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 il modo in cui hai indicato che vorresti usarli . Ma supporta metodi per la formattazione di date e / o orari, come .toLocaleDateString(), .toLocaleTimeString() e .toUTCString().

Il riferimento all'oggetto Date 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. Ci sono stati alcuni dibattiti nella comunità JavaScript nel corso degli anni sul fatto che o non è questa la migliore pratica e non sto sostenendo a favore o contro di essa, ma 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 classe Date ha alcune funzioni di formattazione specifiche:

toDateString : dipende dall'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 : Stringizer 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 nel 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 & amp; 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"

toString : toString generico per 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 & # 8220; universale & # 8221; documentazione 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 che & # 8217; è lo standard EMCAScript; le stringhe standard ECMAScript richiederebbero, come minimo, un'implementazione modificata della definizione ISO 8601.

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

Da questo ci si può aspettare funzionalità di base, ma cosa & # 8220; dovrebbe & # 8221; essere non è intrinsecamente ciò che & # 8220; è & # 8221 ;. Sto & # 8217; vado un po 'in profondità con questo proceduralmente però, 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 cosa succede effettivamente quando si crea un oggetto Date.

La risposta lunga

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 nuovo; & # 8217; s è 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 & n. 8217; 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) <<>> 8217; s un'implementazione di un determinato standard, b) non tutte le implementazioni di uno standard sono puritane ec) funzionalità non viene rilasciato in sincronizzazione con un nuovo standard in quanto d) un'implementazione è un costante lavoro in corso

In sostanza, quando si ha a che fare con javascript, si & # 8217; si tratta di una derivata (javascript specifica per il browser) di un'implementazione (javascript stesso). Google & # 8217; s V8, ad esempio, implementa ECMAScript 5.0, ma Internet Explorer & # 8217; s JScript non & # 8217; t tenta di conformarsi a qualsiasi standard ECMAScript, ma Internet & Nbsp ; Explorer & Nbsp; 9 non è 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 (), lancia questo prototipo di funzione:

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

Entrambe queste funzioni dovrebbero sembrare familiari, ma questo non risponde immediatamente alla tua domanda e cosa si quantifica come & # 8220 accettabile; formato data & # 8221; 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 condizionale in una singola funzione) per nuova data (valore) con la stringa come argomento per & # 8220; valore & # 8221; parametro. 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 guardareil 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 inoltre 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, per esperienza, possiamo riconoscere che l'oggetto Date javascript & # 8217; s 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. Stiamo & # 8217; esamineremo Google & # 8217; implementazione javascript di s, V8; si prega di notare che & # 8217; m non sto suggerendo che questo sia & # 8220; migliore & # 8221; motore javascript (come si può definire & # 8220; migliore & # 8221; o anche & # 8220; buono & # 8221;) 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.

Google & # 8217; s V8, 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 & # 8220; anno & # 8221; non è l'anno effettivo ed è solo un riferimento a & # 8220; anno & # 8221; parametro.

Google & # 8217; s V8, date.js, DateParse

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

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

Google & # 8217; s V8, runtime.cc,% DateParseString

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

La chiamata di funzione che & # 8217; per quanto riguarda 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:

Google V8, 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, controlla 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:

Le parole prima del primo numero sconosciute al parser vengono ignorate.
Il testo tra parentesi viene ignorato.
Numeri non firmati seguiti da & # 8220;: & # 8221; sono interpretati come & # 8220; componente temporale & # 8221 ;.
Numeri non firmati seguiti da & # 8220;. & # 8221; sono interpretati come & # 8220; componente temporale & # 8221 ;, e devono essere seguiti da millisecondi.
Numeri firmati seguiti dall'ora o dall'ora minuto (ad es. +5: 15 o +0515) vengono interpretati come fuso orario.
Quando si dichiarano l'ora e i minuti, è possibile utilizzare & # 8220; hh: mm & # 8221; o & # 8220; hhmm & # 8221 ;.
Le parole che indicano un fuso orario vengono interpretate come fuso orario.
Tutti gli altri numeri sono interpretati come & # 8220; componenti data & # 8221 ;.
Tutte le parole che iniziano con le prime tre cifre di un mese vengono interpretate come il mese.
È possibile definire minuti e ore insieme in uno dei due formati: & # 8220; hh: mm & # 8221; o & # 8220; hhmm & # 8221 ;.
Simboli come & # 8220; + & # 8221 ;, & # 8220; - & # 8220; e senza pari & # 8220;) & # 8221; non sono consentiti dopo l'elaborazione di un numero.
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, che è 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 c'è " documentazione " che rappresenta 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 / Data

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

Assicurati di effettuare il checkout Datejs quando gestisci le date in JavaScript. È piuttosto impressionante e ben documentato come puoi vedere in caso di toString function .

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

Puoi semplicemente espandere Date l'Oggetto con un nuovo metodo format come notato da meizz , di seguito è riportato il codice fornito dall'autore. E 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. Le ECMAScript 3 spec lascia la funzione di analisi e formati di output fino a l'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 consultare 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/

Framework gratuito, 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 è certamente completo, ma raccomanderei questa MOLTO più semplice lib (JavaScript Date Format) che preferisco semplicemente perché sono 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 anche 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:

Utilizza Object.keys () che non è definito nei browser meno recenti, pertanto potrebbe essere necessario implementare 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];
    });
};

USE

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

Solo 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 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/8/9
2013/8/9
2013/8/9
2013/8/9
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 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 uno zero iniziale.

09 agosto 2013
Agosto 2013 09
09 agosto 2013
09 ago 2013
9 agosto 2013
9 agosto 2013
ecc ...

Valido anche in " browser moderni " (o in altre parole 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 in cui Tipo di data MySQL utilizza)

2013/8/9

Utilizzo dei nomi dei mesi:
È interessante notare che quando ho usato 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, sebbene sia utile conoscere i metodi di base, è più pratico usare una libreria di helper.

La libreria javascript XDate di Adam Shaw è in circolazione dalla metà del 2011 ed è ancora in fase di sviluppo attivo. Ha una documentazione fantastica, una grande API, formattazione, cerca di rimanere compatibile con le versioni precedenti 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");

Output:

&
quot; 13: 45: & 20 quot;

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

Sugar dà alla classe Date molto amore a partire da Date.create metodo in grado di comprendere le date in quasi tutti i formati in 15 principali lingue, compresi formati relativi come " 1 ora fa " ;. Le date possono anche essere prodotto in qualsiasi formato o lingua usando un facile da capire sintassi, con collegamenti ai formati di data più comunemente usati. Data complessa il confronto è anche possibile con metodi come is, che ne comprendono qualsiasi formatta e applica la 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 sorgente in uso è applicare i seguenti passaggi:

Usa new Date() per creare un Date oggetto
Usa .getDate(), .getMonth() e .getFullYear() per ottenere rispettivamente il giorno, il mese e l'anno
Incolla i pezzi insieme in base al tuo formato di destinazione

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 metodo .toLocaleDateString 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 la MDN , " Browser moderni " significa ampli Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ &; Safari build notturno

Solo un'altra opzione, che ho scritto:

DP_DateExtensions Library

Non sono sicuro che possa essere d'aiuto, 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à.

Il modo corretto di formattare una data per restituire " 2012-12-29 " è con lo script da 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');

Se vuoi mostrare solo il tempo con due cifre, questo potrebbe 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 queste funzioni

toTimeString() and toLocaleDateString()

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

JsSimpleDateFormat è una libreria che può formattare il oggetto data e analizzare nuovamente la stringa formattata nell'oggetto data. 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. per esempio. nelle specifiche ECMAScript 5.1 ( http: //www.ecma -international.org/publications/files/ECMA-ST/Ecma-262.pdf , 08/02/2013, pagina 173), la funzione toString è documentata come segue:

" I contenuti della stringa sono " dipendenti 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 utilizzare il mio porta di 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

Personalmente, poiché utilizzo PHP e jQuery / javascript in egual misura, utilizzo la funzione date 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 era già stato menzionato, ma altri framework come Uendo di Kendo (globalizzazione) , Yahoo UI (Util) e AngularJS li hanno pure.

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

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

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow