Zauważyłem, że new Date()funkcja JavaScript jest bardzo inteligentna w przyjmowaniu dat w kilku formatach.

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

Nigdzie nie mogłem znaleźć dokumentacji pokazującej wszystkie prawidłowe formaty ciągów podczas wywoływania new Date()funkcji.

Służy do konwertowania ciągu na datę. Jeśli spojrzymy na przeciwną stronę, czyli konwersję obiektu daty na ciąg, do tej pory miałem wrażenie, że JavaScript nie ma wbudowanego API do formatowania obiektu daty na ciąg.

Nota redaktora: Poniższe podejście jest próbą osoby pytającej, która działała w określonej przeglądarce, ale ogólnie nie działa; zobacz odpowiedzi na tej stronie, aby zobaczyć niektóre rzeczywiste rozwiązania.

Dzisiaj grałem toString()metodą na obiekcie date i, co zaskakujące, służy ona formatowaniu daty na ciągi.

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

Również tutaj nie mogłem znaleźć żadnej dokumentacji dotyczącej wszystkich sposobów formatowania obiektu daty na ciąg.

Gdzie jest dokumentacja zawierająca specyfikatory formatu obsługiwane przez Date()obiekt?

Uwielbiam 10 sposobów formatowania godziny i daty za pomocą JavaScript i pracy z .

Zasadniczo masz trzy metody i musisz sam połączyć łańcuchy:

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

Przykład:

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

Jest to (lekka) * biblioteka dat JavaScript do parsowania, manipulowania i formatowania dat.

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"

(*) lekki, co oznacza 9,3 KB zminimalizowane + gzip w najmniejszej możliwej konfiguracji (luty 2014)

Jeśli już używasz interfejsu użytkownika jQuery w swoim projekcie, możesz użyć wbudowanej metody datepicker do sformatowania obiektu daty:

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

Jednak datepicker formatuje tylko daty i nie może formatować godzin.

Spójrz na format datepicker jQuery UI , przykłady.

Gdzie jest dokumentacja zawierająca specyfikatory formatu obsługiwane przez Date()obiekt?

Natknąłem się na to dzisiaj i byłem dość zaskoczony, że nikt nie miał czasu odpowiedzieć na to proste pytanie. To prawda, istnieje wiele bibliotek, które pomagają w manipulowaniu datami. Niektóre są lepsze od innych. Ale to nie było pytanie.

AFAIK, czysty JavaScript nie obsługuje specyfikatorów formatu w sposób, w jaki wskazałeś, że chcesz ich używać . Ale robi metod wsparcia dla formatowania daty i / lub czasu, takich jak .toLocaleDateString(), .toLocaleTimeString()i .toUTCString().

DateOdwołanie do obiektu używam najczęściej znajduje się na stronie internetowej w3schools.com (ale szybkiego wyszukiwania Google ujawni wiele innych, które mogą lepiej swoich potrzeb).

Należy również pamiętać, że sekcja Właściwości obiektu daty zawiera link do prototype, który ilustruje niektóre sposoby rozszerzenia obiektu Date za pomocą metod niestandardowych. Przez lata w społeczności JavaScript toczyła się debata na temat tego, czy jest to najlepsza praktyka, i nie opowiadam się za nią, czy przeciw niej, tylko wskazując na jej istnienie.

Niestandardowa funkcja formatowania:

W przypadku formatów ustalonych wystarczy prosta funkcja. Poniższy przykład wygeneruje międzynarodowy format RRRR-MM-DD:

function dateToYMD(date) {
    var d = date.getDate();
    var m = date.getMonth() + 1;
    var y = date.getFullYear();
    return '' + y + '-' + (m<=9 ? '0' + m : m) + '-' + (d <= 9 ? '0' + d : d);
}

Uwaga: Jednak zwykle nie jest dobrym pomysłem rozszerzenie standardowych bibliotek Javascript (np. Poprzez dodanie tej funkcji do prototypu Date).

Bardziej zaawansowana funkcja może generować konfigurowalne dane wyjściowe na podstawie parametru formatu. Na tej samej stronie znajduje się kilka dobrych przykładów.

