A Date objektum lehetővé teszi a dátumok és időpontok kezelését. A következő szintaxist használjuk egy új dátum objektum létrehozásához:

Új dátum ()

A dátumokat az univerzális idő (UTC) szerint, 1970. január 1. éjfél óta eltelt ezredmásodpercben tárolja. Ezzel a formátummal a Dátum pontosan tud olyan dátumokat ábrázolni, amelyek 1970. január 1-jétől számítva 285 616 év.

Ha a Date konstruktort argumentumok nélkül hívják meg, akkor egy objektum jön létre az aktuális dátum- és időértékekkel. Egy adott dátummal vagy időponttal rendelkező Dátum objektum létrehozásához meg kell adnia a négy lehetséges paraméter egyikét:

• milliszekundum: az értéknek az 1970.01.01. óta eltelt ezredmásodperceknek kell lennie. var birthDate = new Date (8298400000); document.write (születési dátum);
• dátum karakterlánc: bármely dátum a parse () metódus által támogatott formátumban. var birthDate = new Date ("1975. április 16."); document.write (születési dátum);
• év, hónap, nap var birthDate = new Date (1975, 4, 28); document.write (születési dátum);

  Felhívjuk figyelmét, hogy a 4-es szám május hónapnak felel meg. Ez azt jelenti, hogy a 0 szám a januárnak felel meg.A napok kiszámítása ugyanúgy történik, csak a nulla ebben az esetben a vasárnapnak felel meg.

• év, hónap, nap, óra, perc, másodperc, ezredmásodperc

Amikor egy Dátum objektummal dolgozik, ne feledje, hogy a számításokat a koordinált világidő (UTC) használatával hajtják végre, még akkor is, ha a számítógép az időt az időzónának megfelelően jelenítheti meg.

Mód

Módszer	Leírás
getDate ()	A hónap napját (1-től 31-ig) adja vissza a megadott dátumhoz, helyi idő szerint.
getDay ()	A hét napját adja vissza (0-tól 6-ig; 0 = vasárnap, 1 = hétfő stb.) a megadott dátumhoz, helyi idő szerint.
getFullYear ()	Az évet adja vissza (négy számjegy).
getHours ()	Az órát adja vissza (0-tól 23-ig).
get Milliseconds ()	Ezredmásodperceket ad vissza (0-tól 999-ig).
getMinutes ()	Perceket ad vissza (0-tól 59-ig).
get Month ()	A hónapot adja vissza (0-tól 11-ig; 0 = január, 1 = február stb.).
getSeconds ()	A másodperceket adja vissza (0 és 59 között).
getTime ()	Az 1970. 01. 01. éjfél óta eltelt ezredmásodpercek számát adja vissza.
getTimezoneOffset ()	Az UTC és a helyi idő közötti időkülönbséget adja vissza percben.
getUTCDate ()	A hónap UTC napját adja vissza (1-től 31-ig).
getUTCDay ()	A hét napját adja vissza az egyetemes idő szerint (0-tól 6-ig).
getUTCFullYear ()	Az UTC évet adja vissza (négy számjegy).
getUTCHours ()	Az UTC órát adja vissza (0-tól 23-ig).
getUTCMilliseconds ()	Ezredmásodperc UTC értéket ad vissza (0-tól 999-ig).
getUTCMutes ()	UTC-ben (0–59) perceket ad vissza.
getUTCMonth ()	A hónapot adja vissza UTC-ben (0-tól 11-ig).
getUTCSeconds ()	A másodperceket adja vissza UTC-ben (0-tól 59-ig).
elemzés ()	Elemez egy dátumkarakterláncot (például "1992. május 21."), és egy olyan dátumkarakterláncot ad vissza, amely az 1970. január 1. 00:00:00 óta eltelt szám ezredmásodpercben tartalmazza.
dátum beállítása ()	Beállítja a hónap napját a megadott dátumhoz, helyi idő szerint (1-től 31-ig).
setFullYear ()	Beállítja az évet (négy számjegy).
setHours ()	Beállítja az órát a megadott dátumra a helyi idő szerint (0-tól 23-ig).
set Milliseconds ()	Beállítja az ezredmásodperceket a megadott dátumhoz, helyi időhöz.
setMinutes ()	Beállítja a perceket (0 és 59 között).
set Month ()	Beállítja a hónapot (0-tól 11-ig).
setSeconds ()	Beállítja a másodperceket (0-tól 59-ig).
beállítani az időt ()	Beállítja a dátumot ezredmásodpercben 1970.01.01. után (vagy előtte).
setUTCDate ()	Meghatározza a hónap napját.
setUTCFullYear ()	Beállítja az évet az egyetemes idő szerint (négy számjegy).
setUTCHours ()	Beállítja az órát a megadott dátumhoz, UTC.
setUTCM milliszekundum ()	Beállítja az ezredmásodperceket a megadott dátumhoz, UTC.
setUTCMutes ()	Beállítja a perceket a megadott dátumhoz, UTC.
setUTCMhónap ()	Beállítja a hónapot a megadott dátumhoz, UTC.
setUTCSeconds ()	Beállítja a másodperceket a megadott dátumhoz, UTC.
toDateString ()
to ISOString ()	Az ISO 8601 szabvány szerint egy dátumot karakterláncsá alakít át.
to JSON ()	A dátumot karakterláncként adja vissza, JSON-dátumként formázva.
toLocaleDateString ()
toLocaleTimeString ()	A dátum egy részét karakterláncként adja vissza, a dátum rendszerparamétereken alapuló reprezentációjával.
toLocaleString ()	A dátumot karakterláncként adja vissza, rendszerparamétereken alapuló dátumábrázolással.
toString ()	Egy karakterláncot ad vissza, amely a megadott dátum objektumot reprezentálja.
toTimeString ()	A dátum egy részét karakterláncként adja vissza.
toUTCSkarakterlánc ()	A dátumot karakterláncsá alakítja az UTC időzóna használatával.
UTC ()	Ugyanazokat a paramétereket veszi fel, mint a konstruktor hosszú formája (azaz 2-7), és az 1970. január 1., 00:00:00 UTC óta eltelt ezredmásodpercek számát adja vissza.
értéke ()	Egy Date objektum primitív értékét adja vissza.

