JavaScript Ստացեք ընթացիկ ժամը և ամսաթիվը: TempusJS - աշխատում է ամսաթվի հետ javascript Node js ընթացիկ ժամանակում

JavaScript-ում ընթացիկ ամսաթիվը ստանալը շատ հեշտ է: Ահա թե ինչի համար է Date օբյեկտը: Դրա շարահյուսությունը բավականին պարզ է, և մեթոդների անվանումները ինտուիտիվ են: Ստորև բերված օրինակներում ես ձեզ ցույց կտամ, թե ինչպես աշխատել Date օբյեկտի հետ ( JavaScript-ի նոր ամսաթիվ) ընթացիկ տարին, ամիսը, օրը և ժամը մոտակա միլիվայրկյան հասցնելու համար:

Ստանալով ընթացիկ ամսաթիվը.

JavaScript-ում ընթացիկ ամսաթիվը ստանալու համար օգտագործեք հիմնաբառնոր՝ Date օբյեկտի նոր օրինակ ստեղծելու համար:

var date = new Date(); վահանակի մատյան (ամսաթիվ);

Այս կոդը վահանակում տպում է հետևյալ տեղեկատվությունը.

//Երեք փետրվարի 02 2016 15:46:56 GMT-0500 (Արևելյան ստանդարտ ժամանակ)

Այն ցուցադրում է շաբաթվա ընթացիկ օրը, ընթացիկ ամիսը, ամսվա օրը, տարին և նույնիսկ ընթացիկ ժամը 24-ժամյա ձևաչափով: հատված» GMT«նշանակում է GMT ժամանակ, և» -0500 ' տեղական ժամանակի և GMT-ի միջև ժամային գոտիների տարբերությունն է:

Մեջբերում Վիքիպեդիայից. «Գրինվիչի միջին ժամանակ (GMT) GMTԱրեգակնային միջին ժամանակն է Թագավորական աստղադիտարանում, Գրինվիչ, Լոնդոն»: Դա կապված է UTC (UTC). « Արևելյան ստանդարտ ժամանակՑուցադրվող ամսաթվի արժեքի '-ը վերաբերում է ձեր բրաուզերի կամ համակարգչի ժամային գոտուն:

* Խնդրում ենք նկատի ունենալ, որ GMT-ը և UTC-ն տարբեր են: Մենք հաշվի կառնենք UTC արժեքները րոպեների ընթացքում:

* Նաև նկատի ունեցեք, որ JavaScript-ում ամսաթիվը որոշվում է 1970 թվականի հունվարի 1-ի կեսգիշերից UTC ժամանակով միլիվայրկյաններով: Մեկ օրում կա 86,400,000 միլիվայրկյան: Date օբյեկտի տիրույթը -100,000,000 օրից մինչև 100,000,000 օր է՝ 1970 թվականի հունվարի 01-ի UTC-ի համեմատ:

* Վերը նշված մեթոդով ստացված արժեքները կախված են ձեր սարքի համակարգի կարգավորումներից: Եթե փոխեք համակարգչի ժամացույցի կարգավորումները, ապա այս մեթոդով վերադարձված ժամանակը նույնպես կփոխվի:

Լավ, մենք դուրս ենք եկել JavaScript ամսաթվի նոր ձևաչափերից և այժմ պատրաստ ենք առաջ շարժվել:

Ստանալով շաբաթվա օրը.

Շաբաթվա օրը ստանալու համար օգտագործեք մեթոդը JavaScript ամսաթվի օբյեկտ getDay():

varday = date.getDay(); վահանակի մատյան (օր);

*Նշեք, որ շաբաթվա օրերը համարակալված են 0-ից մինչև 6, կիրակի = 0, երկուշաբթի = 1, երեքշաբթի = 2 և այլն:

Ստացեք ամիսը.

Ընթացիկ տարվա ընթացիկ ամիսը ստանալու համար օգտագործեք getMonth() մեթոդը: Մինչ այդ ես ասացի, որ մեթոդների անվանումները ինտուիտիվ են։

var ամիս = date.getMonth(); վահանակի մատյան (ամիս); //մեկ

* Նկատի ունեցեք, որ, ինչպես շաբաթվա օրերը, ամիսները վերադարձվում են թվային ձևաչափով՝ 0-ից 11; Հունվար = 0, Փետրվար = 1, Մարտ = 2 և այլն:

Ստանալով ամսվա օրը.

Ամսվա օրը ստանալու համար կարող եք օգտագործել GetDate() մեթոդը:

var dayOfMonth = date.getDate(); վահանակի տեղեկամատյան (dayOfMonth); //2

* GetDate() մեթոդը վերադարձնում է ամսվա օրերը՝ համարակալված 1-ից մինչև 31; թիվ 1-ը համապատասխանում է ամսվա առաջին օրվան:

Ժամանակ ստանալը.

Ընթացիկ ժամանակը ստանալու համար օգտագործվում է GetTime() մեթոդը:

vartime = date.getTime(); վահանակի մատյան (ժամանակ); //1454461242058

Թվում է... տարօրինակ... Ի՞նչ է դա։ Դուք տեսնում եք 1970 թվականի հունվարի 1-ից 00:00:00 UTC անցած միլիվայրկյանների թիվը: Այսպիսով, քանի տարեկան է դա:

1454461242058 ms / 31540000000 ms տարեկան = մոտ 46 տարի
1970 + 46 տարի = 2016 թ

Եկեք ստուգենք՝ համոզվելու համար.

var տարի = date.getFullYear(); console.log (տարի) //2016

Այո, սա այն է: Մենք նոր ենք հանել JavaScriptնոր ամսաթիվ ընթացիկ ամսաթիվը և ժամը:

JavaScript - Դաս 11. Ամսաթիվ, ներկայացում և մշակում

JavaScript-ում ամսաթիվը սահմանվում է որպես 1970 թվականի հունվարի 1-ից անցած միլիվայրկյանների թիվը:

Ներկառուցված օբյեկտն օգտագործվում է ամսաթվի և ժամի հետ աշխատելու համար Ամսաթիվ. Այս օբյեկտը չունի հատկություններ, բայց ունի մի քանի մեթոդներ, որոնք թույլ են տալիս սահմանել և փոխել ամսաթիվը և ժամը:

Օբյեկտ Ամսաթիվստեղծված օպերատորի հետ նորև կոնստրուկտոր - Ամսաթիվ.

Օրինակ:

var myData=նոր ամսաթիվ();

Փոփոխական արժեք myDataկլինի ընթացիկ ամսաթիվը և ժամը.

Օբյեկտի մեթոդներ ԱմսաթիվԴուք կարող եք առանձին ստանալ ամսվա, շաբաթվա օրվա, ժամերի, րոպեների և վայրկյանների արժեքները.

ստանալ ամսաթիվ- վերադարձնում է 1-ից 31-ի միջև ընկած թիվը, որը ներկայացնում է ամսվա օրը:
ստանալԺամեր- վերադարձնում է օրվա ժամը 0-ից (կեսգիշեր) մինչև 23 միջակայքում:
ստանալ րոպեներ- վերադարձնում է րոպեները 0-ից 59 միջակայքում:
ստանալ վայրկյաններ- վերադարձնում է վայրկյանները 0-ից 59 միջակայքում:

Ենթադրենք, մենք ցանկանում ենք գրել սցենար, որը կորոշի ընթացիկ ժամանակը և այն կթողարկի «hh:mm:ss» ձևաչափով։

javascript ամսաթիվը

Հիմա եկեք գրենք ֆունկցիան ինքնին nTime ():

ֆունկցիա nTime(obj) ( var t=new Date(); var h=t.getHours(); var m=t.getMinutes(); var s=t.getSeconds(); var արդյունք=h+":"+m+ ":"+s; obj.res.value=result;)

* ինչպես հիշում եք, մեթոդները օբյեկտից բաժանվում են կետով, մենք այս մասին խոսեցինք 3-րդ դասում *Ինչպես տեսնում եք, ամեն ինչ պարզ է. Սկզբում մենք որոշում ենք ընթացիկ ժամանակը, այնուհետև, օգտագործելով մեթոդներ, դրանից հանում ենք ժամերի, րոպեների և վայրկյանների անհատական արժեքները:

Այստեղ ես կցանկանայի հստակեցնել գիծը var result=h+":"+m+":"+s. Առաջին անգամ մենք բախվեցինք արդյունքին ինչպես փոփոխական արժեքներ, այնպես էլ պարզ տեքստ դուրս բերելու անհրաժեշտության հետ: Սկզբունքորեն, ոչ մի բարդ բան չկա. փոփոխականները գրվում են այնպես, ինչպես կա, տեքստը վերցվում է չակերտների մեջ, իսկ նշանը. + կատարում է կապակցման գործողությունը, այսինքն. նրանց ասոցիացիաները:

Մեր օրինակում կար մեկ թերություն, մենք ուզում էինք, որ ժամանակը ցուցադրվի «hh:mm:ss» ձևաչափով, իսկ հիմա այն ցուցադրվում է «h:m:s» ձևաչափով։ Այսինքն՝ ժամը 5-ին ժամը կցուցադրվի «5:0:0», բայց ես կուզենայի այսպես՝ «05:00:00» (որն ավելի ծանոթ է): Ինչպես Տնային աշխատանքդուք կարող եք փորձել ուղղել այն: Օրինակ, օգտագործելով օպերատորը եթեիսկ տողը բառացի «0» (գաղափարը պարզ է. եթե ժամերը 10-ից պակաս են, ապա արդյունքում առաջ. հգրել «0» և այլն բոլոր փոփոխականներով):

Այդ ընթացքում շարունակենք ուսումնասիրել օբյեկտի մեթոդները Ամսաթիվ:

ստանալ օր- վերադարձնում է շաբաթվա օրը որպես ամբողջ թիվ 0-ից (կիրակի) մինչև 6 (շաբաթ):
ստանալ ամիս- վերադարձնում է տարվա ամսվա թիվը՝ որպես ամբողջ թիվ 0-ից (հունվար) մինչև 11-ը (դեկտեմբեր):
getYear- վերադարձնում է տարին որպես վերջին երկու թվանշան ( getFullYearվերադարձնում է տարին որպես չորս նիշ):
* Ցավոք, 2000 թվականից ի վեր տարբեր բրաուզերներում տարին ցուցադրելու խնդիր կա: IE-ում getYear մեթոդը ցուցադրում է ամբողջ տարին (վերջին երկու թվանշանի փոխարեն), մինչդեռ FireFox-ը ցուցադրում է 1XX-ը՝ XX-ի փոխարեն (այսինքն՝ փոխարինում է 1-ին): Ուստի նախընտրելի է օգտագործել getFullYear մեթոդը։