Jeśli napisanie funkcji formatowania jest zbyt długie, istnieje wiele bibliotek wokół niej. Niektóre inne odpowiedzi już je wymieniają. Ale rosnące zależności mają również swoje odpowiedniki.

Standardowe funkcje formatowania ECMAScript:

Od nowszych wersji ECMAscript Dateklasa ma pewne specyficzne funkcje formatowania:

toDateString : zależne od implementacji, pokaż tylko datę.

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 : Pokaż datę i godzinę 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 dla 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 : zależna od implementacji, data w formacie ustawień regionalnych.

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

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

toLocaleString : zależna od implementacji, data i godzina w formacie ustawień regionalnych.

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 : zależny od implementacji, czas w formacie ustawień regionalnych.

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 : Ogólny toString dla daty.

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

Uwaga: możliwe jest wygenerowanie niestandardowego wyjścia z tych funkcji formatowania:

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

Krótka odpowiedź

Nie ma „uniwersalnej” dokumentacji, do której javascript mógłby się dostosować; każda przeglądarka z javascript jest naprawdę implementacją. Istnieje jednak standard, który jest zgodny z większością współczesnych przeglądarek, a jest to standard EMCAScript; standardowe ciągi znaków ECMAScript wymagałyby minimalnie zmodyfikowanej implementacji definicji ISO 8601.

Oprócz tego IETF przedstawia drugi standard , który są również stosowane przez przeglądarki, czyli definicję znaczników czasu wykonanych w RFC 2822. Rzeczywistą dokumentację można znaleźć na liście odnośników na dole.

Po tym można oczekiwać podstawowej funkcjonalności, ale to, co „powinno” być, nie jest z natury tym, co „jest”. Zagłębię się nieco w to proceduralnie, ponieważ wydaje się, że tylko trzy osoby faktycznie odpowiedziały na pytanie (Scott, goofballLogic i peller mianowicie), co, według mnie, sugeruje, że większość ludzi nie wie, co tak naprawdę się dzieje, gdy ty utwórz obiekt Date.

Długa odpowiedź

Gdzie jest dokumentacja zawierająca specyfikatory formatu obsługiwane przez obiekt Date ()?

Aby odpowiedzieć na pytanie lub zazwyczaj poszukać odpowiedzi na to pytanie, musisz wiedzieć, że javascript nie jest nowym językiem; w rzeczywistości jest to implementacja ECMAScript i jest zgodna ze standardami ECMAScript (ale uwaga, javascript również faktycznie był wcześniejszy niż te standardy; standardy EMCAScript są zbudowane na podstawie wczesnej implementacji LiveScript / JavaScript). Obecny standard ECMAScript to 5.1 (2011); w momencie, gdy pytanie zostało pierwotnie zadane (czerwiec 2009 r.), standardem było 3 (4 zostało porzucone), ale 5 zostało wydane wkrótce po stanowisku pod koniec 2009 r. Powinno to nakreślić jeden problem; jaki standard może stosować implementacja javascript, może nie odzwierciedlać tego, co faktycznie istnieje, ponieważ a) jest implementacją danego standardu, b) nie wszystkie implementacje standardu są purytanami,

Zasadniczo, mając do czynienia z javascript, masz do czynienia z pochodną (javascript specyficzną dla przeglądarki) implementacji (sam javascript). Na przykład Google V8 implementuje ECMAScript 5.0, ale JScript programu Internet Explorer nie próbuje być zgodny z żadnym standardem ECMAScript, ale Internet Explorer 9 jest zgodny z ECMAScript 5.0.

Gdy pojedynczy argument jest przekazywany do new Date (), rzutuje ten prototyp funkcji:

new Date(value)

Gdy dwa lub więcej argumentów zostanie przekazanych do new Date (), rzutuje ten prototyp funkcji:

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