A dátum és az idő a mi programunk része Mindennapi életés ezért előkelő helyen szerepel a programozásban. A JavaScriptben, amikor egy webhelyet készít, érdemes lehet naptárat, vonatmenetrendet vagy egy találkozó-ütemezési felületet hozzáadni. Ezeknek az alkalmazásoknak meg kell jeleníteniük a megfelelő időpontokat a felhasználó aktuális időzónája alapján, vagy számításokat kell végezniük a repülőgép érkezésével és indulásával, vagy egy esemény kezdési és befejezési idejével kapcsolatban. Ezenkívül előfordulhat, hogy JavaScriptet kell használnia a napi jelentések küldéséhez pontos idő vagy szűréshez (például adott időpontban nyitva tartó éttermek kereséséhez).

Dátum objektum

A dátum szövegben van JavaScript objektum amely a dátumot és az időt tárolja. Számos beépített módszert biztosít ezen adatok formázásához és kezeléséhez.

Alapértelmezés szerint egy új, argumentumok nélküli dátumpéldány létrehoz egy objektumot az aktuális dátummal és időponttal rendszerbeállítások jelenlegi számítógép.

Például próbálja meg hozzárendelni az aktuális dátumot egy változóhoz. Hozzon létre egy fájlt most.js.

// Változó beállítása az aktuális dátumra és időre
const most = új dátum ();
// A kimenet megtekintése
Most;
2017. október 18., szerda, 12:41:34 GMT + 0000 (UTC)

A kimenet egy dátumú karakterlánc, amely a következő adatokat tartalmazza:

A dátum és az idő felosztásra kerül, és olvasható módon jelenik meg.

A JavaScript azonban a dátumot Unix időbélyegként értelmezi, amely az 1970. január 1. éjfél óta eltelt ezredmásodpercek számából áll. Az időbélyeget a getTime () metódussal kaphatja meg.

// Az aktuális időbélyeg lekérése
now.getTime ();
1508330494000

A kimenetben aktuális időbélyegként megjelenő nagy szám az 1970. január 1. éjfél és 2017. október 18. között eltelt ezredmásodpercek számát jelenti.

A nulla időt (vagy korszakidőt) a dátum karakterlánc 1970. január 01. 00:00:00 univerzális idő (UTC) és a 0 időbélyeg jelöli. Ezt a böngészőben tesztelheti úgy, hogy új változót hoz létre az epoch.js fájlban, és új dátumpéldány hozzárendelése a 0 időbélyeg alapján.

// A 0 időbélyeg hozzárendelése egy új változóhoz
const epochTime = új dátum (0);
epochTime;
1970. január 1., 00:00:00 egyetemes idő (UTC)

A nulla időt választották szabványnak a számítógépes időmérésnél, és ezt a módszert használják a JavaScriptben. Fontos megérteni az időbélyegeket és a dátum karakterláncokat, mivel ezek a fogalmak az alkalmazás beállításaitól és céljától függően használhatók.