Եկեք գրենք սցենար, որը կորոշի ընթացիկ ամսաթիվը և թողարկի այն «օր ամսվա տարի» ձևաչափով:

html էջի կոդը պարզ կլինի.

javascript ամսաթիվը

Հիմա եկեք գրենք ֆունկցիան ինքնին tData ():

tData(obj) ֆունկցիա (var s; var t=new Date(); var y=t.getFullYear(); var d=t.getDate(); var mon=t.getMonth(); անջատիչ (երկ) (գործ. 0: s="հունվար"; ընդմիջում; դեպք 1: s="փետրվար"; ընդմիջում; դեպք 2: s="մարտ"; ընդմիջում; դեպք 3: s="ապրիլ"; ընդմիջում; դեպք 4: s="մայիս "; ընդմիջում; դեպք 5: s="հունիս"; ընդմիջում; դեպք 6: s="հուլիս"; ընդմիջում; դեպք 7: s="օգոստոս"; ընդմիջում; դեպք 8: s="սեպտեմբեր"; ընդմիջում; դեպք 9. : s="October"; break; case 10: s="November"; break; case 11: s="December"; break; ) var result=d+" "+s+" "+y; obj.res.value =արդյունք;)

Այն ավելի վավերական է ստացվել, քան առաջին օրինակում, քանի որ Պետք է ամիսների անունները թարգմանեմ ռուսերեն։

Վերևում քննարկված մեթոդները թույլ են տալիս ստանալ ամսաթիվը: Եթե մեզ անհրաժեշտ է ամսաթիվ սահմանել, ապա պետք է օգտագործվեն հետևյալ մեթոդները.

setDate- սահմանում է ամսվա օրը 1-ից 31 միջակայքում:
setHours- սահմանում է ժամը ընթացիկ ժամանակի համար 0-ից (կեսգիշեր) մինչև 23 միջակայքում:
setMiutes- րոպեները սահմանում է 0-ից 59 միջակայքում:
setseconds- սահմանում է վայրկյանները 0-ից 59 միջակայքում:
սահմանելՏար- սահմանում է տարվա արժեքը.
սահմանելԱմիս- սահմանում է ամսվա արժեքը 0-ից (հունվար) մինչև 11 (դեկտեմբեր) միջակայքում:
setTime- սահմանում է օբյեկտի արժեքը Ամսաթիվեւ վերադարձնում է 1970 թվականի հունվարի 1-ից սկսած միլիվայրկյանների թիվը։

Այսպիսով, եթե մեզ անհրաժեշտ լինի ամսաթիվը սահմանել 2010 թվականի դեկտեմբերի 06-ը, գործառույթում կունենանք հետևյալ կոդը.

Vart=new Date(); var y=t.setYear(2010); vard=t.setDate(6); varmon=t.setMonth(11); ...

Դուք կարող եք ամսաթիվը սահմանել ուղղակիորեն կոնստրուկտորում՝ որպես պարամետր նշելով «ամիս, օր, տարի ժամեր՝ րոպեներ, վայրկյաններ» ձևաչափի տողը.

Var t=new Date("Feb, 10, 1975 5:45:10 PM");

Ժամերը, րոպեները և վայրկյանները կարող են բաց թողնել (դրանք զրոյական կլինեն).

Var t=new Date ("Feb, 10, 1975");

Նույն ամսաթիվը կարելի է սահմանել թվերի միջոցով՝ նշելով տարին, ամիսը, օրը, ժամերը, րոպեները, վայրկյանները՝ բաժանված ստորակետերով.

Var t=new Date(75, 1, 10, 17, 45, 10);

Կամ՝ բաց թողնելով ժամերը, րոպեները և վայրկյանները (դրանք զրոյական կլինեն).

Var t=new Date(75, 1, 10);

* Խնդիր կա. IE-ն չի ցանկանում ցուցադրել տարին, ուստի ավելի լավ է չօգտագործել այս տարբերակները:

Այսքանը, դուք բավականին պատրաստ եք ինքներդ գրել սցենար, որը էջը բեռնելիս կցուցադրի այցելության ամսաթիվը, ժամը և օրը (սովորական ռուսերենով): Հաջողություն!

Ամսաթիվը և ժամը մեր մաս են կազմում Առօրյա կյանքև, հետևաբար, զգալի տեղ են զբաղեցնում ծրագրավորման մեջ: JavaScript-ում, վեբկայք ստեղծելիս, գուցե անհրաժեշտ լինի ավելացնել օրացույց, գնացքների ժամանակացույց կամ ինտերֆեյս՝ հանդիպումների պլանավորման համար: Այս հավելվածները պետք է ցույց տան համապատասխան ժամերը՝ ելնելով օգտագործողի ընթացիկ ժամային գոտուց, կամ կատարեն հաշվարկներ՝ կապված ինքնաթիռի ժամանման և մեկնման կամ իրադարձության մեկնարկի և ավարտի ժամերի հետ: Բացի այդ, ձեզ կարող է անհրաժեշտ լինել օգտագործել JavaScript՝ ամենօրյա հաշվետվություններ ուղարկելու համար որոշակի ժամանակկամ զտելու համար (օրինակ՝ որոշակի ժամերի բաց ռեստորաններ գտնելու համար):

