თარიღი ობიექტი საშუალებას გაძლევთ იმუშაოთ თარიღებთან და დროებთან. შემდეგი სინტაქსი გამოიყენება თარიღის ახალი ობიექტის შესაქმნელად:
ახალი თარიღი ()
იგი ინახავს თარიღებს მილიწამების რაოდენობით 1970 წლის 1 იანვრის შუაღამისას, უნივერსალური დროის მიხედვით (UTC). ამ ფორმატით თარიღს შეუძლია ზუსტად წარმოადგინოს თარიღები, რომლებიც 285616 წელია 1970 წლის 1 იანვრიდან.
თუ თარიღის კონსტრუქტორი გამოიძახება არგუმენტების გარეშე, იქმნება ობიექტი მიმდინარე თარიღისა და დროის მნიშვნელობებით. თარიღის ობიექტის შესაქმნელად კონკრეტული თარიღით ან დროით, თქვენ უნდა გაიაროთ ოთხი შესაძლო პარამეტრიდან ერთი:
- მილიწამი: მნიშვნელობა უნდა იყოს მილიწამების რაოდენობა 01.01.1970 წლიდან დაბადების თარიღი = ახალი თარიღი (8298400000); document.write (დაბადების თარიღი);
- თარიღის სტრიქონი: ნებისმიერი თარიღი იმ ფორმატში, რომელსაც მხარს უჭერს parse () მეთოდი var birthDate = new Date ("1975 წლის 16 აპრილი"); document.write (დაბადების თარიღი);
- წელი, თვე, დღე var birthDate = ახალი თარიღი (1975, 4, 28); document.write (დაბადების თარიღი);
გთხოვთ გაითვალისწინოთ, რომ ნომერი 4 შეესაბამება მაისის თვეს. ეს ნიშნავს, რომ რიცხვი 0 შეესაბამება იანვარს. დღეები გამოითვლება ერთნაირად, მხოლოდ ნული ამ შემთხვევაში შეესაბამება კვირას.
- წელი, თვე, დღე, საათი, წუთი, წამი, მილიწამი
თარიღის ობიექტთან მუშაობისას მნიშვნელოვანია გახსოვდეთ, რომ გამოთვლები ხორციელდება კოორდინირებული უნივერსალური დროის (UTC) გამოყენებით, მიუხედავად იმისა, რომ თქვენს კომპიუტერს შეუძლია აჩვენოს დრო თქვენი დროის ზონის მიხედვით.
მეთოდები
| მეთოდი | აღწერა |
|---|---|
| getDate () | აბრუნებს თვის დღეს (1 -დან 31 -მდე) მითითებული თარიღით, ადგილობრივი დროით. |
| getDay () | აბრუნებს კვირის დღეს (0 -დან 6 -მდე; 0 = კვირა, 1 = ორშაბათი და ა.შ.) მითითებულ თარიღს, ადგილობრივ დროს. |
| getFullYear () | აბრუნებს წელს (ოთხნიშნა). |
| getHours () | აბრუნებს საათს (0 -დან 23 -მდე). |
| getMilliseconds () | აბრუნებს მილიწამს (0 -დან 999 -მდე). |
| getMinutes () | აბრუნებს წუთებს (0 -დან 59 -მდე). |
| getMonth () | აბრუნებს თვეს (0 -დან 11 -მდე; 0 = იანვარი, 1 = თებერვალი და ა.შ.). |
| getSeconds () | აბრუნებს წამს (0 -დან 59 -მდე). |
| getTime () | აბრუნებს მილიწამების რაოდენობას შუაღამის შემდეგ 01/01/1970. |
| getTimezoneOffset () | აბრუნებს დროის სხვაობას UTC და ადგილობრივ დროს შორის, წუთებში. |
| getUTCDate () | აბრუნებს თვის დღეს UTC (1 -დან 31 -მდე). |
| getUTCDay () | აბრუნებს კვირის დღეს უნივერსალური დროის მიხედვით (0 -დან 6 -მდე). |
| getUTCFullYear () | აბრუნებს UTC წელს (ოთხნიშნა). |
| getUTCHours () | აბრუნებს UTC საათს (0 -დან 23 -მდე). |
| getUTC მილიწამები () | აბრუნებს მილიწამებში UTC (0 -დან 999 -მდე). |
| getUTCMinutes () | აბრუნებს წუთებს UTC– ში (0 – დან 59 – მდე). |
| getUTCMonth () | აბრუნებს თვეს UTC– ში (0 – დან 11 – მდე). |
| getUTCSeconds () | აბრუნებს წამს UTC- ში (0 -დან 59 -მდე). |
| ანალიზი () | აანალიზებს თარიღის სტრიქონს (მაგალითად, "1992 წლის 21 მაისი") და აბრუნებს თარიღის სტრიქონს, რომელიც შეიცავს რიცხვს მილიწამებში 1970 წლის 1 იანვრიდან 00:00:00. |
| setDate () | ადგენს თვის დღეს განსაზღვრული თარიღისთვის, ადგილობრივი დროით (1 -დან 31 -მდე). |
| setFullYear () | ადგენს წელს (ოთხნიშნა). |
| setHours () | ადგენს საათს მითითებული თარიღისთვის ადგილობრივი დროის მიხედვით (0 -დან 23 -მდე). |
| მითითებული მილიწამები () | ადგენს მილიწამს მითითებული თარიღისთვის, ადგილობრივი დროით. |
| setMinutes () | ადგენს წუთებს (0 -დან 59 -მდე). |
| მითითებული თვე () | ადგენს თვეს (0 -დან 11 -მდე). |
| setSeconds () | ადგენს წამებს (0 -დან 59 -მდე). |
| დროის დაყენება () | ადგენს თარიღს მილიწამებში (ან ადრე) 01/01/1970. |
| setUTCDate () | განსაზღვრავს თვის დღეს. |
| setUTCFullYear () | ადგენს წელს უნივერსალური დროის მიხედვით (ოთხი ციფრი). |
| setUTCHours () | ადგენს საათს მითითებული თარიღისთვის, UTC. |
| setUTC მილიწამები () | ადგენს მილიწამს მითითებული თარიღისთვის, UTC. |
| setUTCMinutes () | ადგენს წუთებს მითითებული თარიღისთვის, UTC. |
| setUTCMonth () | ადგენს თვის მითითებულ თარიღს, UTC. |
| setUTCSeconds () | ადგენს წამებს მითითებული თარიღისთვის, UTC. |
| toDateString () | |
| toISOString () | გარდაქმნის თარიღს სტრიქონად ISO 8601 სტანდარტის გამოყენებით. |
| toJSON () | აბრუნებს თარიღს როგორც სტრიქონი, ფორმატირებული როგორც JSON თარიღი. |
| toLocaleDateString () | |
| toLocaleTimeString () | აბრუნებს თარიღის ნაწილს სტრიქონის სახით, თარიღის გამოსახულებით სისტემის პარამეტრებზე დაყრდნობით. |
| toLocaleString () | აბრუნებს თარიღს სტრიქონის სახით, თარიღის გამოსახულებით სისტემის პარამეტრებზე დაყრდნობით. |
| toString () | აბრუნებს სტრიქონს, რომელიც წარმოადგენს თარიღის მითითებულ ობიექტს. |
| toTimeString () | აბრუნებს თარიღის ნაწილს სტრიქონად. |
| toUTCString () | გარდაქმნის თარიღს სტრიქონად UTC დროის ზონის გამოყენებით. |
| UTC () | იღებს იგივე პარამეტრებს, რაც კონსტრუქტორის გრძელი ფორმა (ანუ 2-7) და აბრუნებს მილიწამების რაოდენობას 1970 წლის 1 იანვრიდან, 00:00:00 UTC. |
| ფასეულობა () | აბრუნებს თარიღის ობიექტის პრიმიტიულ მნიშვნელობას. |
თარიღი და დრო ჩვენი ნაწილია Ყოველდღიური ცხოვრებისდა ამიტომ ფიგურირებს თვალსაჩინოდ პროგრამირებაში. JavaScript– ში, ვებსაიტის შექმნისას, შეიძლება დაგჭირდეთ კალენდრის, მატარებლის განრიგის ან ინტერფეისის დანიშვნა. ამ აპლიკაციებმა უნდა აჩვენონ შესაბამისი დროის წერტილები მომხმარებლის ამჟამინდელი დროის ზონის საფუძველზე, ან განახორციელონ გამოთვლები, რომლებიც დაკავშირებულია თვითმფრინავის ჩამოსვლასა და გამგზავრებასთან ან ღონისძიების დაწყების და დასრულების დროზე. ასევე, შეიძლება დაგჭირდეთ JavaScript– ის გამოყენება ყოველდღიური ანგარიშების გასაგზავნად გარკვეული დროან გაფილტვრის მიზნით (მაგალითად, გარკვეული დროის განმავლობაში გახსნილი რესტორნების მოსაძებნად).
თარიღის ობიექტი
თარიღი შემოსულია JavaScript ობიექტირომელიც ინახავს თარიღს და დროს. ის იძლევა უამრავ ჩაშენებულ მეთოდს ამ მონაცემების ფორმატირებისა და მანიპულირებისათვის.
სტანდარტულად, თარიღის ახალი მაგალითი არგუმენტების გარეშე ქმნის ობიექტს მიმდინარე თარიღისა და დროის შესაბამისად სისტემის პარამეტრებიმიმდინარე კომპიუტერი.
მაგალითად, სცადეთ მიანიჭოთ მიმდინარე თარიღი ცვლადს. შექმენით ფაილი ახლა. Js.
// ცვლადის დაყენება მიმდინარე თარიღსა და დროს
const now = ახალი თარიღი ();
// ნახეთ გამომავალი
ახლა
ოთხ ოქტომბერი 2017 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 ფაილში ახალი ცვლადის შექმნით და თარიღის ახალი მაგალითის მინიჭება მას დროის მარკირების საფუძველზე 0.
// მიანიჭეთ დროის ნიშნული 0 ახალ ცვლადს
const epochTime = ახალი თარიღი (0);
ეპოქის დრო;
01 იანვარი, 1970 00:00:00 უნივერსალური დრო (UTC)
ნულოვანი დრო კომპიუტერების მიერ დროის გაზომვის სტანდარტად იქნა არჩეული და ეს მეთოდი გამოიყენება JavaScript– ში. მნიშვნელოვანია გვესმოდეს დროის ნიშნულები და თარიღის სტრიქონები, რადგან ეს ცნებები შეიძლება გამოყენებულ იქნას პროგრამის პარამეტრებისა და მიზნის მიხედვით.
ახლა თქვენ იცით, თუ როგორ უნდა შექმნათ თარიღის ახალი მაგალითი მიმდინარე დროისა და დროის ნიშნულის საფუძველზე. JavaScript– ში სულ ოთხი თარიღის ფორმატია. ნაგულისხმევი მიმდინარე დროის და დროის ნიშნულის გარდა, ასევე შეგიძლიათ გამოიყენოთ თარიღის სტრიქონი ან მიუთითოთ კონკრეტული თარიღი და დრო.
დემონსტრირება სხვადასხვა გზებიკონკრეტული თარიღის მითითებით, სცადეთ შექმნათ თარიღის ახალი ობიექტები, რომლებიც წარმოადგენენ 1776 წლის 4 ივლისს, 12:30 GMT სამი განსხვავებული გზით.
// დროითი ბეჭდის მეთოდი
ახალი თარიღი (-6106015800000);
// თარიღის სიმებიანი მეთოდი
ახალი თარიღი ("1980 წლის 31 იანვარი 12:30");
// თარიღი და დრო მეთოდი
ახალი თარიღი (1776, 6, 4, 12, 30, 0, 0);
ყველა ეს მაგალითი წარმოგიდგენთ ერთსა და იმავე თარიღსა და დროს ინფორმაციას სამი განსხვავებული გზით.
როგორც ხედავთ, დროის ნიშნულის მეთოდს აქვს უარყოფითი რიცხვი; ნული დრომდე ნებისმიერი თარიღი წარმოდგენილი იქნება უარყოფითი რიცხვის სახით.
მესამე მაგალითში წამები და მილიწამები წარმოდგენილია 0. -ით. თუ თქვენ აკლია რაიმე მონაცემი თარიღის ობიექტის შექმნისას, თქვენ უნდა დააყენოთ ისინი 0 -ზე. გამოტოვებული მონაცემების გამოტოვება შეუძლებელია, რადგან სტრიქონში არსებული მონაცემების თანმიმდევრობა არ არის შეცვლა ისიც უნდა აღინიშნოს, რომ ივლისის თვე აქ არის განსაზღვრული 6 -ით და არა 7 -ით. ეს იმიტომ ხდება, რომ ათვლა არ იწყება 1 -დან, არამედ 0 -დან. დაწვრილებით ამის შესახებ შემდეგ სექციაში.
თარიღის მიღება get- ის გამოყენებით
თარიღის მიღების შემდეგ, თქვენ შეგიძლიათ შეხვიდეთ მის ყველა კომპონენტზე სხვადასხვა ჩამონტაჟებული მეთოდების გამოყენებით. მეთოდები თარიღის თითოეულ ნაწილს უბრუნებს ადგილობრივ დროის ზონას. თითოეული ეს მეთოდი იწყება get- ით და აბრუნებს ფარდობით რიცხვს. ქვემოთ მოცემულია თარიღის ობიექტის მიღების მეთოდების დეტალური ცხრილი.
| თარიღი დრო | მეთოდი | Დიაპაზონი | მაგალითი |
| წელი | getFullYear () | YYYY | 1970 |
| თვე | getMonth () | 0-11 | 0 = იანვარი |
| თვის დღე | getDate () | 1-31 | 1 = თვის 1 |
| Კვირის დღე | getDay () | 0-6 | 0 = კვირა |
| საათი | getHours () | 0-23 | 0 = შუაღამე |
| წუთი | getMinutes () | 0-59 | |
| მეორე | getSeconds () | 0-59 | |
| მილიწამი | getMilliseconds () | 0-999 | |
| დროის ბეჭედი | getTime () |
// დაბადების დღის ახალი მაგალითის ინიციალიზაცია
const დაბადების დღე = ახალი თარიღი (1980, 6, 31);
ყველა მეთოდი შეიძლება გამოყენებულ იქნას თარიღის თითოეული კომპონენტის აღსადგენად.
birthday.getFullYear (); // 1980 წ
birthday.getMonth (); // 6
birthday.getDate (); // 31
birthday.getDay (); // 4
birthday.getHours (); // 0
birthday.getMinutes (); // 0
birthday.getSeconds (); // 0
birthday.getMilliseconds (); // 0
birthday.getTime (); // 333849600000 (GMT– სთვის)
ზოგჯერ თქვენ მხოლოდ თარიღის ნაწილის აღება გჭირდებათ და ჩამონტაჟებული მიღების მეთოდები ამაში დაგეხმარებათ.
მაგალითად, შეგიძლიათ შეადაროთ მიმდინარე თარიღი 3 ოქტომბერს და გაარკვიოთ არის თუ არა 3 ოქტომბერი.
// მიიღეთ დღევანდელი თარიღი
const today = ახალი თარიღი ();
// შეადარეთ დღეს 3 ოქტომბერს
თუ (today.getDate () === 3 && today.getMonth () === 9) (
console.log ("ეს 3 ოქტომბერია.");
) სხვა (
console.log ("ეს არ არის 3 ოქტომბერი.");
}
ეს არ არის 3 ოქტომბერი.
ჩამონტაჟებული მიღების მეთოდები გაძლევთ წვდომას თარიღის კომპონენტებზე.
თარიღის შეცვლა კომპლექტით
ყველა ზემოაღნიშნულ მიმღებს აქვს შესაბამისი სეტერი. თუ get გამოიყენება თარიღის კონკრეტული კომპონენტის მოსაპოვებლად, set გამოიყენება ამ კომპონენტების შესაცვლელად. ქვემოთ მოცემულია თარიღის ობიექტის დადგენილი მეთოდების დეტალური ცხრილი.
| თარიღი დრო | მეთოდი | Დიაპაზონი | მაგალითი |
| წელი | setFullYear () | YYYY | 1970 |
| თვე | მითითებული თვე () | 0-11 | 0 = იანვარი |
| თვის დღე | setDate () | 1-31 | 1 = თვის 1 |
| Კვირის დღე | setDay () | 0-6 | 0 = კვირა |
| საათი | setHours () | 0-23 | 0 = შუაღამე |
| წუთი | setMinutes () | 0-59 | |
| მეორე | setSeconds () | 0-59 | |
| მილიწამი | მითითებული მილიწამები () | 0-999 | |
| დროის ბეჭედი | დროის დაყენება () | მილიწამების რაოდენობა ნულოვანი დროიდან |
ეს სეტერები შეიძლება გამოყენებულ იქნას თარიღის ერთი ან მეტი კომპონენტის შესაცვლელად. მაგალითად, შეგიძლიათ დაბადების წელი ცვალოთ 1997 წელს.
// დაბადების დღის თარიღის შეცვლა
birthday.setFullYear (1997);
დაბადების დღე;
ხუთშაბათი 31 ივლისი 1997 00:00:00 GMT + 0000 (UTC)
ახლა, როდესაც დაბადების დღის ცვლადს ეძახი, ხედავ არა 1980 წელს, არამედ 1997 წელს.
ჩამონტაჟებული დაყენების მეთოდები საშუალებას გაძლევთ შეცვალოთ თარიღის ობიექტის სხვადასხვა ნაწილი.
UTC მეთოდები
ზემოთ მოყვანილი მეთოდები თარიღის კომპონენტების ამოღების საფუძველზე ლოკალური პარამეტრებიმომხმარებლის დროის ზონა. თარიღებსა და დროებზე კონტროლის გასაზრდელად, შეგიძლიათ გამოიყენოთ getUTC მეთოდები, რომლებიც იგივენაირად მუშაობს როგორც მეთოდების მიღება, მაგრამ გამოთვალეთ დრო UTC (უნივერსალური დრო) საფუძველზე. ქვემოთ მოცემულია თარიღის ობიექტის UTC მეთოდების ცხრილი JavaScript– ში.
| თარიღი დრო | მეთოდი | Დიაპაზონი | მაგალითი |
| წელი | getUTCFullYear () | YYYY | 1970 |
| თვე | getUTCMonth () | 0-11 | 0 = იანვარი |
| თვის დღე | getUTCDate () | 1-31 | 1 = თვის 1 |
| Კვირის დღე | getUTCDay () | 0-6 | 0 = კვირა |
| საათი | getUTCHours () | 0-23 | 0 = შუაღამე |
| წუთი | getUTCMinutes () | 0-59 | |
| მეორე | getUTCSeconds () | 0-59 | |
| მილიწამი | getUTC მილიწამები () | 0-999 |
ადგილობრივ მიმღებთა და UTC მიმღებებს შორის სხვაობის შესამოწმებლად, გაუშვით შემდეგი კოდი.
// მიანიჭეთ მიმდინარე დროს ცვლადს
const now = ახალი თარიღი ();
// დაბეჭდეთ ადგილობრივი და UTC დროის ზონები
console.log (now.getHours ());
console.log (ახლა. getUTCHours ());
ეს კოდი დაბეჭდავს მიმდინარე დროსა და დროს UTC დროის ზონაში. თუ თქვენ ამჟამად იმყოფებით UTC დროის ზონაში, მაშინ ის რიცხვები, რასაც პროგრამა გამოუშვებს, იგივე იქნება.
UTC უზრუნველყოფს დროის საერთაშორისო სტანდარტს და, შესაბამისად, შეუძლია შეინარჩუნოს კოდი დროის ზონებთან შესაბამისობაში, თუ ეს საჭიროა თქვენს პროგრამაში.
დასკვნა
ამ სახელმძღვანელოში თქვენ ისწავლეთ როგორ აჩვენოთ თარიღის ობიექტი, როგორ გამოიყენოთ მისი ჩამონტაჟებული მეთოდები კონკრეტული თარიღის კომპონენტებზე წვდომისა და შეცვლისთვის. თქვენ შეგიძლიათ იპოვოთ მეტი ინფორმაცია დროისა და თარიღის შესახებ JavaScript– ში Mozilla დეველოპერების ქსელში.
თარიღებთან მუშაობის ცოდნა მნიშვნელოვანია JavaScript– ის მრავალი საერთო ამოცანისთვის, რეგულარული ანგარიშების შექმნიდან თარიღებისა და გრაფიკების ჩვენება დროის სწორ ზონაში.
ტეგები:გამოიყენეთ ახალი თარიღი () ახალი თარიღის შესაქმნელად, რომელიც შეიცავს მიმდინარე თარიღს და დროს.
ჩაინიშნეთარიღი () მოწოდებულია არგუმენტების გარეშე, ექვივალენტიაახალი თარიღი (თარიღი. ახლა ()) .
მას შემდეგ რაც გაქვთ თარიღის ობიექტი, შეგიძლიათ გამოიყენოთ ნებისმიერი რამდენიმე მეთოდი, რათა მიიღოთ მისი თვისებები (მაგალითად, getFullYear (), რომ მიიღოთ 4-ნიშნა წელი).
ქვემოთ მოცემულია თარიღის რამდენიმე გავრცელებული მეთოდი.
მიიღეთ მიმდინარე წელი
var წელი = (ახალი თარიღი ()). getFullYear (); console.log (წელი); // ნიმუშის გამომუშავება: 2016 წმიიღეთ მიმდინარე თვე
var თვე = (ახალი თარიღი ()). getMonth (); console.log (თვე); // გამომავალი ნიმუში: 0გაითვალისწინეთ, რომ 0 = იანვარი. ეს იმიტომ ხდება, რომ თვეები მერყეობს 0 ადრე 11 ამიტომ ხშირად სასურველია ინდექსში დაამატოთ +1.
მიიღეთ დღევანდელი დღე
var დღე = (ახალი თარიღი ()). getDate (); console.log (დღე); // გამომავალი ნიმუში: 31მიიღეთ მიმდინარე საათი
var საათი = (ახალი თარიღი ()). getHours (); console.log (საათი); // გამომავალი ნიმუში: 10მიიღეთ მიმდინარე წუთები
var წუთი = (ახალი თარიღი ()). getMinutes (); console.log (წუთი); // გამომავალი ნიმუში: 39მიიღეთ მიმდინარე წამები
var წამები = (ახალი თარიღი ()). getSeconds (); console.log (მეორე); // გამომავალი ნიმუში: 48მიიღეთ მიმდინარე მილიწამები
თარიღის ობიექტის მილიწამების (0 -დან 999 -მდე) მისაღებად გამოიყენეთ getMilliseconds მეთოდი.
Var მილიწამები = (ახალი თარიღი ()). GetMilliseconds (); console.log (მილიწამი); // გამომავალი: მილიწამები ახლა
გადააქციეთ მიმდინარე დრო და თარიღი ადამიანის მიერ წაკითხული სტრიქონით
var ახლა = ახალი თარიღი (); // თარიღის კონვერტაცია UTC დროის ზონის ფორმატში: console.log (now.toUTCString ()); // გამომავალი: ოთხ, 21 ივნისი 2017 09:13:01 GMTსტატიკური Date.now () მეთოდი აბრუნებს მილიწამების რაოდენობას 1970 წლის 1 იანვრიდან 00:00:00 UTC. იმ დროიდან მილიწამების რაოდენობის მისაღებად თარიღის ობიექტის მაგალითის გამოყენებით, გამოიყენეთ მისი getTime მეთოდი.
// მიიღეთ მილიწამები სტატიკური მეთოდის გამოყენებით Date of console.log (Date.now ()); // მიიღეთ მილიწამები მეთოდის გამოყენებით getTime of Date მაგალითად console.log ((ახალი თარიღი ()). getTime ());
Გამარჯობა ყველას!
ხშირად მიწევს სტატისტიკურ მონაცემებთან მუშაობა და ბევრია თარიღებთან დაკავშირებული. უფრო მეტიც, ერთი და იგივე თარიღი შეიძლება გამოყენებულ იქნას გვერდზე სხვადასხვა ფორმატში (მაგალითად, მოსახერხებელი მანქანისთვის და მოსახერხებელი ადამიანისთვის). მე ვფიქრობ, რომ თქვენმა უმრავლესობამ მშვენივრად იცის ყველა ეს შემზარავი კოდი, რომელიც მოდის თარიღის ობიექტის გამოყენებით.
მაგალითად, მიმდინარე თარიღის მისაღებად DD.MM.YYYY, ჩვენ უნდა გავაკეთოთ შემდეგი:
var d = ახალი თარიღი (), fd = d.getDate () + "." + (დ. მიიღეთ თვე () + 1) + "." + d.getFullYear ();
და როდის არის ბევრი ასეთი სტრიქონი? ადვილი დასამახსოვრებელია, რომ javascript– ში თვე იწყება ნულიდან, როდესაც თქვენ ვითარდებით არა მხოლოდ მასში? ან ის ფაქტი, რომ არსებობს მილიწამები და არა წამი, როგორც თითქმის ყველგან უკანა მხარეს? თქვენ შეგიძლიათ გადაჭრას ზოგიერთი პრობლემა პოპულარული Moment.js ბიბლიოთეკით, მაგრამ ის ძალიან ნელა მუშაობს.
ბიბლიოთეკა წყვეტს ამ პრობლემებს.
დაინტერესების შემთხვევაში, გირჩევთ წაიკითხოთ ეს მცირე მიმოხილვა.
TempusJS არის ბევრი სინტაქსური შაქარი თარიღის ობიექტზე, ამიტომ ის ძალიან სწრაფია. ბიბლიოთეკის სინტაქსი თავისთავად საკმაოდ მარტივია. მაგალითად, თქვენ შეგიძლიათ დაწეროთ წინა მაგალითი ასე:
var fd = tempus (). ფორმატი ("% d.% m.% Y");
ახლა რაც შეეხება სიჩქარეს. სპოილერში შეგიძლიათ ნახოთ ტემპუსის შედარება მომენტთან და თარიღის ფორმატირებასთან ერთად (იხ. ზემოთ):
მშობლიური JS, MomentJS და TempusJS შედარება
ჩვენ ვიღებთ მიმდინარე თარიღს
მშობლიური JS x 2,175,575 ოპსი / წმ ± 0,75% (96 გაშვება შერჩეული) მომენტი x 284,864 ოპს / წმ ± 0,85% (96 გაშვება შერჩეული) ტემპუსი x 2,086,081 ოპსი / წმ ± 0,73% (97 გაშვება შერჩეული)ფორმატირება
მშობლიური JS x 1,637,517 ოპსი / წმ ± 0.61% (100 გაშვება შერჩეული) მომენტი x 8.808 ოპს / წმ ± 1.07% (100 გაშვება შერჩეული) ტემპი x 942,815 ოპს / წმ ± 0.68% (94 გაშვება შერჩეული)თარიღის ავტომატური გამოვლენა და ანალიზი
მშობლიური JS x 11,204,316 ოპსი / წმ ± 0,81% (88 გაშვება შერჩეული) მომენტი x 38,511 ოპს / წმ ± 1,41% (95 გაშვება შერჩეული) ტემპი x 93,973 ოპს / წმ ± 1.06% (85 გაშვება შერჩეული)თარიღის გაანალიზება ფორმატის მიხედვით
მომენტი x 46.293 ოპსი / წმ ± 0.63% (100 გაშვება შერჩეული) ტემპი x 109.947 ოპს / წმ ± 0.93% (99 გაშვება შერჩეული)გაანალიზება და დადასტურება
მომენტი x 44.588 ოპს / წმ ± 1.09% (90 გაშვება შერჩეული) ტემპი x 103.439 ოპს / წმ ± 0.90% (94 გაშვება შერჩეული)შედეგები მიღებულია ჩემს ლეპტოპზე Გუგლ ქრომი 30.0.1599.114. სხვა ბრაუზერებში შედეგები განსხვავებულია, მაგრამ თანაფარდობა დაახლოებით იგივე რჩება.
ტესტებისათვის გამოიყენებოდა benchmark.js ბიბლიოთეკა.
სხვა მახასიათებლების ნიშნები, თქვენ შეგიძლიათ ნახოთ.
ამრიგად, ამ ბიბლიოთეკის უპირატესობები შეიძლება დაიწეროს შემდეგნაირად:
- მხარს უჭერს IE6 +, Chrome, Firefox, Opera;
- მხარს უჭერს ზარების ჯაჭვებს;
- თვეები შეიძლება დაიწყოს 1 -ით (ნაგულისხმევი) და არა ნულით;
- მილიწამი შეიძლება იყოს გამორთული (ნაგულისხმევი) ან ჩართული;
- სწრაფი მუშაობა (ვინაიდან, ხშირ შემთხვევაში, ბრაუზერის მშობლიური თარიღი გამოიყენება, რომლის განხორციელებაც უფრო სწრაფ ენებზეა დაწერილი);
- მხარს უჭერს პერსონალურ ფორმატებსა და მოდულებს
- თარიღის დადასტურება ძალიან სწრაფია და დამოკიდებულია მხოლოდ იმ ფუნქციებზე, რომლებიც ადგენენ თარიღს (ვინაიდან დადასტურება ხდება უკვე მნიშვნელობების შეყვანისას და ცალკე არ არის გათვლილი);
- მომხმარებლის ენის მრავალენოვანი და ავტომატური ამოცნობა.
აქ ჩვენ მხოლოდ რამდენიმე ფუნქციაზე ვისაუბრებთ.
ფორმატირება და ანალიზი
ასე რომ, დამწყებთათვის, თარიღის ფორმატირების კიდევ ერთი მაგალითი. ჩვენ ასევე ვიყენებთ ზარების ქსელს აქ. თითოეული პარამეტრის დასასრულს, ჩვენ ვიღებთ TempusDate ობიექტს, რომელიც შეგვიძლია გამოვიყენოთ ჯაჭვის ქვემოთ. მაგალითი:
tempus (). // მიიღეთ ახალი თარიღი კალკ ((თვე: -1)). // შეამცირეთ იგი ერთი თვის ფორმატით ("% d.% m.% Y"); // გამოტანა სიმებიანი სახით
ამრიგად, ჩვენ მივიღებთ იმავე დღეს, საათსა და წამს, მაგრამ ერთი თვის წინ. ეს სასარგებლოა გასული თვის ანგარიშების მისაღებად.
შემდეგი მაგალითია თარიღის გაანალიზება.
// აბრუნებს TempusDate ობიექტს თარიღით "2013-11-18" tempus ("11/18/2013"); // აბრუნებს TempusDate ობიექტს თარიღით "2013-12-12" tempus ("2013-12-12", "% Y-% m-% d"));
Tempus– ს შეუძლია ავტომატურად აღმოაჩინოს ზოგიერთი ცნობილი ფორმატი. ასევე, შეგიძლიათ მიუთითოთ გარკვეული ფორმატი, შემდეგ გაანალიზება უფრო სწრაფი იქნება. გარდა ამისა, თქვენ შეგიძლიათ მიუთითოთ თარიღი, რომელიც დაბრუნდება, თუ გაანალიზება ვერ მოხერხდა:
// იმიტომ "123" არ ემთხვევა ფორმატს "% d.% M.% Y", შემდეგ // ობიექტი, რომელიც შეიცავს თარიღს 2013-01-01 tempus ("123", "% d.% M.% Y", tempus ());
ნაგულისხმევი ფორმატების სია შეგიძლიათ იხილოთ
ახლა მოდით შევცვალოთ უკვე ფორმატირებული თარიღის ფორმატი
// "2013-11-05" ტემპუსი ("05.11.2013"). ფორმატი ("% Y-% m-% d"); // ასე თუ ისე // "ოქტომბერი, 12" ტემპუსი ("2013-10-12 12:31:01", "% Y-% m-% d% H:% M:% S"). ფორმატი ("% B,% d ");
ასევე, ფორმატირებისთვის შეგიძლიათ გამოიყენოთ ლოკალიზაცია. ნაგულისხმევად, მომხმარებლის ენა შეირჩევა (აღებულია ბრაუზერიდან) ან ნაგულისხმევი ენა, თუ მომხმარებლის ენა არ მოიძებნება Tempus– ის არსებულ ენებს შორის.
// ენის დაყენება tempus.lang ("ru"); // ნაგულისხმევად ვიყენებთ ფორმატს // "05 ნოემბერი" tempus (1383609600) .ფორმატი ("% B,% d");
ჩართული ამ მომენტსარსებობს მხოლოდ ორი ენა- რუსული და ინგლისური, ასე რომ მოხარული ვიქნები დაგეხმაროთ.
ვალიდაცია
თარიღის შემოწმება შემდეგია:// აბრუნებს ცრუ ტემპს ("08/32/2013", "% d.% M.% Y"). მოქმედი (); // აბრუნებს ჭეშმარიტ ტემპს ("00:00 01.01.2012", "% H:% M% d.% M.% Y"). მოქმედი ();
შეცდომის შემთხვევაში, თქვენ შეგიძლიათ ნახოთ ველები, სადაც ის მოხდა - სადაც მნიშვნელობა არ არის ყალბი:
// აბრუნებს ("წელი": - 5, "თვე": ყალბი, "დღე": ყალბი, "საათი": ყალბი, // "წუთი": ყალბი, "წამი": ყალბი, "მილიწამი": ყალბი) ტემპი () წელი (-5). // დააყენე წელი = -5, ე.ი. არასწორი შეცდომები (); // მიიღეთ ობიექტი შეცდომებით
თარიღის დიაპაზონი
ზოგჯერ ჩვენ გვჭირდება წლების რაოდენობა (მაგალითად, ასაკი), თვეები, დღეები და ა. ორ თარიღს შორის. ამისათვის ჩვენ შეგვიძლია გამოვიყენოთ მეთოდი მეთოდი, რომელიც პოულობს განსხვავებას ორ თარიღს შორის და აბრუნებს სასურველ ფორმატში ("წელი", "თვე", "დღე", "საათი", "წუთი", "წამი", " მილიწამი ").აქ არის მარტივი მაგალითი იმისა, თუ როგორ უნდა მიიღოთ თვეები 2013 წლის 1 ნოემბრიდან 2014 წლის 5 მაისამდე:
// აბრუნებს 6 ტემპუსს (). შორის (ტემპუსი (), "თვე");
ან რამდენი საათი დარჩა ახალ წლამდე
tempus (). შორის (tempus (), "საათი");
ბოლო მაგალითში თქვენ ხედავთ, რომ მე მხოლოდ წელი განვსაზღვრე. მასივის ან ობიექტის მნიშვნელობის დადგენისას, დაკარგული მნიშვნელობები იქნება
ივსება მინიმალურით. მუდმივთა სია ერთად მინიმალური ღირებულებები, შეგიძლიათ ნახოთ დოკუმენტაციაში.
ასევე, ჩვენ შეგვიძლია შევცვალოთ ნებისმიერი თარიღი კალკის ფუნქციის გამოყენებით:
// აბრუნებს TempusDate თარიღით 2012-01-01 tempus (). Calc ((წელი: 1, თვე: -4, დღე: -1));
მორგებული ფორმატები
ჩვენ ვიყენებთ თვის საკუთარ ფორმატს, რომელსაც შეუძლია მიიღოს მნიშვნელობები 1 -დან 12 -მდე (არა 01 -დან 12 -მდე):// ახალი ფორმატის რეგისტრაცია tempus.registerFormat ("% q", // დირექტივა -% q ფუნქცია (თარიღი) (// აქ ჩვენ განვსაზღვრავთ ფორმატირების ფუნქციას, ანუ რას ჩაანაცვლებს% q დაბრუნების თარიღი. თვე (); ), ფუნქცია (მნიშვნელობა) (// და აქ არის ანალიზის ფუნქცია var v = ნომერი (მნიშვნელობა); დაბრუნება (თვე: (isNaN (v)? განუსაზღვრელი: v));), 1, // მინიმალური სიგრძე, რომელიც მნიშვნელობა 2 შეიძლება მიიღოს, // მაქსიმალური სიგრძე "ნომერი" // ტიპი); // ტესტირება // აბრუნებს "01.1.2013"; tempus ((წელი: 2013, თვე: 1, დღე: 1)). ფორმატი ("% d.% q.% Y"); // ანაზღაურება ("წელი": 2013, "თვე": 2, "დღე": 10, "საათი": 0, "წუთი": 0, "წამი": 0); tempus ("10.2.2013", "% d.% q.% Y"). მიიღეთ ();
რეგისტრაციის დროს შეგიძლიათ შეამჩნიოთ, რომ ზოგიერთი პარამეტრი ცალკეა მითითებული, ხოლო თქვენ შეგიძლიათ გამოიყენოთ რეგულარული გამოთქმა... სინამდვილეში, თავდაპირველად ის იქ იყო, მაგრამ მიტოვების შემდეგ, სიჩქარე რამდენჯერმე გაიზარდა.
თუ თქვენ გჭირდებათ ფორმატის ამოღება, გამოიყენეთ unregisterFormat:
tempus.unregisterFormat ("% d"); // აბრუნებს "% d.01.2013" -ს, რადგან დირექტივა% d აღარ არსებობს. tempus.format ((წელი: 2013, თვე: 1, დღე: 1), "% d.% m.% Y");
მიმღებები / სეტერები
თქვენ შეგიძლიათ მიიღოთ / დააყენოთ ზოგიერთი მნიშვნელობა ფუნქციების გამოყენებით წელი (), თვე (), დღე (), საათი (), წუთი (), წამი (), მილიწამი (), dayOfWeek (), utc (), დროის ნიშნული () ან მითითებული (). Მაგალითად:tempus (). // მიიღეთ მიმდინარე თარიღი წელი (1900). // დატოვეთ ის როგორც არის, მაგრამ დააყენეთ 1900 ნახტომი (); // შეამოწმეთ არის თუ არა ნახტომი წელი, ამ შემთხვევაში ცრუ ტემპუსი (). წელი (); // და ასე მივიღებთ მიმდინარე წელს რიცხვითი ფორმით
თარიღების გენერირება
თქვენ შეგიძლიათ შექმნათ თარიღი სხვადასხვა გზით, სრული სიაპარამეტრები დოკუმენტაციაშია. აქ არის მინიმალური მაგალითი.// ბრუნდება ["03/29/2013", "03/30/2013", "03/31/2013", "04/01/2013", "04/02/2013"]; tempus.generate ((თარიღიდან: "20130329", ფორმატიდან: "% Y.% m.% d", თარიღი: "20130402", პერიოდი: (დღე: 1), ფორმატი: "% d.% m.% Y" ));
ეს შეიძლება იყოს სასარგებლო დიაგრამების ჩვენებისათვის თარიღის მიხედვით და ეკრანზე ფორმატის შეცვლისთვის პირდაპირ კლიენტზე, უკანა ფონის მოთხოვნის გარეშე. თარიღი შეიძლება გენერირდეს როგორც მასივის, ასევე ობიექტების სახით, სადაც თარიღები თავად იქნება გასაღები (ეს გამოსადეგია მაშინ, როდესაც ჩვენ გვჭირდება მოვლენის თარიღთან დაკავშირება, მაგალითად, როდესაც ჩვენ ვქმნით საკუთარ კალენდარს). ასევე, თარიღების დაჯგუფება შესაძლებელია დღის, კვირის, თვის, საათის, წლის მიხედვით - რაც არ უნდა იყოს. ეს ასევე შეიძლება გამოყენებულ იქნას კალენდარში.
მოდულები
ბოლო, მაგრამ არანაკლებ მნიშვნელოვანი, მოდული. აქ ჩვენ ვაფართოვებთ ქარხანას შემთხვევითი თარიღის შესაქმნელად. ჩვენ ასევე გვჭირდება TempusDate კლასი, რომელიც გვხვდება tempus.classes () - ში. აქ არის მოდულის მაგალითი:(ფუნქცია (tempus) (var TempusDate = tempus.classes ("TempusDate"); tempus.randomDate = ფუნქცია () (var თარიღი = ახალი TempusDate (); date.year (Math.floor ((Math.random () *) tempus.MAX_YEAR - tempus.MIN_YEAR)) + tempus.MIN_YEAR)). თვე (მათემატიკა სართული ((მათემატიკა შემთხვევითი () * (tempus.MAX_MONTH - tempus.MIN_MONTH)) + tempus.MIN_MONTH)). დღე (მათემატიკა შემთხვევითი () * (tempus.MAX_MONTH - tempus.MIN_MONTH)) + tempus.MIN_MONTH)). დღის სართული ((მათემატიკა. შემთხვევითი () * (თარიღი. დღეების რაოდენობა () - tempus.MIN_DAY)) + tempus.MIN_DAY)). საათი (მათემატიკა სართული ((მათემატიკა. შემთხვევითი)) * (tempus.MAX_HOURS - tempus.MIN_HOURS)) + tempus.MIN_HOURS)). წუთი (მათემატიკა. სართული ((მათემატიკა. შემთხვევითი)) * (tempus.MAX_MINUTES - ტემპუსი MIN_MINUTES)) + tempus.MIN_MINUTES)). წამი (მათემატიკა. სართული ((მათემატიკა) (tempus.MAX_SECONDS - tempus.MIN_SECONDS)) + tempus.MIN_SECONDS)); დაბრუნების თარიღი;);))) (ტემპუსი) ; // ჩვენ შეგვიძლია შევქმნათ თარიღები შემდეგნაირად var someRandomDate = tempus.randomDate ();
მე ვფიქრობ, რომ ამ გზით შესაძლებელი იქნება ვიჯეტების მოხერხებულად ჩაწერა jQuery + Tempus, Angular + Tempus და ა.
წყაროს კოდები
თქვენ შეგიძლიათ დააინსტალიროთ github– დან წყაროების გადმოტვირთვით:https://github.com/crusat/tempus-js/releases
ან bower- ის საშუალებით:
$ bower ინსტალაციის ტემპი
თქვენ გჭირდებათ მხოლოდ ერთი ფაილი - tempus.js ან tempus.min.js.
ვიმედოვნებ, რომ ეს ბიბლიოთეკა სასარგებლო იქნება და ასევე საინტერესო იქნებოდა ვიცოდე რა აკლია მასში ბიბლიოთეკის სწორი მიმართულებით შემდგომი განვითარების მიზნით. მადლობა ყურადღებისთვის!
პ.ს. Მადლობა მოწვევისთვის!
ვებსაიტებისთვის კიდევ ერთი სასარგებლო რამ არის მიმდინარე თარიღის ჩასმა. ინტერნეტში ათეულობით მაგალითია თარიღის სკრიპტებისა, მაგრამ ბევრი მათგანი, ჩემი აზრით, მძიმე და, მაშასადამე, მახინჯია. იმავდროულად, გამოყენებით სტანდარტული საშუალებები JavaScript, ძალიან ადვილია თარიღის ჩასმა ვებგვერდის გვერდზე. მე მას ძალიან ხშირად ვიყენებ! სურათზე (ეკრანის ანაბეჭდი მიმდინარე საიტიდან) ქონება "ზღაპარი" !
აქ არის თარიღის მთელი სკრიპტი:
ჩემი აზრით, ეს არ შეიძლება იყოს უფრო ადვილი, ის საკმაოდ ლამაზი და გასაგებია. თუ თქვენ არ გაქვთ სურვილი შეისწავლოთ ამ სკრიპტის კონსტრუქცია, უბრალოდ ჩასვით იგი სადმე HTML გვერდზე და მიიღებთ შემდეგ წარწერას:
კიდევ ერთი უფრო მოწინავე ვარიანტი
! დღეს
ასე გამოიყურება:
დღეს
ზოგადად, არანაირი უნარი არ არის საჭირო, უბრალოდ სულელურად შეიყვანე კოდი და ყველაფერი კარგადაა!
Უფრო ვრცლად:
ამრიგად, ჩვენ ვიწყებთ ცვლადს თარიღის მნიშვნელობის მინიჭებით დ, შემდეგ შექმენით მასივები ( მასივიკვირის დღეებისთვის ( დღის) და თვეები ( თვე), მიუთითებს მათ საჭირო გრამატიკულ ფორმაში: საქმე, რიცხვი, დიდი ასოთუ სიტყვა არის თარიღის დასაწყისში და ა. სკრიპტის ბოლო ხაზი არის რეალური თარიღის დაბეჭდვა ( დოკუმენტი.წერს). აქ თქვენ ადგენთ რა და რა თანმიმდევრობით აჩვენებთ მიმდინარე თარიღს სტრიქონში. კომპონენტები ერთმანეთისგან გამოყოფილია ნიშნით + ... სივრცის შესასვლელად გამოიყენეთ კონსტრუქცია " " და ასო g (წელი) ჩასასმელად - კონსტრუქცია "გ."
როგორც სკრიპტიდან ხედავთ, მიმდინარე დროის შესახებ მონაცემების მიღება ხდება ელემენტის მიერ მიიღეთ... ეს მეთოდი იძლევა შემდეგ ინფორმაციას:
- getDate ()- აბრუნებს რიცხვს 1 -დან 31 -მდე, რომელიც წარმოადგენს თვის დღეს;
- getDay ()- აბრუნებს კვირის დღეს მთელი რიცხვით 0 -დან (კვირა) 6 -მდე (შაბათი);
- getMonth ()- აბრუნებს წლის თვის ნომერს;
- getFullYear ()- აბრუნებს წელს. გამოიყენოს უბრალოდ getYear (), მაშინ გამოჩნდება მიმდინარე წელი მინუს 1900;
- მიიღეთ საათები ()- აბრუნებს დღის საათს;
- getMinutes ()- აბრუნებს წუთებს რიცხვით 0 -დან 59 -მდე;
- getSeconds ()- აბრუნებს წამების რაოდენობას 0 -დან 59 -მდე.
ჩასვით პირდაპირ ჯავა-სკრიპტი საიტის გვერდზე ყოველთვის არ არის მოსახერხებელი. უმჯობესია სკრიპტის აღწერა მოათავსოთ გვერდის ზედა ნაწილში ტეგებს შორის
და დავაყენოთ ცვლადი, რომელსაც ჩვენ საჭიროებისამებრ დავარქმევთ ტექსტში. მოდი დავარქვათ დღევანდელ დღესდა განსაზღვრეთ თარიღის ჩვენების ფორმა მასში ზემოაღნიშნულის მსგავსად. სკრიპტი ასე გამოიყურება:
თარიღის საჩვენებლად, დარეკეთ სკრიპტს გვერდის HTML კოდის სწორ ადგილას შემდეგი ბრძანების გამოყენებით:
თუ თქვენი საიტი შეიცავს ბევრ გვერდს, რომელზეც გსურთ თარიღის ჩვენება, მაშინ უფრო მოსახერხებელია ხაზგასმა ჯავა-სკრიპტი თარიღის ჩვენების მიზნით ცალკე ფაილი, მაგალითად, მონაცემები. js... პრაქტიკაში, ეს არის გვერდი, რომელიც შედგება პირველი აღწერილი სკრიპტებისაგან, ანუ სტრიქონით დოკუმენტი.წერს(იხილეთ ზემოთ). ის უნდა განთავსდეს იმავე დირექტორიაში, როგორც მთავარი გვერდი, და გამოიძახოს თარიღის გამოტანის ადგილას შემდეგნაირად:
არ დაგავიწყდეთ ფაილის შემოწმება მონაცემები. jsჰქონდა იგივე კოდირება, როგორც ძირითადი დოკუმენტი, წინააღმდეგ შემთხვევაში თარიღი ნაჩვენები იქნება მშვენიერი კაკვებით, კვადრატებით და სხვა შესწორებებით.
კომენტარი. უნდა გვახსოვდეს, რომ აღწერილი სკრიპტი აჩვენებს მომხმარებლის კომპიუტერზე მითითებულ თარიღს, რომელიც ყოველთვის არ შეესაბამება რეალურ მიმდინარე დროს. თუ თქვენ გჭირდებათ ზუსტი დროის ჩვენება, მაშინ თქვენ უნდა გამოიყენოთ PHP სკრიპტი, რომელიც აჩვენებს დროს სერვერზე.