Most már tudja, hogyan hozhat létre új dátumpéldányt az aktuális idő és egy időbélyeg alapján. A JavaScriptben összesen négy dátumformátum található. Az alapértelmezett aktuális idő és időbélyeg mellett dátum karakterláncot is használhat, vagy megadhat egy adott dátumot és időt.

Demonstrálni különböző utak egy adott dátumra hivatkozva próbáljon meg új Date objektumokat létrehozni, amelyek 1776. július 4. 12:30 GMT-t képviselnek három különböző módon.

// Időbélyegző módszer
új dátum (-6106015800000);
// Dátum karakterlánc metódus
új dátum ("1980. január 31. 12:30");
// Dátum és idő módszer
új dátum (1776, 6, 4, 12, 30, 0, 0);

Mindezek a példák ugyanazt a dátumot és időt mutatják be három különböző módon.

Amint láthatja, az időbélyeg módszer negatív számmal rendelkezik; a nulla idő előtti bármely dátum negatív számként jelenik meg.

A harmadik példában a másodperceket és ezredmásodperceket 0 jelöli. Ha hiányzik bármilyen adat a Date objektum létrehozásakor, állítsa azokat 0-ra. A hiányzó adatokat nem lehet kihagyni, mert a karakterláncban lévő időadatok sorrendje nem változás. Azt is meg kell jegyezni, hogy a július hónap itt 6-nak van jelölve, nem 7-nek. Ez azért van, mert a visszaszámlálás nem 1-től kezdődik, hanem 0-tól. Erről bővebben a következő részben.

Dátum lekérése a get segítségével

Ha megvan a dátum, különböző beépített módszerekkel elérheti annak összes összetevőjét. A metódusok a dátum minden részét visszaadják a helyi időzónához képest. Ezen módszerek mindegyike a get karakterrel kezdődik, és egy relatív számot ad vissza. Az alábbiakban a Date objektum lekérési metódusainak részletes táblázata látható.

Dátum idő	Módszer	Hatótávolság	Példa
Év	getFullYear ()	ÉÉÉÉ	1970
Hónap	get Month ()	0-11	0 = január
A hónap napja	getDate ()	1-31	1 = a hónap 1. napja
A hét napja	getDay ()	0-6	0 = vasárnap
Óra	getHours ()	0-23	0 = éjfél
Perc	getMinutes ()	0-59
Második	getSeconds ()	0-59
Miliszekundum	get Milliseconds ()	0-999
Időbélyeg	getTime ()

// Új születésnapi példány inicializálása
const születésnap = új dátum (1980, 6, 31);

Most már minden módszer használható a dátum egyes összetevőinek lekérésére.

születésnap.getFullYear (); // 1980
születésnap.getHónap (); 6
születésnap.getDate (); 31
születésnap.getDay (); 4
születésnap.getHours (); // 0
születésnap.getMinutes (); // 0
születésnap.getSeconds (); // 0
születésnap.getMilliseconds (); // 0
születésnap.getTime (); 333849600000 (GMT esetén)

Néha csak egy dátum egy részét kell kivonnia, és a beépített get metódusok segítenek ebben.

Például összehasonlíthatja az aktuális dátumot az október 3-i dátummal, hogy megtudja, október 3-a-e vagy sem.

