JavaScript'in new Date()işlevinin tarihleri ​​çeşitli formatlarda kabul etmede çok akıllı olduğunu fark ettim .

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

new Date()İşlev çağrılırken tüm geçerli dize biçimlerini gösteren hiçbir yerde belge bulamadım .

Bu, bir dizeyi tarihe dönüştürmek içindir. Karşı tarafa bakarsak, yani bir tarih nesnesini bir dizeye dönüştürürsek, şimdiye kadar JavaScript'in bir tarih nesnesini bir dizeye biçimlendirmek için yerleşik bir API'ye sahip olmadığı izlenimindeydim.

Editörün notu: Aşağıdaki yaklaşım belirli bir tarayıcı üzerinde çalıştı fakat yaptığı asker Nickli Üyenin girişimidir değil , genel anlamda iş; bazı gerçek çözümleri görmek için bu sayfadaki cevaplara bakın.

Bugün, toString()date nesnesindeki yöntemle oynadım ve şaşırtıcı bir şekilde, tarihi dizelere biçimlendirme amacına hizmet ediyor.

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

Ayrıca burada tarih nesnesini bir dizeye biçimlendirebileceğimiz tüm yollarla ilgili herhangi bir belge bulamadım.

Date()Nesne tarafından desteklenen biçim belirleyicilerini listeleyen belgeler nerede ?

JavaScript kullanarak ve Tarihlerle Çalışmak için saat ve tarihi biçimlendirmenin 10 yolunu seviyorum .

Temel olarak, üç yönteminiz var ve dizeleri kendiniz birleştirmeniz gerekiyor:

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

Misal:

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

Tarihleri ​​ayrıştırmak, değiştirmek ve biçimlendirmek için bir (hafif) * JavaScript tarih kütüphanesidir.

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"

(*) hafif anlamı 9.3KB küçültülmüş + mümkün olan en küçük kurulumda sıkıştırılmış (Şubat 2014)

Projenizde zaten jQuery kullanıcı arayüzü kullanıyorsanız , tarih nesnenizi biçimlendirmek için yerleşik datepicker yöntemini kullanabilirsiniz:

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

Ancak, tarih seçici yalnızca tarihleri ​​biçimlendirir ve saatleri biçimlendiremez.

Örnekler olan jQuery UI tarih seçici formatına bir göz atın .

Date()Nesne tarafından desteklenen biçim belirleyicilerini listeleyen belgeler nerede ?

Bugün bununla karşılaştım ve kimsenin bu basit soruyu cevaplamak için zaman ayırmadığına oldukça şaşırdım. Doğru, tarih manipülasyonuna yardımcı olacak birçok kütüphane var. Bazıları diğerlerinden daha iyidir. Ama sorulan soru bu değildi.

AFAIK, saf JavaScript, format belirleyicilerini kullanmak istediğinizi belirttiğiniz şekilde desteklemez . Ama örneğin tarihleri ve / veya süreleri, biçimlendirme için destek yöntemlerini yapar .toLocaleDateString(), .toLocaleTimeString()ve.toUTCString() .

DateBen en sık kullandığınız nesne referansı üzerindedir w3schools.com web (ama hızlı bir Google araması ihtiyaçlarınızı daha iyi karşılayabilir daha çok fazlası ortaya çıkaracaktır).

Tarih Nesnesi Özellikleri bölümünün prototype, Date nesnesini özel yöntemlerle genişletmenin bazı yollarını gösteren bir bağlantı sağladığını da unutmayın . Olmamıştır bazı tartışmalar olsa da olmasa bu konuda yıllardır JavaScript toplumda en iyi uygulamadır ve sadece varlığını işaret ederek, yoksa bunun karşısında savunuyor değilim.

Özel biçimlendirme işlevi:

Sabit formatlar için basit bir işlev işi yapar. Aşağıdaki örnek YYYY-AA-GG uluslararası formatını oluşturur:

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

Not: Bununla birlikte, Javascript standart kitaplıklarını genişletmek genellikle iyi bir fikir değildir (örneğin, bu işlevi Tarih prototipine ekleyerek).

Daha gelişmiş bir işlev, format parametresini temel alarak yapılandırılabilir çıktı oluşturabilir. Aynı sayfada birkaç iyi örnek var.

