ଜାଭାସ୍କ୍ରିପ୍ଟରେ ଲିଖିତ ପ୍ରାୟ କ kind ଣସି ପ୍ରକାରର ପ୍ରୟୋଗ କିଛି କ୍ଷମତା ସହିତ ସମୟ କିମ୍ବା ତାରିଖ ସହିତ କାମ କରେ | ଆରମ୍ଭରେ, ଏହା ବିଲ୍ଟ-ଇନ୍ ତାରିଖ API ରେ ସୀମିତ ଥିଲା | ଏହି API ମ basic ଳିକ କାର୍ଯ୍ୟକାରିତା ଅନ୍ତର୍ଭୂକ୍ତ କରେ, କିନ୍ତୁ ଏହା କ’ଣ କରିପାରିବ ସେଥିରେ ସୀମିତ ଅଟେ | Moment.js ପରି ତୃତୀୟ-ପକ୍ଷ ଲାଇବ୍ରେରୀଗୁଡ଼ିକ, ଏବଂ ପରେ ବିଲ୍ଟ-ଇନ୍ API ଯେପରିକି Intl API ଏବଂ ନୂତନ ସାମୟିକ API, ସମୟ ଏବଂ ତାରିଖ ସହିତ କାର୍ଯ୍ୟ କରିବାରେ ଅଧିକ ନମନୀୟତା ଯୋଗ କରିଥାଏ | ମୁହୂର୍ତ୍ତର ଉତ୍ଥାନ ଏବଂ ପତନ Moment.js ସମୟ ଏବଂ ତାରିଖ ସହିତ କାର୍ଯ୍ୟ କରିବା ପାଇଁ ଶକ୍ତିଶାଳୀ ଉପଯୋଗୀତା ସହିତ ଏକ ଜାଭାସ୍କ୍ରିପ୍ଟ ଲାଇବ୍ରେରୀ | ଏହା ମ basic ଳିକ ତାରିଖ API ରୁ ବ missing ଶିଷ୍ଟ୍ୟଗୁଡିକ ଅନ୍ତର୍ଭୂକ୍ତ କରେ, ଯେପରିକି ଟାଇମ୍ ଜୋନ୍ ମନିପୁଲେସନ୍, ଏବଂ ଅନେକ ସାଧାରଣ କାର୍ଯ୍ୟକୁ ସରଳ କରିଥାଏ | ମୁହୂର୍ତ୍ତ ତାରିଖ ଏବଂ ସମୟ ଫର୍ମାଟିଂ ପାଇଁ କାର୍ଯ୍ୟ ମଧ୍ୟ ଅନ୍ତର୍ଭୁକ୍ତ କରେ | ଏହା ଅନେକ ଭିନ୍ନ ପ୍ରୟୋଗରେ ବହୁଳ ଭାବରେ ବ୍ୟବହୃତ ଲାଇବ୍ରେରୀ ହୋଇଗଲା | ତଥାପି, ମୁହୂର୍ତ୍ତରେ ମଧ୍ୟ ଏହାର ସମସ୍ୟାଗୁଡ଼ିକର ଅଂଶ ଥିଲା | ଏହା ଏକ ବୃହତ ଲାଇବ୍ରେରୀ, ଏବଂ ଏକ ଅନୁପ୍ରୟୋଗର ବଣ୍ଡଲ୍ ଆକାରରେ ଯଥେଷ୍ଟ ଯୋଗ କରିପାରିବ | କାରଣ ଲାଇବ୍ରେରୀ ଗଛ କମ୍ପନକୁ ସମର୍ଥନ କରେ ନାହିଁ (ଆଧୁନିକ ବଣ୍ଡଲରଗୁଡିକର ଏକ ବ that ଶିଷ୍ଟ୍ୟ ଯାହା ଲାଇବ୍ରେରୀଗୁଡ଼ିକର ଅବ୍ୟବହୃତ ଅଂଶଗୁଡ଼ିକୁ ଅପସାରଣ କରିପାରିବ), ସମଗ୍ର ମୁହୂର୍ତ୍ତ ଲାଇବ୍ରେରୀ ଅନ୍ତର୍ଭୂକ୍ତ ହୋଇଛି ଯଦିଓ ଆପଣ ଏହାର ଗୋଟିଏ କିମ୍ବା ଦୁଇଟି କାର୍ଯ୍ୟ ବ୍ୟବହାର କରନ୍ତି | ମୁହୂର୍ତ୍ତ ସହିତ ଅନ୍ୟ ଏକ ସମସ୍ୟା ହେଉଛି ଏହା ସୃଷ୍ଟି କରୁଥିବା ବସ୍ତୁଗୁଡ଼ିକ ପରିବର୍ତ୍ତନଶୀଳ | ଏକ ମୁହୂର୍ତ୍ତ ବସ୍ତୁ ଉପରେ ନିର୍ଦ୍ଦିଷ୍ଟ କାର୍ଯ୍ୟଗୁଡ଼ିକୁ ଡାକିବା ଦ୍ୱାରା ଏହାର ପାର୍ଶ୍ୱ ପ୍ରତିକ୍ରିୟା ରହିଥାଏ ଏବଂ ସେହି ବସ୍ତୁର ମୂଲ୍ୟକୁ ପରିବର୍ତ୍ତନ କରିଥାଏ | ଏହା ଅପ୍ରତ୍ୟାଶିତ ଆଚରଣ କିମ୍ବା ତ୍ରୁଟିର କାରଣ ହୋଇପାରେ | 2020 ରେ, ମୁହୂର୍ତ୍ତର ରକ୍ଷକମାନେ ଲାଇବ୍ରେରୀକୁ ରକ୍ଷଣାବେକ୍ଷଣ ମୋଡରେ ରଖିବାକୁ ସ୍ଥିର କଲେ | କ new ଣସି ନୂତନ ବ feature ଶିଷ୍ଟ୍ୟ ବିକାଶ କରାଯାଉ ନାହିଁ, ଏବଂ ରକ୍ଷକମାନେ ଏହାକୁ ନୂତନ ପ୍ରକଳ୍ପ ପାଇଁ ବ୍ୟବହାର ନକରିବାକୁ ପରାମର୍ଶ ଦିଅନ୍ତି | ସେଠାରେ ଅନ୍ୟାନ୍ୟ ଜାଭାସ୍କ୍ରିପ୍ଟ ତାରିଖ ଲାଇବ୍ରେରୀ ଅଛି, ଯେପରିକି ତାରିଖ- fns, କିନ୍ତୁ ଟାଉନରେ ଏକ ନୂତନ ପ୍ଲେୟାର ଅଛି, ସିଧାସଳଖ ଜାଭାସ୍କ୍ରିପ୍ଟରେ ନିର୍ମିତ ଏକ API: ସାମୟିକ | ଏହା ଏକ ନୂତନ ମାନକ ଯାହା ମୂଳ ତାରିଖ API ର ଛିଦ୍ର ପୂରଣ କରେ ଏବଂ ମୁହୂର୍ତ୍ତ ଏବଂ ଅନ୍ୟାନ୍ୟ ଲାଇବ୍ରେରୀରେ ମିଳୁଥିବା କିଛି ସୀମାବଦ୍ଧତାକୁ ସମାଧାନ କରେ | ସାମୟିକ କ’ଣ? ସାମୟିକ ହେଉଛି ଏକ ନୂତନ ସମୟ ଏବଂ ତାରିଖ API ECMAScript ମାନାଙ୍କ ସହିତ ଯୋଡା ଯାଉଛି, ଯାହା ଆଧୁନିକ ଜାଭାସ୍କ୍ରିପ୍ଟକୁ ବ୍ୟାଖ୍ୟା କରେ | ମାର୍ଚ୍ଚ 20266 ସୁଦ୍ଧା, ଏହା TC39 ପ୍ରକ୍ରିୟାର ପର୍ଯ୍ୟାୟ 4 ରେ ପହଞ୍ଚିଛି (ଜାଭାସ୍କ୍ରିପ୍ଟ ଭାଷାରେ ପ୍ରସ୍ତାବ ଏବଂ ଯୋଗର ତଦାରଖ କରୁଥିବା କମିଟି) ଏବଂ ଏହା ECMAScript ନିର୍ଦ୍ଦିଷ୍ଟକରଣର ପରବର୍ତ୍ତୀ ସଂସ୍କରଣରେ ଅନ୍ତର୍ଭୂକ୍ତ ହେବ | ଏହା ପୂର୍ବରୁ ଅନେକ ବ୍ରାଉଜରରେ ଲାଗୁ ହୋଇଛି: କ୍ରୋମ୍ 144+ ଏବଂ ଫାୟାରଫକ୍ସ 139+, ସଫାରି ଶୀଘ୍ର ଅନୁସରଣ କରିବେ ବୋଲି ଆଶା କରାଯାଉଛି | ଅସମର୍ଥିତ ବ୍ରାଉଜର୍ ଏବଂ Node.js ପାଇଁ ଏକ ପଲିଫିଲ୍ ମଧ୍ୟ ଉପଲବ୍ଧ | ସାମୟିକ API ବସ୍ତୁ ସୃଷ୍ଟି କରେ ଯାହା ସାଧାରଣତ ,, ସମୟର ମୂହୁର୍ତ୍ତକୁ ପ୍ରତିନିଧିତ୍ୱ କରେ | ଏଗୁଡିକ ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ସମୟ ମଣ୍ଡଳରେ ଫୁଲ୍ ଟାଇମ୍ ଏବଂ ଡେଟ୍ ଷ୍ଟାମ୍ପ୍ ହୋଇପାରେ, କିମ୍ବା ସେଗୁଡ଼ିକ କ wall ଣସି ସମୟ ଜୋନ୍ କିମ୍ବା ତାରିଖ ସୂଚନା ବିନା “କାନ୍ଥ ଘଣ୍ଟା” ସମୟର ଏକ ସାଧାରଣ ଉଦାହରଣ ହୋଇପାରେ | ସାମୟିକର କେତେକ ମୁଖ୍ୟ ବ features ଶିଷ୍ଟ୍ୟ ଅନ୍ତର୍ଭୁକ୍ତ:
ତାରିଖ ସହିତ କିମ୍ବା ବିନା ସମୟ | ଏକ ସାମୟିକ ବସ୍ତୁ ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ତାରିଖ, କିମ୍ବା କ date ଣସି ତାରିଖ ସୂଚନା ବିନା ଏକ ସମୟକୁ ପ୍ରତିନିଧିତ୍ୱ କରିପାରିବ | ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ତାରିଖ, ବିନା ସମୟ, ମଧ୍ୟ ଉପସ୍ଥାପିତ ହୋଇପାରେ | ଟାଇମ୍ ଜୋନ୍ ସମର୍ଥନ ମୁହୂର୍ତ୍ତ ମଧ୍ୟ ସମୟ ମଣ୍ଡଳକୁ ସମର୍ଥନ କରେ, କିନ୍ତୁ ଏହା ଅତିରିକ୍ତ ମୁହୂର୍ତ୍ତ-ଟାଇମଜୋନ ଲାଇବ୍ରେରୀ ଆବଶ୍ୟକ କରେ | ଅପରିବର୍ତ୍ତନୀୟତା। ଥରେ ଏକ ସାମୟିକ ବସ୍ତୁ ସୃଷ୍ଟି ହୋଇଗଲେ, ଏହାକୁ ପରିବର୍ତ୍ତନ କରାଯାଇପାରିବ ନାହିଁ | ଟାଇମ୍ ଆରିଥମେଟିକ୍ କିମ୍ବା ଟାଇମ୍ ଜୋନ୍ ରୂପାନ୍ତର ଅନ୍ତର୍ନିହିତ ବସ୍ତୁକୁ ପରିବର୍ତ୍ତନ କରେ ନାହିଁ | ଏହା ପରିବର୍ତ୍ତେ, ସେମାନେ ଏକ ନୂତନ ସାମୟିକ ବସ୍ତୁ ସୃଷ୍ଟି କରନ୍ତି | 1-ଆଧାରିତ ସୂଚକାଙ୍କ | ତାରିଖ API ସହିତ ତ୍ରୁଟିର ଏକ ସାଧାରଣ ଉତ୍ସ (ସେହିପରି ମୁହୂର୍ତ୍ତ ସହିତ) ହେଉଛି ମାସଗୁଡିକ ଶୂନ-ସୂଚୀବଦ୍ଧ | ଏହାର ଅର୍ଥ ହେଉଛି ଯେ ଆମେ ସମସ୍ତେ ବାସ୍ତବ ଜୀବନରେ ବୁ understand ୁଥିବାରୁ ମାସ 1 ଅପେକ୍ଷା ଜାନୁଆରୀ 0 ଅଟେ | 1-ଆଧାରିତ ସୂଚକାଙ୍କ ବ୍ୟବହାର କରି ସାମୟିକ ଏହାକୁ ଠିକ୍ କରେ - ଜାନୁଆରୀ ହେଉଛି ମାସ 1 | ଏହା ବ୍ରାଉଜରରେ ନିର୍ମିତ ହୋଇଛି ଯେହେତୁ ଟେମ୍ପୋରାଲ୍ ବ୍ରାଉଜରରେ ଏକ API ଅଟେ, ଏହା ଆପଣଙ୍କର ଅନୁପ୍ରୟୋଗର ବଣ୍ଡଲ୍ ଆକାରରେ କିଛି ଯୋଗ କରେ ନାହିଁ |
ଏହା ମଧ୍ୟ ଧ୍ୟାନ ଦେବା ଜରୁରୀ ଯେ ତାରିଖ API ଯିବ ନାହିଁ | ଯେତେବେଳେ ସାମୟିକ ଏହି API କୁ ଅତିକ୍ରମ କରେ, ଏହାକୁ ଅପସାରଣ କରାଯାଉ ନାହିଁ କିମ୍ବା ପୁରୁଣା କରାଯାଇ ନାହିଁ | ବ୍ରାଉଜର୍ ଗୁଡିକ ହଠାତ୍ ତାରିଖ API ଅପସାରଣ କଲେ ଅନେକ ପ୍ରୟୋଗ ଭାଙ୍ଗିଯିବ | ତଥାପି, ମନେରଖନ୍ତୁ ଯେ ମୂହୁର୍ତ୍ତ ବର୍ତ୍ତମାନ ରକ୍ଷଣାବେକ୍ଷଣ ମୋଡରେ ଏକ ପୁରୁଣା ପ୍ରକଳ୍ପ ଭାବରେ ପରିଗଣିତ ହୋଇଛି | ବାକି ଆର୍ଟିକିଲରେ, ଆମେ ନୂତନ ଟେମ୍ପୋରାଲ୍ API କୁ ମୁହୂର୍ତ୍ତ-ଆଧାରିତ କୋଡ୍ ସ୍ଥାନାନ୍ତର ପାଇଁ କିଛି “ରେସିପି” ଦେଖିବା | ଚାଲ ରିଫାକ୍ଟରିଂ ଆରମ୍ଭ କରିବା! ତାରିଖ ଏବଂ ସମୟ ଅବଜେକ୍ଟସ୍ ସୃଷ୍ଟି କରିବା | ଆମେ ତାରିଖ ଏବଂ ସମୟକୁ ନିୟନ୍ତ୍ରଣ କରିବା ପୂର୍ବରୁ, ସେମାନଙ୍କୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ବସ୍ତୁ ସୃଷ୍ଟି କରିବାକୁ ପଡିବ | ସାମ୍ପ୍ରତିକ ତାରିଖ ଏବଂ ସମୟକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ ମୁହୂର୍ତ୍ତ ବସ୍ତୁ ସୃଷ୍ଟି କରିବାକୁ, ମୁହୂର୍ତ୍ତ କାର୍ଯ୍ୟ ବ୍ୟବହାର କରନ୍ତୁ | const ବର୍ତ୍ତମାନ = ମୁହୂର୍ତ୍ତ (); console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-02-18T21: 26: 29-05: 00> |
ଏହି ବସ୍ତୁ ବର୍ତ୍ତମାନ ଆବଶ୍ୟକ ଅନୁଯାୟୀ ଫର୍ମାଟ୍ କିମ୍ବା ମନିପ୍ୟୁଲେଟ୍ ହୋଇପାରିବ |
// UTC କୁ ରୂପାନ୍ତର କରନ୍ତୁ | //ଚେତାବନୀ: ଏହା ମୁହୂର୍ତ୍ତ ବସ୍ତୁକୁ ପରିବର୍ତ୍ତନ କରେ ଏବଂ ଏହାକୁ UTC ମୋଡରେ ରଖେ! console.log (now.utc ()); // ମୁହୂର୍ତ୍ତ <2026-02-19T02: 26: 29Z> |
// ଏକ ଫର୍ମାଟ୍ ହୋଇଥିବା ଷ୍ଟ୍ରିଙ୍ଗ୍ ପ୍ରିଣ୍ଟ୍ କରନ୍ତୁ - ଧ୍ୟାନ ଦିଅନ୍ତୁ ଯେ ଏହା ବର୍ତ୍ତମାନ UTC ସମୟ ବ୍ୟବହାର କରୁଛି | console.log (now.format ('MM / DD / YYYY hh: mm: ss a')); // 02/19/2026 02:27:07 ପୂର୍ବାହ୍ନ |
ମୁହୂର୍ତ୍ତ ବିଷୟରେ ମନେରଖିବାକୁ ମୁଖ୍ୟ ବିଷୟ ହେଉଛି ଏକ ମୁହୂର୍ତ୍ତ ବସ୍ତୁ ସର୍ବଦା ସମୟ ଏବଂ ତାରିଖ ବିଷୟରେ ସୂଚନା ଅନ୍ତର୍ଭୁକ୍ତ କରେ | ଯଦି ଆପଣଙ୍କୁ କେବଳ ସମୟ ସୂଚନା ସହିତ କାମ କରିବାକୁ ପଡିବ, ଏହା ସାଧାରଣତ fine ଭଲ, କିନ୍ତୁ ଏହା ଦୀପାବଳି ସଞ୍ଚୟ ସମୟ କିମ୍ବା ଲମ୍ ବର୍ଷ ପରି ପରିସ୍ଥିତିରେ ଅପ୍ରତ୍ୟାଶିତ ଆଚରଣ ସୃଷ୍ଟି କରିପାରେ, ଯେଉଁଠାରେ ତାରିଖ ସମୟ ଗଣନା ଉପରେ ପ୍ରଭାବ ପକାଇପାରେ | ସାମୟିକ ଅଧିକ ନମନୀୟ | ଆପଣ ଏକ ଟେମ୍ପୋରାଲ୍.ଷ୍ଟାଣ୍ଟ ବସ୍ତୁ ସୃଷ୍ଟି କରି ସାମ୍ପ୍ରତିକ ତାରିଖ ଏବଂ ସମୟକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ ବସ୍ତୁ ସୃଷ୍ଟି କରିପାରିବେ | ଏହା “ଯୁଗ” (ଜାନୁଆରୀ 1, 1970 ରେ ମଧ୍ୟରାତ୍ରି UTC) ଠାରୁ ସମୟ ଦ୍ defined ାରା ବ୍ୟାଖ୍ୟା କରାଯାଇଥିବା ସମୟର ଏକ ବିନ୍ଦୁକୁ ପ୍ରତିନିଧିତ୍ୱ କରେ | ସାମୟିକ ଏହି ନାନୋ ସେକେଣ୍ଡ୍ ସ୍ତରର ସଠିକତା ସହିତ ଏହି ତତକ୍ଷଣାତ୍ ରେଫରେନ୍ସ କରିପାରିବ | const now = Temporal.Now.instant ();
// ଯୁଗରୁ କଞ୍ଚା ନାନୋ ସେକେଣ୍ଡ୍ ଦେଖନ୍ତୁ | console.log (now.epochNanoseconds); // 1771466342612000000n
// UTC ପାଇଁ ଫର୍ମାଟ୍ | console.log (now.toString ()); // 2026-02-19T01: 55: 27.844Z
// ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ସମୟ ମଣ୍ଡଳ ପାଇଁ ଫର୍ମାଟ୍ | console.log (now.toString ({timeZone: 'America / New_York'})); // 2026-02-18T20: 56: 57.905-05: 00
ଷ୍ଟାଟିକ୍ ପଦ୍ଧତିରୁ ବ୍ୟବହାର କରି ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ସମୟ ଏବଂ ତାରିଖ ପାଇଁ ଅସ୍ଥାୟୀ ବସ୍ତୁଗୁଡ଼ିକ ମଧ୍ୟ ସୃଷ୍ଟି କରାଯାଇପାରେ |
const myInstant = Temporal.Instant.from ('2026-02-18T21: 10: 00-05: 00');
// ସ୍ଥାନୀୟ ସମୟ ମଣ୍ଡଳରେ ତତକ୍ଷଣାତ୍ ଫର୍ମାଟ୍ କରନ୍ତୁ | ଧ୍ୟାନ ଦିଅନ୍ତୁ ଯେ ଏହା କେବଳ ନିୟନ୍ତ୍ରଣ କରେ | // ଫର୍ମାଟିଂ - ଏହା moment.utc ପରି ବସ୍ତୁକୁ ପରିବର୍ତ୍ତନ କରେ ନାହିଁ | console.log (myInstant.toString ({timeZone: 'America / New_York'})); // 2026-02-18T21: 10: 00-05: 00
ଆପଣ ଅନ୍ୟାନ୍ୟ ପ୍ରକାରର ସାମୟିକ ବସ୍ତୁ ମଧ୍ୟ ସୃଷ୍ଟି କରିପାରିବେ, ଅନ୍ତର୍ଭୁକ୍ତ କରି:
ସାମୟିକ.ପ୍ଲେନ୍ ଡେଟ୍: ସମୟ ସୂଚନା ନଥିବା ଏକ ତାରିଖ | ସାମୟିକ.ପ୍ଲେନ୍ ଟାଇମ୍: କ date ଣସି ତାରିଖ ସୂଚନା ନଥିବା ସମୟ | Temporal.ZonedDateTime: ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ସମୟ ମଣ୍ଡଳରେ ଏକ ତାରିଖ ଏବଂ ସମୟ |
ଏଥିମଧ୍ୟରୁ ପ୍ରତ୍ୟେକର ପଦ୍ଧତି ଅଛି ଯାହାକୁ ତାରିଖ ଏବଂ / କିମ୍ବା ସମୟ ନିର୍ଦ୍ଦିଷ୍ଟ କରୁଥିବା ଏକ ବସ୍ତୁ ସହିତ କୁହାଯାଇପାରେ, କିମ୍ବା ବିଶ୍ଳେଷଣ କରିବାକୁ ଏକ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ | // କେବଳ ଏକ ତାରିଖ | const ଆଜି = Temporal.PlainDate.from ({ ବର୍ଷ: 2026, ମାସ: 2, // ଟିପ୍ପଣୀ ଆମେ ଫେବୃଆରୀ ପାଇଁ 2 ବ୍ୟବହାର କରୁଛୁ | ଦିନ: 18 }); console.log (today.toString ()); // 2026-02-18
// କେବଳ ଗୋଟିଏ ସମୟ | const ମଧ୍ୟାହ୍ନ ଭୋଜନ ସମୟ = ସାମୟିକ | ପ୍ଲେନ୍ ଟାଇମ୍.ଫ୍ରୋମ୍ ({ ଘଣ୍ଟା: 12 }); console.log (ମଧ୍ୟାହ୍ନ ଭୋଜନ ସମୟ। toString ()); // 12:00:00
// ଯୁକ୍ତରାଷ୍ଟ୍ରର ପୂର୍ବ ସମୟ ମଣ୍ଡଳରେ ଏକ ତାରିଖ ଏବଂ ସମୟ | const dueAt = Temporal.ZonedDateTime.from ({ timeZone: 'America / New_York', ବର୍ଷ: 2026, ମାସ: 3, ଦିନ: 1, ଘଣ୍ଟା: 12, ମିନିଟ୍: 0, ଦ୍ୱିତୀୟ: 0 }); console.log (dueAt.toString ()); // 2026-03-01T12: 00: 00-05: 00 [ଆମେରିକା / ନ୍ୟୁ_ ୟର୍କ]
ପାର୍ସିଙ୍ଗ୍ | ଆମେ ତାରିଖ ଏବଂ ସମୟ ସୂଚନାର ପ୍ରୋଗ୍ରାମେଟିକ୍ ସୃଷ୍ଟି କଭର୍ କରିଛୁ | ଏବେ ପାର୍ସିଙ୍ଗ୍ ଦେଖିବା | ପାର୍ସିଂ ହେଉଛି ଏକ କ୍ଷେତ୍ର ଯେଉଁଠାରେ ବିଲ୍ଟ-ଇନ୍ ଟେମ୍ପୋରାଲ୍ API ଅପେକ୍ଷା ମୁହୂର୍ତ୍ତ ଅଧିକ ନମନୀୟ | ଏହାକୁ ଏକ ମୁହୂର୍ତ୍ତ ଫଙ୍କସନ୍ କୁ ପଠାଇ ଆପଣ ଏକ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ପାର୍ସ କରିପାରିବେ | ଗୋଟିଏ ଯୁକ୍ତି ସହିତ, ମୁହୂର୍ତ୍ତ ଏକ ISO ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗକୁ ଆଶା କରେ, କିନ୍ତୁ ତୁମେ ବିକଳ୍ପ ଫର୍ମାଟ୍ ବ୍ୟବହାର କରିପାରିବ ଯଦି ତୁମେ ବ୍ୟବହୃତ ହେଉଥିବା ତାରିଖ ଫର୍ମାଟ୍ ନିର୍ଦ୍ଦିଷ୍ଟ କରି ଦ୍ୱିତୀୟ ଯୁକ୍ତି ପ୍ରଦାନ କର |
const isoDate = ମୁହୂର୍ତ୍ତ ('2026-02-21T09: 00: 00'); const formattedDate = ମୁହୂର୍ତ୍ତ ('2/21/26 9:00:00', 'M / D / YY h: mm: ss');
console.log (isoDate); // ମୁହୂର୍ତ୍ତ <2026-02-21T09: 00: 00-05: 00> |
console.log (ଫର୍ମାଟ୍ ହୋଇଥିବା ତାରିଖ); // ମୁହୂର୍ତ୍ତ <2026-02-21T09: 00: 00-05: 00> |
ପୁରାତନ ସଂସ୍କରଣରେ, ମୁହୂର୍ତ୍ତ ଯେକ any ଣସି ଇଚ୍ଛାଧୀନ ଫର୍ମାଟ୍ ହୋଇଥିବା ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗକୁ ବିଶ୍ଳେଷଣ କରିବା ପାଇଁ ଏକ ଉତ୍ତମ ଅନୁମାନ କରିବ | ଏହା ଅପ୍ରତ୍ୟାଶିତ ଫଳାଫଳକୁ ନେଇପାରେ | ଉଦାହରଣ ସ୍ୱରୂପ, 02-03-2026 ଫେବୃଆରୀ 2 କିମ୍ବା ମାର୍ଚ୍ଚ 3? ଏହି କାରଣରୁ, ମୂହୁର୍ତ୍ତର ନୂତନ ସଂସ୍କରଣଗୁଡ଼ିକ ଯଦି ଏକ ISO ଫର୍ମାଟ୍ ହୋଇଥିବା ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ବିନା ଡାକାଯାଏ (ଯେପର୍ଯ୍ୟନ୍ତ ଇଚ୍ଛାମୁତାବକ ଫର୍ମାଟ୍ ସହିତ ଦ୍ୱିତୀୟ ଯୁକ୍ତି ମଧ୍ୟ ଦିଆଯାଇନଥାଏ) ଏକ ଉଲ୍ଲେଖନୀୟ ଅବନତି ଚେତାବନୀ ପ୍ରଦର୍ଶନ କରେ | ସାମୟିକ କେବଳ ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ଫର୍ମାଟ୍ ହୋଇଥିବା ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗକୁ ବିଶ୍ଳେଷଣ କରିବ | ଷ୍ଟ୍ରିଙ୍ଗ୍ ନିଶ୍ଚିତ ଭାବରେ ISO 8601 ଫର୍ମାଟ୍ କିମ୍ବା ଏହାର ବିସ୍ତାର, RFC 9557 ସହିତ ଅନୁରୂପ ହେବା ଉଚିତ | ଯଦି ଏକ ଅନୁପଯୁକ୍ତ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ପଦ୍ଧତିରୁ ପଠାଯାଏ, ଟେମ୍ପୋରାଲ୍ ଏକ ରେଞ୍ଜ ଏରର୍ ପକାଇବ |
// ଏକ RFC 9557 ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ବ୍ୟବହାର କରି | const myDate = Temporal.Instant.from ('2026-02-21T09: 00: 00-05: 00 [America / New_York]'); console.log (myDate.toString ({timeZone: 'America / New_York'})); // 2026-02-21T09: 00: 00-05: 00
// ଏକ ଅଜ୍ଞାତ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ବ୍ୟବହାର କରି | const otherDate = Temporal.Instant.from ('2/21/26 9:00:00'); // RangeError: ସାମୟିକ ତ୍ରୁଟି: ବର୍ଷର ମୂଲ୍ୟ ବିଶ୍ଳେଷଣ କରିବା ସମୟରେ ଅବ val ଧ ବର୍ଣ୍ଣ |
ଆପଣ କେଉଁ ପ୍ରକାରର ସାମୟିକ ବସ୍ତୁ ସୃଷ୍ଟି କରୁଛନ୍ତି ତାହା ଉପରେ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗର ସଠିକ ଆବଶ୍ୟକତା ନିର୍ଭର କରେ | ଉପରୋକ୍ତ ଉଦାହରଣରେ, Temporal.Instant ଏକ ସମ୍ପୂର୍ଣ୍ଣ ISO ଆବଶ୍ୟକ କରେ |8601 କିମ୍ବା RFC 9557 ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ଏକ ଟାଇମ୍ ଜୋନ୍ ଅଫସେଟ୍ ସହିତ ତାରିଖ ଏବଂ ସମୟ ନିର୍ଦ୍ଦିଷ୍ଟ କରେ, କିନ୍ତୁ ଆପଣ ତାରିଖ ଫର୍ମାଟ୍ର କେବଳ ଏକ ସବ୍ସେଟ୍ ବ୍ୟବହାର କରି ପ୍ଲେନ୍ ଡେଟ୍ କିମ୍ବା ପ୍ଲେନ୍ ଟାଇମ୍ ବସ୍ତୁ ସୃଷ୍ଟି କରିପାରିବେ | const myDate = Temporal.PlainDate.from ('2026-02-21'); console.log (myDate.toString ()); // 2026-02-21
const myTime = Temporal.PlainTime.from ('09: 00: 00 '); console.log (myTime.toString ()); // 09:00:00
ଧ୍ୟାନ ଦିଅନ୍ତୁ ଯେ ଏହି ଷ୍ଟ୍ରିଙ୍ଗଗୁଡିକ ନିଶ୍ଚିତ ଭାବରେ ଆଶାକରାଯାଇଥିବା ଫର୍ମାଟକୁ ପାଳନ କରିବା ଆବଶ୍ୟକ, କିମ୍ବା ଏକ ତ୍ରୁଟି ପକାଯିବ |
// ଏକ ଅନୁପଯୁକ୍ତ ସମୟ ଷ୍ଟ୍ରିଙ୍ଗ୍ ବ୍ୟବହାର କରିବା | ଏମାନେ ସମସ୍ତେ ଏକ ରେଞ୍ଜ ଏରର୍ ପକାଇବେ | Temporal.PlainTime.from ('9:00'); Temporal.PlainTime.from ('9:00:00 AM');
ପ୍ରୋ ଟିପ୍ସ: ଅଣ- ISO ଷ୍ଟ୍ରିଙ୍ଗଗୁଡିକ ପରିଚାଳନା କରିବା କାରଣ ସାମୟିକତା ନିର୍ଭରଯୋଗ୍ୟତାକୁ ପ୍ରାଧାନ୍ୟ ଦେଇଥାଏ, ଏହା 02-01-2026 ପରି ଏକ ଷ୍ଟ୍ରିଙ୍ଗର ଫର୍ମାଟ୍ ଅନୁମାନ କରିବାକୁ ଚେଷ୍ଟା କରିବ ନାହିଁ | ଯଦି ଆପଣଙ୍କର ଡାଟା ଉତ୍ସ ଏହିପରି ଷ୍ଟ୍ରିଙ୍ଗଗୁଡିକ ବ୍ୟବହାର କରେ, ତେବେ ଟେମ୍ପୋରାଲ୍ ସହିତ ଏହାକୁ ବ୍ୟବହାର କରିବାକୁ ଚେଷ୍ଟା କରିବା ପୂର୍ବରୁ 2026-02-01 ପରି ISO ଷ୍ଟ୍ରିଙ୍ଗରେ ମୂଲ୍ୟଗୁଡ଼ିକୁ ପୁନ arr ସଜାଇବା ପାଇଁ ଆପଣଙ୍କୁ କିଛି ଷ୍ଟ୍ରିଙ୍ଗ୍ ମନିପୁଲେସନ୍ କରିବାକୁ ପଡିବ |
ଫର୍ମାଟିଂ ଥରେ ତୁମର ଏକ ମୁହୂର୍ତ୍ତ କିମ୍ବା ସାମୟିକ ବସ୍ତୁ ଥଲେ, ତୁମେ ବୋଧହୁଏ ଏହାକୁ କିଛି ସମୟରେ ଏକ ଫର୍ମାଟ୍ ହୋଇଥିବା ଷ୍ଟ୍ରିଙ୍ଗରେ ରୂପାନ୍ତର କରିବାକୁ ଚାହୁଁଛ | ଏହା ହେଉଛି ଏକ ଉଦାହରଣ ଯେଉଁଠାରେ ମୁହୂର୍ତ୍ତ ଟିକିଏ ଅଧିକ ଟର୍ସେ | ତୁମେ ବସ୍ତୁର ଫର୍ମାଟ୍ ପଦ୍ଧତିକୁ ଟୋକେନ୍ ର ଏକ ଷ୍ଟ୍ରିଙ୍ଗ୍ ସହିତ ଡାକ, ଯାହା ଇଚ୍ଛିତ ତାରିଖ ଫର୍ମାଟ୍ ବର୍ଣ୍ଣନା କରେ | const ତାରିଖ = ମୁହୂର୍ତ୍ତ ();
console.log (date.format ('MM / DD / YYYY')); // 02/22/2026
console.log (date.format ('MMMM Do YYYY, h: mm: ss a')); // ଫେବୃଆରୀ 22nd 2026, 8:18:30 ଅପରାହ୍ନ |
ଅନ୍ୟ ପଟେ, ଟେମ୍ପୋରାଲ୍ ଆପଣଙ୍କୁ ଟିକେ ଅଧିକ କ୍ରିୟାଶୀଳ ହେବା ଆବଶ୍ୟକ କରେ | ସାମୟିକ ବସ୍ତୁଗୁଡ଼ିକ, ଯେପରିକି ଇନଷ୍ଟାଣ୍ଟ, ଏକ ଲୋକାଲ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ପଦ୍ଧତି ଅଛି ଯାହା ଏକ ବସ୍ତୁର ଗୁଣ ଭାବରେ ନିର୍ଦ୍ଦିଷ୍ଟ ବିଭିନ୍ନ ଫର୍ମାଟିଂ ବିକଳ୍ପଗୁଡ଼ିକୁ ଗ୍ରହଣ କରେ |
const date = Temporal.Now.instant ();
// କ arg ଣସି ଆର୍ଗୁମେଣ୍ଟ୍ ବିନା, ଆମେ ସାମ୍ପ୍ରତିକ ଲୋକାଲ୍ ପାଇଁ ଡିଫଲ୍ଟ ଫର୍ମାଟ୍ ପାଇବୁ | console.log (date.toLocaleString ()); // 2/22/2026, 8:23:36 PM (en-US ର ଏକ ଲୋକାଲ୍ ଅନୁମାନ କରି)
// ଏକ କଷ୍ଟମ୍ ଫର୍ମାଟ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ସୃଷ୍ଟି କରିବାକୁ ଫର୍ମାଟିଂ ଅପ୍ସନ୍ ପାସ୍ କରନ୍ତୁ | console.log (date.toLocaleString ('en-US', {) ମାସ: 'ଲମ୍ବା', ଦିନ: 'ସାଂଖ୍ୟିକ', ବର୍ଷ: 'ସାଂଖ୍ୟିକ', ଘଣ୍ଟା: '2-ଅଙ୍କ', ମିନିଟ୍: '2-ଅଙ୍କ' })); // ଫେବୃଆରୀ 22, 2026 ଟା 8:23 PM |
// କେବଳ ଫର୍ମାଟ୍ ଷ୍ଟ୍ରିଙ୍ଗରେ ଆପଣ ଚାହୁଁଥିବା ଫିଲ୍ଡଗୁଡିକ ପାସ୍ କରନ୍ତୁ | console.log (date.toLocaleString ('en-US', {) ମାସ: 'କ୍ଷୁଦ୍ର', ଦିନ: 'ସାଂଖ୍ୟିକ' })); // ଫେବୃଆରୀ 22
ସାମୟିକ ତାରିଖ ଫର୍ମାଟିଂ ପ୍ରକୃତରେ ହୁଡ୍ ତଳେ Intl.DateTimeFormat API (ଯାହା ଆଧୁନିକ ବ୍ରାଉଜର୍ରେ ସହଜରେ ଉପଲବ୍ଧ) ବ୍ୟବହାର କରେ | ଏହାର ଅର୍ଥ ତୁମେ ତୁମର କଷ୍ଟମ୍ ଫର୍ମାଟିଂ ଅପ୍ସନ୍ ସହିତ ଏକ ପୁନ us ବ୍ୟବହାରଯୋଗ୍ୟ ତାରିଖ ଟାଇମ୍ ଫର୍ମାଟ୍ ବସ୍ତୁ ସୃଷ୍ଟି କରିପାରିବ, ତାପରେ ସାମୟିକ ବସ୍ତୁଗୁଡ଼ିକୁ ଏହାର ଫର୍ମାଟ୍ ପଦ୍ଧତିକୁ ପଠାଇବ | ଏହି କାରଣରୁ, ଏହା ମୁହୂର୍ତ୍ତ ପରି କଷ୍ଟମ୍ ତାରିଖ ଫର୍ମାଟ୍ କୁ ସମର୍ଥନ କରେ ନାହିଁ | ଯଦି ଆପଣ 'Q1 2026' କିମ୍ବା ଅନ୍ୟାନ୍ୟ ବିଶେଷ ଫର୍ମାଟିଂ ଭଳି କିଛି ଆବଶ୍ୟକ କରନ୍ତି, ତେବେ ଆପଣଙ୍କୁ କିଛି କଷ୍ଟମ୍ ଡେଟ୍ ଫର୍ମାଟିଂ କୋଡ୍ ଆବଶ୍ୟକ ହୋଇପାରେ କିମ୍ବା ଏକ ତୃତୀୟ ପକ୍ଷ ଲାଇବ୍ରେରୀ ପାଇଁ ପହଞ୍ଚିପାରେ | const ଫର୍ମାଟର୍ = ନୂତନ Intl.DateTimeFormat ('en-US', { ମାସ: '2-ଅଙ୍କ', ଦିନ: '2-ଅଙ୍କ', ବର୍ଷ: 'ସାଂଖ୍ୟିକ' });
const date = Temporal.Now.instant (); console.log (formatter.format (ତାରିଖ)); // 02/22/2026
ମୁହୂର୍ତ୍ତର ଫର୍ମାଟିଂ ଟୋକେନ୍ ଲେଖିବା ସରଳ, କିନ୍ତୁ ସେଗୁଡ଼ିକ ଲୋକାଲ୍-ଫ୍ରେଣ୍ଡଲି ନୁହେଁ | ଫର୍ମାଟ୍ “ହାର୍ଡ କୋଡ୍” ଜିନିଷଗୁଡିକ ମାସ / ଦିନ କ୍ରମ ପରି ଷ୍ଟ୍ରିଙ୍ଗ୍ କରେ | ଟେମ୍ପୋରାଲ୍ ଭଳି ଏକ ବିନ୍ୟାସ ବସ୍ତୁ ବ୍ୟବହାର କରିବାର ସୁବିଧା ହେଉଛି ଏହା ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଯେକ given ଣସି ପ୍ରଦତ୍ତ ଲୋକାଲ୍ ସହିତ ଖାପ ଖାଇବ ଏବଂ ସଠିକ୍ ଫର୍ମାଟ୍ ବ୍ୟବହାର କରିବ | const date = Temporal.Now.instant ();
const formatOptions = { ମାସ: 'ସାଂଖ୍ୟିକ', ଦିନ: 'ସାଂଖ୍ୟିକ', ବର୍ଷ: 'ସାଂଖ୍ୟିକ' };
console.log (date.toLocaleString ('en-US', formatOptions)); // 2/22/2026
console.log (date.toLocaleString ('en-GB', formatOptions)); // 22/02/2026
ତାରିଖ ଗଣନା ଅନେକ ପ୍ରୟୋଗରେ, ଆପଣଙ୍କୁ ଏକ ତାରିଖରେ କିଛି ଗଣନା କରିବା ଶେଷ କରିବାକୁ ପଡିବ | ଆପଣ ହୁଏତ ସମୟର ଏକକ (ଦିନ, ଘଣ୍ଟା, ସେକେଣ୍ଡ, ଇତ୍ୟାଦି) ଯୋଡିବାକୁ କିମ୍ବା ବାହାର କରିବାକୁ ଚାହୁଁଥିବେ | ଉଦାହରଣ ସ୍ୱରୂପ, ଯଦି ଆପଣଙ୍କର ସାମ୍ପ୍ରତିକ ତାରିଖ ଅଛି, ତେବେ ଆପଣ ଉପଭୋକ୍ତାଙ୍କୁ ବର୍ତ୍ତମାନ ଠାରୁ 1 ସପ୍ତାହ ତାରିଖ ଦେଖାଇବାକୁ ଚାହିଁପାରନ୍ତି | ମୂହୁର୍ତ୍ତ ବସ୍ତୁଗୁଡ଼ିକରେ ପଦ୍ଧତି ଅଛି ଯେପରିକି ଯୋଡିବା ଏବଂ ବାହାର କରିବା ଯାହାକି ଏହି ଅପରେସନ୍ସ କରେ | ଏହି କାର୍ଯ୍ୟଗୁଡ଼ିକ ଏକ ମୂଲ୍ୟ ଏବଂ ଏକ ୟୁନିଟ୍ ନିଏ, ଉଦାହରଣ ସ୍ୱରୂପ: ଯୋଗ (7, 'ଦିନ') | ମୁହୂର୍ତ୍ତ ଏବଂ ସାମୟିକ ମଧ୍ୟରେ ଗୋଟିଏ ଅତି ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ପାର୍ଥକ୍ୟ ହେଉଛି, ଏହି ତାରିଖ ଗଣନା କରିବାବେଳେ, ଅନ୍ତର୍ନିହିତ ବସ୍ତୁକୁ ପରିବର୍ତ୍ତନ କରାଯାଇଥାଏ ଏବଂ ଏହାର ମୂଳ ମୂଲ୍ୟ ନଷ୍ଟ ହୋଇଯାଏ | const ବର୍ତ୍ତମାନ = ମୁହୂର୍ତ୍ତ ();
console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-02-24T20: 08: 36-05: 00> |
const nextWeek = now.add (7, 'ଦିନ'); console.log (nextWeek); // ମୁହୂର୍ତ୍ତ <2026-03-03T20: 08: 36-05: 00> |
// ଗୋଚା - ମୂଳ ବସ୍ତୁ ପରିବର୍ତ୍ତନ କରାଯାଇଥିଲା | console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-03-03T20: 08: 36-05: 00> |
ମୂଳ ତାରିଖ ହରାଇବାକୁ ଏଡାଇବା ପାଇଁ, ଆପଣ ଏକ କପି ସୃଷ୍ଟି କରିବାକୁ ମୁହୂର୍ତ୍ତ ବସ୍ତୁରେ କ୍ଲୋନ୍ କଲ୍ କରିପାରିବେ | ବର୍ତ୍ତମାନ= ମୁହୂର୍ତ୍ତ (); const nextWeek = now.clone () ଯୋଡନ୍ତୁ (7, 'ଦିନ');
console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-02-24T20: 12: 55-05: 00> |
console.log (nextWeek); // ମୁହୂର୍ତ୍ତ <2026-03-03T20: 12: 55-05: 00> |
ଅନ୍ୟ ପଟେ, ସାମୟିକ ବସ୍ତୁଗୁଡ଼ିକ ଅପରିବର୍ତ୍ତନୀୟ | ଥରେ ତୁମେ ଏକ ଇନଷ୍ଟାଣ୍ଟ, ପ୍ଲେନ୍ ଡେଟ୍ ଇତ୍ୟାଦି ପରି ଏକ ବସ୍ତୁ ସୃଷ୍ଟି କରିସାରିବା ପରେ, ସେହି ବସ୍ତୁର ମୂଲ୍ୟ କଦାପି ପରିବର୍ତ୍ତନ ହେବ ନାହିଁ | ସାମୟିକ ବସ୍ତୁଗୁଡ଼ିକରେ ମଧ୍ୟ ଯୋଗ ଏବଂ ବିସ୍ତାର ପଦ୍ଧତି ଅଛି | କେଉଁ ଅବଜେକ୍ଟ ପ୍ରକାରରେ କେଉଁ ସମୟ ୟୁନିଟ୍ ଯୋଡିହେବ ସେ ବିଷୟରେ ସାମୟିକ ଟିକିଏ ପସନ୍ଦ | ଉଦାହରଣ ସ୍ୱରୂପ, ଆପଣ ଏକ ତତକ୍ଷଣାତ୍ ଦିନ ଯୋଡି ପାରିବେ ନାହିଁ:
const now = Temporal.Now.instant (); const nextWeek = now.add ({ଦିନ: 7}); // RangeError: ସାମୟିକ ତ୍ରୁଟି: ବୃହତ ଏକକ ଏକ ତାରିଖ ଏକକ ହୋଇପାରିବ ନାହିଁ |
ଏହାର କାରଣ ହେଉଛି ତତକ୍ଷଣାତ୍ ବସ୍ତୁଗୁଡ଼ିକ UTC ରେ ଏକ ନିର୍ଦ୍ଦିଷ୍ଟ ବିନ୍ଦୁକୁ ପ୍ରତିନିଧିତ୍ୱ କରେ ଏବଂ କ୍ୟାଲେଣ୍ଡର-ଏଗ୍ନୋଷ୍ଟିକ୍ ଅଟେ | କାରଣ ଦିନର ଦ length ର୍ଘ୍ୟ ଟାଇମ୍ ଜୋନ୍ ନିୟମ ଉପରେ ଆଧାର କରି ପରିବର୍ତ୍ତନ ହୋଇପାରେ ଯେପରିକି ଦୀପାବଳି ସଞ୍ଚୟ ସମୟ, ଏହି ଗଣନା ଏକ ତତକ୍ଷଣାତ୍ ଉପଲବ୍ଧ ନୁହେଁ | ଆପଣ, ତଥାପି, ଅନ୍ୟ ପ୍ରକାରର ବସ୍ତୁ ଉପରେ ଏହି ଅପରେସନ୍ ସଂପାଦନ କରିପାରିବେ, ଯେପରିକି ଏକ ପ୍ଲେନ୍ ଡେଟ୍ ଟାଇମ୍: const now = Temporal.Now.plainDateTimeISO (); console.log (now.toLocaleString ()); // 2/24/2026, 8:23:59 PM |
const nextWeek = now.add ({ଦିନ: 7});
// ଧ୍ୟାନ ଦିଅନ୍ତୁ ଯେ ମୂଳ PlainDateTime ଅପରିବର୍ତ୍ତିତ ରହିଛି | console.log (now.toLocaleString ()); // 2/24/2026, 8:23:59 PM |
console.log (nextWeek.toLocaleString ()); // 3/3/2026, 8:23:59 PM |
ଦୁଇଟି ମୁହୂର୍ତ୍ତ କିମ୍ବା ସାମୟିକ ବସ୍ତୁ ମଧ୍ୟରେ କେତେ ସମୟ ଅଛି ତାହା ମଧ୍ୟ ଆପଣ ଗଣନା କରିପାରିବେ | ମୁହୂର୍ତ୍ତର ଡିଫ୍ ଫଙ୍କସନ୍ ସହିତ, ଆପଣଙ୍କୁ ଗ୍ରାନୁଲାରିଟି ପାଇଁ ଏକ ୟୁନିଟ୍ ପ୍ରଦାନ କରିବାକୁ ପଡିବ, ନଚେତ୍ ଏହା ମିଲିସେକେଣ୍ଡରେ ପାର୍ଥକ୍ୟ ଫେରାଇବ | const date1 = ମୁହୂର୍ତ୍ତ ('2026-02-21T09: 00: 00'); const date2 = ମୁହୂର୍ତ୍ତ ('2026-02-22T10: 30: 00');
console.log (date2.diff (date1)); // 91800000
console.log (date2.diff (date1, 'days')); // 1
ଏକ ସାମୟିକ ବସ୍ତୁ ସହିତ ଏହା କରିବାକୁ, ଆପଣ ପଦ୍ଧତି ପର୍ଯ୍ୟନ୍ତ କିମ୍ବା ପରଠାରୁ ଅନ୍ୟ ଏକ ସାମୟିକ ବସ୍ତୁକୁ ତାହା ନିକଟକୁ ପଠାଇ ପାରିବେ | ଏହା ଏକ ଟେମ୍ପୋରାଲ୍ ରିଟର୍ନ କରେ | ସମୟ ପାର୍ଥକ୍ୟ ବିଷୟରେ ସୂଚନା ଧାରଣ କରିଥାଏ | ପାର୍ଥକ୍ୟର ପ୍ରତ୍ୟେକ ଉପାଦାନ ପାଇଁ ଅବଧି ଅବଜେକ୍ଟର ଗୁଣ ଅଛି, ଏବଂ ସମୟ ପାର୍ଥକ୍ୟକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ ISO 8601 ଅବଧି ଷ୍ଟ୍ରିଙ୍ଗ ମଧ୍ୟ ସୃଷ୍ଟି କରିପାରିବ |
const date1 = Temporal.PlainDateTime.from ('2026-02-21T09: 00: 00'); const date2 = Temporal.PlainDateTime.from ('2026-02-22T10: 30: 00');
// ସର୍ବ ବୃହତ ୟୁନିଟ୍ ପ୍ରତିନିଧିତ୍ୱ କରିବାକୁ ସମୟର ସର୍ବ ବୃହତ ଏକକ ନିର୍ଦ୍ଦିଷ୍ଟ କରେ | // ଅବଧି ଗଣନାରେ | const diff = date2.since (date1, {largestUnit: 'day'});
console.log (diff.days); // 1
console.log (diff.hours); // 1
console.log (diff.minutes); // 30
console.log (diff.toString ()); // P1DT1H30M | // (ISO 8601 ଅବଧି ଷ୍ଟ୍ରିଙ୍ଗ୍: 1 ଦିନ, 1 ଘଣ୍ଟା, 30 ମିନିଟ୍)
ତାରିଖ ଏବଂ ସମୟ ତୁଳନା କରିବା | ମୁହୂର୍ତ୍ତ ଏବଂ ଅସ୍ଥାୟୀ ଉଭୟ ଆପଣଙ୍କୁ ତାରିଖ ଏବଂ ସମୟ ତୁଳନା କରିବାକୁ ଦିଅନ୍ତି ଯାହା ଅନ୍ୟ ପୂର୍ବରୁ ଆସେ ତାହା ନିର୍ଣ୍ଣୟ କରିବାକୁ, କିନ୍ତୁ API ସହିତ ଭିନ୍ନ ଆଭିମୁଖ୍ୟ ଗ୍ରହଣ କରନ୍ତୁ | ମୁହୂର୍ତ୍ତ ଦୁଇଟି ପଦ୍ଧତିକୁ ତୁଳନା କରିବା ପାଇଁ isBefore, isAfter, ଏବଂ isSame ପରି ପଦ୍ଧତି ପ୍ରଦାନ କରେ | const date1 = ମୁହୂର୍ତ୍ତ ('2026-02-21T09: 00: 00'); const date2 = ମୁହୂର୍ତ୍ତ ('2026-02-22T10: 30: 00');
console.log (date1.isBefore (date2)); // ସତ
ସମାନ ପ୍ରକାରର ଦୁଇଟି ବସ୍ତୁ ମଧ୍ୟରେ ତୁଳନା କରିବା ପାଇଁ ସାମୟିକ ଏକ ଷ୍ଟାଟିକ୍ ତୁଳନା ପଦ୍ଧତି ବ୍ୟବହାର କରେ | ଯଦି ଏହା ପ୍ରଥମ ତାରିଖ ଦ୍ before ିତୀୟ ପୂର୍ବରୁ ଆସେ, 0 ଯଦି ସମାନ ହୁଏ, କିମ୍ବା ଯଦି ପ୍ରଥମ ତାରିଖ ଦ୍ୱିତୀୟ ପରେ ଆସେ ତେବେ ଏହା -1 ରିଟର୍ନ କରେ | ଦୁଇଟି ପ୍ଲେନ୍ ଡେଟ୍ ବସ୍ତୁକୁ କିପରି ତୁଳନା କରାଯିବ ତାହା ନିମ୍ନ ଉଦାହରଣ ଦର୍ଶାଏ | Temporal.PlainDate.compare ପାଇଁ ଉଭୟ ଆର୍ଗୁମେଣ୍ଟ୍ ପ୍ଲେନ୍ ଡେଟ୍ ବସ୍ତୁ ହେବା ଜରୁରୀ |
const date1 = Temporal.PlainDate.from ({ବର୍ଷ: 2026, ମାସ: 2, ଦିନ: 24}); const date2 = Temporal.PlainDate.from ({ବର୍ଷ: 2026, ମାସ: 3, ଦିନ: 24});
// ତାରିଖ 1 ତାରିଖ 2 ପୂର୍ବରୁ ଆସେ, ତେଣୁ -1 | console.log (Temporal.PlainDate.compare (date1, date2));
// ଯଦି ଆମେ ବିଭିନ୍ନ ପ୍ରକାରର ଦୁଇଟି ବସ୍ତୁ ତୁଳନା କରିବାକୁ ଚେଷ୍ଟା କରିବା ତ୍ରୁଟି | console.log (Temporal.PlainDate.compare (date1, Temporal.Now.instant ())); // TypeError: ସାମୟିକ ତ୍ରୁଟି: ଅବ val ଧ ପ୍ଲେନ୍ ଡେଟ୍ ଫିଲ୍ଡଗୁଡିକ ପ୍ରଦାନ କରାଯାଇଛି |
ବିଶେଷ ଭାବରେ, ଏହା ସାମୟିକ ବସ୍ତୁଗୁଡ଼ିକର ଏକ ଆରେକୁ କ୍ରମାନୁସାରେ ସଜାଡ଼ିବା ସହଜ କରିଥାଏ | // Temporal.PlainDate ବସ୍ତୁର ଏକ ଆରେ | const ତାରିଖ = [...];
// ତୁଳନାକାରୀ କାର୍ଯ୍ୟ ଭାବରେ Temporal.PlainDate.compare ବ୍ୟବହାର କରନ୍ତୁ | date.sort (Temporal.PlainDate.compare);
ସମୟ ମଣ୍ଡଳ ପରିବର୍ତ୍ତନ | ମୂଳ ମୁହୂର୍ତ୍ତ ଲାଇବ୍ରେରୀ ଟାଇମ୍ ଜୋନ୍ ପରିବର୍ତ୍ତନକୁ ସମର୍ଥନ କରେନାହିଁ | ଯଦି ଆପଣ ଏହି କାର୍ଯ୍ୟକାରିତା ଆବଶ୍ୟକ କରନ୍ତି, ତେବେ ଆପଣଙ୍କୁ କ୍ଷଣ-ସମୟ ମଣ୍ଡଳ ପ୍ୟାକେଜ୍ ମଧ୍ୟ ସଂସ୍ଥାପନ କରିବାକୁ ପଡିବ | ଏହି ପ୍ୟାକେଜ୍ ଗଛ-କମ୍ପନଯୋଗ୍ୟ ନୁହେଁ, ଏବଂ ସେଥିପାଇଁ ତୁମର ବଣ୍ଡଲ୍ ଆକାରରେ ଯଥେଷ୍ଟ ଯୋଗ କରିପାରିବ | ଥରେ ଆପଣ ମୁହୂର୍ତ୍ତ-ସମୟ ମଣ୍ଡଳ ସଂସ୍ଥାପନ କରିସାରିବା ପରେ, ଆପଣ tz ପଦ୍ଧତି ସହିତ ମୁହୂର୍ତ୍ତ ବସ୍ତୁଗୁଡ଼ିକୁ ବିଭିନ୍ନ ସମୟ ମଣ୍ଡଳରେ ରୂପାନ୍ତର କରିପାରିବେ | ଅନ୍ୟାନ୍ୟ ମୁହୂର୍ତ୍ତ ଅପରେସନ୍ ପରି, ଏହା ଅନ୍ତର୍ନିହିତ ପରିବର୍ତ୍ତନ କରେ |ବସ୍ତୁ // US ପୂର୍ବାଞ୍ଚଳ ସମୟ ଅନୁମାନ କରିବା | const ବର୍ତ୍ତମାନ = ମୁହୂର୍ତ୍ତ (); console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-02-28T20: 08: 20-05: 00> |
// ପ୍ରଶାନ୍ତ ସମୟକୁ ରୂପାନ୍ତର କରନ୍ତୁ | // ମୂଳ ପୂର୍ବାଞ୍ଚଳ ସମୟ ହଜିଯାଇଛି | now.tz ('ଆମେରିକା / ଲସ୍_ ଆଞ୍ଜେଲସ୍'); console.log (ବର୍ତ୍ତମାନ); // ମୁହୂର୍ତ୍ତ <2026-02-28T17: 08: 20-08: 00> |
ଏକ ଟେମ୍ପୋରାଲ୍.ଜୋନେଡ୍ ଡେଟ୍ ଟାଇମ୍ ଅବଜେକ୍ଟ ବ୍ୟବହାର କରିବା ସମୟରେ ଟାଇମ୍ ଜୋନ୍ କାର୍ଯ୍ୟକାରିତା ସାମୟିକ API ରେ ନିର୍ମିତ | ଏହି ବସ୍ତୁଗୁଡ଼ିକ ସହିତ ଏକ ଟାଇମ୍ ଜୋନ୍ ପଦ୍ଧତି ଅନ୍ତର୍ଭୂକ୍ତ କରେ ଯାହା ଏକ ନୂତନ ଜୋନେଡ୍ ଡେଟ୍ ଟାଇମ୍ ସମାନ ମୁହୂର୍ତ୍ତକୁ ପ୍ରତିନିଧିତ୍ୱ କରେ, କିନ୍ତୁ ନିର୍ଦ୍ଦିଷ୍ଟ ସମୟ ମଣ୍ଡଳରେ | // ପୁନର୍ବାର, US ପୂର୍ବାଞ୍ଚଳ ସମୟ ଅନୁମାନ | const now = Temporal.Now.zonedDateTimeISO (); console.log (now.toLocaleString ()); // 2/28/2026, 8:12:02 PM EST |
// ପ୍ରଶାନ୍ତ ସମୟକୁ ରୂପାନ୍ତର କରନ୍ତୁ | const nowPacific = now.withTimeZone ('ଆମେରିକା / ଲସ୍_ ଆଞ୍ଜେଲସ୍'); console.log (nowPacific.toLocaleString ()); // 2/28/2026, 5:12:02 PM PST |
// ମୂଳ ବସ୍ତୁ ଅପରିବର୍ତ୍ତିତ ରହିଛି | console.log (now.toLocaleString ()); // 2/28/2026, 8:12:02 PM EST |
ଟିପନ୍ତୁ: ଲୋକାଲ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ଦ୍ୱାରା ଫେରସ୍ତ ହୋଇଥିବା ଫର୍ମାଟ୍ ହୋଇଥିବା ମୂଲ୍ୟଗୁଡ଼ିକ ହେଉଛି, ଯେପରି ନାମ ସୂଚିତ କରେ, ଲୋକାଲ୍-ନିର୍ଭରଶୀଳ | ନମୁନା କୋଡ୍ en-US ଲୋକାଲରେ ବିକଶିତ ହୋଇଥିଲା, ତେଣୁ ଫର୍ମାଟ୍ ଏହିପରି: 2/28/2026, 5:12:02 PM PST | ଅନ୍ୟ ଏକ ସ୍ଥାନରେ, ଏହା ଭିନ୍ନ ହୋଇପାରେ | ଉଦାହରଣ ସ୍ୱରୂପ, en-GB ଲୋକାଲରେ, ଆପଣ 28/2/2026, 17:12:02 GMT-8 ପରି କିଛି ପାଇବେ | ଏକ ବାସ୍ତବ ଦୁନିଆର ରିଫାକ୍ଟରିଙ୍ଗ୍ | ଧରାଯାଉ ଆମେ ସମୟ ମଣ୍ଡଳରେ ଇଭେଣ୍ଟ ନିର୍ଦ୍ଧାରଣ ପାଇଁ ଏକ ଆପ୍ ନିର୍ମାଣ କରୁଛୁ | ଏହି ଆପର ଏକ ଅଂଶ ହେଉଛି ଏକ ଫଙ୍କସନ୍, getEventTimes, ଯାହା ଇଭେଣ୍ଟର ସମୟ ଏବଂ ତାରିଖ, ଏକ ସ୍ଥାନୀୟ ଟାଇମ୍ ଜୋନ୍ ଏବଂ ଏକ ଟାର୍ଗେଟ୍ ଟାଇମ୍ ଜୋନ୍ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ ISO 8601 ଷ୍ଟ୍ରିଙ୍ଗ୍ ନେଇଥାଏ | ଫଙ୍କସନ୍ ଉଭୟ ଟାଇମ୍ ଜୋନ୍ରେ ଇଭେଣ୍ଟ ପାଇଁ ଫର୍ମାଟ୍ ହୋଇଥିବା ସମୟ ଏବଂ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ସୃଷ୍ଟି କରେ | ଯଦି ଫଙ୍କସନ୍ କୁ ଏକ ଇନପୁଟ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ଦିଆଯାଏ ଯାହା ଏକ ବ valid ଧ ସମୟ / ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ନୁହେଁ, ଏହା ଏକ ତ୍ରୁଟି ପକାଇବ | ମୁହୂର୍ତ୍ତ ବ୍ୟବହାର କରି ଏଠାରେ ମୂଳ କାର୍ଯ୍ୟକାରିତା (ମୁହୂର୍ତ୍ତ-ସମୟ ମଣ୍ଡଳ ପ୍ୟାକେଜ୍ ବ୍ୟବହାର ମଧ୍ୟ ଆବଶ୍ୟକ) |
'ମୁହୂର୍ତ୍ତ-ସମୟ ମଣ୍ଡଳ'ରୁ ମୁହୂର୍ତ୍ତ ଆମଦାନି କରନ୍ତୁ;
getEventTimes (inputString, userTimeZone, targetTimeZone) function const timeFormat = 'MMM D, YYYY, h: mm: ss a z';
// 1। ଉପଭୋକ୍ତାଙ୍କର ସମୟ ମଣ୍ଡଳରେ ପ୍ରାରମ୍ଭିକ ମୁହୂର୍ତ୍ତ ସୃଷ୍ଟି କରନ୍ତୁ | const eventTime = moment.tz ( inputString, moment.ISO_8601, // ଏକ ISO 8601 ଷ୍ଟ୍ରିଙ୍ଗ ଆଶାକର | ସତ, // କଠୋର ବିଶ୍ଳେଷଣ | ୟୁଜର୍ ଟାଇମ୍ ଜୋନ୍ | );
// ଯଦି ଏକ ଇନପୁଟ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ଏକ ବ date ଧ ତାରିଖକୁ ପ୍ରତିନିଧିତ୍ୱ କରେ ନାହିଁ ତେବେ ଏକ ତ୍ରୁଟି ପକାନ୍ତୁ | if (! eventTime.isValid ()) { ନୂତନ ତ୍ରୁଟି ପକାନ୍ତୁ ('ଅବ val ଧ ତାରିଖ / ସମୟ ଇନପୁଟ୍'); }
// 2। ଲକ୍ଷ୍ୟ ସମୟ ଗଣନା କର | // ସମାଲୋଚନା: ଆମକୁ କ୍ଲୋନ୍ କରିବାକୁ ପଡିବ, କିମ୍ବା 'ଇଭେଣ୍ଟ ଟାଇମ୍' ସବୁଦିନ ପାଇଁ ବଦଳିବ! const targetTime = eventTime.clone ()। tz (targetTimeZone);
ଫେରସ୍ତ { ସ୍ଥାନୀୟ: ଇଭେଣ୍ଟ ଟାଇମ୍.ଫର୍ମାଟ୍ (ଟାଇମ୍ ଫର୍ମାଟ୍), ଲକ୍ଷ୍ୟ: targetTime.format (timeFormat), }; }
const କାର୍ଯ୍ୟସୂଚୀ = getEventTimes ( '2026-03-05T15: 00-05: 00', 'ଆମେରିକା / ନ୍ୟୁ_ ୟର୍କ', 'ୟୁରୋପ / ଲଣ୍ଡନ', );
console.log (schedule.local); // ମାର୍ଚ୍ଚ 5, 2026, 3:00:00 EST |
console.log (schedule.target); // ମାର୍ଚ୍ଚ 5, 2026, 8:00:00 GMT |
ଏହି ଉଦାହରଣରେ, ଆମେ ISO 8601 ର ଏକ ଆଶାକରାଯାଇଥିବା ତାରିଖ ଫର୍ମାଟ୍ ବ୍ୟବହାର କରୁଛୁ, ଯାହା ସାହାଯ୍ୟରେ ମୁହୂର୍ତ୍ତରେ ନିର୍ମିତ | ଆମେ ମଧ୍ୟ କଠୋର ପାର୍ସିଂ ବ୍ୟବହାର କରୁଛୁ, ଯାହାର ଅର୍ଥ ହେଉଛି ମୁହୂର୍ତ୍ତ ଏକ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ ସହିତ ଅନୁମାନ କରିବାକୁ ଚେଷ୍ଟା କରିବ ନାହିଁ ଯାହା ଫର୍ମାଟ୍ ସହିତ ମେଳ ଖାଉ ନାହିଁ | ଯଦି ଏକ ଅଣ- ISO ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ପାସ୍ ହୁଏ, ଏହା ଏକ ଅବ alid ଧ ତାରିଖ ବସ୍ତୁ ସୃଷ୍ଟି କରିବ, ଏବଂ ଆମେ ଏକ ତ୍ରୁଟି ପକାଇବୁ | ସାମୟିକ କାର୍ଯ୍ୟକାରିତା ସମାନ ଦେଖାଯାଏ, କିନ୍ତୁ ଏହାର କିଛି ମୁଖ୍ୟ ପାର୍ଥକ୍ୟ ଅଛି |
getEventTimes (inputString, userTimeZone, targetTimeZone) function // 1। ଇନପୁଟ୍ କୁ ଏକ ଇନଷ୍ଟାଣ୍ଟରେ ସିଧାସଳଖ ପାର୍ସ କରନ୍ତୁ, ତାପରେ ସୃଷ୍ଟି କରନ୍ତୁ | // ଉପଭୋକ୍ତା ଜୋନରେ ଏକ ZonedDateTime | const instant = Temporal.Instant.from (inputString); const eventTime = instant.toZonedDateTimeISO (userTimeZone);
// 2। ଟାର୍ଗେଟ୍ ଜୋନ୍ କୁ ରୂପାନ୍ତର କରନ୍ତୁ | // ଏହା ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଏକ ନୂତନ ବସ୍ତୁ ଫେରସ୍ତ କରେ; 'ଇଭେଣ୍ଟ ଟାଇମ୍' ସୁରକ୍ଷିତ ଅଟେ | const targetTime = eventTime.withTimeZone (targetTimeZone);
// 3। Intl (ବିଲ୍ଟ-ଇନ୍) ବ୍ୟବହାର କରି ଫର୍ମାଟ୍ କରନ୍ତୁ | const ବିକଳ୍ପଗୁଡ଼ିକ = { ବର୍ଷ: 'ସାଂଖ୍ୟିକ', ମାସ: 'କ୍ଷୁଦ୍ର', ଦିନ: 'ସାଂଖ୍ୟିକ', ଘଣ୍ଟା: 'ସାଂଖ୍ୟିକ', ମିନିଟ୍: '2-ଅଙ୍କ', ଦ୍ୱିତୀୟ: '2-ଅଙ୍କ', timeZoneName: 'କ୍ଷୁଦ୍ର' };
ଫେରସ୍ତ { ସ୍ଥାନୀୟ: eventTime.toLocaleString (navigator.language, options), ଲକ୍ଷ୍ୟ: targetTime.toLocaleString (navigator.language, options) }; }
const କାର୍ଯ୍ୟସୂଚୀ = getEventTimes ( '2026-03-05T15: 00-05: 00', 'ଆମେରିକା / ନ୍ୟୁ_ ୟର୍କ', 'ୟୁରୋପ / ଲଣ୍ଡନ', );
console.log (schedule.local); // ମାର୍ଚ୍ଚ 5, 2026, 3:00:00 PM EST |
console.log (schedule.target); // ମାର୍ଚ୍ଚ 5, 2026, 8:00:00 PM GMT |
ମୁହୂର୍ତ୍ତ ସହିତ, ଫଳାଫଳ ତାରିଖ ଷ୍ଟ୍ରିଙ୍ଗ୍ ପାଇଁ ଆମକୁ ଏକ ଫର୍ମାଟ୍ ଷ୍ଟ୍ରିଙ୍ଗ୍ ନିର୍ଦ୍ଦିଷ୍ଟ ଭାବରେ ନିର୍ଦ୍ଦିଷ୍ଟ କରିବାକୁ ପଡିବ | ଉପଭୋକ୍ତାଙ୍କର ଅବସ୍ଥାନ କିମ୍ବା ଲୋକାଲ୍ ନିର୍ବିଶେଷରେ, ଇଭେଣ୍ଟ ସମୟ ସବୁବେଳେ ମାର୍ଚ 5, 2026, 3:00:00 ଭାବରେ ଫର୍ମାଟ୍ ହେବ |pm EST ଆହୁରି ମଧ୍ୟ, ଆମକୁ ସ୍ପଷ୍ଟ ଭାବରେ ଏକ ବ୍ୟତିକ୍ରମ ପକାଇବାକୁ ପଡିବ ନାହିଁ | ଯଦି ଏକ ଅବ alid ଧ ଷ୍ଟ୍ରିଙ୍ଗ୍ Temporal.Instant.from କୁ ପଠାଯାଏ, ଟେମ୍ପୋରାଲ୍ ଆମ ପାଇଁ ବ୍ୟତିକ୍ରମ ପକାଇବ | ଗୋଟିଏ କଥା ଧ୍ୟାନ ଦେବା ଉଚିତ ଯେ କଡା ବିଶ୍ଳେଷଣ ସହିତ ମଧ୍ୟ ମୁହୂର୍ତ୍ତ ସଂସ୍କରଣ ଅଧିକ ବିନମ୍ର ଅଟେ | ଷ୍ଟ୍ରିଙ୍ଗ୍ ଶେଷରେ ଟେମ୍ପୋରାଲ୍ ଟାଇମ୍ ଜୋନ୍ ଅଫସେଟ୍ ଆବଶ୍ୟକ କରେ | ଆପଣ ଏହା ମଧ୍ୟ ଧ୍ୟାନ ଦେବା ଉଚିତ ଯେ ଯେହେତୁ ଆମେ navigator.language ବ୍ୟବହାର କରୁଛୁ, ଏହି କୋଡ୍ କେବଳ ବ୍ରାଉଜର୍ ପରିବେଶରେ ଚାଲିବ, ଯେହେତୁ Node.js ପରିବେଶରେ ନାଭିଗେଟର୍ ବ୍ୟାଖ୍ୟା କରାଯାଇ ନାହିଁ | ସାମୟିକ କାର୍ଯ୍ୟକାରିତା ବ୍ରାଉଜରର ସାମ୍ପ୍ରତିକ ଲୋକାଲ୍ (navigator.language) ବ୍ୟବହାର କରେ, ତେଣୁ ଉପଭୋକ୍ତା ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଇଭେଣ୍ଟ ସମୟକୁ ସେମାନଙ୍କ ସ୍ଥାନୀୟ ସମୟ ଫର୍ମାଟରେ ଫର୍ମାଟ୍ କରିବେ | En-US ଲୋକାଲରେ, ଏହା ହେଉଛି ମାର୍ଚ୍ଚ 5, 2026, 3:00:00 ଅପରାହ୍ନ EST | ଯଦିଓ, ଯଦି ଉପଭୋକ୍ତା ଲଣ୍ଡନରେ ଅଛନ୍ତି, ଉଦାହରଣ ସ୍ୱରୂପ, ଇଭେଣ୍ଟ ସମୟଗୁଡିକ 5 ମାର୍ଚ 2026, 15:00:00 GMT-5 ଭାବରେ ଫର୍ମାଟ୍ ହେବ | ସାରାଂଶ
କାର୍ଯ୍ୟ Moment.js ସାମୟିକ | ସାମ୍ପ୍ରତିକ ସମୟ | ମୁହୂର୍ତ୍ତ () Temporal.Now.zonedDateTimeISO () ISO ପାର୍ସ କରିବା | ମୁହୂର୍ତ୍ତ (str) Temporal.Instant.from (str) ସମୟ ଯୋଡନ୍ତୁ | .add (7, 'days') (mutates) .add ({ଦିନ: 7}) (ନୂତନ ବସ୍ତୁ) ପାର୍ଥକ୍ୟ | .diff (ଅନ୍ୟ, 'ଘଣ୍ଟା') .since (ଅନ୍ୟ) .ହୋର୍ସ ସମୟ ମଣ୍ଡଳ | .tz ('ଜୋନ୍ / ନାମ') .WithTimeZone ('ଜୋନ୍ / ନାମ')
ପ୍ରଥମ ଦେଖାରେ, ପାର୍ଥକ୍ୟ ସାମାନ୍ୟ ଭିନ୍ନ ହୋଇପାରେ (ଏବଂ ଟେମ୍ପୋରାଲ୍ କ୍ଷେତ୍ରରେ, ବେଳେବେଳେ ଅଧିକ କ୍ରିୟା ଏବଂ ଅଧିକ କଠୋର) ବାକ୍ୟବିନ୍ୟାସ, କିନ୍ତୁ Moment.js ଉପରେ ଟେମ୍ପୋରାଲ୍ ବ୍ୟବହାର କରିବାର ଅନେକ ପ୍ରମୁଖ ସୁବିଧା ଅଛି:
ଅଧିକ ସ୍ପଷ୍ଟ ହେବା ଅର୍ଥ କମ୍ ଆଶ୍ଚର୍ଯ୍ୟ ଏବଂ ଅବାଞ୍ଛିତ ତ୍ରୁଟି | ମୁହୂର୍ତ୍ତଟି ଅଧିକ ଲୋଭନୀୟ ମନେହୁଏ, କିନ୍ତୁ ଏଥିରେ “ଅନୁମାନ କାର୍ଯ୍ୟ” ଅନ୍ତର୍ଭୁକ୍ତ, ଯାହା ବେଳେବେଳେ ଭୁଲ୍ ତାରିଖ ଦେଇପାରେ | ଯଦି ଆପଣ ସାମୟିକ କିଛି ଅବ alid ଧ ଦିଅନ୍ତି, ଏହା ଏକ ତ୍ରୁଟି ପକାଇଥାଏ | ଯଦି କୋଡ୍ ଚାଲିବ, ଆପଣ ଜାଣନ୍ତି ଯେ ଆପଣ ଏକ ବ date ଧ ତାରିଖ ପାଇଛନ୍ତି | କ୍ଷଣଟି ଅନୁପ୍ରୟୋଗର ବଣ୍ଡଲରେ ମହତ୍ size ପୂର୍ଣ୍ଣ ଆକାର ଯୋଡିପାରେ, ବିଶେଷତ if ଯଦି ଆପଣ ମୁହୂର୍ତ୍ତ-ସମୟ କ୍ଷେତ୍ର ପ୍ୟାକେଜ୍ ବ୍ୟବହାର କରୁଛନ୍ତି | ସାମୟିକ କିଛି ଯୋଗ କରେ ନାହିଁ (ଥରେ ଏହା ତୁମର ଲକ୍ଷ୍ୟ ବ୍ରାଉଜରରେ ପଠାଯାଏ) | ଅକ୍ଷୟତା ଆପଣଙ୍କୁ ଆତ୍ମବିଶ୍ୱାସ ପ୍ରଦାନ କରେ ଯେ ତାରିଖ ପରିବର୍ତ୍ତନ ଏବଂ କାର୍ଯ୍ୟ କରିବା ସମୟରେ ଆପଣ କଦାପି ତଥ୍ୟ ହରାଇବେ ନାହିଁ କିମ୍ବା ଓଭର୍ ରାଇଟ୍ କରିବେ ନାହିଁ | ଆପଣଙ୍କ ଆବଶ୍ୟକତା ଉପରେ ନିର୍ଭର କରି ସମୟର ବିଭିନ୍ନ ଉପସ୍ଥାପନା (ତତକ୍ଷଣାତ୍, ପ୍ଲେନ୍ ଡେଟ୍ ଟାଇମ୍, ଜୋନ୍ଡ୍ ଡେଟ୍ ଟାଇମ୍), ଯେଉଁଠାରେ ମୁହୂର୍ତ୍ତ ସର୍ବଦା ଏକ UTC ଟାଇମଷ୍ଟ୍ୟାମ୍ପରେ ଏକ ରାପର୍ ଅଟେ | ତାରିଖ ଫର୍ମାଟିଂ ପାଇଁ ସାମୟିକ Intl API ଗୁଡିକ ବ୍ୟବହାର କରେ, ଯାହାର ଅର୍ଥ ହେଉଛି ଟୋକେନ୍ଗୁଡ଼ିକୁ ନିର୍ଦ୍ଦିଷ୍ଟ ଭାବରେ ନିର୍ଦ୍ଦିଷ୍ଟ ନକରି ଆପଣ ଲୋକାଲ୍-ସଚେତନ ଫର୍ମାଟିଂ କରିପାରିବେ |
ପଲିଫିଲ୍ ଉପରେ ଟିପ୍ପଣୀ | ପୂର୍ବରୁ କୁହାଯାଇଥିବା ପରି, ଏକ ଟେମ୍ପୋରାଲ୍ ପଲିଫିଲ୍ ଉପଲବ୍ଧ, @ ns-temporal / polyfill ନାମକ ଏକ npm ପ୍ୟାକେଜ୍ ଭାବରେ ବଣ୍ଟିତ | ଯଦି ଆପଣ ଆଜି ସାମୟିକ ବ୍ୟବହାର କରିବାକୁ ଚାହାଁନ୍ତି, ସଫାରି ପରି ବ୍ରାଉଜରକୁ ସମର୍ଥନ କରିବାକୁ ଆପଣଙ୍କୁ ଏହି ପଲିଫିଲ୍ ଆବଶ୍ୟକ ହେବ ଯାହା ଏପର୍ଯ୍ୟନ୍ତ API ପଠାଇ ନାହିଁ | ଏହା ସହିତ ଖରାପ ଖବର ହେଉଛି ଏହା ଆପଣଙ୍କ ବଣ୍ଡଲ୍ ଆକାରରେ ଯୋଗ କରିବ | ଭଲ ଖବର ହେଉଛି ଯେ ଏହା ଏପର୍ଯ୍ୟନ୍ତ କ୍ଷଣ କିମ୍ବା କ୍ଷଣ-ସମୟ କ୍ଷେତ୍ରଠାରୁ ଯଥେଷ୍ଟ କମ୍ ଯୋଗ କରିଥାଏ | ବଣ୍ଡଲଫୋବିୟା ଡଟ୍ କମ୍ ଦ୍ୱାରା ରିପୋର୍ଟ କରାଯାଇଥିବା ବଣ୍ଡଲ୍ ଆକାରର ଏକ ତୁଳନା, ଏଠାରେ ଏକ ୱେବସାଇଟ୍ ଯାହା npm ପ୍ୟାକେଜ୍ ଆକାର ବିଷୟରେ ସୂଚନା ଉପସ୍ଥାପନ କରେ (ବୁଣ୍ଡଲେଫୋବିୟା ବିଶ୍ଳେଷଣ ଦେଖିବାକୁ ପ୍ରତ୍ୟେକ ପ୍ୟାକେଜ୍ ନାମ ଉପରେ କ୍ଲିକ୍ କରନ୍ତୁ):
ପ୍ୟାକେଜ୍ କ୍ଷୁଦ୍ରତର | କ୍ଷୁଦ୍ର ଏବଂ ଜିଜାଇଡ୍ | @ js- ସାମୟିକ / ପଲିଫିଲ୍ | 154.1 kB 44.1 kB ମୁହୂର୍ତ୍ତ 294.4 kB 75.4 kB ମୁହୂର୍ତ୍ତ-ସମୟ ମଣ୍ଡଳ | 1 MB 114.2 kB
ପଲିଫିଲ୍ ମଧ୍ୟ memory ତିହାସିକ ଭାବରେ ସ୍ମୃତି ବ୍ୟବହାରକୁ ନେଇ କିଛି କାର୍ଯ୍ୟଦକ୍ଷତା ସମସ୍ୟା ରହିଥିଲା ଏବଂ ଲେଖିବା ସମୟରେ ଏହା ଏକ ଆଲଫା ସ୍ଥିତିରେ ପରିଗଣିତ ହୋଇଥିଲା | ଏହି କାରଣରୁ, ଆପଣ ଏହାକୁ ଅଧିକ ପରିପକ୍ୱ ସ୍ଥିତିରେ ପହଞ୍ଚିବା ପର୍ଯ୍ୟନ୍ତ ଉତ୍ପାଦନରେ ବ୍ୟବହାର କରିବାକୁ ଚାହୁଁନାହାଁନ୍ତି | ଅନ୍ୟ ଏକ ଭଲ ଖବର ହେଉଛି ଆଶାକରାଯେ ପଲିଫିଲ୍ ଅଧିକ ସମୟ ଆବଶ୍ୟକ ହେବ ନାହିଁ (ଯଦି ଆପଣ ନିଶ୍ଚିତ ଭାବରେ ପୁରୁଣା ବ୍ରାଉଜରକୁ ସମର୍ଥନ କରିବା ଆବଶ୍ୟକ କରନ୍ତି ନାହିଁ) | ଲେଖିବା ସମୟରେ, ଟେମ୍ପୋରାଲ୍ କ୍ରୋମ୍, ଏଜ୍ ଏବଂ ଫାୟାରଫକ୍ସରେ ପଠାଯାଇଛି | ସଫାରିରେ ଏହା ଏପର୍ଯ୍ୟନ୍ତ ପ୍ରସ୍ତୁତ ନୁହେଁ, ଯଦିଓ ଏହା ଅତ୍ୟାଧୁନିକ ଟେକ୍ନୋଲୋଜି ପୂର୍ବାବଲୋକନରେ ଚାଲିବା ସମୟ ପତାକା ସହିତ ଉପଲବ୍ଧ ଥିବା ପରି ଦେଖାଯାଉଛି |