// Szerezd meg a mai dátumot
const ma = új Dátum ();
// Hasonlítsa össze a mai napot október 3-ával
if (ma.getDate () === 3 && today.getMonth () === 9) (
console.log ("Ez" október 3. ");
) más (
console.log ("Ez nem október 3.");
}
Nem október 3.

A beépített get metódusok lehetővé teszik a dátumösszetevők elérését.

Dátum módosítása beállítással

A fenti getterek mindegyike rendelkezik megfelelő beállítóval. Ha a get a dátum egy adott összetevőjének lekérésére szolgál, akkor a set az összetevők módosítására szolgál. Az alábbiakban egy részletes táblázat található a Date objektumhoz beállított metódusokról.

Dátum idő	Módszer	Hatótávolság	Példa
Év	setFullYear ()	ÉÉÉÉ	1970
Hónap	set Month ()	0-11	0 = január
A hónap napja	dátum beállítása ()	1-31	1 = a hónap 1. napja
A hét napja	setDay ()	0-6	0 = vasárnap
Óra	setHours ()	0-23	0 = éjfél
Perc	setMinutes ()	0-59
Második	setSeconds ()	0-59
Miliszekundum	set Milliseconds ()	0-999
Időbélyeg	beállítani az időt ()	Ezredmásodpercek száma nulla időpont óta

Ezek a beállítók használhatók egy vagy több dátumkomponens megváltoztatására. Például módosíthatja az évet a születésnapi változóban 1997-re.

// Születésnapi dátum évének módosítása
születésnap.setFullYear (1997);
születésnap;
1997. július 31., csütörtök, 00:00:00 GMT + 0000 (UTC)

Most, amikor meghívja a születésnapi változót, nem 1980-at lát, hanem 1997-et.

A beépített setter metódusok lehetővé teszik a Date objektum különböző részei módosítását.

UTC módszerek

A fenti get metódusok dátum-összetevőket kérnek le az alapján helyi beállítások a felhasználó időzónája. A dátumok és időpontok szabályozásának növeléséhez használhatja a getUTC metódusokat, amelyek ugyanúgy működnek, mint a get metódusok, de az időt UTC (univerzális idő) alapján számítják ki. Az alábbiakban a Date objektum UTC-metódusainak táblázata látható JavaScriptben.

Dátum idő	Módszer	Hatótávolság	Példa
Év	getUTCFullYear ()	ÉÉÉÉ	1970
Hónap	getUTCMonth ()	0-11	0 = január
A hónap napja	getUTCDate ()	1-31	1 = a hónap 1. napja
A hét napja	getUTCDay ()	0-6	0 = vasárnap
Óra	getUTCHours ()	0-23	0 = éjfél
Perc	getUTCMutes ()	0-59
Második	getUTCSeconds ()	0-59
Miliszekundum	getUTCMilliseconds ()	0-999

A helyi getterek és az UTC getterek közötti különbség ellenőrzéséhez futtassa a következő kódot.

// Aktuális idő hozzárendelése egy változóhoz
const most = új dátum ();
// Helyi és UTC időzónák nyomtatása
console.log (now.getHours ());
console.log (now.getUTCHours ());

Ez a kód kinyomtatja a pontos időt és az időt UTC időzónában. Ha jelenleg az UTC időzónában tartózkodik, akkor a program által kiadott számok ugyanazok lesznek.

Az UTC nemzetközi időszabványt biztosít, ezért a kódot konzisztensen tudja tartani az időzónákkal, ha szükséges a programban.

Következtetés

Ebben az oktatóanyagban megtanulta, hogyan kell példányosítani egy dátumobjektumot, és hogyan használhatja beépített metódusait egy adott dátum összetevőinek elérésére és módosítására. Az időről és a dátumról további információkat találhat a Mozilla fejlesztői hálózatán található JavaScriptben.

A dátumok kezelésének ismerete fontos a JavaScript számos gyakori feladatához, a rendszeres jelentések létrehozásától a dátumok és ütemezések megfelelő időzónában történő megjelenítéséig.

Címkék:

Használja az új dátumot () az aktuális dátumot és időt tartalmazó új dátum objektum létrehozásához.

vegye figyelembe, hogy Dátum () argumentumok nélkül hívható, egyenértékűúj dátum (Date.now ()) .

Ha rendelkezik egy dátumobjektummal, a számos rendelkezésre álló módszer bármelyikével lekérheti a tulajdonságait (például a getFullYear () négyjegyű évszámot kaphat).

Az alábbiakban néhány általános dátumozási módszert olvashat.

Szerezd meg az aktuális évet

var év = (új dátum ()). getFullYear (); console.log (év); // Minta kimenet: 2016

Szerezze meg az aktuális hónapot

var hónap = (új dátum ()). getMonth (); console.log (hónap); // Minta kimenet: 0

Vegye figyelembe, hogy 0 = január. Ennek az az oka, hogy a hónapok tól 0 előtt 11 ezért gyakran kívánatos +1-et adni az indexhez.

Szerezze meg az aktuális napot

var day = (új dátum ()). getDate (); console.log (nap); // Minta kimenet: 31

Az aktuális óra lekérése

var hours = (új dátum ()). getHours (); console.log (óra); // Minta kimenet: 10

Az aktuális percek lekérése

var minutes = (új dátum ()). getMinutes (); console.log (perc); // Minta kimenet: 39

Az aktuális másodpercek lekérése

var seconds = (új dátum ()). getSeconds (); console.log (második); // Minta kimenet: 48

Az aktuális ezredmásodpercek lekérése

Egy Date objektum példányának ezredmásodperceinek (0-tól 999-ig) lekéréséhez használja a getMilliseconds metódust.

Var milliszekundum = (új dátum ()). Get Milliszekundum (); console.log (ezredmásodperc); // Kimenet: ezredmásodperc jelenleg

Konvertálja az aktuális időt és dátumot ember által olvasható karakterláncra

var now = new Dátum (); // dátum konvertálása karakterláncra UTC időzóna formátumban: console.log (now.toUTCString ()); // Kimenet: 2017. június 21., szerda, 09:13:01 GMT

A statikus Date.now () metódus az 1970. január 1. 00:00:00 UTC óta eltelt ezredmásodpercek számát adja vissza. Az azóta eltelt ezredmásodpercek számának lekéréséhez egy Date objektumpéldány használatával használja a getTime metódust.

// ezredmásodpercek lekérése a Date console.log statikus most módszerével (Date.now ()); // ezredmásodpercek lekérése a getTime of Date metódussal console.log ((új dátum ()). getTime ());

Üdv mindenkinek!
Gyakran kell statisztikai adatokkal dolgoznom, és sok minden dátumhoz kötődik. Ezenkívül ugyanaz a dátum különböző formátumokban használható egy oldalon (például egy autó számára kényelmesen és egy személy számára kényelmesen). Azt hiszem, a legtöbben tökéletesen tisztában vannak ezzel a szörnyű kóddal, amely a dátum objektum használatával jár.
Például, hogy az aktuális dátumot DD.HH.ÉÉÉÉ formátumban kapjuk meg, a következőket kell tennünk:
var d = új dátum (), fd = d.getDate () + "." + (d.getMonth () + 1) + "." + d.getFullYear ();
És amikor sok ilyen sor van? Könnyű megjegyezni, hogy a javascriptben egy hónap a nulláról indul, ha nem csak abban fejlődsz? Vagy az, hogy ezredmásodpercek vannak, nem másodpercek, mint szinte mindenhol a háttérben? Néhány probléma megoldható a népszerű Moment.js könyvtárral, de nagyon lassan működik.
A szóban forgó könyvtár ezeket a problémákat oldja meg.
Ha érdekel, javaslom, hogy olvassa el ezt a kis ismertetőt.

A TempusJS sok szintaktikai cukrot tartalmaz a Date objektumon, ezért nagyon gyors. Maga a könyvtár szintaxisa meglehetősen egyszerű. Például az előző példát így írhatja le:
var fd = tempus (). formátum ("% d.% m.% Y");
Most a sebességről. A spoilerben a Tempus és a Moment és a natív dátumformátum összehasonlítása látható (lásd fent):

A natív JS, MomentJS és TempusJS összehasonlítása

Megkapjuk az aktuális dátumot

Natív JS x 2 175 575 művelet / mp ± 0,75% (96 művelet mintavétellel) Pillanat x 284 864 művelet / mp ± 0,85% (96 mintavételezés) Tempus x 2 086 081 művelet / mp ± 0,73% (97 futás mintavételezés)

Formázás

Natív JS x 1 637 517 művelet/mp ± 0,61% (100 mintavételezés) Pillanat x 8,808 művelet / mp ± 1,07% (100 mintavételezés) Tempus x 942 815 művelet/mp ± 0,68% (94 mintavételezés)

Dátum automatikus felismerése és elemzése

Natív JS x 11 204 316 művelet/mp ± 0,81% (88 művelet mintavétellel) Pillanat x 38 511 művelet/mp ± 1,41% (95 mintavételezés) Tempus x 93 973 művelet/mp ± 1,06% (85 mintavételezés)

Dátum elemzése formátum szerint

Pillanat x 46,293 művelet/mp ± 0,63% (100 mintavételezés) Tempus x 109,947 művelet/mp ± 0,93% (99 mintavételezés)

Elemzés és érvényesítés

Pillanat x 44,588 művelet/mp ± 1,09% (90 mintavételezés) Tempus x 103,439 művelet/mp ± 0,90% (94 mintavételezés)
Az eredményeket a laptopomon kaptam ben Google chrome 30.0.1599.114. Más böngészőkben az eredmények eltérőek, de az arány nagyjából ugyanaz marad.
A tesztekhez a benchmark.js könyvtárat használtuk.
Az egyéb funkciók referenciaértékeit láthatja.

Tehát ennek a könyvtárnak az előnyei a következőképpen írhatók le:

• Támogatja az IE6+, Chrome, Firefox, Opera verziókat;
• Támogatja a hívásláncokat;
• A hónapok kezdődhetnek 1-gyel (alapértelmezett), nem nullával;
• A ezredmásodpercek letilthatók (alapértelmezett) vagy engedélyezhetők;
• Gyors munka (Mivel sok esetben a böngésző natív Date objektumot használják, aminek megvalósítása gyorsabb nyelveken íródott);
• Támogatja az egyéni formátumokat és bővítményeket
• A dátumérvényesítés nagyon gyors, és csak a dátumot beállító függvényektől függ (mivel az érvényesítés már az értékek megadásakor megtörténik, és nincs külön számítva);
• Többnyelvű és a felhasználó nyelvének automatikus felismerése.

Itt csak néhány funkcióról fogunk beszélni.

Formázás és elemzés

Kezdetnek tehát még egy példa a dátum formázására. Itt is használjuk a hívásláncolást. Minden beállítás végén visszakapunk egy TempusDate objektumot, amelyet a láncon lejjebb használhatunk. Példa:
tempus (). // az új dátum számítása ((hónap: -1)). // csökkenti egy hónapos formátummal ("% d.% m.% Y"); // Kimenet karakterláncként
Így ugyanazt a napot, órát és másodpercet kapjuk, de egy hónapja. Ez hasznos az elmúlt hónapra vonatkozó jelentések lekéréséhez.

A következő példa egy dátum elemzése.
// Egy TempusDate objektumot ad vissza "2013-11-18" dátummal tempus ("11/18/2013"); // Egy TempusDate objektumot ad vissza "2013-12-12" tempus ("2013-12-12", "% Y-% m-% d"));
A Tempus automatikusan képes felismerni néhány ismert formátumot. Ezenkívül megadhat egy bizonyos formátumot, akkor az elemzés gyorsabb lesz. Ezenkívül beállíthatja a dátumot, amely visszaküldésre kerül, ha az elemzés sikertelen:
// Mivel A "123" nem egyezik a "% d.% M.% Y" formátummal, majd // egy objektum, amely a dátumot tartalmazza: 2013-01-01 tempus ("123", "% d.% M.% Y", tempus ());
Az alapértelmezett formátumok listája megtekinthető

Most változtassuk meg a már formázott dátum formátumát
// "2013-11-05" tempus ("05.11.2013"). Formátum ("% Y-% m-% d"); // Vagy úgy // "Október, 12" tempus ("2013-10-12 12:31:01", "% Y-% m-% d% H:% M:% S"). Formátum ("% B,%d");

A formázáshoz használhatja a lokalizációt is. Alapértelmezés szerint a rendszer a felhasználó nyelvét választja ki (a böngészőből veszi), vagy az alapértelmezett nyelvet, ha a felhasználó nyelve nem található az elérhető Tempus nyelvek között.
// Nyelv beállítása tempus.lang ("ru"); // Alapértelmezésben a formátumot használjuk // "November 05" tempus (1383609600) .format ("% B,% d");
Tovább Ebben a pillanatban Csak két nyelv van - orosz és angol, ezért szívesen segítek.

Érvényesítés

Az érvényesítés dátuma a következő:
// False tempust ad vissza ("08/32/2013", "% d.% M.% Y"). Érvényes (); // Visszaadja a valódi tempust ("00:00 01.01.2012", "% H:% M% d.% M.% Y"). Érvényes ();

Hiba esetén láthatja azokat a mezőket, amelyekben az előfordult - ahol az érték nem hamis:
// Visszatér ("év": - 5, "hónap": hamis, "nap": hamis, "óra": hamis, // "percek": hamis, "másodpercek": hamis, "ezredmásodperc": hamis) tempus (). év (-5). // az év beállítása = -5, azaz. érvénytelen hibák (); // a hibás objektum lekérése

Dátumtartományok

Néha meg kell kapnunk az évek számát (például életkor), hónapokat, napokat stb. két időpont között. Ehhez használhatjuk a két dátum közötti különbséget, amely megkeresi a különbséget két dátum között, és a kívánt formátumban ("év", "hónap", "nap", "óra", "perc", "másodperc", " ezredmásodperc").
Íme egy egyszerű példa a 2013. november 1. és 2014. május 5. közötti hónapok számának kiszámítására:
// 6 tempust () ad vissza. Között (tempus (), "hónap");
Vagy hány óra van még hátra az újévig
tempus (). között (tempus (), "óra");
Az utolsó példában látható, hogy csak az évet adtam meg. Ha értéket állít be egy tömbhöz vagy objektumhoz, a hiányzó értékek a következők lesznek
a minimummal megtöltve. Konstansok listája -val minimális értékeket, láthatja a dokumentációban.

Ezenkívül a calc függvény segítségével bármilyen dátumot módosíthatunk:
// TempusDate-et ad vissza dátummal: 2012-01-01 tempus (). Calc ((év: 1, hónap: -4, nap: -1));

Egyedi formátumok

Saját formátumunkat alkalmazzuk a hónapra, amely 1 és 12 közötti értékeket vehet fel (nem 01 és 12 között):
// Új formátum regisztrálása tempus.registerFormat ("% q", // direktíva -% q függvény (dátum) (// Itt adjuk meg a formázási függvényt, azaz mi lesz a % q helyére return date.month (); ) , function (value) (// És itt van az elemző függvény var v = Number (value); return (month: (isNaN (v)? undefined: v));), 1, // Az a minimális hossz, amelyet a a 2. érték veheti fel , // Maximális hossz "szám" // Típus); // Tesztelés // Visszaadja: "2013.01.01"; tempus ((év: 2013, hónap: 1, nap: 1)). formátum ("% d.% q.% Y"); // Visszatér ("év": 2013, "hónap": 2, "nap": 10, "óra": 0, "perc": 0, "másodperc": 0); tempus ("10.2.2013", "% d.% q.% Y"). get ();
A regisztráció során észreveheti, hogy egyes paraméterek külön vannak beállítva, miközben használhatja reguláris kifejezés... Valójában kezdetben ott volt, de miután elhagyták, a sebesség több tucatszorosára nőtt.
Ha el kell távolítania egy formátumot, használja az unregisterFormat parancsot:
tempus.unregisterFormat ("% d"); // „% d.01.2013”, mert a% d direktíva már nem létezik. tempus.format ((év: 2013, hónap: 1, nap: 1), "% d.% m.% Y");

Getterek / szetterek

Néhány értéket az év (), hónap (), nap (), óra (), perc (), másodperc (), ezredmásodperc (), hét napja (), utc (), időbélyeg () függvények segítségével - beállíthat / beállíthat. vagy állítsa be (). Például:
tempus (). // Az aktuális dátum évszámának lekérése (1900). // Hagyja úgy, ahogy van, de állítsa 1900 szökőévre (); // Ellenőrizze, hogy szökőév-e, ebben az esetben false tempus () Év (); // És így megkapjuk az aktuális évet számszerű formában

Dátumok generálása

Különféle módon hozhat létre dátumot, teljes lista paraméterei a dokumentációban találhatók. Íme egy minimális példa.
// visszaadja ["03/29/2013", "03/30/2013", "03/31/2013", "04/01/2013", "04/02/2013"]; tempus.generate ((dátumFrom: "20130329", formatFrom: "% Y.% m.% d", dateTo: "20130402", időszak: (nap: 1), formátum: "% d.% m.% Y") ));
Ez hasznos lehet a diagramok dátum szerinti megjelenítéséhez és a megjelenítési formátum módosításához közvetlenül a kliensen, a háttérrendszer megkérdezése nélkül. A dátum generálható tömbként vagy objektumként, ahol maguk a dátumok lesznek a kulcsok (ez akkor hasznos, ha egy eseményt dátumhoz kell kötnünk, például ha saját naptárat készítünk). Ezenkívül a dátumok csoportosíthatók nap, hét, hónap, óra, év - bármi módon - szerint. Ez a naptárra is alkalmazható.

Beépülő modulok

És végül, de nem utolsósorban a bővítmények. Itt bővítjük a gyárat, hogy véletlenszerű dátumot generáljunk. Szükségünk van a TempusDate osztályra is, amely a tempus.classes () alatt található. Íme egy példa plugin:
(függvény (tempus) (var TempusDate = tempus.classes ("TempusDate"); tempus.randomDate = függvény () (var date = new TempusDate (); dátum.év (Math.floor ((Math.random ()) *) tempus.MAX_YEAR - tempus.MIN_YEAR)) + tempus.MIN_YEAR)). hónap (Math.floor ((Math.random () * (tempus.MAX_MONTH - tempus.MIN_MONTH)) + tempus.MIN_MONTH)). nap (Math. random () floor ((Math.random () * (date.dayCount () - tempus.MIN_DAY)) + tempus.MIN_DAY)). óra (Math.floor ((Math.random ()) * (tempus.MAX_HOURS - tempus .MIN_HOURS) ) + tempus.MIN_HOURS)). perc (Math.floor ((Math.random () * (tempus.MAX_MINUTES - tempus.MIN_MINUTES)) + tempus.MIN_MINUTES)). másodperc (Math.floor ((Math. véletlenszerű () * (tempus.MAX_SECONDS - tempus.MIN_SECONDS)) + tempus.MIN_SECONDS)); visszatérési dátum;);)) (tempus); // Most a következőképpen hozhatunk létre dátumokat: var someRandomDate = tempus.randomDate ();
Úgy gondolom, hogy így kényelmesen lehet widgeteket írni egy csomó jQuery + Tempus, Angular + Tempus stb. segítségével.