Biçimlendirme işlevi yazmak çok uzunsa, çevresinde çok sayıda kitaplık vardır. Bazı cevaplar zaten onları numaralandırıyor. Ancak artan bağımlılıklar da buna ters düşmektedir.

Standart ECMAScript formatlama fonksiyonları:

ECMAscript'in daha yeni sürümlerinden bu yana, Datesınıfın bazı belirli biçimlendirme işlevleri vardır:

toDateString : Uygulamaya bağımlıdır, yalnızca tarihi gösterir.

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 : ISO 8601 tarih ve saatini göster.

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 : JSON için stringifier.

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 : Uygulamaya bağlı, yerel ayar biçimindeki bir tarih.

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

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

toLocaleString : Uygulamaya bağlı, yerel ayar biçiminde bir tarih ve saat.

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 : Uygulamaya bağlı, yerel ayar biçiminde bir zaman.

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

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

: Tarih için Genel toString.

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

Not: Bu biçimlendirme işlevlerinden özel çıktı oluşturmak mümkündür:

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

Kısa Cevap

Javascript'in sunduğu “evrensel” bir belge yoktur; javascript olan her tarayıcı gerçekten bir uygulamadır. Ancak, çoğu modern tarayıcının takip etme eğilimi olan bir standart vardır ve bu EMCAScript standardıdır; ECMAScript standart dizeleri, ISO 8601 tanımının en azından değiştirilmiş bir uygulamasını alacaktır.

Buna ek olarak, IETF tarafından tarayıcıların da takip etme eğiliminde olduğu ikinci bir standart vardır, bu da RFC 2822'de yapılan zaman damgalarının tanımıdır. Gerçek belgeler, alttaki referanslar listesinde bulunabilir.

Bundan temel işlevsellik bekleyebilirsiniz, ancak “olması gereken” doğal olarak “ne” değildir. Bununla birlikte, prosedürel olarak biraz derinlemesine gideceğim, çünkü sadece üç kişi aslında soruyu yanıtladı (Scott, goofballLogic ve peller), ki bana göre, çoğu insanın aslında ne zaman olduğunun farkında olmadığını gösteriyor bir Date nesnesi yarat.

Uzun Cevap

Date () nesnesi tarafından desteklenen format belirteçlerini listeleyen belgeler nerede?

Soruyu cevaplamak veya genellikle bu sorunun cevabını aramak için, javascript'in yeni bir dil olmadığını bilmeniz gerekir; aslında ECMAScript'in bir uygulamasıdır ve ECMAScript standartlarını takip eder (ancak, javascript aslında bu standartlardan da önce gelir; EMCAScript standartları LiveScript / JavaScript'in erken uygulanmasından oluşur). Mevcut ECMAScript standardı 5.1 (2011); sorunun asıl sorulduğu sırada (Haziran '09), standart 3'dü (4 terk edildi), ancak 5 2009 sonunda görevden kısa bir süre sonra serbest bırakıldı. Bu bir sorunun ana hatlarını çizmeli; bir javascript uygulamasının hangi standardı takip edebileceği, gerçekte mevcut olanı yansıtmayabilir, çünkü a) belirli bir standardın uygulamasıdır, b) bir standardın tüm uygulamaları püriten değildir,

