Chwila.js

Jest to (lightweight)* JavaScript date library 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"

(*) lekkie znaczenie 9.3 KB minified + gziped w najmniejszej możliwej konfiguracji (luty 2014)

Jeśli używasz już jQuery UI w swoim projekcie, możesz użyć wbudowanej metody datepicker do formatowania obiektu date:

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

Jednak datepicker formatuje tylko daty i nie może formatować czasów.

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

Gdzie znajduje się dokumentacja z listą formatów obsługiwanych przez obiekt Date()?

Natknąłem się na to dzisiaj i byłem zaskoczony, że nikt nie poświęcił czasu, aby odpowiedzieć na to proste pytanie. To prawda, że istnieje wiele bibliotek, które pomagają w manipulacji datą. Niektórzy są lepsi od innych. Ale nie o to pytano.

AFAIK, czysty JavaScript nie obsługuje specyfikacji formatu sposób, w jaki wskazałeś, że chcesz użyć them . Ale obsługuje metody formatowania dat i / lub godzin, takie jak .toLocaleDateString(), .toLocaleTimeString(), i .toUTCString().

Date odniesienie do obiektu, którego używam najczęściej znajduje się na w3schools.com strona internetowa (Ale szybkie wyszukiwanie w Google ujawni wiele innych, które mogą lepiej zaspokoić Twoje potrzeby).

Należy również zauważyć, że sekcja Właściwości obiektu Date zawiera link do prototype, co ilustruje kilka sposobów rozszerzenia obiektu Date za pomocą niestandardowych metod. Od lat w społeczności JavaScript toczy się dyskusja na temat tego, czy jest to najlepsza praktyka, czy też nie, a ja nie opowiadam się za nią ani przeciwko niej, tylko wskazując na jej istnienie.

Funkcja formatowania niestandardowego:

Dla stałych formatów zadanie wykonuje 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);
}

Notatka: jednak zwykle nie jest dobrym pomysłem Rozszerzanie 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. Jest kilka dobrych przykładów w tym samym strona.

Jeśli pisanie funkcji formatowania jest zbyt długie, istnieje wiele bibliotek, wokół których to robi. Niektóre inne odpowiedzi już je wyliczają. Ale rosnące zależności mają również jej przeciwstawność.

Standardowe funkcje formatowania ECMAScript:

Od nowszych wersji ECMAscript, Klasa Date posiada pewne specyficzne funkcje formatowania:

ToDateString: Implementation dependent, show only the date.

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 : pokazuje 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: Implementation dependent, a date in locale format.

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żny od implementacji, Data i czas w formacie 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 : zależny od implementacji, czas w formacie 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: 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 formatujących:

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

Krótka Odpowiedź

Nie ma "uniwersalnej" dokumentacji, którą obsługuje javascript; każda przeglądarka, która ma javascript, jest naprawdę implementacją. Jednak istnieje standard, który większość nowoczesnych przeglądarek ma tendencję do naśladowania, i jest to standard EMCAScript; standardowe ciągi znaków ECMAScript zajęłyby, minimalnie, zmodyfikowaną implementację definicji ISO 8601.

Oprócz tego istnieje drugi standard ustawiony przez IETF , który przeglądarki mają tendencję do poniżej znajduje się również definicja znaczników czasu wykonanych w RFC 2822. Aktualna dokumentacja znajduje się na liście referencji na dole.

Od tego można oczekiwać podstawowej funkcjonalności, ale to ,co "powinno" być, nie jest z natury tym, co"jest". Mam zamiar trochę zagłębiać się w tym proceduralnie, ponieważ wydaje się, że tylko trzy osoby odpowiedziały na pytanie (Scott, goofballogic i peller mianowicie), co sugeruje, że większość ludzi nie wie, co naprawdę dzieje się podczas tworzenia obiektu daty.

Długa Odpowiedź

Gdzie znajduje się dokumentacja, która zawiera listę formatów obsługiwanych przez obiekt Date ()?