Forráskódok

Telepítheti a források letöltésével a githubból:
https://github.com/crusat/tempus-js/releases
Vagy boweren keresztül:
$ bower install tempus
Csak egy fájlra van szüksége - tempus.js vagy tempus.min.js.

Remélem, hasznos lesz ez a könyvtár, és azt is érdekes lenne tudni, hogy mi hiányzik belőle a könyvtár további megfelelő fejlesztéséhez. Köszönöm a figyelmet!
P.S. Köszi a meghívást!

Egy másik hasznos dolog a webhelyek számára az aktuális dátum beillesztése. Az interneten több tucat példa található dátum szkriptekre, de véleményem szerint sok közülük nehéz, és ezért csúnya. Közben használva szabvány azt jelenti JavaScript, nagyon egyszerű dátumot beszúrni egy weboldal oldalára. Nagyon gyakran használom! A képen (képernyőkép az aktuális oldalról) "Tündérmese" birtok !

Íme a teljes dátum szkript:

Véleményem szerint nem is lehetne könnyebb, egész szép és érthető. Ha nem kívánja tanulmányozni a szkript felépítését, egyszerűen illessze be bárhová a HTML-oldalon, és a következő feliratot kapja:

Egy másik lehetőség fejlettebb

! Ma

Ez így néz ki:

