జావాస్క్రిప్ట్లో వ్రాసిన దాదాపు ఏ రకమైన అప్లికేషన్ అయినా కొంత సామర్థ్యంతో సమయాలు లేదా తేదీలతో పని చేస్తుంది. ప్రారంభంలో, ఇది అంతర్నిర్మిత తేదీ APIకి పరిమితం చేయబడింది. ఈ API ప్రాథమిక కార్యాచరణను కలిగి ఉంటుంది, కానీ అది చేయగలిగింది చాలా పరిమితం. Moment.js వంటి థర్డ్-పార్టీ లైబ్రరీలు మరియు Intl APIలు మరియు కొత్త టెంపోరల్ API వంటి అంతర్నిర్మిత APIలు సమయాలు మరియు తేదీలతో పని చేయడానికి చాలా ఎక్కువ సౌలభ్యాన్ని జోడిస్తాయి. Moment.js యొక్క రైజ్ అండ్ ఫాల్ Moment.js అనేది సమయాలు మరియు తేదీలతో పని చేయడానికి శక్తివంతమైన యుటిలిటీలతో కూడిన JavaScript లైబ్రరీ. ఇది టైమ్ జోన్ మానిప్యులేషన్ వంటి ప్రాథమిక తేదీ API నుండి తప్పిపోయిన లక్షణాలను కలిగి ఉంటుంది మరియు అనేక సాధారణ కార్యకలాపాలను సులభతరం చేస్తుంది. క్షణం కూడా తేదీలు మరియు సమయాలను ఫార్మాటింగ్ చేయడానికి ఫంక్షన్లను కలిగి ఉంటుంది. ఇది అనేక విభిన్న అనువర్తనాల్లో విస్తృతంగా ఉపయోగించే లైబ్రరీగా మారింది. అయితే, క్షణం కూడా సమస్యలలో దాని వాటాను కలిగి ఉంది. ఇది పెద్ద లైబ్రరీ, మరియు అప్లికేషన్ బండిల్ పరిమాణానికి గణనీయంగా జోడించవచ్చు. లైబ్రరీ ట్రీ షేకింగ్కు మద్దతు ఇవ్వదు కాబట్టి (లైబ్రరీలలో ఉపయోగించని భాగాలను తొలగించగల ఆధునిక బండ్లర్ల లక్షణం), మీరు దాని ఫంక్షన్లలో ఒకటి లేదా రెండు మాత్రమే ఉపయోగించినప్పటికీ మొత్తం మూమెంట్ లైబ్రరీ చేర్చబడుతుంది. క్షణంతో ఉన్న మరో సమస్య ఏమిటంటే, అది సృష్టించే వస్తువులు మార్చదగినవి. మూమెంట్ ఆబ్జెక్ట్పై నిర్దిష్ట ఫంక్షన్లను కాల్ చేయడం వల్ల దుష్ప్రభావాలు ఉంటాయి మరియు ఆ వస్తువు విలువను మార్చేస్తుంది. ఇది ఊహించని ప్రవర్తన లేదా బగ్లకు దారి తీస్తుంది. 2020లో, మూమెంట్ నిర్వహణదారులు లైబ్రరీని మెయింటెనెన్స్ మోడ్లో ఉంచాలని నిర్ణయించుకున్నారు. కొత్త ఫీచర్ డెవలప్మెంట్ జరగడం లేదు మరియు కొత్త ప్రాజెక్ట్ల కోసం దీన్ని ఉపయోగించకుండా మెయింటెయినర్లు సిఫార్సు చేస్తున్నారు. డేట్-ఎఫ్ఎన్ఎస్ వంటి ఇతర జావాస్క్రిప్ట్ తేదీ లైబ్రరీలు ఉన్నాయి, అయితే పట్టణంలో కొత్త ప్లేయర్ ఉంది, జావాస్క్రిప్ట్: టెంపోరల్లో నేరుగా రూపొందించబడిన API. ఇది అసలైన తేదీ API యొక్క రంధ్రాలను పూరించే కొత్త ప్రమాణం, అలాగే క్షణం మరియు ఇతర లైబ్రరీలలో ఉన్న కొన్ని పరిమితులను పరిష్కరిస్తుంది. టెంపోరల్ అంటే ఏమిటి? టెంపోరల్ అనేది ఆధునిక జావాస్క్రిప్ట్ని నిర్వచించే ECMAScript స్టాండర్డ్కి జోడించబడుతున్న కొత్త సమయం మరియు తేదీ API. మార్చి 20266 నాటికి, ఇది TC39 ప్రక్రియ యొక్క 4వ దశకు చేరుకుంది (జావాస్క్రిప్ట్ భాషకు ప్రతిపాదనలు మరియు జోడింపులను పర్యవేక్షించే కమిటీ), మరియు ECMAScript స్పెసిఫికేషన్ యొక్క తదుపరి వెర్షన్లో చేర్చబడుతుంది. ఇది ఇప్పటికే అనేక బ్రౌజర్లలో అమలు చేయబడింది: Chrome 144+ మరియు Firefox 139+, Safari త్వరలో అనుసరించే అవకాశం ఉంది. మద్దతు లేని బ్రౌజర్లు మరియు Node.js కోసం కూడా పాలీఫిల్ అందుబాటులో ఉంది. టెంపోరల్ API అనేది సాధారణంగా, సమయానికి సంబంధించిన క్షణాలను సూచించే వస్తువులను సృష్టిస్తుంది. ఇవి ఇచ్చిన టైమ్ జోన్లో పూర్తి సమయం మరియు తేదీ స్టాంపులు కావచ్చు లేదా సమయ మండలం లేదా తేదీ సమాచారం లేకుండా “వాల్ క్లాక్” సమయానికి సాధారణ ఉదాహరణ కావచ్చు. టెంపోరల్ యొక్క కొన్ని ప్రధాన లక్షణాలు:
తేదీలతో లేదా లేని సమయాలు. ఒక తాత్కాలిక వస్తువు నిర్దిష్ట తేదీలో నిర్దిష్ట సమయాన్ని లేదా తేదీ సమాచారం లేని సమయాన్ని సూచిస్తుంది. సమయం లేకుండా నిర్దిష్ట తేదీని కూడా సూచించవచ్చు. టైమ్ జోన్ సపోర్ట్. టెంపోరల్ ఆబ్జెక్ట్లు పూర్తిగా టైమ్ జోన్ను కలిగి ఉంటాయి మరియు వివిధ టైమ్ జోన్లలో మార్చబడతాయి. క్షణం సమయ మండలాలకు కూడా మద్దతు ఇస్తుంది, కానీ దీనికి అదనపు క్షణ-సమయ మండలి లైబ్రరీ అవసరం. మార్పులేనిది.ఒకసారి తాత్కాలిక వస్తువు సృష్టించబడితే, దానిని మార్చలేరు. సమయ అంకగణితం లేదా సమయ మండలి మార్పిడులు అంతర్లీన వస్తువును సవరించవు. బదులుగా, అవి కొత్త తాత్కాలిక వస్తువును ఉత్పత్తి చేస్తాయి. 1-ఆధారిత ఇండెక్సింగ్. తేదీ API (అలాగే క్షణంతో పాటు)తో బగ్ల యొక్క సాధారణ మూలం నెలలు సున్నా-సూచిక. అంటే నిజ జీవితంలో మనందరికీ అర్థమయ్యేలా జనవరి 1 కాకుండా నెల 0 అని అర్థం. 1-ఆధారిత ఇండెక్సింగ్ని ఉపయోగించడం ద్వారా తాత్కాలికంగా దీనిని పరిష్కరిస్తుంది - జనవరి నెల 1. ఇది బ్రౌజర్లో అంతర్నిర్మితమైంది.తాత్కాలిక బ్రౌజర్లోనే API అయినందున, ఇది మీ అప్లికేషన్ బండిల్ పరిమాణానికి ఏమీ జోడించదు.
తేదీ API దూరంగా ఉండదని కూడా గమనించడం ముఖ్యం. టెంపోరల్ ఈ APIని భర్తీ చేస్తున్నప్పుడు, ఇది తీసివేయబడదు లేదా తీసివేయబడదు. బ్రౌజర్లు అకస్మాత్తుగా తేదీ APIని తీసివేస్తే చాలా అప్లికేషన్లు విరిగిపోతాయి. అయితే, మూమెంట్ ఇప్పుడు మెయింటెనెన్స్ మోడ్లో లెగసీ ప్రాజెక్ట్గా పరిగణించబడుతుందని కూడా గుర్తుంచుకోండి. మిగిలిన కథనంలో, కొత్త టెంపోరల్ APIకి క్షణం-ఆధారిత కోడ్ని తరలించడానికి మేము కొన్ని “వంటకాలను” పరిశీలిస్తాము. రీఫ్యాక్టరింగ్ ప్రారంభిద్దాం! తేదీ మరియు సమయ వస్తువులను సృష్టిస్తోంది మేము తేదీలు మరియు సమయాలను మార్చడానికి ముందు, వాటిని సూచించే వస్తువులను సృష్టించాలి. ప్రస్తుత తేదీ మరియు సమయాన్ని సూచించే క్షణం ఆబ్జెక్ట్ని సృష్టించడానికి, క్షణం ఫంక్షన్ని ఉపయోగించండి. const now = క్షణం(); 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 am
క్షణం గురించి గుర్తుంచుకోవలసిన ముఖ్య విషయం ఏమిటంటే, ఒక క్షణం వస్తువు ఎల్లప్పుడూ సమయం మరియు తేదీ గురించి సమాచారాన్ని కలిగి ఉంటుంది. మీరు సమయ సమాచారంతో మాత్రమే పని చేయాల్సి ఉంటే, ఇది సాధారణంగా మంచిది, కానీ ఇది డేలైట్ సేవింగ్ టైమ్ లేదా లీప్ ఇయర్స్ వంటి సందర్భాల్లో ఊహించని ప్రవర్తనకు కారణం కావచ్చు, ఇక్కడ తేదీ సమయం గణనలపై ప్రభావం చూపుతుంది. టెంపోరల్ మరింత సరళమైనది. మీరు Temporal.Instant ఆబ్జెక్ట్ని సృష్టించడం ద్వారా ప్రస్తుత తేదీ మరియు సమయాన్ని సూచించే వస్తువును సృష్టించవచ్చు. ఇది "యుగం" (జనవరి 1, 1970 అర్ధరాత్రి UTC) నుండి సమయం ద్వారా నిర్వచించబడిన సమయాన్ని సూచిస్తుంది. నానోసెకండ్-స్థాయి ఖచ్చితత్వంతో టెంపోరల్ ఈ తక్షణాన్ని సూచించగలదు. 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
మీరు ఇతర రకాల తాత్కాలిక వస్తువులను కూడా సృష్టించవచ్చు, వీటితో సహా:
Temporal.PlainDate: సమయ సమాచారం లేని తేదీ. Temporal.PlainTime: తేదీ సమాచారం లేని సమయం. Temporal.ZonedDateTime: నిర్దిష్ట సమయ మండలంలో తేదీ మరియు సమయం.
వీటిలో ప్రతి ఒక్కటి తేదీ మరియు/లేదా సమయాన్ని పేర్కొనే వస్తువుతో లేదా అన్వయించడానికి తేదీ స్ట్రింగ్తో పిలవబడే పద్ధతిని కలిగి ఉంటుంది. // కేవలం ఒక తేదీ const today = Temporal.PlainDate.from({ సంవత్సరం: 2026, నెల: 2, // మేము ఫిబ్రవరి కోసం 2ని ఉపయోగిస్తున్నామని గమనించండి రోజు: 18 }); console.log(today.toString()); // 2026-02-18
// ఒక్కసారి const lunchTime = Temporal.PlainTime.from({ గంట: 12 }); console.log(lunchTime.toString()); // 12:00:00
// US ఈస్టర్న్ టైమ్ జోన్లో తేదీ మరియు సమయం const dueAt = Temporal.ZonedDateTime.from({ టైమ్జోన్: 'అమెరికా/న్యూయార్క్', సంవత్సరం: 2026, నెల: 3, రోజు: 1, గంట: 12, నిమిషం: 0, రెండవది: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[అమెరికా/న్యూ_యార్క్]
పార్సింగ్ మేము తేదీ మరియు సమయ సమాచారం యొక్క ప్రోగ్రామాటిక్ క్రియేషన్ను కవర్ చేసాము. ఇప్పుడు అన్వయించడాన్ని చూద్దాం. పార్సింగ్ అనేది అంతర్నిర్మిత టెంపోరల్ API కంటే క్షణం మరింత అనువైన ప్రాంతం. మీరు తేదీ స్ట్రింగ్ని మొమెంట్ ఫంక్షన్కి పాస్ చేయడం ద్వారా అన్వయించవచ్చు. ఒకే ఆర్గ్యుమెంట్తో, Moment ISO తేదీ స్ట్రింగ్ను ఆశిస్తుంది, కానీ మీరు ఉపయోగించబడుతున్న తేదీ ఆకృతిని పేర్కొంటూ రెండవ ఆర్గ్యుమెంట్ను అందిస్తే మీరు ప్రత్యామ్నాయ ఫార్మాట్లను ఉపయోగించవచ్చు.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // క్షణం<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // క్షణం<2026-02-21T09:00:00-05:00>
పాత సంస్కరణల్లో, ఏదైనా ఏకపక్షంగా ఆకృతీకరించబడిన తేదీ స్ట్రింగ్ని అన్వయించడానికి మూమెంట్ ఉత్తమంగా అంచనా వేస్తుంది. ఇది అనూహ్య ఫలితాలకు దారితీయవచ్చు. ఉదాహరణకు, 02-03-2026 ఫిబ్రవరి 2నా లేక మార్చి 3నా? ఈ కారణంగా, ISO ఆకృతీకరించిన తేదీ స్ట్రింగ్ లేకుండా (కావాల్సిన ఫార్మాట్తో రెండవ ఆర్గ్యుమెంట్ కూడా ఇవ్వకపోతే) మూమెంట్ యొక్క కొత్త వెర్షన్లు ప్రముఖమైన డిప్రికేషన్ హెచ్చరికను ప్రదర్శిస్తాయి. టెంపోరల్ ప్రత్యేకంగా ఆకృతీకరించిన తేదీ స్ట్రింగ్ను మాత్రమే అన్వయిస్తుంది. స్ట్రింగ్ తప్పనిసరిగా ISO 8601 ఫార్మాట్ లేదా దాని పొడిగింపు, RFC 9557కి అనుగుణంగా ఉండాలి. నాన్-కాంప్లైంట్ డేట్ స్ట్రింగ్ని ఫ్రమ్ మెథడ్కి పంపితే, టెంపోరల్ RangeErrorని విసురుతుంది.
// 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: తాత్కాలిక లోపం: సంవత్సరం విలువను అన్వయించేటప్పుడు చెల్లని అక్షరం.
తేదీ స్ట్రింగ్ యొక్క ఖచ్చితమైన ఆవశ్యకాలు మీరు ఏ రకమైన తాత్కాలిక వస్తువును సృష్టిస్తున్నారనే దానిపై ఆధారపడి ఉంటుంది. పై ఉదాహరణలో, Temporal.Instantకి పూర్తి ISO అవసరం8601 లేదా RFC 9557 తేదీ స్ట్రింగ్ టైమ్ జోన్ ఆఫ్సెట్తో తేదీ మరియు సమయాన్ని పేర్కొంటుంది, కానీ మీరు తేదీ ఫార్మాట్లోని ఉపసమితిని ఉపయోగించి PlainDate లేదా PlainTime ఆబ్జెక్ట్లను కూడా సృష్టించవచ్చు. 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 స్ట్రింగ్లోకి మార్చడానికి మీరు కొన్ని స్ట్రింగ్ మానిప్యులేషన్ చేయాల్సి ఉంటుంది.
ఫార్మాటింగ్ మీరు ఒక క్షణం లేదా తాత్కాలిక వస్తువును కలిగి ఉంటే, మీరు బహుశా ఏదో ఒక సమయంలో దానిని ఫార్మాట్ చేసిన స్ట్రింగ్గా మార్చాలనుకోవచ్చు. ఇది క్షణం కొంచెం తీక్షణంగా ఉన్న సందర్భం. మీరు కోరుకున్న తేదీ ఆకృతిని వివరించే టోకెన్ల స్ట్రింగ్తో ఆబ్జెక్ట్ ఫార్మాట్ పద్ధతిని కాల్ చేస్తారు. స్థిర తేదీ = క్షణం ();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM చేయండి YYYY, h:mm:ss a')); // ఫిబ్రవరి 22, 2026, 8:18:30 pm
మరోవైపు, టెంపోరల్కి మీరు కొంచెం వెర్బోస్గా ఉండాలి. తక్షణం వంటి తాత్కాలిక వస్తువులు, ఆబ్జెక్ట్ యొక్క లక్షణాలుగా పేర్కొన్న వివిధ ఫార్మాటింగ్ ఎంపికలను ఆమోదించే toLocaleString పద్ధతిని కలిగి ఉంటాయి.
const date = Temporal.Now.instant();
// వాదనలు లేకుండా, మేము ప్రస్తుత లొకేల్ కోసం డిఫాల్ట్ ఆకృతిని పొందుతాము 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 (ఆధునిక బ్రౌజర్లలో ఇది ఇప్పటికే అందుబాటులో ఉంది)ని ఉపయోగిస్తుంది. అంటే మీరు మీ కస్టమ్ ఫార్మాటింగ్ ఎంపికలతో పునర్వినియోగ DateTimeFormat ఆబ్జెక్ట్ని సృష్టించవచ్చు, ఆపై టెంపోరల్ ఆబ్జెక్ట్లను దాని ఫార్మాట్ పద్ధతికి పంపవచ్చు. దీని కారణంగా, ఇది మూమెంట్ వంటి అనుకూల తేదీ ఫార్మాట్లకు మద్దతు ఇవ్వదు. మీకు 'Q1 2026' లేదా ఇతర ప్రత్యేక ఫార్మాటింగ్ వంటి ఏదైనా అవసరమైతే, మీకు కొంత అనుకూల తేదీ ఫార్మాటింగ్ కోడ్ అవసరం కావచ్చు లేదా మూడవ పక్షం లైబ్రరీకి చేరుకోవచ్చు. const formatter = కొత్త Intl.DateTimeFormat('en-US', { నెల: '2-అంకెలు', రోజు: '2-అంకెలు', సంవత్సరం: 'సంఖ్య' });
const date = Temporal.Now.instant(); console.log(formatter.format(తేదీ)); // 02/22/2026
మూమెంట్ ఫార్మాటింగ్ టోకెన్లు రాయడం చాలా సులభం, కానీ అవి లొకేల్-ఫ్రెండ్లీ కాదు. ఫార్మాట్ స్ట్రింగ్స్ "హార్డ్ కోడ్" నెల/రోజు ఆర్డర్ వంటి అంశాలు. టెంపోరల్ లాగా కాన్ఫిగరేషన్ ఆబ్జెక్ట్ను ఉపయోగించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, అది ఏదైనా ఇచ్చిన లొకేల్కు స్వయంచాలకంగా అనుగుణంగా ఉంటుంది మరియు సరైన ఆకృతిని ఉపయోగిస్తుంది. 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 వారం తేదీని చూపాలనుకోవచ్చు. మూమెంట్ ఆబ్జెక్ట్లు జోడించడం మరియు తీసివేయడం వంటి పద్ధతులను కలిగి ఉంటాయి. ఈ ఫంక్షన్లు విలువ మరియు యూనిట్ను తీసుకుంటాయి, ఉదాహరణకు: add(7, 'days'). మూమెంట్ మరియు టెంపోరల్ మధ్య చాలా ముఖ్యమైన వ్యత్యాసం ఏమిటంటే, ఈ తేదీ గణనలను నిర్వహిస్తున్నప్పుడు, అంతర్లీన వస్తువు సవరించబడుతుంది మరియు దాని అసలు విలువ పోతుంది. const now = క్షణం();
console.log(ఇప్పుడు); // క్షణం<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(nextWeek); // క్షణం<2026-03-03T20:08:36-05:00>
// గోట్చా - అసలు వస్తువు మార్చబడింది console.log(ఇప్పుడు); // క్షణం<2026-03-03T20:08:36-05:00>
అసలు తేదీని కోల్పోకుండా ఉండటానికి, మీరు కాపీని సృష్టించడానికి మూమెంట్ ఆబ్జెక్ట్పై క్లోన్కి కాల్ చేయవచ్చు. ఇప్పుడు స్థిరంగా= క్షణం(); const nextWeek = now.clone().add(7, 'days');
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({days: 7 }); // RangeError: తాత్కాలిక లోపం: అతిపెద్ద యూనిట్ తేదీ యూనిట్ కాకూడదు
ఎందుకంటే తక్షణ వస్తువులు UTCలో నిర్దిష్ట సమయ బిందువును సూచిస్తాయి మరియు క్యాలెండర్-అజ్ఞాతవాసి. డేలైట్ సేవింగ్ టైమ్ వంటి టైమ్ జోన్ నియమాల ఆధారంగా ఒక రోజు నిడివి మారవచ్చు కాబట్టి, ఈ గణన తక్షణమే అందుబాటులో ఉండదు. అయితే, మీరు PlainDateTime వంటి ఇతర రకాల వస్తువులపై ఈ చర్యను చేయవచ్చు: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
const nextWeek = now.add({days: 7 });
// అసలు PlainDateTime మారలేదని గమనించండి console.log(now.toLocaleString()); // 2/24/2026, 8:23:59 PM
console.log(nextWeek.toLocaleString()); // 3/3/2026, 8:23:59 PM
మీరు రెండు క్షణం లేదా తాత్కాలిక వస్తువుల మధ్య ఎంత సమయం ఉందో కూడా లెక్కించవచ్చు. మూమెంట్స్ డిఫ్ ఫంక్షన్తో, మీరు గ్రాన్యులారిటీ కోసం ఒక యూనిట్ను అందించాలి, లేకుంటే అది మిల్లీసెకన్లలో వ్యత్యాసాన్ని అందిస్తుంది. స్థిర తేదీ1 = క్షణం('2026-02-21T09:00:00'); స్థిర తేదీ2 = క్షణం('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');
// అతిపెద్ద యూనిట్ ప్రాతినిధ్యం వహించడానికి అతిపెద్ద యూనిట్ సమయాన్ని నిర్దేశిస్తుంది // వ్యవధి గణనలో కాన్స్ట్ డిఫ్ = తేదీ2.నుండి(తేదీ1, {అతిపెద్ద యూనిట్: 'రోజు'});
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తో విభిన్న విధానాలను తీసుకోండి. Moment రెండు మూమెంట్ వస్తువులను పోల్చడానికి isBefore, isAfter మరియు isSame వంటి పద్ధతులను అందిస్తుంది. స్థిర తేదీ1 = క్షణం('2026-02-21T09:00:00'); స్థిర తేదీ2 = క్షణం('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // నిజం
ఒకే రకమైన రెండు వస్తువుల మధ్య పోలికను నిర్వహించడానికి టెంపోరల్ స్టాటిక్ కంపేర్ పద్ధతిని ఉపయోగిస్తుంది. మొదటి తేదీ రెండవ తేదీకి ముందు వస్తే -1, అవి సమానంగా ఉంటే 0 లేదా రెండవ తేదీ తర్వాత మొదటి తేదీ వస్తే 1ని అందిస్తుంది. కింది ఉదాహరణ రెండు ప్లెయిన్డేట్ ఆబ్జెక్ట్లను ఎలా పోల్చాలో చూపిస్తుంది. Temporal.PlainDate.compareకి రెండు ఆర్గ్యుమెంట్లు తప్పనిసరిగా PlainDate వస్తువులు అయి ఉండాలి.
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: తాత్కాలిక లోపం: చెల్లని PlainDate ఫీల్డ్లు అందించబడ్డాయి.
ప్రత్యేకించి, ఇది తాత్కాలిక వస్తువుల శ్రేణిని కాలక్రమానుసారంగా క్రమబద్ధీకరించడాన్ని సులభతరం చేస్తుంది. // Temporal.PlainDate ఆబ్జెక్ట్ల శ్రేణి స్థిర తేదీలు = [... ];
// Comparator ఫంక్షన్గా Temporal.PlainDate.compareని ఉపయోగించండి dates.sort(Temporal.PlainDate.compare);
టైమ్ జోన్ మార్పిడులు కోర్ మూమెంట్ లైబ్రరీ టైమ్ జోన్ కన్వర్షన్లకు మద్దతు ఇవ్వదు. మీకు ఈ ఫంక్షనాలిటీ అవసరమైతే, మీరు క్షణం-టైమ్జోన్ ప్యాకేజీని కూడా ఇన్స్టాల్ చేయాలి. ఈ ప్యాకేజీ ట్రీ-షేకేబుల్ కాదు, కాబట్టి మీ బండిల్ పరిమాణానికి గణనీయంగా జోడించవచ్చు. మీరు మొమెంట్-టైమ్జోన్ని ఇన్స్టాల్ చేసిన తర్వాత, మీరు tz పద్ధతితో మొమెంట్ ఆబ్జెక్ట్లను వేర్వేరు టైమ్ జోన్లకు మార్చవచ్చు. ఇతర మూమెంట్ ఆపరేషన్ల మాదిరిగానే, ఇది అంతర్లీనాన్ని మారుస్తుందివస్తువు. // US తూర్పు సమయాన్ని ఊహించడం const now = క్షణం(); console.log(ఇప్పుడు); // క్షణం<2026-02-28T20:08:20-05:00>
// పసిఫిక్ సమయానికి మార్చండి. // అసలు తూర్పు సమయం పోయింది. now.tz('అమెరికా/లాస్_ఏంజిల్స్'); console.log(ఇప్పుడు); // క్షణం<2026-02-28T17:08:20-08:00>
Temporal.ZonedDateTime ఆబ్జెక్ట్ని ఉపయోగిస్తున్నప్పుడు టైమ్ జోన్ కార్యాచరణ తాత్కాలిక APIలో నిర్మించబడింది. ఈ ఆబ్జెక్ట్లు విత్టైమ్జోన్ పద్ధతిని కలిగి ఉంటాయి, ఇది కొత్త జోన్డ్డేట్ టైమ్ని అదే క్షణాన్ని సూచిస్తుంది, కానీ పేర్కొన్న టైమ్ జోన్లో అందిస్తుంది. // మళ్ళీ, US తూర్పు సమయాన్ని ఊహిస్తూ const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
// పసిఫిక్ సమయానికి మార్చండి const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 2/28/2026, 5:12:02 PM PST
// అసలు వస్తువు మారదు console.log(now.toLocaleString()); // 2/28/2026, 8:12:02 PM EST
గమనిక: toLocaleString ద్వారా అందించబడిన ఫార్మాట్ చేయబడిన విలువలు, పేరు సూచించినట్లుగా, లొకేల్-ఆధారితమైనవి. నమూనా కోడ్ en-US లొకేల్లో అభివృద్ధి చేయబడింది, కాబట్టి ఫార్మాట్ ఇలా ఉంటుంది: 2/28/2026, 5:12:02 PM PST. మరొక లొకేల్లో, ఇది భిన్నంగా ఉండవచ్చు. ఉదాహరణకు, en-GB లొకేల్లో, మీరు 28/2/2026, 17:12:02 GMT-8 వంటిది పొందుతారు. వాస్తవ-ప్రపంచ రీఫ్యాక్టరింగ్ టైమ్ జోన్లలో ఈవెంట్లను షెడ్యూల్ చేయడానికి మేము యాప్ను రూపొందిస్తున్నామని అనుకుందాం. ఈ యాప్లో భాగమే ఒక ఫంక్షన్, getEventTimes, ఇది ఈవెంట్ యొక్క సమయం మరియు తేదీ, స్థానిక టైమ్ జోన్ మరియు టార్గెట్ టైమ్ జోన్ను సూచించే ISO 8601 స్ట్రింగ్ను తీసుకుంటుంది. ఫంక్షన్ రెండు టైమ్ జోన్లలో ఈవెంట్ కోసం ఫార్మాట్ చేసిన సమయం మరియు తేదీ స్ట్రింగ్లను సృష్టిస్తుంది. ఫంక్షన్కు చెల్లుబాటు అయ్యే సమయం/తేదీ స్ట్రింగ్ లేని ఇన్పుట్ స్ట్రింగ్ ఇచ్చినట్లయితే, అది ఎర్రర్ను విసురుతుంది. క్షణం ఉపయోగించి అసలు అమలు ఇక్కడ ఉంది (మూమెంట్-టైమ్జోన్ ప్యాకేజీని ఉపయోగించడం కూడా అవసరం).
'మొమెంట్-టైమ్జోన్' నుండి క్షణం దిగుమతి;
ఫంక్షన్ getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. యూజర్ టైమ్ జోన్లో ప్రారంభ క్షణాన్ని సృష్టించండి const eventTime = moment.tz( ఇన్పుట్ స్ట్రింగ్, moment.ISO_8601, // ISO 8601 స్ట్రింగ్ను ఆశించండి నిజం, // కఠినమైన పార్సింగ్ యూజర్ టైమ్జోన్ );
// ఇన్పుట్స్ట్రింగ్ చెల్లుబాటు అయ్యే తేదీని సూచించనట్లయితే లోపాన్ని విసిరేయండి అయితే (!eventTime.isValid()) { కొత్త లోపం ('చెల్లని తేదీ/సమయం ఇన్పుట్'); }
// 2. లక్ష్య సమయాన్ని లెక్కించండి // క్లిష్టమైనది: మనం క్లోన్ చేయాలి లేదా 'ఈవెంట్ టైమ్' ఎప్పటికీ మారాలి! const targetTime = eventTime.clone().tz(targetTimeZone);
తిరిగి { స్థానికం: eventTime.format(timeFormat), లక్ష్యం: targetTime.format(timeFormat), }; }
స్థిర షెడ్యూల్ = 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
ఈ ఉదాహరణలో, మేము ISO 8601 యొక్క అంచనా తేదీ ఆకృతిని ఉపయోగిస్తున్నాము, ఇది క్షణంలో సహాయకరంగా నిర్మించబడింది. మేము కఠినమైన పార్సింగ్ను కూడా ఉపయోగిస్తున్నాము, అంటే మూమెంట్ ఫార్మాట్తో సరిపోలని తేదీ స్ట్రింగ్తో ఊహించడానికి ప్రయత్నించదు. ISO కాని తేదీ స్ట్రింగ్ను ఆమోదించినట్లయితే, అది చెల్లని తేదీ ఆబ్జెక్ట్కు దారి తీస్తుంది మరియు మేము ఎర్రర్ను విసిరాము. తాత్కాలిక అమలు ఒకేలా కనిపిస్తోంది, కానీ కొన్ని కీలకమైన తేడాలు ఉన్నాయి.
ఫంక్షన్ getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ఇన్పుట్ను నేరుగా ఇన్స్టంట్లోకి అన్వయించి, ఆపై సృష్టించండి // వినియోగదారు జోన్లో ZonedDateTime. కాన్స్ట్ తక్షణం = తాత్కాలిక.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. టార్గెట్ జోన్కి మార్చండి // ఇది స్వయంచాలకంగా కొత్త వస్తువును అందిస్తుంది; 'eventTime' సురక్షితం. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl (అంతర్నిర్మిత) ఉపయోగించి ఫార్మాట్ చేయండి స్థిర ఎంపికలు = { సంవత్సరం: 'సంఖ్య', నెల: 'చిన్న', రోజు: 'సంఖ్య', గంట: 'సంఖ్య', నిమిషం: '2-అంకెలు', రెండవది: '2-అంకెలు', timeZoneName: 'చిన్న' };
తిరిగి { స్థానికం: eventTime.toLocaleString(navigator.language, ఎంపికలు), లక్ష్యం: targetTime.toLocaleString(navigator.language, ఎంపికలు) }; }
స్థిర షెడ్యూల్ = 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. అలాగే, మేము స్పష్టంగా మినహాయింపును ఇవ్వాల్సిన అవసరం లేదు. చెల్లని స్ట్రింగ్ Temporal.Instant.fromకి పంపబడితే, టెంపోరల్ మాకు మినహాయింపును అందిస్తుంది. గమనించదగ్గ విషయం ఏమిటంటే, కఠినమైన పార్సింగ్తో కూడా, మూమెంట్ వెర్షన్ ఇంకా చాలా తేలికగా ఉంటుంది. టెంపోరల్కి స్ట్రింగ్ చివరిలో టైమ్ జోన్ ఆఫ్సెట్ అవసరం. మేము navigator.languageని ఉపయోగిస్తున్నందున, నావిగేటర్ Node.js వాతావరణంలో నిర్వచించబడనందున, ఈ కోడ్ బ్రౌజర్ వాతావరణంలో మాత్రమే రన్ అవుతుందని మీరు గమనించాలి. తాత్కాలిక అమలు బ్రౌజర్ యొక్క ప్రస్తుత లొకేల్ (navigator.language)ని ఉపయోగిస్తుంది, కాబట్టి వినియోగదారు వారి స్థానిక సమయ ఆకృతిలో ఈవెంట్ సమయాలను స్వయంచాలకంగా ఫార్మాట్ చేస్తారు. en-US లొకేల్లో, ఇది మార్చి 5, 2026, 3:00:00 pm EST. అయితే, వినియోగదారు లండన్లో ఉన్నట్లయితే, ఉదాహరణకు, ఈవెంట్ సమయాలు 5 మార్చి 2026, 15:00:00 GMT-5గా ఫార్మాట్ చేయబడతాయి. సారాంశం
చర్య Moment.js తాత్కాలిక ప్రస్తుత సమయం క్షణం () Temporal.Now.zonedDateTimeISO() ISOని అన్వయించడం క్షణం(str) Temporal.Instant.from(str) సమయాన్ని జోడించండి .జోడించు(7, 'రోజులు') (పరివర్తనలు) .జోడించు({రోజులు: 7 }) (కొత్త వస్తువు) తేడా .diff(ఇతర, 'గంటలు') .నుండి(ఇతర).గంటలు సమయ క్షేత్రం .tz('జోన్/పేరు') .withTimeZone('జోన్/పేరు')
మొదటి చూపులో, వ్యత్యాసం కొద్దిగా భిన్నంగా ఉండవచ్చు (మరియు టెంపోరల్ విషయంలో, కొన్నిసార్లు మరింత వెర్బోస్ మరియు మరింత కఠినమైనది) సింటాక్స్, కానీ Moment.jsలో టెంపోరల్ని ఉపయోగించడం వల్ల అనేక కీలక ప్రయోజనాలు ఉన్నాయి:
మరింత స్పష్టంగా ఉండటం అంటే తక్కువ ఆశ్చర్యాలు మరియు అనాలోచిత బగ్లు. క్షణం మరింత తేలికగా కనిపించవచ్చు, కానీ ఇది "అంచనాల పని"ని కలిగి ఉంటుంది, ఇది కొన్నిసార్లు తప్పు తేదీలకు దారి తీస్తుంది. మీరు తాత్కాలికంగా ఏదైనా చెల్లనిది ఇస్తే, అది ఎర్రర్ను విసురుతుంది. కోడ్ అమలు చేయబడితే, మీరు చెల్లుబాటు అయ్యే తేదీని కలిగి ఉన్నారని మీకు తెలుసు. మొమెంట్ అప్లికేషన్ బండిల్కి గణనీయ పరిమాణాన్ని జోడించగలదు, ప్రత్యేకించి మీరు మొమెంట్-టైమ్జోన్ ప్యాకేజీని ఉపయోగిస్తుంటే. టెంపోరల్ ఏమీ జోడించదు (ఇది మీ లక్ష్య బ్రౌజర్లలో రవాణా చేయబడిన తర్వాత). మార్పులేని మీరు తేదీ మార్పిడులు మరియు కార్యకలాపాలను నిర్వహిస్తున్నప్పుడు డేటాను ఎప్పటికీ కోల్పోరు లేదా ఓవర్రైట్ చేయరు అనే విశ్వాసాన్ని మీకు అందిస్తుంది. మీ అవసరాలను బట్టి సమయం యొక్క విభిన్న ప్రాతినిధ్యాలు (ఇన్స్టంట్, ప్లెయిన్డేట్ టైమ్, జోన్డ్డేట్ టైమ్), ఇక్కడ క్షణం ఎల్లప్పుడూ UTC టైమ్స్టాంప్ చుట్టూ చుట్టబడుతుంది. టెంపోరల్ తేదీ ఫార్మాటింగ్ కోసం Intl APIలను ఉపయోగిస్తుంది, అంటే మీరు టోకెన్లను స్పష్టంగా పేర్కొనకుండానే లొకేల్-అవేర్ ఫార్మాటింగ్ను కలిగి ఉండవచ్చు.
పాలీఫిల్పై గమనికలు ముందుగా చెప్పినట్లుగా, తాత్కాలిక పాలీఫిల్ అందుబాటులో ఉంది, @js-temporal/polyfill పేరుతో npm ప్యాకేజీగా పంపిణీ చేయబడింది. మీరు ఈరోజు టెంపోరల్ని ఉపయోగించాలనుకుంటే, ఇంకా APIని షిప్పింగ్ చేయని Safari వంటి బ్రౌజర్లకు మద్దతు ఇవ్వడానికి మీకు ఈ పాలీఫిల్ అవసరం. దీనితో చెడు వార్త ఏమిటంటే ఇది మీ బండిల్ పరిమాణానికి జోడిస్తుంది. శుభవార్త ఏమిటంటే ఇది ఇప్పటికీ క్షణం లేదా మూమెంట్-టైమ్జోన్ కంటే చాలా తక్కువ జోడిస్తుంది. npm ప్యాకేజీ పరిమాణాలపై సమాచారాన్ని అందించే వెబ్సైట్ Bundlephobia.com ద్వారా నివేదించబడిన బండిల్ పరిమాణాల పోలిక ఇక్కడ ఉంది (బండిల్ఫోబియా విశ్లేషణను చూడటానికి ప్రతి ప్యాకేజీ పేరుపై క్లిక్ చేయండి):
ప్యాకేజీ కనిష్టీకరించబడింది మినిఫైడ్ & జిజిప్ చేయబడింది @js-టెంపోరల్/పాలీఫిల్ 154.1 కి.బి 44.1 కి.బి క్షణం 294.4 కి.బి 75.4 కి.బి క్షణం-సమయ మండలి 1 MB 114.2 కి.బి
పాలీఫిల్ చారిత్రాత్మకంగా మెమరీ వినియోగం చుట్టూ కొన్ని పనితీరు సమస్యలను కలిగి ఉంది మరియు వ్రాసే సమయంలో, ఇది ఆల్ఫా స్థితిలో ఉన్నట్లు పరిగణించబడుతుంది. దీని కారణంగా, ఇది మరింత పరిణతి చెందిన స్థితికి చేరుకునే వరకు మీరు దానిని ఉత్పత్తిలో ఉపయోగించకూడదనుకోవచ్చు. ఇతర శుభవార్త ఏమిటంటే, ఆశాజనక పాలీఫిల్ ఎక్కువ కాలం అవసరం లేదు (మీరు పాత బ్రౌజర్లకు మద్దతు ఇవ్వాల్సిన అవసరం ఉంటే తప్ప). వ్రాసే సమయంలో, టెంపోరల్ Chrome, Edge మరియు Firefoxలో షిప్పింగ్ చేయబడింది. ఇది సఫారిలో ఇంకా పూర్తిగా సిద్ధంగా లేదు, అయితే ఇది తాజా టెక్నాలజీ ప్రివ్యూలో రన్టైమ్ ఫ్లాగ్తో అందుబాటులో ఉన్నట్లు కనిపిస్తోంది.