Aby odpowiedzieć na pytanie, lub zazwyczaj nawet szukać odpowiedzi na to pytanie, musisz wiedzieć, że javascript nie jest nowym językiem; jest to w rzeczywistości implementacja ECMAScript i jest zgodna ze standardami ECMAScript (ale zauważ, że javascript również jest wcześniej przestarzały standardy; standardy EMCAScript zbudowane są z wczesnej implementacji LiveScript/JavaScript). Obecny standard ECMAScript to 5.1( 2011); w czasie, gdy pytanie zostało pierwotnie zadane (Czerwiec '09), standard był 3 (4 został porzucony), ale 5 został wydany krótko po poście pod koniec 2009 roku. To powinno zarysować jeden problem; jaki standard implementacja javascript może naśladować, może nie odzwierciedlać tego, co faktycznie istnieje, ponieważ a) jest to implementacja danego standardu, b) nie wszystkie implementacje standardu są purytańskie, A C) funkcjonalność nie jest uwalniana w synchronizacji z nowym standardem jako D) implementacja jest stałą pracą w toku

Zasadniczo, gdy mamy do czynienia z javascript, mamy do czynienia z pochodną (javascript specyficzną dla przeglądarki) implementacji (samego javascript). Google V8, na przykład, implementuje ECMAScript 5.0, ale JScript Internet Explorera nie próbuje dostosować się do żadnego standardu ECMAScript, jeszcze Internet Explorer 9 jest zgodny z ECMAScript 5.0.

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

new Date(value)

Gdy dwa lub więcej argumentów są przekazywane do new Date (), to rzuca 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 kwantyfikuje jako akceptowalny "format daty", wymaga dalszych wyjaśnień. Kiedy przekazujesz łańcuch znaków do new Date (), będzie wywołanie prototypu (zauważ, że używam słowa prototype luźno; wersje mogą być pojedynczymi funkcjami lub mogą być częścią instrukcji warunkowej w pojedynczej funkcji) dla new Date(value) z Twoim łańcuchem jako argumentem parametru "value". Ta funkcja najpierw sprawdzi, czy jest to liczba, czy ciąg znaków. Dokumentację dla tej funkcji można znaleźć tutaj:

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

Z tego możemy wywnioskować, że aby uzyskać dozwolone formatowanie ciągu znaków dla nowej daty (wartości), musimy spojrzeć na metodę Date.parse (string). Dokumentację dla tej metody można znaleźć tutaj:

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

I możemy dalej wnioskować, że daty mają być w zmodyfikowanym formacie rozszerzonym ISO 8601, ponieważ podane tutaj:

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

Możemy jednak z doświadczenia rozpoznać, że obiekt javascript date akceptuje inne formaty (wymuszone przez istnienie tego pytania w pierwszej kolejności), i jest to w porządku, ponieważ ECMAScript pozwala na implementację określonych formatów. To jednak nadal nie odpowiada na pytanie, Jaka dokumentacja jest dostępna w dostępnych formatach, ani jakie formaty są właściwie to dozwolone. Mamy zamiar spojrzeć na implementację javascript Google, V8; proszę zauważyć, że nie sugeruję, że jest to" najlepszy "silnik javascript (jak można zdefiniować "najlepszy" lub nawet "dobry") i nie można założyć, że formaty dozwolone w V8 reprezentują wszystkie formaty dostępne dzisiaj, ale myślę, że można założyć, że postępują zgodnie z nowoczesnymi oczekiwaniami.

Google V8, Data.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 zauważyć, że " year "nie jest faktycznym rokiem i jest tylko odniesieniem do parametru" year".

Google V8, Data.js, DateParse

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

Wywołanie %DateParseString, która jest w rzeczywistości referencją funkcji w czasie wykonywania dla funkcji C++. Odnosi się do następującego kodu:

Google ' s V8, runtime.cc, % DateParseString

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

Wywołanie funkcji, którym zajmujemy się w tej funkcji jest dla DateParser:: Parse (); ignoruj logikę otaczającą te wywołania funkcji, są to tylko kontrole zgodności z typem kodowania (ASCII i UC16). DateParser:: Parse jest zdefiniowane 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 standard EMCASCRIPT 5.0 ISO 8601 i jeśli nie jest zgodny ze standardami, spróbuje zbudować datę w oparciu o starsze formaty. Kilka kluczowych punktów opartych na komentarze:

1. słowa przed pierwszą liczbą, które nie są znane parserowi, są ignorowane.
2. tekst w nawiasie jest ignorowany.
3. liczby niepodpisane, po których następuje": "są interpretowane jako"składnik czasu".
4. liczby niepodpisane, po których następuje "."są interpretowane jako "składnik czasu", po którym muszą następować milisekundy.
5. podpisane liczby, po których następuje godzina lub godzina minuty (np. +5:15 lub +0515) są interpretowane jako Strefa czasowa.
6. deklarując godzinę i minutę, możesz użyć "HH: mm" lub "hhmm".
7. słowa wskazujące strefę czasową są interpretowane jako strefa czasowa.
8. wszystkie inne 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 jak"+", " - " i niezrównane ")" nie są dozwolone po przetworzeniu numeru.
12. elementy, które pasują do wielu formatów (np. 1970-01-01)są przetwarzane jako zgodny ze standardem łańcuch EMCASCRIPT 5.0 ISO 8601.

Więc to powinno wystarczyć, aby dać ci podstawowe pojęcie, czego możesz się spodziewać, jeśli chodzi o przekazywanie ciągu znaków do obiektu Date. Możesz to jeszcze rozszerzyć, patrząc na poniższą specyfikację, którą Mozilla wskazuje na Mozilla Developer Network (zgodną z IETF RFC 2822 timestamps):

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

Microsoft Developer Network wymienia dodatkowo dodatkowy standard dla obiektu Date: ECMA-402, specyfikację ECMAScript Internationalization API, która jest komplementarna do standardu ECMAScript 5.1 (i przyszłych). Które można znaleźć tutaj:

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

W każdym razie powinno to pomoc w podkreślaniu, że nie ma "dokumentacji", która ogólnie reprezentuje wszystkie implementacje javascript, ale nadal jest wystarczająco dużo dokumentacji dostępnej, aby rozsądnie zrozumieć, jakie łańcuchy są akceptowalne dla obiektu Date. Całkiem niezłe pytanie, Kiedy się nad tym zastanowisz, prawda? : P

Referencje

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

Upewnij się, że checkout Datejs Gdy masz do czynienia z datami w JavaScript. Jest to dość imponujące i dobrze udokumentowane, jak widać w przypadku funkcji toString .

EDIT : Tyler Forsythe zwraca uwagę, że datejs jest przestarzały. Używam go w moim obecnym projekcie i nie miałem z nim żadnych problemów, jednak powinieneś być tego świadomy i rozważyć alternatywy.

Możesz po prostu rozwinąć obiekt Date za pomocą nowej metody format, jak zaznaczono przez meizz, Poniżej znajduje się kod podany przez autora. Oraz 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"));

Cytowana funkcjonalność nie jest standardowym Javascript, prawdopodobnie nie będzie przenośna w przeglądarkach, a zatem nie jest dobrą praktyką. Specyfikacja ECMAScript 3 pozostawia funkcje formatów parse i output aż do implementacji Javascript. ECMAScript 5 dodaje podzbiór obsługi ISO8601. Uważam, że funkcja toString (), o której wspominasz, jest innowacją w jednej przeglądarce (Mozilla?)

Kilka bibliotek zapewnia procedury parametryzacji, niektóre z rozbudowanymi obsługa lokalizacji. Możesz również sprawdzić metody w dojo.Data.locale .

Zrobiłem ten bardzo prosty formatter, jest cut / n / pastable (zaktualizowany o wersję neater):

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 free, limited but light

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 ten znacznie prostszy lib (JavaScript Date Format){[2] } który wolę po prostu dlatego, że to tylko 120 linii lub tak.

Po przejrzeniu kilku opcji podanych w innych odpowiedziach, postanowiłem napisać własne, ograniczone, ale proste rozwiązanie, które inni również mogą znaleźć 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, której często używam. Wynik to yyyy-mm-dd 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);
}