Ma

Általában nincs szükség készségekre, csak hülyén szúrja be a kódot, és minden rendben van!

További részletek:

Tehát kezdjük azzal, hogy dátumértéket rendelünk egy változóhoz d, majd hozzon létre tömböket ( Sor) a hét napjaira ( nap) és hónapok ( hónap), a szükséges nyelvtani formában feltüntetve: kisbetű, szám, nagybetű ha a szó egy randevú elején van stb. A szkript utolsó sora a tényleges dátum nyomtatása ( dokumentum.írni). Itt állíthatja be, hogy mit és milyen sorrendben jelenítsen meg az aktuális dátumot a stringben. A komponenseket a jel választja el egymástól + ... Szóköz beírásához használja a konstrukciót " " , és a g (év) betű beírásához - a konstrukció "G."

Amint a szkriptből látható, az aktuális időre vonatkozó adatok lekérését az elem végzi kap... Ez a módszer a következő információkat nyújtja:

• getDate ()- 1 és 31 közötti számot ad vissza, amely a hónap napját jelzi;
• getDay ()- a hét napját egész számként adja vissza 0-tól (vasárnap) 6-ig (szombat);
• get Month ()- visszaadja az év hónapjának számát;
• getFullYear ()- adja vissza az évet. Egyszerű használathoz getYear (), akkor az aktuális év mínusz 1900 jelenik meg;
• lekérni az órákat ()- visszaadja a nap óráját;
• getMinutes ()- a perceket 0 és 59 közötti számként adja vissza;
• getSeconds ()- visszaadja a másodpercek számát 0 és 59 között.

