A dátum és az idő a mindennapi életünk része, ezért kiemelkedő helyet foglal el a programozásban. A JavaScriptet egy webhely létrehozásakor előfordulhat, hogy hozzá kell adnia egy naptárat, a vonat ütemezését vagy az interfészt a találkozók tervezéséhez. Ezeknek az alkalmazásoknak meg kell mutatniuk a megfelelő időtartamot a felhasználó aktuális időzónájától függően, vagy a légi jármű érkezésével és távozásával kapcsolatos számításokat, vagy bármely esemény kezdetét és befejezését. Ezenkívül előfordulhat, hogy a JavaScriptet bizonyos időpontban vagy szűrés esetén küldje el a JavaScriptet (például a nyitott éttermek kereséséhez).

Objektum dátuma.

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

Alapértelmezés szerint az új dátumfogyasztás argumentumok nélkül objektumot hoz létre az aktuális dátummal és idővel az aktuális számítógép rendszerbeállításainak megfelelően.

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

// Állítsa be a változót az aktuális dátumra és időre
Const most \u003d új dátum ();
// A kimenet megtekintése
Most;
Sze okt 18 2017 12:41:34 GMT + 0000 (UTC)

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

A dátum és az idő megszakad, és kényelmes az észleléshez.

Azonban JavaScript érzékeli a dátum alapján timestrate UNIX-idő, ami egy olyan érték, amely a ezredmásodperc óta eltelt éjfél január 1-jén, 1970-ig. Kaphat egy időbélyeget a gettime () módszerrel.

// kapja meg az aktuális időbélyegzőt
most.gettime ();
1508330494000

Nagyszámú, hogy megjelenik a kimeneti jel aktuális időbélyeg az ezredmásodperc óta eltelt éjfél január 1-jén 1970. október 18., 2017.

A nulla idő (vagy az EPOCH TIME) a \u200b\u200bdátumvonal, 1970. január, 1970 00:00:00 Univerzális idő (UTC) és egy időbélyegzés 0. Meg tudja jelölni a böngészőben egy új változó létrehozásával az EPOCH.JS fájlban és hozzárendeli egy új dátumfunkciót. Az időbélyegző 0 alapján.

// hozzárendelje az időbélyegzetet egy új változóhoz
CONST EPOCHTIME \u003d új dátum (0);
Epochtime;
Január 01, 1970 00:00:00 Univerzális idő (UTC)

A nulla időt a számítógépek mérésére szolgáló szabványként választották ki, és ezt a módszert Javascriptben használják. Fontos megérteni az ideiglenes címkéket és a dátumok sorát, mivel ezek a fogalmak az alkalmazás beállításaitól és célkitűzéseitől függően használhatók.

Most már tudod, hogyan kell létrehozni egy új dátum-példát az aktuális idő alapján és az időcím alapján. Összesen négy dátumformátum JavaScript. Az aktuális idő mellett az alapértelmezett és ideiglenes címke is használható a dátumok karakterlánc vagy meghatározott dátum és idő megadása.

Annak igazolására, különböző módokon linkek helyeket, próbálja új dátum objektumot, amelyet képviselt július 4-én, 1776 12:30 Greenwich háromféleképpen.

// időbélyegző módszer
Új dátum (-6106015800000);
// dátum string módszer
Ú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, 0);

Mindezek a példák ugyanazokat az információkat képviselik, mint a dátum és az idő három különböző módon.

Amint látja, az ideiglenes címke módszer negatív számmal rendelkezik; A nulla időre vonatkozó bármely dátumot negatív számként fogják bemutatni.

A második és milliszekundum harmadik példájában 0. Ha nincs elég adat a dátum objektum létrehozásakor, akkor hozzárendelni kell őket. változás. Azt is meg kell jegyezni, hogy a július hónapban 6, és nem pedig 7. Ez azért van, mert a számlálás nem kezdődik 1, hanem a 0. Többetől - a következő szakaszban.

A dátum eltávolítása a Get használatával

A dátumot, az összes összetevőjét különböző beépített módszerekkel érheti el. A módszerek a dátum minden egyes részét a helyi időzónához viszonyítják. Ezeknek a módszereknek mindegyike elkezdődik, és relatív számot ad vissza. Az alábbiakban részletes táblázat a dátum objektumhoz.