Temel olarak, javascript ile uğraşırken, bir uygulamanın (javascript'in kendisi) bir türevi (tarayıcıya özgü javascript) ile uğraşıyorsunuz. Google'ın V8'i, örneğin, ECMAScript 5.0'ı uygular, ancak Internet Explorer'ın JScript'i herhangi bir ECMAScript standardına uymaya çalışmaz, ancak Internet Explorer 9 ECMAScript 5.0'a uygundur.

Yeni Date () öğesine tek bir argüman iletildiğinde, bu işlev prototipini verir:

new Date(value)

Yeni Date () öğesine iki veya daha fazla argüman iletildiğinde, bu işlev prototipini yayınlar:

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

Bu işlevlerin her ikisi de tanıdık gelmelidir, ancak bu hemen sorunuza cevap vermez ve kabul edilebilir bir “tarih formatı” olarak neyin nicelendirildiğini daha fazla açıklama gerektirir. (Kelimesini kullanıyorum o notu siz) yeni tarihi (bir dize geçtiğinizde, bu prototip arayacak prototipi ; versiyonları bireysel fonksiyonları olabilir veya tek bir işlevde bir koşullu ifadenin parçası olabilir gevşek) için “value” parametresi için bağımsız değişken olarak dizenizle yeni Date (değer) . Bu işlev önce bir sayı mı yoksa dize mi olduğunu kontrol edecektir. Bu işlevin belgelerini burada bulabilirsiniz:

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

Bundan, yeni Date (değer) için dize biçimlendirmesine izin vermek için Date.parse (string) yöntemine bakmamız gerektiğini çıkarabiliriz. Bu yöntemin belgelerini burada bulabilirsiniz:

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

Ayrıca, tarihlerin burada belirtildiği gibi değiştirilmiş bir ISO 8601 Genişletilmiş Biçiminde olması beklenebilir:

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

Bununla birlikte, javascript'in Date nesnesinin (bu sorunun ilk etapta varlığıyla zorunlu kılınan) diğer formatları kabul ettiğini deneyimlerden anlayabiliriz ve ECMAScript uygulamaya özel formatlara izin verdiğinden bu sorun olmaz. Bununla birlikte, bu hala mevcut biçimlerde hangi belgelerin mevcut olduğu veya hangi biçimlere gerçekten izin verildiği sorusuna cevap vermez. Google'ın javascript uygulamasına (V8) bakacağız; Lütfen bunun "en iyi" javascript motoru olduğunu önermiyorum (biri "en iyi" veya hatta "iyi" olarak nasıl tanımlanabilir) ve V8'de izin verilen biçimlerin bugün mevcut olan tüm biçimleri temsil ettiğini varsayamam, ancak bunun adil olduğunu düşünüyorum modern beklentileri takip ettiklerini varsaymak.

Google'ın V8, date.js, DateConstructor

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

DateConstructor işlevine baktığımızda, DateParse işlevini bulmamız gerektiğini belirleyebiliriz; ancak, “yıl” ın gerçek yıl olmadığını ve yalnızca “yıl” parametresine referans olduğunu unutmayın.

Google'ın V8, date.js, DateParse

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

Bu, aslında bir C ++ işlevi için çalışma zamanı işlev başvurusu olan% DateParseString öğesini çağırır. Aşağıdaki kodu ifade eder:

Google'ın V8, runtime.cc,% DateParseString

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

Bu işlevde ilgilendiğimiz işlev çağrısı DateParser :: Parse (); bu fonksiyon çağrılarını çevreleyen mantığı yok sayın, bunlar sadece kodlama türüne (ASCII ve UC16) uygunluk kontrolleridir. DateParser :: Ayrıştırma burada tanımlanmıştır:

Google'ın V8, dateparser-inl.h, DateParser :: Ayrıştırma

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

Bu, hangi formatları kabul ettiğini gerçekten tanımlayan işlevdir. Esasen, EMCAScript 5.0 ISO 8601 standardını kontrol eder ve standartlarla uyumlu değilse, tarihi eski formatlara göre oluşturmaya çalışır. Yorumlara dayanan birkaç önemli nokta:

1. Ayrıştırıcı tarafından bilinmeyen ilk sayıdan önceki sözcükler yoksayılır.
2. Parantez içine alınmış metin yoksayılır.
3. İmzasız numaralar ve ardından “:”, “zaman bileşeni” olarak yorumlanır.
4. İmzasız numaralar ve ardından “.” "zaman bileşeni" olarak yorumlanır ve bunu milisaniye takip etmelidir.
5. İmzalı numaralar ve ardından saat veya saat dakikası (örn. +5: 15 veya +0515) saat dilimi olarak yorumlanır.
6. Saati ve dakikayı bildirirken "ss: dd" veya "ssd" kullanabilirsiniz.
7. Bir saat dilimini gösteren kelimeler bir saat dilimi olarak yorumlanır.
8. Diğer tüm sayılar “tarih bileşenleri” olarak yorumlanır.
9. Bir ayın ilk üç basamağıyla başlayan tüm kelimeler ay olarak yorumlanır.
10. Dakikaları ve saatleri birlikte şu iki formattan birinde tanımlayabilirsiniz: “ss: dd” veya “ssmm”.
11. Bir sayı işlendikten sonra “+”, “-“ ve eşleşmeyen “)” gibi sembollere izin verilmez.
12. Birden çok formatla eşleşen öğeler (örn. 1970-01-01) standart uyumlu EMCAScript 5.0 ISO 8601 dizesi olarak işlenir.