Beillesztés közvetlenül Jáva A webhelyoldalon belüli -script nem mindig kényelmes. Jobb, ha a szkript leírását az oldal tetejére helyezi a címkék közé és állítsunk be egy változót, amelyet szükség szerint hívunk meg a szövegben. Nevezzük el MAés a fentiekhez hasonlóan definiálja benne a dátum megjelenítési űrlapot. A szkript így fog kinézni:

A dátum megjelenítéséhez hívja meg a szkriptet az oldal HTML kódjának megfelelő helyén a következő paranccsal:

Ha webhelye sok olyan oldalt tartalmaz, amelyen meg szeretné jeleníteni a dátumot, akkor kényelmesebb kiemelni Jáva-szkript a dátum megjelenítéséhez külön fájl, például, data.js... A gyakorlatban ez egy oldal, amely a leírt szkriptek közül az elsőből áll, vagyis a sorral dokumentum.írni(lásd fent). Ugyanabban a könyvtárban kell elhelyezni, mint a főoldal, és a dátum kimeneti helyén kell meghívni a következőképpen:

Ne felejtse el ellenőrizni, hogy a fájl data.js ugyanaz volt a kódolása, mint a fő dokumentum, különben a dátum csodálatos horgokkal, négyzetekkel és egyéb finomításokkal jelenik meg.

Megjegyzés. Figyelembe kell venni, hogy a leírt szkript a felhasználó számítógépén beállított dátumot jeleníti meg, amely nem mindig felel meg a valós aktuális időnek. Ha meg kell mutatnia a pontos időt, akkor egy PHP szkriptet kell használnia, amely megmutatja az időt a szerveren.