Użyteczna może okazać się ta modyfikacja obiektu date, która jest mniejsza niż jakakolwiek biblioteka i można ją łatwo rozbudować, aby obsługiwać różne formaty:

Uwaga:

• używa obiektu.keys () , która jest niezdefiniowana w starszych przeglądarkach, więc może być konieczne zaimplementowanie polyfill 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];
    });
};

Użyj

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-to 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 byłem w stanie znaleźć żadnej ostatecznej dokumentacji na temat ważnych formatów dat, więc napisałem własny test, aby zobaczyć, co jest obsługiwane w różnych przeglądarkach.

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

Moje wyniki wykazały, że następujące formaty są ważne we wszystkich przeglądarkach, które testowałem (przykłady używają daty "9 sierpnia 2013"):

[Pełny Rok]/[Miesiąc] / [numer daty] - miesiąc może być liczbą z wiodącym zerem lub bez niego lub nazwą miesiąca w krótki lub długi format, 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

[Month]/[Full Year]/[date Number] - miesiąc może być liczbą z zerem wiodącym lub bez, lub nazwą miesiąca w formacie krótkim lub długim, a Numer daty może być z zerem wiodącym lub bez niego.

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

Każda kombinacja [pełny rok], [nazwa miesiąca] i [numer daty] oddzielona spacjami - nazwa miesiąca może być w formacie krótkim lub długim, a Numer daty może być z lub bez zera wiodącego.