Obie te funkcje powinny wyglądać znajomo, ale nie odpowiada to od razu na twoje pytanie, a to, co określa się jako akceptowalny „format daty” wymaga dalszych wyjaśnień. Gdy przekażesz ciąg znaków do nowej daty (), wywoła on prototyp (zwróć uwagę, że używam słowa prototyp luźno; wersje mogą być pojedynczymi funkcjami lub mogą być częścią instrukcji warunkowej w jednej funkcji) dla nowa data (wartość) z ciągiem jako argumentem parametru „wartość”. Ta funkcja najpierw sprawdzi, czy jest to liczba, czy ciąg. Dokumentację tej funkcji można znaleźć tutaj:

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

Na podstawie tego możemy wywnioskować, że aby zezwolić na formatowanie łańcucha dla nowej daty (wartości), musimy przyjrzeć się metodzie Date.parse (łańcuch). Dokumentację tej metody można znaleźć tutaj:

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

Możemy ponadto wywnioskować, że spodziewane są daty w zmodyfikowanym rozszerzonym formacie ISO 8601, jak określono tutaj:

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

Z doświadczenia możemy jednak rozpoznać, że obiekt Date javascript akceptuje inne formaty (wymuszone przez istnienie tego pytania w pierwszej kolejności), i jest to w porządku, ponieważ ECMAScript pozwala na formaty specyficzne dla implementacji. Jednak to wciąż nie odpowiada na pytanie, jaka dokumentacja jest dostępna w dostępnych formatach, ani jakie formaty są faktycznie dozwolone. Przyjrzymy się implementacji javascript Google, V8; Uwaga: nie sugeruję, że jest to „najlepszy” silnik javascript (w jaki sposób można zdefiniować „najlepszy”, a nawet „dobry”) i nie można zakładać, że formaty dozwolone w V8 reprezentują wszystkie dostępne obecnie formaty, ale myślę, że to uczciwe zakładać, że spełniają współczesne oczekiwania.

Google V8, date.js, DateConstructor

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

Patrząc na funkcję DateConstructor, możemy wywnioskować, że musimy znaleźć funkcję DateParse; należy jednak pamiętać, że „rok” nie jest faktycznym rokiem i jest jedynie odniesieniem do parametru „rok”.

Google V8, date.js, DateParse

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

To wywołuje% DateParseString, który w rzeczywistości jest referencją funkcji czasu wykonania dla funkcji C ++. Odnosi się do następującego kodu:

Google V8, runtime.cc,% DateParseString

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

Wywołanie funkcji, której dotyczy ta funkcja, dotyczy funkcji DateParser :: Parse (); zignoruj ​​logikę otaczającą te wywołania funkcji, są to tylko kontrole zgodności z typem kodowania (ASCII i UC16). DateParser :: Parse jest zdefiniowany tutaj:

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

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

Jest to funkcja, która faktycznie określa, jakie formaty akceptuje. Zasadniczo sprawdza zgodność ze standardem EMCAScript 5.0 ISO 8601, a jeśli nie jest zgodny ze standardami, podejmie próbę zbudowania daty na podstawie starszych formatów. Kilka kluczowych punktów na podstawie komentarzy:

1. Słowa przed pierwszą liczbą, które są nieznane przez analizator składni, są ignorowane.
2. Tekst w nawiasach jest ignorowany.
3. Numery bez znaku, po których następuje „:”, są interpretowane jako „składnik czasu”.
4. Numery bez znaku, po których następuje „.” są interpretowane jako „składnik czasu” i muszą następować milisekundy.
5. Podpisane liczby, a następnie godzina lub minuta (np. +5: 15 lub +0515) są interpretowane jako strefa czasowa.
6. Podczas deklarowania godziny i minuty możesz użyć „hh: mm” lub „hhmm”.
7. Słowa wskazujące strefę czasową są interpretowane jako strefa czasowa.
8. Wszystkie pozostałe liczby są interpretowane jako „składniki daty”.
9. Wszystkie słowa zaczynające się od pierwszych trzech cyfr miesiąca są interpretowane jako miesiąc.
10. Możesz zdefiniować minuty i godziny razem w jednym z dwóch formatów: „hh: mm” lub „hhmm”.
11. Symbole takie jak „+”, „-” i niedopasowane „)” są niedozwolone po przetworzeniu liczby.
12. Elementy pasujące do wielu formatów (np. 1970-01-01) są przetwarzane jako standardowy zgodny z normą EMCAScript 5.0 ciąg znaków ISO 8601.