ամսաթվի օբյեկտ

Ամսաթիվը ներկառուցված JavaScript օբյեկտ է, որը պահում է ամսաթիվը և ժամը: Այն տրամադրում է մի շարք ներկառուցված մեթոդներ այս տվյալների ձևաչափման և մանիպուլյացիայի համար:

Լռելյայնորեն, նոր Date օրինակը առանց արգումենտների ստեղծում է օբյեկտ ընթացիկ ամսաթվի և ժամի համաձայն համակարգի կարգավորումներըընթացիկ համակարգիչ:

Որպես օրինակ, փորձեք ընթացիկ ամսաթիվը վերագրել փոփոխականին: Ստեղծեք now.js ֆայլ:

// Սահմանել փոփոխականը ընթացիկ ամսաթվի և ժամի վրա
const now = new Date();
// դիտել ելքը
հիմա;
Չորք Հոկտ. 18 2017 12:41:34 GMT+0000 (UTC)

Արդյունքը ամսաթվի տող է, որը պարունակում է հետևյալ տվյալները.

Ամսաթիվը և ժամը բաժանված են և ցուցադրվում են հեշտ ընթեռնելի ձևով:

Այնուամենայնիվ, JavaScript-ը մեկնաբանում է ամսաթիվը` հիմնված Unix-ի ժամանակային դրոշմակնիքի վրա, որը մի արժեք է, որը բաղկացած է 1970 թվականի հունվարի 1-ի կեսգիշերից անցած միլիվայրկյանների քանակից: Դուք կարող եք ստանալ ժամանակի դրոշմը՝ օգտագործելով getTime() մեթոդը:

// Ստացեք ընթացիկ ժամադրոշմը
now.getTime();
1508330494000

Մեծ թիվը, որը հայտնվում է ելքում որպես ընթացիկ ժամանակի դրոշմակնիք, այն միլիվայրկյանների թիվն է, որն անցել է 1970 թվականի հունվարի 1-ի կեսգիշերից մինչև 2017 թվականի հոկտեմբերի 18-ը:

Զրոյական ժամանակը (կամ դարաշրջանի ժամանակը) ներկայացված է ամսաթվի տողով 01 հունվարի, 1970 00:00:00 Համընդհանուր ժամանակ (UTC) և ժամանակի դրոշմակնիք 0: Դուք կարող եք դա ստուգել դիտարկիչում՝ epoch.js ֆայլում ստեղծելով նոր փոփոխական: և դրան վերագրելով Date-ի նոր օրինակ՝ հիմնվելով 0-ի ժամանակի վրա:

// Նոր փոփոխականին նշանակեք ժամանակի դրոշմակնիք 0
const epochTime = նոր Ամսաթիվ (0);
դարաշրջան;
Հունվարի 01, 1970 00:00:00 Համընդհանուր ժամանակ (UTC)

Որպես համակարգիչներով ժամանակի չափման չափանիշ ընտրվել է զրոյական ժամանակը, և այս մեթոդն օգտագործվում է JavaScript-ում։ Կարևոր է հասկանալ ժամադրոշմները և ամսաթվերի տողերը, քանի որ այս հասկացությունները կարող են օգտագործվել՝ կախված հավելվածի կարգավորումներից և նպատակից:

Այժմ դուք գիտեք, թե ինչպես ստեղծել նոր Ամսաթիվ օրինակ՝ հիմնվելով ընթացիկ ժամանակի և ժամադրոշմի վրա: Ընդհանուր առմամբ JavaScript-ում կա ամսաթվի չորս ձևաչափ: Բացի լռելյայն ընթացիկ ժամից և ժամադրոշմից, կարող եք նաև օգտագործել ամսաթվի տող կամ նշել կոնկրետ ամսաթիվ և ժամ:

Ցույց տալու համար տարբեր ձևերովհղում կատարելով կոնկրետ ամսաթվի, փորձեք ստեղծել նոր Date օբյեկտներ, որոնք ներկայացնում են հուլիսի 4, 1776, 12:30 GMT երեք տարբեր ձևերով:

// ժամանակի դրոշմակնիքի մեթոդ
նոր Ամսաթիվ (-6106015800000);
// ամսաթվի տողերի մեթոդ
նոր ամսաթիվ («Հունվարի 31 1980 12:30»);
// ամսաթվի և ժամի մեթոդ
նոր ամսաթիվ (1776, 6, 4, 12, 30, 0, 0);

Այս բոլոր օրինակները ներկայացնում են նույն օրվա և ժամի տեղեկատվությունը երեք տարբեր ձևերով:

Ինչպես տեսնում եք, ժամանակի դրոշմակնիքի մեթոդը բացասական թիվ ունի. զրոյական ժամից առաջ ցանկացած ամսաթիվ կներկայացվի որպես բացասական թիվ:

Երրորդ օրինակում վայրկյանները և միլիվայրկյանները ներկայացված են 0-ով: Եթե Date օբյեկտը ստեղծելիս որևէ տվյալ բացակայում եք, ապա այն պետք է վերագրեք 0-ին: Բաց թողնված տվյալները չեն կարող բաց թողնել, քանի որ տողի ժամանակի տվյալների հերթականությունը չի համապատասխանում: փոփոխություն. Հարկ է նաև նշել, որ այստեղ հուլիս ամիսը նշանակված է որպես 6, այլ ոչ թե 7: Դա պայմանավորված է նրանով, որ հետհաշվարկը սկսվում է 0-ից, այլ ոչ թե 1-ից: Այս մասին ավելի մանրամասն՝ հաջորդ բաժնում:

Ժամադրության առբերում get-ի հետ

Ամսաթիվ ունենալուց հետո կարող եք մուտք գործել դրա բոլոր բաղադրիչները՝ օգտագործելով տարբեր ներկառուցված մեթոդներ: Մեթոդները վերադարձնում են ամսաթվի յուրաքանչյուր մասը՝ կապված տեղական ժամային գոտու հետ: Այս մեթոդներից յուրաքանչյուրը սկսվում է get-ով և վերադարձնում հարաբերական թիվ: Ստորև ներկայացված է Date օբյեկտի ստանալու մեթոդների մանրամասն աղյուսակ:

Ամսաթիվ Ժամ	Մեթոդ	Շրջանակ	Օրինակ
Տարի	getFullYear ()	YYYY	1970
Ամիս	ստանալ ամիս ()	0-11	0 = հունվար
Ամսվա օր	ստանալ ամսաթիվ ()	1-31	1 = ամսի 1-ին
Շաբաթվա օր	getDay ()	0-6	0 = կիրակի
Ժամ	getHours ()	0-23	0 = կեսգիշեր
Րոպե	getMinutes ()	0-59
Երկրորդ	ստանալ վայրկյաններ ()	0-59
Միլվայրկյան	ստանալ Միլիվայրկյան ()	0-999
ժամանակի դրոշմ	getTime ()

// Նախաձեռնել ծննդյան նոր օրինակ
const ծննդյան = նոր ամսաթիվ (1980, 6, 31);

Այժմ դուք կարող եք օգտագործել բոլոր մեթոդները՝ ամսաթվի յուրաքանչյուր բաղադրիչ հանելու համար:

birthday.getFullYear(); // 1980 թ
birthday.getMonth(); // 6
birthday.getDate(); // 31
birthday.getDay (); // չորս
birthday.getHours(); // 0
birthday.getMinutes(); // 0
birthday.getSeconds(); // 0
birthday.getMilliseconds(); // 0
birthday.getTime(); // 333849600000 (GMT-ի համար)

Երբեմն կարող է անհրաժեշտ լինել հանել ամսաթվի միայն մի մասը, և ներկառուցված get մեթոդները կօգնեն ձեզ այս հարցում:

Օրինակ՝ այսօրվա ամսաթիվը կարող եք համեմատել հոկտեմբերի 3-ի հետ՝ տեսնելու՝ հոկտեմբերի 3-ն է, թե ոչ:

// Ստացեք այսօրվա ամսաթիվը
const today = new Date();
// Համեմատե՛ք այսօր հոկտեմբերի 3-ի հետ
if (today.getDate() === 3 && today.getMonth() === 9) (
console.log ("Սա հոկտեմբերի 3-ն է");
) ուրիշ (
console.log ("Դա հոկտեմբերի 3-ը չէ");
}
Հոկտեմբերի 3-ը չէ։

Ներկառուցված ստանալու մեթոդները թույլ են տալիս մուտք գործել ամսաթվի բաղադրիչներ:

Ամսաթիվը փոխելով set-ով

Վերը թվարկված բոլոր ստացման մեթոդների համար կա համապատասխան հավաքածուի մեթոդ: Եթե get օգտագործվում է որոշակի ամսաթվի բաղադրիչ առբերելու համար, set-ն օգտագործվում է այդ բաղադրիչները փոխելու համար: Ստորև ներկայացված է Date օբյեկտի կարգավորող մեթոդների մանրամասն աղյուսակ:

Ամսաթիվ Ժամ	Մեթոդ	Շրջանակ	Օրինակ
Տարի	setFullYear ()	YYYY	1970
Ամիս	setMonth ()	0-11	0 = հունվար
Ամսվա օր	setDate ()	1-31	1 = ամսի 1-ին
Շաբաթվա օր	setDay ()	0-6	0 = կիրակի
Ժամ	setHours ()	0-23	0 = կեսգիշեր
Րոպե	setMinutes ()	0-59
Երկրորդ	setseconds ()	0-59
Միլվայրկյան	setMilliseconds ()	0-999
ժամանակի դրոշմ	setTime ()	Զրոյական ժամանակից միլիվայրկյանների թիվը

Այս հավաքածուի մեթոդները կարող են օգտագործվել ամսաթվի մեկ կամ մի քանի բաղադրիչ փոխելու համար: Օրինակ՝ ծննդյան փոփոխականում կարող եք տարին փոխել մինչև 1997 թվական:

// Փոխել ծննդյան տարեթիվը
birthday.setFullYear (1997);
ծննդյան օր;
Հինգ, հուլիսի 31, 1997 00:00:00 GMT+0000 (UTC)

Այժմ, երբ զանգում եք ծննդյան փոփոխականը, տեսնում եք ոչ թե 1980, այլ 1997 թվական:

Ներկառուցված հավաքածուի մեթոդները թույլ են տալիս փոխել Date օբյեկտի տարբեր մասերը:

UTC մեթոդներ

Ստանալու մեթոդները, որոնք նկարագրված են վերևում, առբերում են ամսաթվի բաղադրիչները՝ հիմնվելով տեղական կարգավորումներօգտագործողի ժամային գոտին. Ամսաթվերի և ժամերի նկատմամբ վերահսկողությունը մեծացնելու համար կարող եք օգտագործել getUTC մեթոդները, որոնք աշխատում են նույնը, ինչ ստացման մեթոդները, բայց ժամանակը հաշվարկում են UTC (համակարգված համընդհանուր ժամանակ) ստանդարտի հիման վրա։ Ստորև բերված է JavaScript-ում Date օբյեկտի UTC մեթոդների աղյուսակը:

Ամսաթիվ Ժամ	Մեթոդ	Շրջանակ	Օրինակ
Տարի	getUTCFullYear ()	YYYY	1970
Ամիս	getUTCMonth()	0-11	0 = հունվար
Ամսվա օր	getUTCDate ()	1-31	1 = ամսի 1-ին
Շաբաթվա օր	getUTCDday ()	0-6	0 = կիրակի
Ժամ	getUTCHours ()	0-23	0 = կեսգիշեր
Րոպե	getUTCMinutes ()	0-59
Երկրորդ	getUTCSecons()	0-59
Միլվայրկյան	getUTCMilliseconds()	0-999

Տեղական ստացողների և UTC ստացողների միջև տարբերությունը ստուգելու համար գործարկեք հետևյալ կոդը.

// Նշանակել ընթացիկ ժամանակը փոփոխականին
const now = new Date();
// Տպել տեղական և UTC ժամային գոտիները
console.log (now.getHours());
console.log(now.getUTCHours());

Այս կոդը կտպագրի ընթացիկ ժամը և ժամը UTC ժամային գոտում: Եթե դուք ներկայումս գտնվում եք UTC ժամային գոտում, ապա այն թվերը, որոնք կցուցադրի ծրագիրը, նույնը կլինեն:

UTC-ն ապահովում է միջազգային ստանդարտժամանակը և, հետևաբար, կարող է կոդը պահել ժամանակային գոտիներին համապատասխան, եթե անհրաժեշտ է ձեր ծրագրում:

Եզրակացություն

Այս ձեռնարկում դուք սովորեցիք, թե ինչպես օրինականացնել Date օբյեկտը, ինչպես օգտագործել դրա ներկառուցված մեթոդները՝ տվյալ ամսաթվի բաղադրիչները մուտք գործելու և փոփոխելու համար: JavaScript-ում ժամի և ամսաթվի մասին լրացուցիչ տեղեկություններ կարելի է գտնել Mozilla Developer Network-ում:

Ամսաթվերի հետ աշխատելու իմացությունը կարևոր է JavaScript-ում շատ սովորական առաջադրանքների համար՝ կանոնավոր հաշվետվություններ ստեղծելուց մինչև ճիշտ ժամային գոտում ամսաթվերի և ժամանակացույցերի ցուցադրումը:

Tags:

JavaScript-ում ամսաթվերի և ժամերի հետ աշխատելու համար կա հատուկ օբյեկտ՝ Date: Այս օբյեկտը աջակցվում է JavaScript-ի գրեթե բոլոր տարբերակներով, և այն կարող է օգտագործվել անկախ համատեղելիության խնդիրներից:

Ամսաթիվը և ժամը Date օբյեկտում բացահայտորեն չեն պահվում, այլ, ինչպես ծրագրավորման լեզուների մեծ մասում, որպես Unix-ի ծնունդից անցած միլիվայրկյանների թիվը, այսինքն. հունվարի 1-ի ժամը 0000-ից 1970 թ. Date օբյեկտի տարբերակիչ առանձնահատկությունն այն է, որ միջակայքի բոլոր արժեքներն ունեն զրոյական ինդեքսներ: Սա նշանակում է, որ հունվարը կունենա 0 ինդեքս (ամիս #0), իսկ դեկտեմբերը տասներկուերորդի փոխարեն կլինի տասնմեկերորդ ամիսը։ Նույնը վերաբերում է շաբաթվա օրերին, ժամերին, րոպեներին և այլն:

Date օբյեկտ ստեղծելը շատ պարզ է.

// ընթացիկ ամսաթիվ-ժամ var date = new Date(); // ամսաթիվ-ժամ՝ տողից կամ թվից var date = new Date(date); // ամսաթիվ-ժամը առանձին արժեքներից var date = new Date (տարի, ամիս, օր, ժամ, րոպե, վայրկյան, միլիվայրկյան);

Ամսաթիվ օբյեկտն ունի մի շարք շատ օգտակար մեթոդներ, որոնք թույլ են տալիս աշխատել առանձին ամսաթիվ-ժամային բաղադրիչների հետ, ինչպես նաև ստուգել ճշգրտությունը և ճիշտ ցուցադրել ամսաթիվը տվյալ ձևաչափով:

Ամսաթիվ-ժամային բաղադրիչների առբերման մեթոդներ
getFullYear	Վերադարձնում է տարին (օրինակ՝ 2011 թ.)։
getYear	Վերադարձնում է տարին։ GetYear մեթոդի նպատակը նույնն է, ինչ getFullYear-ը, սակայն այս մեթոդը հնացած է և խորհուրդ չի տրվում օգտագործել, քանի որ դրա աշխատանքի արդյունքները միանշանակ չեն. 1900-ից 1999 թվականների ամսաթվերի համար մեթոդը վերադարձնում է տարվա թիվը դարում (երկանիշ, օրինակ՝ 77), իսկ այս միջակայքից դուրս ամսաթվերի համար լրիվ արժեքը վերադարձված (քառանիշ, օրինակ 2009 թ.):
ստանալ ամիս	Վերադարձնում է ամիսը։
ստանալ ամսաթիվ	Վերադարձնում է ամսվա օրը (ամսվա թիվը):
ստանալԺամեր	Վերադարձնում է ժամը։
ստանալ րոպեներ	Վերադարձնում է րոպեն։
ստանալ վայրկյաններ	Վերադարձնում է վայրկյան:
ստանալ Միլիվայրկյաններ	Վերադարձնում է միլիվայրկյան:
ստանալ օր	Վերադարձնում է շաբաթվա օրվա թիվը։
getTime	Վերադարձնում է օբյեկտի կողմից պահված միլիվայրկյան շեղումը:
Ամսաթիվ-ժամային բաղադրիչները փոխելու մեթոդներ
setFullYear	Սահմանում է տարին:
սահմանելՏար	Սահմանում է տարին: SetYear մեթոդի նպատակը նման է setFullYear-ի նպատակին, սակայն այս մեթոդը հնացած և հնացած է (ինչպես getYear մեթոդը):
սահմանելԱմիս	Սահմանում է ամիսը:
setDate	Ամսաթիվը սահմանում է ամսվա (ամսվա օրը):
setHours	Սահմանում է ժամը:
setMiutes	Սահմանում է րոպե:
setseconds	Սահմանում է երկրորդը:
setMilliseconds	Սահմանում է միլիվայրկյան:
setTime	Սահմանում է միլիվայրկյան շեղում 00:00:00-ի համեմատ 01/01/1970 թ.
Ձևաչափման և ամսաթիվ-ժամ ելքային գործառույթներ
toString	Վերադարձնում է ամսաթվի և ժամի լարային ներկայացում:
toUTCString	Վերադարձնում է UTC ժամանակի փոխարկված ամսաթվի և ժամի լարային ներկայացում: Վերադարձված տողի ձևաչափը հարգում է ինտերնետի բոլոր ստանդարտները:
դեպի GMTString	Վերադարձնում է GMT-ի (Գրինվիչի միջին ժամանակ) փոխարկված ամսաթվի և ժամի լարային ներկայացում։ Վերադարձված տողի ձևաչափը հարգում է ինտերնետի բոլոր ստանդարտները:
դեպիLocaleString	Նման է toString-ին, բայց վերադարձնում է ամսաթվի և ժամի տողային ներկայացում, որը ձևաչափված է ըստ օգտագործողի տեղանքի:
toTimeString	Վերադարձնում է ժամանակի լարային ներկայացում (տողը պարունակում է միայն ժամանակը):
toDateString	Վերադարձնում է ամսաթվի տողի ներկայացումը (տողը պարունակում է միայն ամսաթիվը):
դեպիLocaleTimeString	Նման է toTimeString-ին, բայց վերադարձնում է ժամանակի տողային ներկայացում, որը ձևաչափված է ըստ օգտագործողի տեղանքի:
toLocaleDateString	Նման է toDateString-ին, բայց վերադարձնում է ամսաթվի տողային ներկայացում, որը ձևաչափված է ըստ օգտագործողի տեղանքի:

Լրացուցիչ գործառույթներ
getTimezoneOffset	Վերադարձնում է օգտատիրոջ համակարգչի տեղական ժամանակի շեղումը UTC-ի համեմատ: Օֆսեթը վերադարձվում է րոպեների ընթացքում:
վերլուծել	Ֆունկցիան թույլ է տալիս ստուգել տողի տեսքով գրված ամսաթվի ճիշտությունը: Եթե տողը ճիշտ է, ապա անմիջապես կստեղծվի Date օբյեկտ:

Date օբյեկտը պարունակում է նաև UTC ամսաթվերի հետ աշխատելու մի շարք մեթոդներ: Այս գործառույթները լիովին նման են արդեն դիտարկվածներին, բայց դրանք պարունակում են «UTC» նախածանցը անվանման մեջ և աշխատում են միայն «ունիվերսալ» ժամանակով՝ getUTCSeconds, setUTCFullYear և այլն։

Դիտարկենք ամսաթվերի հետ աշխատելու օրինակ.

Եվ ահա այս սցենարի արդյունքը.

Ինչպես տեսնում եք, ամսաթվի ներկայացումը զգալիորեն տարբերվում է՝ կախված օգտագործված ձևաչափից: Հետևաբար, ամսաթվի հետ աշխատելիս պետք է հետևել մի քանի պարզ կանոնների.

1. Եթե հնարավոր է, օգտագործեք UTC կամ GMT ձևաչափերը: Սա հատկապես կարևոր է բաշխված լուծումներ ստեղծելիս (օրինակ՝ հաճախորդներ վճարային համակարգեր) Ընդհանուր հղման ժամանակի օգտագործումը ձեզ երաշխիքներ կտա (թեև ոչ հարյուր տոկոսով), որ և՛ դուք, և՛ ձեր հեռավոր գործընկերը նույն կերպ կմեկնաբանեք ստացված տվյալները:

2. Իմաստ ունի օգտագործել տեղայնացված ամսաթիվը և ժամը միայն դրանք օգտագործողին ցուցադրելիս: Մնացած բոլոր դեպքերում ավելի լավ է հրաժարվել տեղայնացված տվյալներից։

3. Եթե դուք դեռ պետք է օգտագործեք տեղական ամսաթիվը և ժամը, մի մոռացեք հաշվի առնել տեղական ժամանակի շեղումը հղման ժամանակի համեմատ (UTC կամ GMT):

Այս կանոններին հետևելը կազատի ձեզ տրամաբանական սխալներից և թերություններից, ինչը նշանակում է, որ ձեր կոդը ավելի կայուն և որակյալ կդարձնի:

Օգտագործեք new Date()՝ ընթացիկ ամսաթիվը և ժամը պարունակող նոր Date օբյեկտ ստեղծելու համար:

նշեք, որԱմսաթիվ () կանչված առանց արգումենտների համարժեք էնոր ամսաթիվ (ամսաթիվ. այժմ ()) .

Երբ դուք ունեք ամսաթվի օբյեկտ, կարող եք օգտագործել մի քանի մատչելի մեթոդներից որևէ մեկը՝ դրա հատկությունները ստանալու համար (օրինակ՝ getFullYear()՝ 4 նիշանոց տարի ստանալու համար):

Ստորև բերված են ամսաթվի մի քանի ընդհանուր մեթոդներ:

Ստացեք ընթացիկ տարին

var տարի = (new Date()).getFullYear(); վահանակի մատյան (տարի); // Նմուշի արդյունք՝ 2016թ

Ստացեք ընթացիկ ամիսը

var ամիս = (նոր Ամսաթիվ()).getMonth(); վահանակի մատյան (ամիս); // նմուշի ելք՝ 0

Նշենք, որ 0 = հունվար: Դա պայմանավորված է նրանով, որ ամիսները տարբերվում են 0 նախքան 11 , ուստի հաճախ ցանկալի է ինդեքսին ավելացնել +1։

Ստացեք ընթացիկ օրը

varday = (new Date()).getDate(); վահանակի մատյան (օր); // նմուշի ելք՝ 31

Ստացեք ընթացիկ ժամը

var ժամ = (նոր Ամսաթիվ()).getHours(); վահանակի մատյան (ժամեր); // նմուշի ելք՝ 10

Ստացեք ընթացիկ րոպեները

var րոպե = (նոր Ամսաթիվ()).getMinutes(); վահանակի մատյան (րոպե); // նմուշի ելք՝ 39

Ստացեք ընթացիկ վայրկյանները

var seconds = (new Date()).getSeconds(); վահանակի մատյան (երկրորդ); // նմուշի ելք՝ 48

Ստացեք ընթացիկ միլիվայրկյանները

Date օբյեկտի օրինակի միլիվայրկյանները (0-ից 999) ստանալու համար օգտագործեք getMilliseconds մեթոդը:

var milliseconds = (new Date()).getMilliseconds(); վահանակի մատյան (միլիվայրկյաններ); // Արդյունք՝ միլիվայրկյաններ հենց հիմա

Ընթացիկ ժամանակը և ամսաթիվը փոխարկեք մարդու համար ընթեռնելի տողի

varnow = նոր Ամսաթիվ (); // փոխարկել ամսաթիվը UTC ժամային գոտու ձևաչափով տողի՝ console.log(now.toUTCString()); // Արդյունք՝ չորեքշաբթի, 21 հունիսի 2017 09:13:01 GMT

Ստատիկ Date.now() մեթոդը վերադարձնում է միլիվայրկյանների թիվը 1970 թվականի հունվարի 1-ից 00:00:00 UTC: Այն ժամանակից ի վեր անցած միլիվայրկյանների թիվը ստանալու համար Date օբյեկտի օրինակով, օգտագործեք դրա getTime մեթոդը:

// ստանալ միլիվայրկյաններ՝ օգտագործելով Date console.log(Date.now()-ի ստատիկ մեթոդը հիմա: // ստանալ միլիվայրկյաններ՝ օգտագործելով getTime of Date մեթոդը console.log((new Date()).getTime());