Bu nedenle, bir Date nesnesine bir dize geçirme konusunda ne bekleyebileceğiniz konusunda temel bir fikir vermek için bu yeterli olmalıdır. Mozilla'nın Mozilla Geliştirici Ağı'nda (IETF RFC 2822 zaman damgalarıyla uyumlu) işaret ettiği aşağıdaki spesifikasyona bakarak bunu daha da genişletebilirsiniz:

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

Microsoft Developer Network ek olarak Date nesnesi için ek bir standarttan bahsetmektedir: ECMA-402, ECMAScript Uluslararasılaşma API Spesifikasyonu, ECMAScript 5.1 standardını (ve gelecekteki). Burada bulunabilir:

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

Her durumda, bu, evrensel olarak tüm javascript uygulamalarını temsil eden bir "belge" olmadığını vurgulamaya yardımcı olmalıdır, ancak bir Date nesnesi için hangi dizelerin kabul edilebilir olduğuna dair makul bir anlam elde etmek için hala yeterli belge vardır. Düşündüğünüzde oldukça yüklü soru, değil mi? : P

Referanslar

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

kaynaklar

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

JavaScript'teki tarihlerle uğraşırken Datejs'i kontrol ettiğinizden emin olun . ToString işlevi durumunda görebileceğiniz gibi oldukça etkileyici ve iyi belgelenmiştir .

EDIT : Tyler Forsythe işaret ediyor, o datejs modası geçmiş. Mevcut projemde kullanıyorum ve herhangi bir sorun yaşamadım, ancak bunun farkında olmalı ve alternatifleri düşünmelisiniz.

DateObject'i meizzformat tarafından not edildiği gibi yeni bir yöntemle genişletebilirsiniz , aşağıda yazar tarafından verilen kod bulunmaktadır. Ve işte bir 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"));

Alıntı yaptığınız işlevsellik standart Javascript değildir, tarayıcılar arasında taşınabilir olması muhtemel değildir ve bu nedenle iyi bir uygulama değildir. ECMAScript 3 Spec yapraklar ayrıştırma ve çıkış biçimleri JavaScript uygulanmasına kadar çalışır. ECMAScript 5 , ISO8601 desteğinin bir alt kümesini ekler. Bahsettiğiniz toString () işlevinin bir tarayıcıda (Mozilla?) Bir yenilik olduğuna inanıyorum

Birçok kütüphane bunu parametreleştirmek için rutin programlar sunar, bazıları da kapsamlı yerelleştirme desteğine sahiptir. Ayrıca dojo.date.locale içindeki yöntemleri de kontrol edebilirsiniz .

Bu çok basit biçimlendiriciyi yaptım, kesilmiş / n / yapıştırılabilir (daha temiz sürümle güncellendi):

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/

Çerçevesiz, sınırlı ancak hafif

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 kesinlikle tam özellikli, ama sadece 120 satır ya da öylesine çünkü tercih ettiğim bu ÇOK daha basit lib (JavaScript Tarih Formatı) tavsiye ederim.

Diğer cevaplarda sunulan seçeneklerin birkaçını inceledikten sonra, başkalarının da faydalı bulabileceği kendi sınırlı ama basit çözümümü yazmaya karar verdim.

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

Örnek kullanım:

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

İşte çok kullandığım bir fonksiyon. Sonuç yyyy-aa-gg ss: dd: ss.nnn'dir.

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

Herhangi bir kitaplıktan daha küçük olan ve farklı formatları desteklemek için kolayca genişletilebilen tarih nesnesinin bu şekilde değiştirilmesini yararlı bulabilirsiniz:

NOT:

• Eski tarayıcılarda tanımsız olan Object.keys () öğesini kullanır , böylece verilen bağlantıdan çoklu dolguyu uygulamanız gerekebilir.

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

KULLANIM

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

Sadece gongzhitaao'nun sağlam cevabına devam etmek - bu AM / PM'yi ele alıyor

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

Geçerli tarih biçimleriyle ilgili kesin bir belge bulamadım, bu yüzden çeşitli tarayıcılarda nelerin desteklendiğini görmek için kendi testimi yazdım.

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

Sonuçlarım aşağıdaki biçimlerin test ettiğim tüm tarayıcılarda geçerli olduğu sonucuna vardı (örnekler "9 Ağustos 2013" tarihini kullanıyor):