• 2013 Sierpień 09
• Sierpień 2013 09
• 09 Sierpień 2013
• 2013 Aug 09
• 9 sierpnia 2013
• 2013 9 Sie
• itd...

Również ważne w "nowoczesnych przeglądarkach" (lub innymi słowy we wszystkich przeglądarkach z wyjątkiem IE9 i poniżej)

[pełny rok]-[Numer miesiąca]-[numer daty] - numer miesiąca i Daty musi zawierać początkowe zera (jest to format używany przez typ daty MySQL)

• 2013-08-09

Używanie nazw miesięcy:
Co ciekawe, przy użyciu nazwy miesięcy odkryłem, że tylko pierwsze 3 znaki nazwy miesiąca są kiedykolwiek używane, więc wszystkie z poniższych 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ć bólem głowy. Nie wszystkie przeglądarki obsługują daty w ten sam sposób. Tak więc, chociaż warto znać podstawowe metody, bardziej praktyczne jest użycie biblioteki pomocniczej.

Xdate javascript libraryby Adam Shaw istnieje od połowy 2011 roku i jest nadal aktywnie rozwijany. Ma fantastyczną dokumentację, świetne API, formatowanie, stara się pozostać wstecznie kompatybilne, a nawet obsługuje zlokalizowane struny.

Link do zmiany łańcuchów locale: https://gist.github.com/1221376

Przykładowy kod:

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

Wyjście:

"13:45:20"

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

Sugar daje klasie Date dużo miłości począwszy od daty.Utwórz metoda, która może zrozumieć daty w prawie każdym formacie w 15 głównych języków, w tym formatów względnych jak "1 hour ago". Daty mogą również być wyprowadzane w dowolnym formacie lub języku za pomocą łatwego do zrozumienia składnia, ze skrótami do powszechnie używanej daty formaty. Data złożona porównanie jest również możliwe z metodami takimi jak is, które rozumieją wszelkie sformatuj i zastosuj 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"

Kolejna opcja, którą napisałem:

Biblioteka DP_DateExtensions

Nie wiem, czy to pomoże, ale znalazłem to przydatne w kilku projektach-wygląda na to, że zrobi to, czego potrzebujesz.

Obsługuje formatowanie daty/czasu, matematykę daty( dodawanie / odejmowanie części daty), porównywanie daty, parsowanie daty itp. Jest szeroko rozpowszechniony.

Nie ma powodu, aby wziąć to pod uwagę, jeśli już używasz frameworka( wszystkie są w stanie), ale jeśli potrzebujesz tylko szybko dodać manipulację datą do projektu daj mu szansę.

Wszystkie przeglądarki

Najbardziej niezawodnym sposobem sformatowania daty za pomocą używanego formatu źródłowego jest zastosowanie następujących kroków:]}

1. Użyj new Date(), aby utworzyć Date obiekt
2. użycie .getDate(), .getMonth() i .getFullYear(), aby uzyskać odpowiednio dzień, miesiąc i rok
3. Wklej elementy razem zgodnie z docelowym formatem

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 this Fiddle).

Nowoczesny tylko przeglądarki

Możesz również użyć wbudowanej metody .toLocaleDateString, aby wykonać formatowanie za Ciebie. Wystarczy przekazać 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 this Fiddle).

(*) według MDN, "nowoczesne przeglądarki" czyli Chrome 24+, Firefox 29+, IE11, Edge12+, Opera 15+ i Safari nightly build

Poprawnym sposobem sformatowania daty powrotu "2012-12-29" jest skrypt z JavaScript Date Format:

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

Ten kod nie działa:

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

Jeśli chcesz pokazać tylko czas z dwoma cyframi , może Ci 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()

Zobacz poniższy link, aby uzyskać więcej informacji https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat jest biblioteką, która może formatować obiekt date i analizować sformatowany łańcuch znaków z powrotem do obiektu Date. Używa formatu Java (Klasa SimpleDateFormat). Nazwy miesięcy i dni mogą być zlokalizowane.

Przykład:

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

Jeśli nie potrzebujesz wszystkich funkcji, które biblioteka lubi .js zapewnia, wtedy możesz użyć mojego portu strftime . Jest lekki (1.35 KB vs. 57.9 KB minified w porównaniu do chwili.js 2.15.0) i dostarcza większość funkcjonalności 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

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

"Zawartość łańcucha jest zależna od implementacji"

Funkcje takie jak poniższe przykłady może być używany do dość łatwego formatowania.

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

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

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

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 wynika z tego, że znacznik czasu javascript jest w milisekundach, ale znacznik czasu PHP jest w sekundach.

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

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

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