Dátum idő	Módszer	Hatótávolság	Példa
Év	getfulear ()	Yyyy.	1970
Hónap	getmonth ()	0-11	0 \u003d január.
A hónap napja	getdate ()	1-31	1 \u003d a hónap 1.1
A hét napja	dayday ()	0-6	0 \u003d vasárnap.
Óra	gethours ()	0-23	0 \u003d éjfél
Perc	getminutes ()	0-59
Második	getseconds ()	0-59
Miliszekundum	getmilliseconds ()	0-999
Ideiglenes címke	gettime ()

// inicializálja az új születésnapi példát
CONST BIRTHDET \u003d új dátum (1980, 6, 31);

Mostantól minden módszert használhat az egyes dátumkomponensek kivonására.

születésnap.getfulear (); // 1980.
Születésnap.getmonth (); // 6.
Születésnap.GetDate (); // 31.
Születésnap.7 (); // 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)

Néha csak a dátum egy részét kell kivonni, és a beépített szerzési módszerek segítenek Önnel.

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

// a mai nap dátuma
CONST ma \u003d új dátum ();
// hasonlítsa össze ma október 3-án
Ha (ma.getdate () \u003d\u003d\u003d 3 && mai nap .getmonth () \u003d\u003d\u003d 9) (
Konzol.log ("ez" október 3-án. ");
) MÁS (
Konzol.log ("ez nem október 3-ig");
}
Ez nem október 3-ig.

A beépített szerzési módszerek lehetővé teszik a dátumelemek elérését.

A dátum beállítása

A fent felsorolt \u200b\u200bösszes szerzési módszer esetében van megfelelő beállítási módszer. Ha a Get egy adott dátumösszetevő kivonására szolgál, az összetevők megváltoztatására használják. Az alábbiakban részletes táblázatot tartalmaz a dátum objektum szerinti beállított módszerekről.

Dátum idő	Módszer	Hatótávolság	Példa
Év	setFourear ()	Yyyy.	1970
Hónap	setmonth ()	0-11	0 \u003d január.
A hónap napja	dÁTUM BEÁLLÍTÁSA ()	1-31	1 \u003d a hónap 1.1
A hét napja	szekrény ()	0-6	0 \u003d vasárnap.
Óra	sethours ()	0-23	0 \u003d éjfél
Perc	setminutes ()	0-59
Második	setSeconds ()	0-59
Miliszekundum	setmilliseconds ()	0-999
Ideiglenes címke	beállítani az időt ()	A milliszekundumok száma nulla időből

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

// A születésnapi időpont változása
Születésnapi.setfonear (1997);
Születésnap;
Thu július 31 1997 00:00:00 GMT + 0000 (UTC)

Most, amikor egy változó születésnapot hívsz, amit nem látsz, és 1997-ben.

Beépített beállított módszerek lehetővé teszik a dátum objektum különböző részeit.

UTC módszerek

A fent leírt szerkesztési módszerek a helyi felhasználói zóna beállításai alapján megkerülik a dátumkomponenseket. A vezérlési időpontok és az időtartam növelése érdekében a Getutc módszereket ugyanúgy működtetheti, mint a szerkesztési módszerek, de az UTC szabvány (világszerte összehangolt idő) alapján kiszámíthatja az időt. Az alábbiakban az UTC módszer táblázat a JavaScript dátumobjektumához.

Dátum idő	Módszer	Hatótávolság	Példa
Év	getutclyear ()	Yyyy.	1970
Hónap	getutcmonth ()	0-11	0 \u003d január.
A hónap napja	getutcdate ()	1-31	1 \u003d a hónap 1.1
A hét napja	getutmday ()	0-6	0 \u003d vasárnap.
Óra	gotutchours ()	0-23	0 \u003d éjfél
Perc	getutcminutes ()	0-59
Második	getuteconds ()	0-59
Miliszekundum	getutcmilliseconds ()	0-999

A helyi szerkesztési módszerek és az UTC módszerek közötti különbség ellenőrzéséhez indítsa el a következő kódot.

// hozzárendelje az aktuális időt egy változóhoz
Const most \u003d új dátum ();
// Nyomtassa ki a helyi és az utc időzenét
Konzol.log (most.gethours ());
Konzol.log (most.getutchours ());

Ez a kód megjeleníti az aktuális időt és időt az UTC időzónában. Ha most az UTC időzónában van, akkor a program azon számok lesznek, amelyek visszavonulnak.

Az UTC nemzetközi időtartamot biztosít, ezért támogathatja a kódot az időzónáknak megfelelően, ha szükséges a programban.

Következtetés

Ebben a kézikönyvben megtudta, hogyan lehet létrehozni a dátum objektum példányát, hogyan kell használni a beépített módszereket egy adott dátum összetevőinek eléréséhez és megváltoztatásához. További információ a JavaScript időpontjáról és dátumáról A Mozilla Developer hálózaton találhatók.

A dátumokkal való együttműködés képessége fontos a JavaScript számos közös feladatához: rendszeres jelentések létrehozása a dátumok és ütemtervek megjelenítése előtt a megfelelő időzónában.

Címkék:

Üdv mindenkinek!
Gyakran kell dolgoznom a statisztikai adatokkal, és nagyon sok időpontban van kötve. Ezenkívül egy és ugyanazon dátumot használhatunk egy másik formátumban (például egy kényelmes gépben és kényelmes személyben). Azt hiszem, a legtöbbetek tökéletesen képviselik ezt a rémisztáló kódot, amelyet a dátum objektum használata során kapnak.
Például, hogy az aktuális dátumot dd.mm.ygyy formátumban kapja meg. A következőket kell tennünk:
var d \u003d új dátum (), fd \u003d d.getdate () + "." + (d.getmonth () + 1) + "." + d.getlyear ();
És amikor ilyen húrok sokat válnak? Könnyű megemlíteni, hogy a JavaScriptben egy hónap elindul a semmiből, amikor nemcsak rajta alakul ki? Vagy mi van milliszekundum, és nem egy másodperc, milyen szinte mindenütt a háttérben? Megoldhatja a népszerű könyvtár pillanatának feladatai részét.js, de nagyon lassan működik.
A vizsgált könyvtár megoldja ezeket a problémákat.
Ha kíváncsi vagyok, azt javaslom, hogy olvassa el ezt a kis áttekintést.

A TEMPUSJS nagyrészt a dátum objektum feletti szintaxiscukorból áll, így nagyon gyorsan működik. Maga a könyvtár szintaxisa nagyon egyszerű. Írja be például az előző példát, akkor:
var fd \u003d tempus (). Formátum ("% d.% m% y");
Most a sebességről. A spoilerben a TEMPUS-összehasonlítást a pillanat és a natív dátum formázási módszerrel láthatja (lásd fent):

A natív JS, Momentjs és Tempusjs összehasonlítása

Megkapjuk az aktuális dátumot

Native JS x 2,175,575 Op / sec ± 0,75% (96 futam) X 284,864 ops / sec ± 0,85% (96 futam) Tempus x 2,086,081 ops / sec ± 0,73% (97 futam)

Formázás

Natív JS X 1,637,517 OPS / SEC ± 0,61% (100 futamminta) X 8,808 ops / sec ± 1,07% (100 futam) Tempus x 942,815 OPS / sec ± 0,68% (94 futam)

A dátum és az elemzés automatikus felismerése

Native JS x 11,204,316 OPS / SEC ± 0,81% (88 futás) X 38,511-es műszer / sec ± 1,41% (95 futam) Tempus x 93,973 OPS / sec ± 1,06% (85 futam)

Dátum formátumban

MOMENT X 46.293 OPS / SEC ± 0,63% (100 futamminta) Tempus x 109.947 OP / sec ± 0,93% (99 futam)

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

MOMENT X 44,588 OPS / SEC ± 1,09% (90 futóminta) Tempus x 103,439 OPS / sec ± 0,90% (94 futási minta)
Az eredményeket a Google Chrome 30.0.1599.14-ben szerezték meg. Más böngészőkben az eredmények különböznek, de az arány ugyanolyan marad.
A Használt könyvtári benchmark.js teszteknél
A többi funkcióval kapcsolatos referenciaértéket láthatja.

Tehát a könyvtár előnyei során a következőket rögzítheti:

• Támogatja az IE6 +, Chrome, Firefox, Opera;
• Támogatja a hívások láncát;
• Hónapok kezdődhetnek az 1 (alapértelmezett), nem nulla;
• A milliszekundumok le vannak tiltva (alapértelmezés szerint), vagy tartalmazza;
• Gyors munka (mivel sok esetben a dátum objektumot a böngésző számára használják, amelynek végrehajtása gyorsabban van írva);
• Támogatja az egyéni formátumokat és a bővítményeket
• A dátum validálása nagyon gyors, és csak a funkciók beállítási dátumától függ (mivel a hitelesítés már a növekvő értékek alatt van, és nem számítva külön-külön);
• A felhasználói nyelv többnyelvű és automatikus meghatározása.

Itt csak néhány funkcióról lesz.

Formázás és csomag

Tehát az indítók számára egy másik példa a dátum formázására. Itt is használunk lánc kihívásokat is. Az egyes beállítások végén kapunk egy tempusdate objektumot, amelyet a láncban tovább lehet használni. Példa:
Tempus (). // kap egy új dátumot ((hónap: -1)). // csökkenti egy hónapos formátumot ("% d.% M% y"); // megjelenítés egy karakterlánc formájában
Így ugyanazon a napon, egy óra és egy második, de egy hónappal ezelőtt kapunk. Ez hasznos az elmúlt hónapban jelentésekre.

A következő példa a dátumok parceling.
// visszaadja az objektum tempusdates dátumát "2013-11-18" Tempus ("18.11.2013"); // visszaadja az objektum tempusdate-t a "2013-12-12" Tempus dátummal ("2013-12-12", "% y-% m-% d"))));
A Tempus automatikusan meghatározhatja az ismert formátumokat. Ezenkívül megadhat egy adott formátumot, akkor a csomag gyorsabban fordul elő. Plusz megadhatja azt a dátumot, amelyet vissza kell adni, ha az elemzés sikertelen:
// t.k. "123" nem felel meg a "% d.% M% y" formátumban, majd // A 2013-01-01 Tempus dátumát tartalmazó objektum visszakerül ("123", "% d.% M% y ", Tempus ());
A formátumok listája alapértelmezés szerint megtekinthető.

És most módosítsa a már formázott dátum formátumát
// "2013-11-05" Tempus ("05.11.2013"). Formátum ("% y-% m-% d); // Of // "október, 12" Tempus ("2013-10-12 12:31:01", "% Y-% m-% d% h:% m:% s"). Formátum ("% B,% d ");

A formázáshoz is használhatja a lokalizációt. Alapértelmezés szerint a felhasználói nyelv kiválasztása (Vegye ki a böngészőből) vagy az alapértelmezett nyelvet, ha a felhasználói nyelvet nem észleli a rendelkezésre álló tempus nyelvek között.
// telepítse a tempus.lang nyelvet ("ru"); // standard használatra formátum // "november, 05" tempus (1383609600) .Format ("% b,% d");
Jelenleg a nyelvek csak két - orosz és angol, így örömmel segítek.

Érvényesítés

A dátum érvényesítése az alábbiak szerint történik:
// vissza a hamis tempus ("32.08.2013", "% d.% M% y"). Érvényes (); // megtartja az igazi tempust ("00:00 01.01.2012", "% h:% m% d.% M.% y"). Érvényes ();

Hiba esetén láthatja azokat a mezőket, amelyekben származik - mindenütt, ahol az érték nem hamis:
// Return ("Év": - 5, "hónap": hamis, "nap": hamis, "Órák": hamis, // "perc": hamis, "másodperc": hamis, "Milliszekundum": hamis) Tempus (). Év (-5). // Állítsa be az évet \u003d -5, azaz. Nevid hibák (); // kap egy objektum hibákkal

DAT tartományok

Néha meg kell kapnunk az évek számát (például életkor), hónapok, napok stb. két dátum között. Ehhez használhatjuk azokat a módszert, amelyek két dátum közötti különbséget találnak és a kívánt formátumban ("év", "hónap", "nap", "órák", "perc", "másodperc", Milliszekundum ").
Itt van egy egyszerű példa arra, hogy megkapja a hónapok számát 2013. november 1-jétől és május 5-én, 2014. május 5-én:
// visszatér 6 tempus (). Között (tempus (), "hónap");
Vagy hány órát hagyott az új év előtt
Tempus (). Között (tempus (), "óra");
Az utolsó példában láthatod, hogy csak az évre mutatottam. Amikor az értéket tömb vagy objektummal állítjuk be, az értékek hiánya lesz
kitöltött minimális. A Minimális értékekkel rendelkező állandók listája látható a dokumentációban.

Azt is megváltoztathatjuk a dátumot a Calc funkció használatával:
// visszatérési tempusdate a dátum 2012-01-01 Tempus (). Calc ((év: 1, hónap: -4, nap: -1));

Formátuma

A formátumot egy hónapra használjuk, amely 1-től 12-ig (és nem 01-12) értékre vehetjük:
// új formátumú tempus.registerformat ("% q", // irányelv -% q funkció (dátum) (dátum) (dátum) (// jelölje meg a formázási funkciót, azaz a% Q visszaadási dátum helyett helyettesíthető. ), Függvény (érték) (// és itt a var v \u003d szám elemző funkció; visszatérés (hónap: (ISNAN (v)? Undefined: v);), 1, // minimális hossz, amely 2, // Maximális hosszúságú "szám" // típus); // teszt // visszatérítés "01.1113"; Tempus ((év: 2013, hónap: 1, nap: 1)). Formátum ("% d.% Q.% y"); // megőrzés ("É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 láthatja, hogy egyes paraméterek külön-külön vannak megadva, míg a rendszeres kifejezés használható. Valójában eredetileg ez volt, de az elutasítás után a sebesség néhány tucatszor emelkedett.
Ha meg kell törölnie a formátumot, használja az UnregisterFormat használatát:
Tempus.unregisterformat ("% d"); // visszatérés "% D.01.2013", mert A% D irányelv már nem létezik. Tempus.format ((év: 2013, hónap: 1, nap: 1), "% d.% M.% Y");

Getter / setters

Bizonyos értékeket kaphat / beállíthat az év (), hónap (), nap (), gépek (), percek (), másodperc (), milliszekundum (), napi (), UTC (), UTC (), időbélyegző () vagy beállítva (). Például:
Tempus (). // megkapja az aktuális dátumot (1900). // hagyja mindent, ahogy van, de telepítjük az 1900-as lepyear (); // ellenőrzése, hogy ez az év egy év, ebben az esetben hamis tempus (). Év (); // és így megkapjuk az aktuális évet a numerikus formában

Generációs dat.

A dátumot sokféle módon generálhatja, a paraméterek teljes listája a dokumentációban van. Itt van egy minimális példa.
// "03/29/2013", "03/30/2013", "03/30/2013", "04/01/2013", "04/01/2013", "04/02/2013"]; Tempus.generate ((dátumfutó: "20130329", formátumfrom: "% y.% M.% D", dateto: "20130402", időszak: (Nap: 1), formátum: "% d.% M.% Y" ));
Hasznos lehet a grafikonok megjelenítéséhez dátum szerint, és a kijelzési formátumot közvetlenül az ügyfélre változtathatja, anélkül, hogy a backendre szüksége lenne. A dátumot tömbként lehet generálni, valamint olyan tárgyakat, ahol maguk a dátumok kulcsokként vannak (ez hasznos, ha bármilyen eseményt bármilyen időpontra kell kötnünk, például amikor naptárat készítünk). Ugyanakkor a dátumok napi, hetek, hónapok, órák, évek - bármit is csoportosíthatók. Ez a naptárra is alkalmazható.

Pluginok

Nos, az utolsó - pluginok. Itt bővítjük a gyárat, hogy véletlenszerű dátumot generáljunk. Szükségünk van egy Tempusdate osztályra is, megtalálható a Tempus.Classes (). Itt van egy példa egy pluginra:
(Tempusdate \u003d tempus.Classes ("tempusdate"); tempus.randomdate \u003d funkció () (var dátum \u003d új tempusdate (); dátum.year (Math.Floor (Math.Random () * (tempus.mar_year - tempus. min_year)) + tempus.min_year)). hónap (Math.Floor ((Math.Random () * (tempus.max_month - tempus.min_monteh)) + tempus.min_month)). Nap (matematika (Math.Random) () * (date.daycount () - tempus.min_day)) + tempus.min_day)). Óra (Math.floor ((Math.random () * (tempus.main_hours)) + Tempus.min_hours)). Perc ( Math.Floor ((Math.Random () * (tempus.main_minutes)) + tempus.min_minutes). Másodpercek (Math.Floor ((Math.Random () * (tempus.max_seconds - tempus.min_seconds)) + Tempus. min_seconds)); Visszatérési dátum;);)) (Tempus); // Most megteremthetjük a dátumokat a következőképpen var somerandomdate \u003d tempus.randomdate ();
Úgy gondolom, hogy így kényelmes lesz a widgetek írása egy jQuery + tempus, a szögletes + tempus és hasonlók segítségével. 2014. december 7-én 12: 30-kor