[Tam Yıl] / [Ay] / [Tarih numarası] - Ay, başında sıfır olan veya olmayan sayı veya ay adı kısa veya uzun biçiminde olabilir ve tarih numarası, önde gelen sıfırlı veya sıfırsız olabilir.

• 2013/08/09
• 2013/08/09
• 2013/08/09
• 2013/08/09
• 2013 / Ağustos / 09
• 2013 / Ağustos / 9
• 2013 / Ağustos / 09
• 2013 / Ağustos / 9

[Ay] / [Tam Yıl] / [Tarih Numarası] - Ay, başında sıfır olan veya olmayan sayı veya kısa veya uzun biçimde ay adı olabilir ve tarih numarası, önde gelen sıfırlı veya sıfırsız olabilir.

• 08/2013/09
• 08/2013/9
• 8/2013/09
• 8/2013/9
• Ağustos / 2013/09
• Ağustos / 2013/9
• Ağustos / 2013/09
• Ağustos / 2013/9

[Tam Yıl], [Ay Adı] ve [Tarih Numarası] öğelerinin boşluklarla ayrılmış herhangi bir kombinasyonu - Ay adı kısa veya uzun biçiminde olabilir ve tarih numarası başında sıfır ile veya sıfır olmadan olabilir.

• 09 Ağustos 2013
• Ağustos 2013 09
• 09 Ağustos 2013
• 09 Ağu 2013
• 9 Ağu 2013
• 9 Ağustos 2013
• vb...

"Modern tarayıcılarda" (veya başka bir deyişle IE9 ve altı dışındaki tüm tarayıcılarda) da geçerlidir

[Tam Yıl] - [Ay Numarası] - [Tarih Numarası] - Ay ve Tarih Numarası baştaki sıfırları içermelidir ( MySQL Tarih türünün kullandığı biçimdir )

• 2013/08/09

Ay adlarını kullanma:
İlginç bir şekilde, ay adlarını kullanırken ay adının yalnızca ilk 3 karakterinin kullanıldığını keşfettim, böylece aşağıdakilerin hepsi mükemmel şekilde geçerli:

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

JavaScript'te tarihleri ​​biçimlendirme ve özellikle ayrıştırma biraz baş ağrısı olabilir. Tüm tarayıcılar tarihleri ​​aynı şekilde işlemez. Bu yüzden temel yöntemleri bilmek yararlı olsa da, bir yardımcı kütüphane kullanmak daha pratiktir.

XDate javascript kütüphanesi tarafından Adam Shaw 2011 yılının ortalarında bu yana yaklaşık edilmiş ve aktif hala geliştirilme aşamasındadır olmuştur. Harika belgelere, harika bir API'ye, biçimlendirmeye, geriye dönük olarak uyumlu kalmaya çalışır ve hatta yerelleştirilmiş dizeleri destekler.

Yerel ayar dizelerini değiştirme bağlantısı: https://gist.github.com/1221376

Örnek kod:

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

Çıktı:

"13:45:20"

Sugar.js kütüphanesi , JavaScript ile tarihlerle çalışmak için harika bir işleve sahiptir. Ve çok iyi belgelenmiştir .

Sugar Date sınıfına Date.create yöntemiyle başlayan ve "1 saat önce" gibi bağıl biçimler de dahil olmak üzere 15 büyük dilde hemen hemen her formatta tarihleri ​​anlayabilen çok sevgi verir. Tarihler, yaygın olarak kullanılan tarih biçimlerine kısayollarla anlaşılması kolay bir sözdizimi kullanılarak herhangi bir biçimde veya dilde de çıktılanabilir. Herhangi bir formatı anlayan ve yerleşik hassasiyeti uygulayan is gibi yöntemlerle karmaşık tarih karşılaştırması da mümkündür.

Birkaç örnek:

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"

Tüm tarayıcılar

Bir tarihi, kullandığınız kaynak biçimiyle biçimlendirmenin en güvenilir yolu, aşağıdaki adımları uygulamaktır:

1. Nesne new Date()oluşturmak için kullanınDate
2. Kullanın .getDate(), .getMonth()ve .getFullYear()gün, ay ve yılı sırasıyla almak
3. Parçaları hedef biçiminize göre birbirine yapıştırın

Misal :

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

