A new Date() használatával hozzon létre egy új Date objektumot, amely az aktuális dátumot és időt tartalmazza.
vegye figyelembe, hogy Dátum() argumentumok nélkül hívva egyenértékűúj dátum (Dátum.most()) .
Ha rendelkezik egy dátumobjektummal, akkor több közül bármelyiket alkalmazhatja elérhető módszerek tulajdonságainak lekéréséhez (pl. getFullYear() 4 számjegyű évszámhoz).
Az alábbiakban bemutatunk néhány általános dátumozási módszert.
Az aktuális év lekérése
var év = (new Date()).getFullYear(); konzolnapló(év); // Minta kimenet: 2016Az aktuális hónap lekérése
var hónap = (new Date()).getMonth(); konzolnapló(hónap); // minta kimenet: 0Vegye figyelembe, hogy 0 = január. Ez azért van, mert a hónapok eltérőek 0 előtt 11 , ezért gyakran kívánatos +1-et adni az indexhez.
Az aktuális nap lekérése
varday = (new Date()).getDate(); konzolnapló(nap); // minta kimenet: 31Az aktuális óra lekérése
var hours = (new Date()).getHours(); konzolnapló (óra); // minta kimenet: 10Az aktuális percek lekérése
var minutes = (new Date()).getMinutes(); konzolnapló(percek); // minta kimenet: 39Az aktuális másodpercek lekérése
var seconds = (new Date()).getSeconds(); konzolnapló(második); // minta kimenet: 48Az aktuális ezredmásodpercek lekérése
A Date objektumpéldány ezredmásodperceinek (0–999) lekéréséhez használja a getMilliseconds metódust.
var milliseconds = (new Date()).getMilliseconds(); konzolnapló (ezredmásodperc); // Kimenet: ezredmásodperc jelenleg
Konvertálja az aktuális időt és dátumot ember által olvasható karakterláncra
varnow = new Date(); // 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 GMTStatikus módszer A Date.now() 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 megállapításához a Date objektum egy példányával használja a getTime metódust.
// ezredmásodpercek lekérése a Date most statikus metódusával console.log(Date.now()); // ezredmásodpercek lekérése a getTime of Date metódussal console.log((new Date()).getTime());
A dátum és az idő mindennapi életünk részét képezik, ezért kiemelt szerepet kapnak a programozásban. A JavaScriptben a webhely létrehozásakor előfordulhat, hogy hozzá kell adnia egy naptárt, vonatmenetrendet vagy egy felületet a találkozók ütemezéséhez. Ezeknek az alkalmazásoknak a felhasználó aktuális időzónája alapján kell megjeleníteniük a megfelelő időpontokat, 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 napi jelentések meghatározott időpontokban történő küldéséhez vagy szűréshez (például meghatározott időpontokban nyitva tartó éttermek megkereséséhez).
dátum objektum
A dátum egy beépített JavaScript objektum, amely tárolja a dátumot és az időt. 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éldaként próbálja meg hozzárendelni az aktuális dátumot egy változóhoz. Hozzon létre egy now.js fájlt.
// Változó beállítása az aktuális dátumra és időre
const most = new Date();
// 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ült, és könnyen olvasható módon jelenik meg.
A JavaScript azonban egy Unix-időbélyeg alapján értelmezi a dátumot, 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áma.
A nulla időt (vagy korszakidőt) a dátum karakterlánc 1970. január 1. 00:00:00 univerzális idő (UTC) és egy 0 időbélyeg jelenti. Ezt a böngészőben tesztelheti úgy, hogy új változót hoz létre az epoch.js fájlban és a Date új példányának 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 = new Date(0);
epochTime;
1970. január 1., 00:00:00 univerzális 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 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 konkrét dátumot és időt.
Demonstrálni különböző módokon Ha egy adott dátumra hivatkozik, próbáljon meg új Date objektumokat létrehozni, amelyek három különböző módon reprezentálják 1776. július 4-ét, 12:30 GMT-t.
// időbélyeg módszer
új dátum (-6106015800000);
// dátum karakterlánc metódus
new Date("1980. január 31. 12:30");
// dátum és idő módszer
new Dátum(1776, 6, 4, 12, 30, 0, 0);
Mindezek a példák ugyanazt a dátumot és időt képviselik három különböző módon.
Amint láthatja, az időbélyeg módszer negatív számmal rendelkezik; minden nulla idő előtti dátum negatív számként jelenik meg.
A harmadik példában a másodperceket és ezredmásodperceket 0 jelöli. Ha a Date objektum létrehozásakor hiányzik bármilyen adat, akkor 0-hoz kell rendelnie. 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-ként van jelölve, és nem 7-ként. Ennek az az oka, hogy a visszaszámlálás 0-tól kezdődik, nem 1-től. Erről bővebben a következő részben.
Időpont 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 = new Date(1980, 6, 31);
Mostantól az összes módszert felhasználhatja a dátum egyes összetevőinek kinyerésére.
születésnap.getFullYear(); // 1980
születésnap.getHónap(); 6
születésnap.getDate(); 31
születésnap.getDay(); // négy
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 előfordulhat, hogy egy dátumnak csak egy részét kell kivonni, és a beépített get metódusok segítenek ebben.
Például összehasonlíthatja a mai dátumot október 3-ával, hogy megtudja, október 3-a-e vagy sem.
// Szerezze meg a mai dátumot
const ma = new Date();
// Hasonlítsa össze a mai napot október 3-ával
if (ma.getDate() === 3 && today.getMonth() === 9) (
console.log("Október 3. van.");
) más (
console.log("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
Az összes fent felsorolt get metódushoz létezik egy megfelelő beállított metódus. Ha a get egy adott dátum-összetevő lekérésére szolgál, akkor a set az összetevők módosítására szolgál. Az alábbiakban a dátum objektum beállítási metódusainak részletes táblázata látható.
| 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 | setMilliseconds() | 0-999 | |
| időbélyeg | beállítani az időt() | Ezredmásodpercek száma nulla időpont óta |
Ezekkel a beállítási módszerekkel módosítható egy vagy több dátumkomponens. 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 set metódusok lehetővé teszik a Date objektum különböző részeinek megváltoztatását.
UTC módszerek
A fent ismertetett get metódusok a dátum-összetevőket az alapján kérik le 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 az UTC (Coordinated Universal Time) szabvány 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 | getUTCSecons() | 0-59 | |
| Miliszekundum | getUTCMilliseconds() | 0-999 |
Hogy ellenőrizze a különbséget a helyi módszereket szerezniés az UTC metódusok lekéréséhez futtassa a következő kódot.
// Aktuális idő hozzárendelése egy változóhoz
const most = new Date();
// 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 megjelenített számok ugyanazok lesznek.
Az UTC nemzetközi időszabványt biztosít, és ezért támogatja az időzónák szerinti kódot, ha a programnak szüksége van rá.
Következtetés
Ebben az oktatóanyagban megtanulta, hogyan kell példányosítani egy dátum objektumot, hogyan használhatja beépített metódusait egy adott dátum összetevőinek eléréséhez és módosításához. Több részletes információk az időről és a dátumról a JavaScriptben a Mozilla Developer Network oldalán találhat.
A dátumok kezelésének ismerete fontos a JavaScript számos gyakori feladatához, a rendszeres jelentések generálásától a dátumok és ütemezések megfelelő időzónában történő megjelenítéséig.
Címkék:Az aktuális dátum lekérése JavaScriptben nagyon egyszerű. Erre szolgál a Dátum objektum. A szintaxisa meglehetősen egyszerű, a metódusnevek pedig intuitívak. Az alábbi példákban megmutatom, hogyan kell dolgozni a Date objektummal ( JavaScript új dátum), hogy az aktuális évet, hónapot, napot és időt ezredmásodperc pontossággal leírja!
Az aktuális dátum lekérése:
Az aktuális dátum JavaScriptben való lekéréséhez használja a kulcsszó new a Date objektum új példányának létrehozásához.
var date = new Date(); konzolnapló(dátum);
Ez a kód a következő információkat nyomtatja ki a konzolra:
//2016. február 2., kedd, 15:46:56 GMT-0500 (keleti szabványidő)
24 órás formátumban jeleníti meg a hét aktuális napját, az aktuális hónapot, a hónap napját, az évet, sőt az aktuális időt is. töredék" GMT" jelentése GMT idő, és " -0500 ' a helyi idő és a GMT közötti időzónák közötti különbség.
Idézet a Wikipédiából: "Greenwichi középidő (GMT) GMT) az átlagos szoláris idő a londoni greenwichi királyi obszervatóriumban." Összefügg azzal UTC (UTC). « Keleti szabványidő A megjelenített dátumértékben szereplő ' a böngésző vagy a számítógép időzónájára utal.
* Felhívjuk figyelmét, hogy a GMT és az UTC eltérő. Az UTC értékeket percekben vesszük figyelembe.
* Vegye figyelembe azt is, hogy a JavaScriptben a dátumot az 1970. január 1. (UTC) éjfél óta eltelt idő ezredmásodpercben határozza meg. Egy napban 86 400 000 ezredmásodperc van. A Date objektumok tartománya -100 000 000 nap és 100 000 000 nap között van, 1970. január 01-hez viszonyítva (UTC).
* A fent említett módszerrel kapott értékek az eszköz rendszerbeállításaitól függenek. Ha módosítja a számítógép órabeállításait, az ezzel a módszerrel visszaadott idő is megváltozik.
Rendben, az új JavaScript-dátumformátumok kikerültek az útból, és készen állunk a továbblépésre!
A hét napjának megszerzése:
A hét napjának meghatározásához használja a módszert JavaScript objektum Dátum getDay() :
varday = dátum.getDay(); konzolnapló(nap);
*Ne feledje, hogy a hét napjai 0-tól 6-ig vannak számozva, vasárnap = 0, hétfő = 1, kedd = 2 és így tovább.
Szerezd meg a hónapot:
Az aktuális év aktuális hónapjának lekéréséhez használja a getMonth() metódust. Előtte azt mondtam, hogy a módszerek elnevezése intuitív!
var hónap = dátum.getHónap(); konzolnapló(hónap); //egy
* Vegye figyelembe, hogy a hét napjaihoz hasonlóan a hónapok is numerikus formátumban jelennek meg 0 és 11 között; január = 0, február = 1, március = 2 és így tovább.
A hónap napjának megszerzése:
A hónap napjának meghatározásához használhatja a GetDate() metódust.
var dayOfMonth = dátum.getDate(); konzolnapló(Hónap napja); //2
* A GetDate() metódus a hónap napjait adja vissza, 1-től 31-ig számozva; az 1-es szám a hónap első napjának felel meg.
Idő lekérése:
Az aktuális idő megállapításához a GetTime() metódust használjuk.
vartime = date.getTime(); konzolnapló(idő); //1454461242058
Úgy néz ki... furcsán... Mi az? Megjelenik az 1970. január 1. 00:00:00 UTC óta eltelt ezredmásodpercek száma. Szóval hány éves?
1454461242058 ms / 31540000000 ms évente = körülbelül 46 év
1970 + 46 év = 2016
Ellenőrizzük, hogy megbizonyosodjunk:
var év = dátum.getFullYear(); console.log(év) //2016
Igen, ez az! Csak az aktuális dátumot és időt adjuk ki a JavaScript új dátum használatával.
A dátumok és időpontok JavaScriptben való kezeléséhez van egy speciális objektum - a dátum. Ezt az objektumot a JavaScript szinte minden verziója támogatja, és a kompatibilitási problémáktól függetlenül használható.
A Date objektumban a dátum és az idő nem kifejezetten, hanem a legtöbb programozási nyelvhez hasonlóan a Unix születése óta eltelt ezredmásodpercek számaként, pl. 1970. január 1-jén 0000 órától. A Dátum objektum megkülönböztető jellemzője, hogy minden tartományérték nulla alapú indexekkel rendelkezik. Ez azt jelenti, hogy a januári index 0 lesz (0. hónap), december pedig a tizenkettedik helyett a tizenegyedik hónap lesz. Ugyanez igaz a hét napjaira, órákra, percekre stb.
A dátum objektum létrehozása nagyon egyszerű:
// aktuális dátum-idő var date = new Date(); // dátum-idő karakterláncból vagy számból var date = new Date(date); // dátum-idő külön értékekből var date = new Date(év, hónap, nap, óra, perc, másodperc, ezredmásodperc);
A Dátum objektum számos nagyon hasznos metódussal rendelkezik, amelyek lehetővé teszik a munkát egyedi komponensek dátum-idő, valamint a dátum helyességének és helyes kimenetének ellenőrzése a megadott formátumban.
| Módszerek a dátum-idő összetevők lekérésére | |
| getFullYear | Az évet adja vissza (például 2011). |
| getYear | Visszaadja az évet. A getYear módszer célja azonban megegyezik a getFullYear céljával ez a módszer elavult és nem ajánlott használni, mert munkájának eredménye nem egyértelmű: egy 1900-tól 1999-ig terjedő dátumtartományra a metódus az évszázad évszámát adja vissza (kétjegyű, például 77), ezen a tartományon kívüli dátumok esetén pedig a teljes érték visszaküldték (négy számjegyű, például 2009). |
| get Month | A hónapot adja vissza. |
| getDate | A hónap napját adja vissza (számot a hónapban). |
| getHours | Visszaadja az órát. |
| getMinutes | Visszaadja a percet. |
| getSeconds | Egy másodpercet ad vissza. |
| get Milliseconds | A milliszekundumot adja vissza. |
| getDay | A hét napjának számát adja vissza. |
| getTime | Az objektum által tárolt ezredmásodperces eltolást adja vissza. |
| A dátum-idő összetevők megváltoztatásának módszerei | |
| setFullYear | Beállítja az évet. |
| setYear | Beállítja az évet. A setYear metódus célja hasonló a setFullYear céljához, de ez a módszer elavult és elavult (a getYear metódushoz hasonlóan). |
| set Month | Beállítja a hónapot. |
| dátum beállítása | Beállítja a dátumot a hónapban (a hónap napja). |
| setHours | Beállítja az órát. |
| setMinutes | Beállítja a percet. |
| setSeconds | Beállítja a másodikat. |
| set Milliseconds | Beállítja a milliszekundumot. |
| beállítani az időt | Ezredmásodperces eltolást állít be 00:00:00-hoz képest 1970.01.01. |
| Formázási és dátum-idő kimeneti funkciók | |
| toString | A dátum és az idő karakterlánc-ábrázolását adja vissza. |
| toUTCSkarakterlánchoz | A dátum és az idő UTC időre konvertált karakterláncát adja vissza. A visszaadott karakterlánc formátuma tiszteletben tartja az összes internetes szabványt. |
| to GMTString | Egy dátum és idő karakterlánc-ábrázolását adja vissza GMT-re (Greenwich Mean Time). A visszaadott karakterlánc formátuma tiszteletben tartja az összes internetes szabványt. |
| toLocaleString | Hasonló a toStringhez, de a dátum és az idő karakterlánc-ábrázolását adja vissza, a felhasználó területi beállításának megfelelően. |
| toTimeString | Az idő karakterlánc-ábrázolását adja vissza (a karakterlánc csak az időt tartalmazza). |
| toDateString | A dátum karakterlánc-reprezentációját adja vissza (a karakterlánc csak a dátumot tartalmazza). |
| toLocaleTimeString | Hasonló a toTimeStringhez, de az idő karakterlánc-ábrázolását adja vissza, a felhasználó területi beállításának megfelelően formázva. |
| toLocaleDateString | Hasonló a toDateStringhez, de a dátum karakterlánc-ábrázolását adja vissza a felhasználó területi beállításának megfelelően. |
| További funkciók | |
| getTimezoneOffset | A helyi idő eltolását adja vissza a felhasználó számítógépén az UTC-hez viszonyítva. Az eltolás percek alatt visszaadásra kerül. |
| elemezni | A függvény lehetővé teszi a karakterláncként írt dátum-idő helyességének ellenőrzését. Ha a karakterlánc helyes, akkor azonnal létrejön egy dátum objektum. |
A Date objektum számos módszert is tartalmaz az UTC-dátumokkal való munkavégzéshez. Ezek a függvények teljesen hasonlóak a már figyelembe vettekhez, de a névben az "UTC" előtagot tartalmazzák, és csak "univerzális" idővel működnek: getUTCSeconds, setUTCFullYear stb.
Vegyünk egy példát a dátumokkal való munkavégzésre:
És itt van ennek a szkriptnek a kimenete:
Amint láthatja, a dátum megjelenítése jelentősen eltér a használt formátumtól függően. Ezért, amikor a dátum-idővel dolgozik, be kell tartania néhány egyszerű szabályt:
1. Ha lehetséges, használjon UTC vagy GMT formátumot. Ez különösen fontos elosztott megoldások (például ügyfelek) létrehozásakor fizetési rendszerek). A közös referenciaidő használata garantálja (ha nem is száz százalékig), hogy Ön és távoli partnere is egyformán értelmezi a kapott adatokat.
2. A honosított dátum és idő használata csak a felhasználó számára történő megjelenítéskor célszerű. Minden más esetben jobb megtagadni a lokalizált adatokat.
3. Ha továbbra is a helyi dátumot és időt kell használnia, ne felejtse el figyelembe venni a referenciaidőhöz (UTC vagy GMT) viszonyított helyi időeltolást.
E szabályok betartása megóvja Önt a legtöbb logikai bugtól és hiányosságtól, ami azt jelenti, hogy a kód stabilabbá és minőségibbé válik.
Sziasztok!
Gyakran kell statisztikai adatokkal dolgoznom, és sok minden van dátumhoz kötve. Sőt, ugyanaz a dátum különböző formátumokban (például gépbarát és emberbarát) is felhasználható az oldalon. Azt hiszem, a legtöbben nagyon jó elképzelésekkel rendelkeznek arról a szörnyű kódról, amely a Date objektum használatából adódik.
Például, hogy az aktuális dátumot DD.HH.ÉÉÉÉ formátumban kapjuk meg, a következőket kell tennünk:
var d = new Date(), fd = d.getDate() + "." + (d.getHónap()+1) + "." + d.getFullYear();
És amikor sok ilyen sor van? Könnyű megjegyezni, hogy javascriptben a hónap nulláról indul, ha nem csak rajta fejlesztesz? Vagy az, hogy itt ezredmásodpercek vannak, és nem másodpercek, mint a háttérben szinte mindenhol? 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 rövid 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élda így írható:
var fd = tempus().format("%d.%m.%Y");
Most a sebességről. A spoilerben láthatja a Tempus és a Moment összehasonlítását, valamint a natív dátumformátumot (lásd fent):
A natív JS, MomentJS és TempusJS összehasonlítása
Szerezze meg az aktuális dátumot
Natív JS x 2 175 575 művelet/s ±0,75% (96 mintavételezés) Pillanat x 284 864 művelet/s ±0,85% (96 mintavételezés) Tempus x 2 086 081 művelet/s ±0,73% (97 mintavételezés)Formázás
Natív JS x 1 637 517 művelet/s ±0,61% (100 mintavételezés) Pillanat x 8 808 művelet/s ±1,07% (100 mintavételezés) Tempus x 942 815 művelet/s ±0,68% (94 mintavételezés)Dátum automatikus felismerése és elemzése
Natív JS x 11 204 316 művelet/s ±0,81% (88 mintavételezés) Pillanat x 38 511 művelet/s ±1,41% (95 mintavételezés) Tempus x 93 973 művelet/s ±1,06% (85 mintavételezés)Dátum elemzése formátum szerint
Pillanat x 46,293 művelet/s ±0,63% (100 mintavételezés) Tempus x 109,947 művelet/s ±0,93% (99 mintavételezés)Elemzés és érvényesítés
Pillanat x 44 588 művelet/s ±1,09% (90 mintavételezés) Tempus x 103 439 művelet/s ±0,90% (94 mintavételezés)Az eredmények a laptopomból származnak 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:
- IE6+, Chrome, Firefox, Opera támogatása;
- Támogatja a hívásláncokat;
- A hónapok nulla helyett 1-től kezdődhetnek (alapértelmezett);
- A ezredmásodpercek letilthatók (alapértelmezett) vagy engedélyezhetők;
- Gyors munka (Mert sok esetben a böngésző natív Date objektuma kerül felhasználásra, aminek megvalósítása gyorsabb nyelveken van megírva);
- Támogatja az egyéni formátumokat és bővítményeket
- A dátumellenőrzé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ég é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 egy másik példa a dátum formázására. Itt is használjuk a hívásláncolást. Minden egyes értékbeállítás végén visszakapunk egy TempusDate objektumot, amelyet a lánc lejjebb használhatunk. Példa:
tempus(). // kap új dátum calc((hónap: -1)). // csökkenti egy hónapig format("%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 a dátumelemzés.
// Egy TempusDate objektumot ad vissza "2013-11-18" dátummal tempus("11/18/2013"); // Egy TempusDate objektumot ad vissza "2013-12-12" dátummal tempus("2013-12-12", "%Y-%m-%d"));
A Tempus automatikusan képes felismerni néhány ismert formátumot. Ezenkívül megadhat egy adott 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:
// Mert A "123" nem egyezik a "%d.%m.%Y" formátummal, akkor // a 2013-01-01 dátumot tartalmazó objektum tempus("123", "%d.%m.%Y" ", tempus ());
Megtekintheti az alapértelmezett formátumok listáját
Most változtassuk meg a már formázott dátum formátumát
// "2013-11-05" tempus("11/05/2013").format("%Y-%m-%d"); // Vagy így // "October, 12" tempus("2013-10-12 12:31:01", "%Y-%m-%d %H:%M:%S").format(" % 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"); // Szabványos használati formátum // "Nov, 05" tempus(1383609600).format("%B, %d");
A Ebben a pillanatban Csak két nyelv van - orosz és angol, ezért szívesen segítek.
Érvényesítés
A dátum érvényesítése a következőképpen történik:// False tempus("08/32/2013", "%d.%m.%Y").valid(); // Visszaadja a true tempus("00:00 01/01/2012", "%H:%M %d.%m.%Y").valid();
Hiba esetén láthatja azokat a mezőket, amelyekben az előfordult - ahol az érték nem hamis:
// Visszatér ("year":-5,"month":false"day":false,"hours":false, // "minutes":false,"seconds":false,"ezreszekundum":false) tempus (). év (-5). // beállítva az évet=-5, azaz. érvénytelen hibák(); // 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 between metódust, amely megkeresi a különbséget két dátum között, és visszatér kívánt formátumot("é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 tempus().between(tempus(), "hónap" értéket ad vissza;
Vagy hány óra van még hátra az újévig
tempus().between(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
minimális. 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 megváltoztathatunk:
// TempusDate visszaküldése 2012-01-01 dátummal tempus().calc((év: 1, hónap: -4, nap: -1));
Saját formátumok
Saját formátumunkat alkalmazzuk a hónapra, amely 1 és 12 közötti értékeket vehet fel (01 és 12 helyett):// Új formátum regisztrálása tempus.registerFormat("%q", // direktíva - %q function(date) ( // Itt adja meg a formázási függvényt, azaz mi lesz a %q return date.month(); ) , function(value) (// És itt van az elemző függvény var v = Number(value); return (month: (isNaN(v) ? undefined: v) ); ), 1, // Ennek az értéknek a minimális hossza 2 vehet , // Max. hossz "szám" // Típus); // Tesztelés // "2013.01.01."-t adja vissza; tempus((év: 2013, hónap: 1, nap: 1)).format("%d.%q.%Y"); // Visszatér ("year":2013,"month":2"day":10,"hours":0,"minutes":0,"seconds":0); tempus("10.2.2013", "%d.%q.%Y").get();
Regisztrációkor é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 néhány formátumot, használja az unregisterFormat parancsot:
tempus.unregisterFormat("%d"); // „%d.01.2013”-t adja vissza, 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(), milliszekundum(), hét napja(), utc(), timestamp() vagy funkciók beállítása (). Például:tempus(). // Az aktuális dátum lekérése year(1900). // Hagyjon mindent úgy, ahogy van, de állítsa az évet 1900-ra leapYear(); // Ellenőrizd, hogy szökőév-e, ebben az esetben false tempus().year(); // És így megkapjuk az aktuális évet számszerű formában
Dátumgenerálás
Sokféleképpen hozhat létre dátumot, teljes lista paraméterei a dokumentációban találhatók. Íme egy minimális példa.// visszatér ["29.03.2013", "30.03.2013", "31.03.2013", "01.04.2013", "02.04.2013"]; tempus.generate(( dateFrom: "20130329", formatFrom: "%Y.%m.%d", dateTo: "20130402", időszak: (nap: 1), formátum: "%d.%m.%Y" ));
Ez hasznos lehet 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érhez intézett kérések nélkül. A dátum generálható tömbként vagy objektumként, ahol maguk a dátumok lesznek kulcsként használva (ez akkor hasznos, ha egy eseményt dátumhoz kell kötnünk, például ha saját naptárt készítünk). Ezenkívül a dátumok csoportosíthatók napok, hetek, hónapok, órák, évek szerint – bármi. Ez a naptárra is alkalmazható.
Beépülő modulok
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. Ezenkívül szükségünk van a TempusDate osztályra, amely a tempus.classes()-ban található. Íme egy példa plugin:(függvény (tempus) ( var TempusDate = tempus.classes("TempusDate"); tempus.randomDate = function() ( 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. floor((Math.random()*(date.dayCount() - tempus.MIN_DAY)) + tempus.MIN_DAY)).hours(Math.floor((Math.random()*(tempus.MAX_HOURS - tempus.MIN_HOURS)) ) + tempus.MIN_ÓRA)).perc(Math.floor((Math.random()*(tempus.MAX_MINUTES - tempus.MIN_MINUTES)) + tempus.MIN_MINUTES)).másodperc(Math.floor((Math.random()) *(tempus.MAX_SECONDS - tempus.MIN_SECONDS)) + tempus.MIN_SECONDS)); visszatérés dátuma; ); ))(tempus); // Most már létrehozhatunk ehhez hasonló dátumokat var someRandomDate = tempus.randomDate();
Úgy gondolom, hogy így kényelmesen lehet majd widgeteket írni a jQuery + Tempus, Angular + Tempus stb. használatával.
Források
A github forráskódjának letöltésével telepítheti: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 hogy adott könyvtár hasznos lesz, és azt is érdekes lenne tudni, hogy mi hiányzik belőle a könyvtár megfelelő irányú továbbfejlesztéséhez. Köszönöm a figyelmet!
P.S. Köszi a meghívást!