Dátum és időproblémák JS-ben

• JavaScript.

A ritka programozó úgy történik, hogy elkerülje a dátumot és az időt. Általában a dátum / idő alapvető koncepció és a nyelvek nagy részében vannak beépített mechanizmusok az ilyen típusú adatokkal való munkavégzéshez. Úgy tűnik, hogy a JS nem kivétel, van egy beépített típusú dátum, van azonban egy csomó funkció a prototípusban, de ...

Ki bűnös

Az első probléma akkor fordul elő, ha be kell állítania a dátumot / időt az UTC és a helyi időzónájában. A dátumtervezőnek nincs ilyen paramétere.

Új dátum (); Új dátum (érték); Új dátum (adatérték); Új dátum (év, hónap [, nap [, óra [, perc [, perc [, második [, milliszekund]]]);
Az egyetlen lehetőség, ahol megadhatja az Offset-t az UTC-hez viszonyítva - a harmadik módszerhez. A formátumú konstruktorhívás lehetővé teszi az eltolás átvitelét a sor részeként:

Új dátum ("Sun február 1, 1998 00:00:00 GMT + 0700")
A sor az RFC2822 formátumban elfogadható, nagyon kényelmetlen és nehéz kézzel történő bevitelben. Szinte lehetetlen, hogy ilyen karakterláncot kapjon a felhasználói bemenetről. Nem tudom elképzelni, hogy egy olyan személy, aki beleegyezett abba, hogy adja meg a dátumot egy ilyen formátumban.

Annak ellenére, hogy az összes paramétert külön-külön állapíthatja meg az UTC Times számára - a problémák nem oldják meg - az időzóna helyi marad. De ez nem az egyetlen probléma.

Az UTC-hez viszonyítva nem állandó. Ez egy dátum, idő (nos, vagy Timesshampa) funkciója, ha kérem), és ismét az időzónát. Például Moszkvához, az utolsó átutalás:

Új dátum (2014, 9, 25, 0, 0, 0); // 26.10.2014, 21:00:00 GMT + 3 új dátum (2014, 9, 27, 0, 0, 0); // 25.10.2014, 22:00:00 GMT + 4
Így a harmadik változat tervezője szinte haszontalan lesz, mert az eltolásnak előre ismerni kell. És azt, ahogy azt mondta, így egyszerűen megkapta. Az egyetlen könyvtár, amit kaptam, amely az Olson adatbázist használja a műszakok eltolódásához - TimeZone-Js. A könyvtár használatának problémája az, hogy a földalatti könyvtárak (dátum / idő picker-ek) nem ismernek semmit, és ragaszkodjanak a szabványos dátumot. A dátum objektummal dolgozó fennmaradó könyvtárak nyilvánvalóan nem utalnak erre az adatbázisra, és a frissítések nem kapják meg. (Javítsa meg a megjegyzéseket.)

Az időzóna használatának üzleti tevékenysége csak akkor van értelme, ha a dátum és az idő meg van adva. Például, ha a munkanap 9: 00-kor kezdődik, akkor valószínűleg azt várja, hogy a Vladivostokból származó kollégája 15:00 óráig dolgozik. A tatonokat nem szabad figyelembe venni, és ebben az esetben meg kell jeleníteni az UTC dátumát. Azonban a különböző időzónákban egy időben előforduló rendszeres események esetén még mindig szükség van az időre. Például a napi heg 10:00 órakor kezdődik, és 13:00 órakor Novoszibirszkért. By the way, ez pontosan a különbség a GMT és az UTC között. Az UTC az eltolás nélküli idő, és a GMT az idő az elmozdulással 0. Megmagyarázom a példát:

2014/12/31, 20:59:59 GMT A moszkvai idő kell kinéznie 2014/12/31, 23:59:59 2014/12/12, 20:59:59 UTC a moszkvai idő kell kinéznie a 12/31/2014, 20:59: 59.
Ez az aritmetika miatt elsősorban zavaros. Sajnos ez a paraméter mindenütt lakott. A JS-ben való idő közvetlen jelzését helyi időzónként értelmezik, és az UTC és a GMT utasítása egyenértékű.

Egy helyzetben segíthetek az intl-nek. Lehet, de nem köteles. Különösen van ilyen paraméter-időzóna, de egy kicsit tovább, a szabvány meghatározza: az időzónát. Az egyetlen értékeltetésnek fel kell ismernie az "UTC". Jelenleg a króm mellett nem egy böngésző önkényes időzítő nem támogat.
A JS-ben lévő időszalagokkal minden teljesen rossz - nincs ilyen, mint a nyelv. Szeretné jól csinálni magam.

Mit kell tenni

• 1.opció.

  Ne használjon tetszőleges Timson-t. Az opció előnyösebb és valószínűleg a legfájosabb. Vagyis csak helyi idők és UTC vannak. Ezekre az esetekre minden böngészőben úgy tűnik, hogy minden, bár sem nagyon kényelmes. Ezenkívül az idő globálisan van beállítva az operációs rendszerhez, és módosítja azt, hogy egy adott webes alkalmazás NotoSherly.

• 2. lehetőség.

  Ha tetszőleges időre van szükség - nem használja az időbélyegzőt. Egyáltalán. Tárolja az időt a megtakarítási pénztárban az RFC karakterláncban, jelezve az időzónákat. Nem biztos benne, hogy ez segíti az időzítő eltolódását a kereszt böngésző megértésében, de legalábbis króm az ilyen változásokról a tudásban.

• 3. lehetőség.

  Vannak különböző helyzetek, és ez megtörténik, hogy az adatbázis időpontjában bármely eszközzel rögzül. Azaz timestampa formájában. Itt nincs hely, amely helyesen jeleníti meg az időt, amit meg kell ismernie az eszköz időtartamát, vagy a felhasználó thaimonját, vagy mindkét másikat, és azonosítja az összes mozgását. Olon bázisának használata nélkül ne tegye itt.

Ennek a megfelelőnek kell lennie, de nincs többé hozzá. Az ECMA szabvány tervezetében nem tartom meg az előrehaladást, valószínűleg nem.

Egy másik hasznos dolog a webhelyek számára az aktuális dátum beillesztése. A dátumok szkriptek példái megtalálhatók az interneten tucatnyi, de sokan véleményem szerint nehézek és ezért csúnyaak. Közben szabványos eszközök segítségével JavaScript., Helyezze be a webhely oldalán található dátumot nagyon egyszerű lehet. Gyakran alkalmazom! A képen (képernyőkép az operációs helyre) "Tündérmes" !

Itt van az egész dátum szkript:

Véleményem szerint könnyebb a semmi, nagyon szép és érthető. Ha nincs vágya, hogy tanulmányozza a szkript kialakítását, akkor egyszerűen illessze be a HTML oldal bármely helyére, és kapja meg a következő felirat:

Egy további lehetőség fejlettebb

! Ma

Úgy néz ki, mint ez:

Ma

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

Olvass tovább:

Tehát kezdje el a változó dátumértékének hozzárendelésével d., akkor hozzon létre tömlőket ( Sor.) A hét napjaira ( nap.) és hónapok ( hÓNAP.), jelezve őket a szükséges nyelvtani formában: az ügy, a szám, a cím betű, ha a szó a dátum elején stb. A szkript utolsó sora valójában a dátum nyomtatása ( dokumentum.Write.). Itt telepítheti, hogy melyik sorrendben jelenik meg az aktuális dátum sorában. Alkatrészeket különítenek el egymástól. + . Az építményt egy térbe való belépéshez használják " " , és a G levélbe való belépéshez - Design "G."

Amint a szkriptből látható, az aktuális időre vonatkozó adatok fogadása az elemet elvégzi kap.. Ez a módszer lehetővé teszi a következő információkat:

• getdate () - visszaadja az 1-31-es számot, amely a hónapok számát képviseli;
• dayday () - visszaadja a hét napját, mint egész számot 0 (vasárnap) 6 (szombat);
• getmonth () - Visszaadja az évek számát;
• getfulear () - Visszaadja az évet. Ha egyszerűen használ getyear ()Ezután az aktuális év kimenet mínusz 1900;
• Óra () - visszatér egy órányi nap;
• getminutes () - a pillanatokat 0-ról 59-re adja vissza;
• getseconds () - Visszaadja a másodpercek számát 0-ról 59-re.

Helyezzen be közvetlenül Jáva.A webhelyen belüli szkript nem mindig kényelmes. Jobb, ha a szkript leírását a címkék között az oldal tetejére helyezi És állítsa be azt a változót, amelyet a szövegben szükség szerint hívunk. Hívjuk Ma. És a kimeneti űrlapot hasonlóan meghatározzuk a fentiekhez. A szkript így fog kinézni:

A dátum megjelenítéséhez hívja a parancsfájlt az oldal HTML oldalának megfelelő helyén a következő parancs segítségével:

Ha webhelye számos olyan oldalt tartalmaz, amelyen meg szeretné mutatni a dátumot, kényelmesebb az elosztani Jáva.A szkript kimeneti dátuma egy külön fájlban, például, például, data.js.. Gyakorlatilag ez egy olyan oldal, amely a leírt parancsfájlok közül az első, azaz egy karakterlánc dokumentum.Write. (lásd fent). Szükségesnek kell lennie ugyanabban a könyvtárban, mint a főoldal, és a dátumot a kimeneti helyen a következőképpen okozza:

Ne felejtsd el ellenőrizni a fájlt data.js. Ugyanaz volt a kódolása, mint a fő dokumentum, különben a dátumot csodálatos horgokkal, négyzetekkel és más Fintyphikivel eltávolítják.

Megjegyzés. Emlékeztetni kell arra, hogy a leírt parancsfájl megjeleníti a felhasználó számítógépén beállított dátumot, amely nem mindig felel meg a valódi aktuális időnek. Ha pontos időt kell mutatnia, akkor a PNP parancsfájlot kell használnia, amely időt mutat a kiszolgálón.

A JavaScript aktuális dátuma nagyon egyszerű. Ebből a célból a dátumobjektum célja. Szintaxisja meglehetősen egyszerű, és a módszerek neve intuitív módon érthető. Az alábbi példákban megmutatom, hogyan kell dolgozni a dátum objektummal ( JavaScript új dátum.) Az aktuális év, a hónap, a nap és az idő elérése a milliszekundum pontosságával!

Az aktuális dátum fogadása:

A JavaScript aktuális dátumának megszerzéséhez használja az új kulcsszót a dátum objektum új példányának létrehozásához.

vAR dátum \u003d új dátum (); Konzol.log (dátum);

Ez a kód a következő információkat jeleníti meg a konzolnak:

// Tue február 02 2016 15:46:56 GMT-0500 (keleti szabvány)

Megjeleníti a hét aktuális napját, az aktuális hónapot, a hónap napját, az évet, és akár az aktuális időt 24 órás formátumban. Fragmentum GMT."Greenwich time, és" -0500 "Ez a helyi idő és a GMT közötti időzónák különbsége.

Idézet a Wikipedia: "Greenwich átlagos ideje ( GMT.) - Ez egy másodlagos napsütéses idő a Greenwichi Királyi Megfigyelőközpontban, Londonban. " Ez kapcsolódik univerzális koordinált idő (UTC.). « Kelet-standard idő."A megjelenített időpontban a böngésző vagy a számítógép időzónájára utal.

* Kérjük, vegye figyelembe, hogy a GMT és az UTC különbözik egymást. Az UTC értékeket percekben tartjuk meg.

* Szintén fontos megjegyezni, hogy a dátum a JavaScript határozza meg ezredmásodpercben, amely átment éjfél óta január 1. 1970 UTC-kor. Egy nap 86.400.000 milliszekundum. A dátum objektum tartománya -100 000 000 nap és 100.000.000. nap között, 1970. január 1-jéig, UTC.

* A fent említett módszerrel kapott értékek függenek a készülék rendszerbeállításaitól. Ha módosítja a számítógép óra beállításait, akkor a visszaküldött idő megváltozik.

Nos, új dátumú JavaScript formátumokkal foglalkozunk, és most készen állunk továbblépni!

A hét napjának megszerzése:

Ahhoz, hogy megkapja a hét napját, használja a módszert JavaScript objektum dátuma Gonddás ():

var day \u003d dátum.getday (); Konzol.log (nap);

* Kérjük, vegye figyelembe, hogy a hét napjai 0 és 6 között vannak, vasárnap \u003d 0, hétfő \u003d 1, kedd \u003d 2 és így tovább.

Egy hónap:

Ahhoz, hogy az ebben az évben az aktuális hónap, használja a getmonth () módszert. Ezt megelőzően azt mondtam, hogy a módszerek neve intuitív módon megérti!

var hónap \u003d dátum.getmonth (); Konzol.log (hónap); //egy

* Kérjük, vegye figyelembe, hogy a hét napjaihoz hasonlóan a hónapok 0-tól 11-ig numerikus formátumban kerülnek vissza; Január \u003d 0, február \u003d 1, március \u003d 2 és így tovább.

A hónap napjának megszerzése:

A hónap napjának megszerzéséhez használhatja a GetDate () módszert.

var dayofmonth \u003d dátum.getdate (); Konzol.log (dayofmonth); // 2.

* GetDate () módszer visszaadja a hónap napjait, számozott 1-től 31-ig; Az 1. szám megfelel a hónap első napjának.

Idő megszerzése:

Az aktuális idő megszerzéséhez a gettime () módszert használják.

var time \u003d dátum.gettime (); Konzol.log (idő); // 1454461242058.

Furcsa ... Mi az? Látod az 1970. január 1-jétől, 00: 00:00 óta. Szóval milyen régi?

1454461242058 ms / 31540000000 ms évente \u003d körülbelül 46 év
1970 + 46 éves \u003d 2016

Ellenőrizze, hogy megbizonyosodjon róla:

var év \u003d dátum.getfulear (); Konzol.log (év) // 2016

Igen ez az! Épp most hoztuk az aktuális dátumot és időt a JavaScript új dátumával.