To powinno wystarczyć, aby dać ci podstawowe pojęcie o tym, czego możesz się spodziewać, jeśli chodzi o przekazywanie ciągu znaków do obiektu Date. Możesz dalej rozwinąć tę kwestię, patrząc na następującą specyfikację, na którą wskazuje Mozilla w Mozilla Developer Network (zgodna ze znacznikami czasu IETF RFC 2822):

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

Microsoft Developer Network dodatkowo wspomina o dodatkowym standardzie dla obiektu Date: ECMA-402, specyfikacji interfejsu API internacjonalizacji ECMAScript, która jest komplementarna do standardu ECMAScript 5.1 (i przyszłych). Można to znaleźć tutaj:

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

W każdym razie powinno to pomóc w podkreśleniu, że nie ma „dokumentacji”, która uniwersalnie reprezentowałaby wszystkie implementacje javascript, ale wciąż dostępna jest wystarczająca ilość dokumentacji, aby rozsądnie zrozumieć, jakie ciągi znaków są dopuszczalne dla obiektu Date. Całkiem zadane pytanie, kiedy o tym pomyślisz, tak? : P

Bibliografia

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

Zasoby

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

Pamiętaj, aby sprawdzić dane Datejs, gdy masz do czynienia z datami w JavaScript. Jest dość imponujący i dobrze udokumentowany, jak widać w przypadku funkcji toString .

EDYCJA : Tyler Forsythe zauważa, że ​​dane są nieaktualne. Używam go w moim obecnym projekcie i nie miałem z tym żadnych problemów, jednak powinieneś być tego świadomy i rozważyć alternatywy.

Możesz po prostu rozwinąć DateObiekt nową formatmetodą, jak zauważył meizz , poniżej znajduje się kod podany przez autora. A oto 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"));

Przytaczana przez ciebie funkcjonalność nie jest standardowym Javascriptem, prawdopodobnie nie będzie przenośna w różnych przeglądarkach, a zatem nie jest dobrą praktyką. Specyfikacja ECMAScript 3 pozostawia funkcję analizy składni i formatów wyjściowych do implementacji Javascript. ECMAScript 5 dodaje podzbiór obsługi ISO8601. Wierzę, że wspomniana funkcja toString () jest innowacją w jednej przeglądarce (Mozilla?)

Kilka bibliotek udostępnia procedury do parametryzacji, niektóre z rozbudowaną obsługą lokalizacji. Możesz także sprawdzić metody w dojo.date.locale .

Zrobiłem ten bardzo prosty formatyzator, jest wycięty / n / pastowalny (zaktualizowany o starszą wersję):

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/

Bez ram, ograniczony, ale lekki

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 jest z pewnością w pełni funkcjonalny, ale polecam WIELE WIĘCEJ prostszej biblioteki lib (format daty JavaScript), którą wolę po prostu dlatego, że ma tylko około 120 linii.

Po przejrzeniu kilku opcji podanych w innych odpowiedziach, postanowiłem napisać własne ograniczone, ale proste rozwiązanie, które inni mogą również okazać się przydatne.

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

Przykładowe użycie:

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

Oto funkcja, z której często korzystam. Wynikiem jest rrrr-mm-dd gg: 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);
}

Przydatna może być ta modyfikacja obiektu daty, która jest mniejsza niż jakakolwiek biblioteka i można ją łatwo rozszerzyć w celu obsługi różnych formatów:

UWAGA:

• Wykorzystuje Object.keys (), który jest niezdefiniowany w starszych przeglądarkach, więc może być konieczne zaimplementowanie wypełniania polifill z podanego linku.

KOD

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

POSŁUGIWAĆ SIĘ

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

Aby kontynuować solidną odpowiedź gongzhitaao - obsługuje 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;
}

Nie mogłem znaleźć żadnej ostatecznej dokumentacji dotyczącej prawidłowych formatów dat, dlatego napisałem własny test, aby sprawdzić, co jest obsługiwane w różnych przeglądarkach.

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