(Ayrıca bu Fiddle'a bakın ).

Yalnızca modern tarayıcılar

.toLocaleDateStringBiçimlendirmeyi sizin yerinize yapmak için yerleşik yöntemi de kullanabilirsiniz . Maalesef sadece modern tarayıcılar (*) tarafından desteklenen doğru formatla eşleşmesi için uygun yerel ayar ve seçeneklerden geçmeniz yeterlidir :

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

(Ayrıca bu Fiddle'a bakın ).

(*) MDN'ye göre "Modern tarayıcılar", Chrome 24+, Firefox 29+, IE11, Edge12 +, Opera 15+ ve Safari gecelik yapıları anlamına gelir

Yazdığım sadece başka bir seçenek:

DP_DateExtensions Kütüphanesi

Yardım edip etmeyeceğinden emin değilim, ancak birkaç projede yararlı buldum - ihtiyacınız olanı yapacak gibi görünüyor.

Tarih / saat biçimlendirme, tarih matematik (tarih bölümlerini ekleme / çıkarma), tarih karşılaştırma, tarih ayrıştırma, vb destekler.

Zaten bir çerçeve kullanıyorsanız (hepsi yetenekli), ancak bir projeye hızlı bir şekilde tarih manipülasyonu eklemeniz gerekiyorsa, bunu bir şans verin.

Yalnızca iki basamaklı zamanı göstermek istiyorsanız , bu size yardımcı olabilir:

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

bu işlevleri kullan

toTimeString() and toLocaleDateString()

daha fazla ayrıntı için aşağıdaki bağlantıya bakın https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date

JsSimpleDateFormat , tarih nesnesini biçimlendirebilen ve biçimlendirilmiş dizeyi Date nesnesine geri çözümleyebilen bir kitaplıktır. Java biçimini (SimpleDateFormat sınıfı) kullanır. Ayların ve günlerin adı yerelleştirilebilir.

Misal:

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

Tarih biçimlendirme özel işlevsellik olduğu için yanıt "hiçbir yerde" değildir. ToString işlevlerinin belirli bir formata uygun olduğunu düşünmüyorum. örneğin ECMAScript 5.1 spesifikasyonunda ( http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , 2/8/2013, sayfa 173), toString işlevi aşağıdaki gibi belgelenmiştir :

"Dizenin içeriği uygulamaya bağlıdır"

Aşağıdaki örnekler gibi işlevler, biçimlendirmeyi oldukça kolay bir şekilde gerçekleştirmek için kullanılabilir.

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

Moment.js gibi bir kütüphanenin sağladığı tüm özelliklere ihtiyacınız yoksa , strftime portumu kullanabilirsiniz . Hafiftir (Moment.js 2.15.0'a kıyasla küçültülmüş 1,35 KB vs. 57,9 KB) ve işlevselliğinin çoğunu sağlar 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;
  });
}

Örnek kullanım:

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"

En son kodu burada bulabilirsiniz: https://github.com/thdoan/strftime

Bir tarihi "2012-12-29" döndürecek şekilde biçimlendirmenin doğru yolu, JavaScript Tarih Biçimi'nden komut dosyasıdır :

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

Bu kod çalışmaz:

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

Şahsen, hem PHP hem de jQuery / javascript'i eşit ölçülerde kullandığım için php.js'den date fonksiyonunu kullanıyorum http://phpjs.org/functions/date/

Zaten bildiğim bir şeyle aynı biçim dizelerini kullanan bir kütüphane kullanmak benim için daha kolay ve tarih işlevi için tüm biçim dizesi olanaklarını içeren kılavuz elbette php.net adresinde çevrimiçi

Date.js dosyasını HTML'nize tercih ettiğiniz yöntemi kullanarak eklemeniz yeterlidir, ardından şu şekilde adlandırın:

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

İsterseniz valueOf () yerine d1.getTime () kullanabilirsiniz, aynı şeyi yaparlar.

Javascript zaman damgasının 1000'e bölünmesi, bir javascript zaman damgasının milisaniye cinsinden olması, ancak bir PHP zaman damgasının saniyeler içinde olmasıdır.

Birçok çerçeve (zaten kullanıyor olabilirsiniz), farkında olmayabileceğiniz tarih biçimlendirmesine sahiptir. jQueryUI'den daha önce bahsedilmişti, ancak Kendo UI (Küreselleşme) , Yahoo UI (Util) ve AngularJS gibi diğer çerçeveler de bunlara sahip.

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

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