Z moich wyników wynika, że ​​następujące formaty są prawidłowe we wszystkich testowanych przeglądarkach (przykłady używają daty „9 sierpnia 2013 r.”):

[Pełny rok] / [Miesiąc] / [Numer daty] - Miesiąc może być albo liczbą z wiodącym zerem lub bez niego, albo nazwą miesiąca w krótkim lub długim formacie, a numer daty może być z wiodącym zerem lub bez niego.

• 2013/08/09
• 2013/08/9
• 2013/8/09
• 2013/8/9
• 2013 / sierpień / 09
• 2013 / sierpień / 9
• 2013 / sie / 09
• 2013 / sie / 9

[Miesiąc] / [Pełny rok] / [Numer daty] - Miesiąc może być liczbą z wiodącym zerem lub bez niego albo nazwą miesiąca w krótkim lub długim formacie, a numer daty może być z wiodącym zerem lub bez niego.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• Sierpień / 2013/09
• Sierpień / 2013/9
• Sierpień / 2013/09
• Sie / 2013/9

Dowolna kombinacja [Pełny rok], [Nazwa miesiąca] i [Numer daty] oddzielone spacjami - Nazwa miesiąca może mieć zarówno krótki, jak i długi format, a numer daty może być z wiodącym zerem lub bez niego.

• 09 sierpnia 2013
• Sierpień 2013 09
• 09 sierpnia 2013 r
• 09 sierpnia 2013
• 9 sierpnia 2013 r
• 2013 9 sierpnia
• itp...

Obowiązuje również w „nowoczesnych przeglądarkach” (lub innymi słowy we wszystkich przeglądarkach oprócz IE9 i niższych)

[Pełny rok] - [Numer miesiąca] - [Numer daty] - Numer miesiąca i daty musi zawierać początkowe zera (jest to format, którego używa typ daty MySQL )

• 2013-08-09

Używanie nazw miesięcy:
Co ciekawe, podczas używania nazw miesięcy odkryłem, że używane są tylko pierwsze 3 znaki nazwy miesiąca, więc wszystkie poniższe elementy są całkowicie poprawne:

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

Formatowanie, a zwłaszcza parsowanie dat w JavaScript może być trochę uciążliwe. Nie wszystkie przeglądarki obsługują daty w ten sam sposób. Więc chociaż warto znać podstawowe metody, bardziej praktyczne jest użycie biblioteki pomocniczej.

Biblioteka XDate javascript przez Adam Shaw istnieje od połowy 2011 roku i nadal jest pod aktywnego rozwoju. Ma fantastyczną dokumentację, świetne API, formatowanie, stara się zachować zgodność wsteczną, a nawet obsługuje zlokalizowane ciągi.

Link do zmiany ciągów ustawień regionalnych: https://gist.github.com/1221376

Przykładowy kod:

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

Wynik:

„13:45:20”

Biblioteka sugar.js ma świetną funkcjonalność do pracy z datami w JavaScript. I jest to bardzo dobrze udokumentowane .

Sugar bardzo lubi klasę Date, poczynając od metody Date.create, która potrafi rozumieć daty w prawie dowolnym formacie w 15 głównych językach, w tym w formatach względnych, takich jak „1 godzina temu”. Daty mogą być również generowane w dowolnym formacie lub języku przy użyciu łatwej do zrozumienia składni, ze skrótami do często używanych formatów dat. Złożone porównanie dat jest również możliwe przy użyciu metod takich jak is, które rozumieją każdy format i stosują wbudowaną precyzję.

Kilka przykładów:

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"

Wszystkie przeglądarki

Najbardziej niezawodnym sposobem sformatowania daty za pomocą formatu źródłowego, którego używasz, jest wykonanie następujących kroków:

1. Posługiwać się new Date() do tworzenia Dateobiektu
2. Posługiwać się .getDate() , .getMonth()i .getFullYear()aby uzyskać odpowiednio dzień, miesiąc i rok
3. Wklej elementy razem zgodnie z formatem docelowym

Przykład:

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

(Zobacz także to skrzypce ).

Tylko nowoczesne przeglądarki

Możesz również użyć wbudowanej .toLocaleDateStringmetody, aby wykonać formatowanie za Ciebie. Musisz tylko podać odpowiednie ustawienia regionalne i opcje, aby dopasować odpowiedni format, który niestety jest obsługiwany tylko przez nowoczesne przeglądarki (*) :

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

(Zobacz także to skrzypce ).

(*) Zgodnie z MDN "Nowoczesne przeglądarki Chrome 24+" oznacza, Firefox 29+, IE11, Edge12 +, Opera 15+ & Safari nightly build

Kolejna opcja, którą napisałem:

Biblioteka DP_DateExtensions

Nie jestem pewien, czy to pomoże, ale uznałem to za przydatne w kilku projektach - wygląda na to, że zrobi to, czego potrzebujesz.

Obsługuje formatowanie daty / godziny, matematykę dat (dodawanie / odejmowanie części daty), porównywanie dat, parsowanie dat itp. Jest to dowolnie otwarte źródło.

Nie ma powodu, aby to rozważać, jeśli już używasz frameworka (wszystkie są w stanie), ale jeśli potrzebujesz tylko szybkiego dodania manipulacji datami do projektu, daj mu szansę.

Jeśli chcesz wyświetlać tylko czas za pomocą dwóch cyfr, może to pomóc:

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

użyj tej funkcji

toTimeString() and toLocaleDateString()

zapoznaj się z poniższym linkiem, aby uzyskać więcej informacji https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat to biblioteka, która może sformatować obiekt daty i przetworzyć sformatowany ciąg znaków z powrotem na obiekt daty. Używa formatu Java (klasa SimpleDateFormat). Nazwę miesięcy i dni można zlokalizować.

Przykład:

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

Odpowiedź brzmi „nigdzie”, ponieważ formatowanie daty stanowi zastrzeżoną funkcjonalność. Nie sądzę, aby funkcje toString były zgodne z określonym formatem. np. w specyfikacji ECMAScript 5.1 ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, strona 173), funkcja toString jest udokumentowana w następujący sposób :

„Zawartość ciągu zależy od implementacji”

Funkcje takie jak poniższe przykłady mogą być wykorzystane do dość łatwego sformatowania.

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

Jeśli nie potrzebujesz wszystkich funkcji, które zapewnia biblioteka taka jak Moment.js , możesz użyć mojego portu Strftime . Jest lekki (1,35 KB vs. 57,9 KB zminimalizowany w porównaniu z Moment.js 2.15.0) i zapewnia większość funkcji 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;
  });
}

Przykładowe użycie:

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"

Najnowszy kod jest dostępny tutaj: https://github.com/thdoan/strftime

Prawidłowy sposób sformatowania daty zwrotu „2012-12-29” to skrypt skryptu z formatu daty JavaScript :

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

Ten kod NIE działa:

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

Osobiście, ponieważ używam zarówno PHP, jak i jQuery / javascript w równych miarach, używam funkcji daty z php.js http://phpjs.org/functions/date/

Korzystanie z biblioteki, która używa tych samych ciągów formatu, co coś, co już wiem, jest dla mnie łatwiejsze, a instrukcja zawierająca wszystkie możliwości ciągów formatu dla funkcji daty jest oczywiście dostępna online na stronie php.net

Po prostu umieść plik date.js w swoim HTML za pomocą preferowanej metody, a następnie wywołaj go w następujący sposób:

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

Możesz użyć d1.getTime () zamiast valueOf (), jeśli chcesz, robią to samo.

Dzielenie przez 1000 znacznika czasu javascript polega na tym, że znacznik czasu javascript jest wyrażony w milisekundach, ale znacznik czasu PHP jest wyrażony w sekundach.

Wiele frameworków (których już prawdopodobnie używasz) ma formatowanie daty, o którym możesz nie wiedzieć. jQueryUI zostało już wspomniane, ale inne frameworki, takie jak Kendo UI (Globalizacja) , Yahoo UI (Util) i AngularJS również je mają.

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

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