JavaScript માં લખેલી લગભગ કોઈપણ પ્રકારની એપ્લિકેશન અમુક ક્ષમતામાં સમય અથવા તારીખો સાથે કામ કરે છે. શરૂઆતમાં, આ બિલ્ટ-ઇન તારીખ API સુધી મર્યાદિત હતું. આ API માં મૂળભૂત કાર્યક્ષમતા શામેલ છે, પરંતુ તે શું કરી શકે છે તે ખૂબ મર્યાદિત છે. Moment.js જેવી તૃતીય-પક્ષ લાઇબ્રેરીઓ અને પછીથી બિલ્ટ-ઇન APIs જેમ કે Intl API અને નવા ટેમ્પોરલ API, સમય અને તારીખો સાથે કામ કરવા માટે ઘણી વધુ સુગમતા ઉમેરે છે. Moment.js નો ઉદય અને પતન Moment.js એ સમય અને તારીખો સાથે કામ કરવા માટે શક્તિશાળી ઉપયોગિતાઓ સાથેની JavaScript લાઇબ્રેરી છે. તેમાં મૂળભૂત તારીખ API માંથી ખૂટતી સુવિધાઓનો સમાવેશ થાય છે, જેમ કે ટાઇમ ઝોન મેનીપ્યુલેશન, અને ઘણી સામાન્ય કામગીરીને સરળ બનાવે છે. મોમેન્ટમાં તારીખો અને સમયના ફોર્મેટિંગ માટેના કાર્યો પણ શામેલ છે. તે ઘણી વિવિધ એપ્લિકેશનોમાં વ્યાપકપણે ઉપયોગમાં લેવાતી લાઇબ્રેરી બની ગઈ. જો કે, મોમેન્ટમાં પણ તેનો હિસ્સો હતો. તે એક મોટી લાઇબ્રેરી છે અને એપ્લિકેશનના બંડલ કદમાં નોંધપાત્ર રીતે ઉમેરી શકે છે. કારણ કે લાઇબ્રેરી ટ્રી શેકિંગને સપોર્ટ કરતી નથી (આધુનિક બંડલર્સની એક વિશેષતા જે લાઇબ્રેરીના ન વપરાયેલ ભાગોને દૂર કરી શકે છે), સમગ્ર મોમેન્ટ લાઇબ્રેરીનો સમાવેશ કરવામાં આવે છે, પછી ભલે તમે તેના માત્ર એક કે બે કાર્યોનો ઉપયોગ કરો. મોમેન્ટ સાથેનો બીજો મુદ્દો એ છે કે તે બનાવેલી વસ્તુઓ પરિવર્તનશીલ છે. મોમેન્ટ ઑબ્જેક્ટ પર અમુક ફંક્શનને કૉલ કરવાથી આડઅસર થાય છે અને તે ઑબ્જેક્ટના મૂલ્યમાં પરિવર્તન થાય છે. આ અનપેક્ષિત વર્તન અથવા ભૂલો તરફ દોરી શકે છે. 2020 માં, મોમેન્ટના જાળવણીકારોએ લાઇબ્રેરીને જાળવણી મોડમાં મૂકવાનું નક્કી કર્યું. કોઈ નવી સુવિધા વિકસાવવામાં આવી રહી નથી, અને જાળવણીકારો નવા પ્રોજેક્ટ્સ માટે તેનો ઉપયોગ કરવા સામે ભલામણ કરે છે. ત્યાં અન્ય JavaScript તારીખ લાઇબ્રેરીઓ છે, જેમ કે date-fns, પરંતુ શહેરમાં એક નવું પ્લેયર છે, એક API સીધું JavaScript માં બનેલ છે: Temporal. તે એક નવું ધોરણ છે જે મૂળ તારીખ API ના છિદ્રોમાં ભરે છે તેમજ મોમેન્ટ અને અન્ય લાઇબ્રેરીઓમાં મળેલી કેટલીક મર્યાદાઓને ઉકેલે છે. ટેમ્પોરલ શું છે? ટેમ્પોરલ એ ECMAScript સ્ટાન્ડર્ડમાં ઉમેરવામાં આવેલ એક નવો સમય અને તારીખ API છે, જે આધુનિક JavaScript ને વ્યાખ્યાયિત કરે છે. માર્ચ 20266 સુધીમાં, તે TC39 પ્રક્રિયાના સ્ટેજ 4 પર પહોંચી ગયું છે (સમિતિ કે જે JavaScript ભાષામાં દરખાસ્તો અને વધારાની દેખરેખ રાખે છે), અને ECMAScript સ્પષ્ટીકરણના આગામી સંસ્કરણમાં તેનો સમાવેશ કરવામાં આવશે. તે પહેલાથી જ કેટલાક બ્રાઉઝર્સમાં લાગુ કરવામાં આવ્યું છે: Chrome 144+ અને Firefox 139+, Safari ટૂંક સમયમાં અનુસરવાની અપેક્ષા સાથે. અસમર્થિત બ્રાઉઝર્સ અને Node.js માટે પોલિફીલ પણ ઉપલબ્ધ છે. ટેમ્પોરલ API એવી વસ્તુઓ બનાવે છે જે સામાન્ય રીતે સમયની ક્ષણોનું પ્રતિનિધિત્વ કરે છે. આ આપેલ ટાઈમ ઝોનમાં પૂર્ણ-સમય અને તારીખની સ્ટેમ્પ હોઈ શકે છે, અથવા તે કોઈપણ સમય ઝોન અથવા તારીખની માહિતી વિના "વોલ ક્લોક" સમયનો સામાન્ય દાખલો હોઈ શકે છે. ટેમ્પોરલની કેટલીક મુખ્ય લાક્ષણિકતાઓમાં નીચેનાનો સમાવેશ થાય છે:
તારીખો સાથે અથવા વગરનો સમય. એક ટેમ્પોરલ ઑબ્જેક્ટ ચોક્કસ તારીખે ચોક્કસ સમય અથવા કોઈપણ તારીખની માહિતી વિનાનો સમય રજૂ કરી શકે છે. ચોક્કસ તારીખ, સમય વિના, પણ રજૂ કરી શકાય છે. ટાઈમ ઝોન સપોર્ટ. ટેમ્પોરલ ઑબ્જેક્ટ્સ સંપૂર્ણપણે સમય ઝોનથી વાકેફ છે અને વિવિધ સમય ઝોનમાં રૂપાંતરિત કરી શકાય છે. મોમેન્ટ ટાઇમ ઝોનને પણ સપોર્ટ કરે છે, પરંતુ તેને વધારાની મોમેન્ટ-ટાઇમઝોન લાઇબ્રેરીની જરૂર છે. અપરિવર્તનક્ષમતા. એકવાર ટેમ્પોરલ ઑબ્જેક્ટ બનાવવામાં આવે, તે બદલી શકાતું નથી. સમય અંકગણિત અથવા સમય ઝોન રૂપાંતરણો અંતર્ગત ઑબ્જેક્ટને સંશોધિત કરતા નથી. તેના બદલે, તેઓ એક નવો ટેમ્પોરલ ઑબ્જેક્ટ જનરેટ કરે છે. 1-આધારિત અનુક્રમણિકા. તારીખ API (તેમજ મોમેન્ટ સાથે) સાથે બગ્સનો સામાન્ય સ્ત્રોત એ છે કે મહિનાઓ શૂન્ય-અનુક્રમિત છે. આનો અર્થ એ છે કે જાન્યુઆરી મહિનો 0 છે, મહિનો 1 ને બદલે આપણે બધા વાસ્તવિક જીવનમાં સમજીએ છીએ. ટેમ્પોરલ 1-આધારિત અનુક્રમણિકાનો ઉપયોગ કરીને આને ઠીક કરે છે — જાન્યુઆરી મહિનો 1 છે. તે બ્રાઉઝરમાં બનેલ છે. ટેમ્પોરલ એ બ્રાઉઝરમાં જ એક API હોવાથી, તે તમારી એપ્લિકેશનના બંડલ કદમાં કંઈ ઉમેરતું નથી.
તે નોંધવું પણ મહત્વપૂર્ણ છે કે તારીખ API દૂર નથી થઈ રહ્યું. જ્યારે ટેમ્પોરલ આ APIને સ્થાનાંતરિત કરે છે, ત્યારે તેને દૂર કરવામાં અથવા અવમૂલ્યન કરવામાં આવી રહ્યું નથી. જો બ્રાઉઝર અચાનક Date API કાઢી નાખે તો ઘણી એપ્લિકેશનો તૂટી જશે. જો કે, એ પણ ધ્યાનમાં રાખો કે મોમેન્ટને હવે મેન્ટેનન્સ મોડમાં લેગસી પ્રોજેક્ટ ગણવામાં આવે છે. બાકીના લેખમાં, અમે મોમેન્ટ-આધારિત કોડને નવા ટેમ્પોરલ API પર સ્થાનાંતરિત કરવા માટે કેટલીક "રેસીપી" જોઈશું. ચાલો રિફેક્ટિંગ શરૂ કરીએ! તારીખ અને સમયની વસ્તુઓ બનાવવી અમે તારીખો અને સમયની હેરફેર કરી શકીએ તે પહેલાં, આપણે તેમને રજૂ કરતી વસ્તુઓ બનાવવાની છે. વર્તમાન તારીખ અને સમયનું પ્રતિનિધિત્વ કરતી મોમેન્ટ ઑબ્જેક્ટ બનાવવા માટે, મોમેન્ટ ફંક્શનનો ઉપયોગ કરો. const now = moment(); 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); // 1771466342612000000એન
// 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.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
// યુએસ પૂર્વીય સમય ઝોનમાં તારીખ અને સમય const dueAt = Temporal.ZonedDateTime.from({ સમય ઝોન: 'અમેરિકા/ન્યૂ_યોર્ક', વર્ષ: 2026, મહિનો: 3, દિવસ: 1, કલાક: 12, મિનિટ: 0, બીજું: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[અમેરિકા/ન્યૂ_યોર્ક]
પદચ્છેદન અમે તારીખ અને સમયની માહિતીની પ્રોગ્રામેટિક રચનાને આવરી લીધી છે. હવે પાર્સિંગ જોઈએ. પાર્સિંગ એ એક ક્ષેત્ર છે જ્યાં બિલ્ટ-ઇન ટેમ્પોરલ API કરતાં મોમેન્ટ વધુ લવચીક છે. તમે તારીખ સ્ટ્રિંગને મોમેન્ટ ફંક્શનમાં પાસ કરીને પાર્સ કરી શકો છો. એક દલીલ સાથે, મોમેન્ટ 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 સાથે સુસંગત હોવી જોઈએ. જો બિન-સુસંગત તારીખ સ્ટ્રિંગ એ ફ્રોમ મેથડમાં પસાર થાય છે, તો ટેમ્પોરલ રેન્જ એરર ફેંકશે.
// 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 તારીખ શબ્દમાળા સમય ઝોન ઑફસેટ સાથે તારીખ અને સમયનો ઉલ્લેખ કરે છે, પરંતુ તમે માત્ર તારીખ ફોર્મેટના સબસેટનો ઉપયોગ કરીને પ્લેનડેટ અથવા પ્લેનટાઇમ ઑબ્જેક્ટ્સ પણ બનાવી શકો છો. 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 સ્ટ્રિંગમાં મૂલ્યોને ફરીથી ગોઠવવા માટે થોડી સ્ટ્રિંગ મેનિપ્યુલેશન કરવાની જરૂર પડશે.
ફોર્મેટિંગ એકવાર તમારી પાસે મોમેન્ટ અથવા ટેમ્પોરલ ઑબ્જેક્ટ હોય, તો તમે કદાચ તેને અમુક સમયે ફોર્મેટ કરેલ સ્ટ્રિંગમાં રૂપાંતરિત કરવા માંગો છો. આ એક ઉદાહરણ છે જ્યાં મોમેન્ટ થોડી વધુ સંક્ષિપ્ત છે. તમે ટોકન્સની સ્ટ્રિંગ સાથે ઑબ્જેક્ટની ફોર્મેટ પદ્ધતિને કૉલ કરો છો જે ઇચ્છિત તારીખ ફોર્મેટનું વર્ણન કરે છે. const date = moment();
console.log(date.format('MM/DD/YYYY')); // 02/22/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // ફેબ્રુઆરી 22, 2026, રાત્રે 8:18:30
બીજી બાજુ, ટેમ્પોરલ માટે તમારે થોડી વધુ વર્બોઝ બનવાની જરૂર છે. ટેમ્પોરલ ઑબ્જેક્ટ્સ, જેમ કે ઇન્સ્ટન્ટ, પાસે 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 વાગ્યે
// ફોર્મેટ સ્ટ્રિંગમાં તમને જોઈતા ફીલ્ડ્સને જ પાસ કરો console.log(date.toLocaleString('en-US', { મહિનો: 'ટૂંકા', દિવસ: 'સંખ્યાત્મક' })); // 22 ફેબ્રુઆરી
ટેમ્પોરલ ડેટ ફોર્મેટિંગ ખરેખર Intl.DateTimeFormat API નો ઉપયોગ કરે છે (જે આધુનિક બ્રાઉઝર્સમાં પહેલેથી જ સરળતાથી ઉપલબ્ધ છે) હૂડ હેઠળ. તેનો અર્થ એ કે તમે તમારા કસ્ટમ ફોર્મેટિંગ વિકલ્પો સાથે ફરીથી વાપરી શકાય તેવી DateTimeFormat ઑબ્જેક્ટ બનાવી શકો છો, પછી ટેમ્પોરલ ઑબ્જેક્ટને તેની ફોર્મેટ પદ્ધતિમાં પાસ કરી શકો છો. આ કારણે, તે મોમેન્ટની જેમ કસ્ટમ તારીખ ફોર્મેટને સપોર્ટ કરતું નથી. જો તમને 'Q1 2026' અથવા અન્ય વિશિષ્ટ ફોર્મેટિંગ જેવી કોઈ વસ્તુની જરૂર હોય, તો તમારે અમુક કસ્ટમ તારીખ ફોર્મેટિંગ કોડની જરૂર પડી શકે છે અથવા તૃતીય-પક્ષ લાઇબ્રેરી સુધી પહોંચવાની જરૂર પડી શકે છે. const formatter = new Intl.DateTimeFormat('en-US', { મહિનો: '2-અંક', દિવસ: '2-અંક', વર્ષ: 'સંખ્યાત્મક' });
const date = Temporal.Now.instant(); console.log(formatter.format(date)); // 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 = moment();
console.log(હવે); // ક્ષણ<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'days'); console.log(આગામી સપ્તાહ); // ક્ષણ<2026-03-03T20:08:36-05:00>
// ગોટચા - મૂળ ઑબ્જેક્ટ પરિવર્તિત થઈ હતી console.log(હવે); // ક્ષણ<2026-03-03T20:08:36-05:00>
મૂળ તારીખ ગુમાવવાનું ટાળવા માટે, તમે નકલ બનાવવા માટે મોમેન્ટ ઑબ્જેક્ટ પર ક્લોન કૉલ કરી શકો છો. const હવે= ક્ષણ(); const nextWeek = now.clone().add(7, 'days');
console.log(હવે); // ક્ષણ<2026-02-24T20:12:55-05:00>
console.log(આગામી સપ્તાહ); // ક્ષણ<2026-03-03T20:12:55-05:00>
બીજી બાજુ, ટેમ્પોરલ ઓબ્જેક્ટ્સ અપરિવર્તનશીલ છે. એકવાર તમે ઑબ્જેક્ટ બનાવી લો, જેમ કે ઇન્સ્ટન્ટ, પ્લેનડેટ, વગેરે, તે ઑબ્જેક્ટનું મૂલ્ય ક્યારેય બદલાશે નહીં. ટેમ્પોરલ ઑબ્જેક્ટ્સમાં પણ ઉમેરવા અને બાદબાકી કરવાની પદ્ધતિઓ હોય છે. ટેમ્પોરલ એ થોડું પસંદ છે કે કયા પ્રકારનાં ઑબ્જેક્ટમાં કયા સમય એકમો ઉમેરી શકાય છે. ઉદાહરણ તરીકે, તમે ત્વરિતમાં દિવસો ઉમેરી શકતા નથી:
const now = Temporal.Now.instant(); const nextWeek = now.add({ દિવસો: 7 }); // રેન્જ એરર: ટેમ્પોરલ એરર: સૌથી મોટું એકમ તારીખ એકમ હોઈ શકતું નથી
આ એટલા માટે છે કારણ કે ઇન્સ્ટન્ટ ઑબ્જેક્ટ્સ UTC માં સમયના ચોક્કસ બિંદુને રજૂ કરે છે અને તે કૅલેન્ડર-અજ્ઞેયવાદી છે. કારણ કે ડેલાઇટ સેવિંગ ટાઇમ જેવા ટાઇમ ઝોન નિયમોના આધારે દિવસની લંબાઈ બદલાઈ શકે છે, આ ગણતરી ત્વરિત પર ઉપલબ્ધ નથી. જો કે, તમે આ ઑપરેશન અન્ય પ્રકારના ઑબ્જેક્ટ પર કરી શકો છો, જેમ કે PlainDateTime: 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 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'days')); // 1
અ આ એક Temporal.Duration ઑબ્જેક્ટ આપે છે જેમાં સમયના તફાવત વિશેની માહિતી હોય છે. સમયગાળો ઑબ્જેક્ટમાં તફાવતના દરેક ઘટક માટે ગુણધર્મો છે, અને તે સમયના તફાવતને રજૂ કરતી ISO 8601 અવધિની સ્ટ્રિંગ પણ જનરેટ કરી શકે છે.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// largeUnit રજૂ કરવા માટે સમયનો સૌથી મોટો એકમ સ્પષ્ટ કરે છે // સમયગાળાની ગણતરીમાં const diff = date2.since(date1, { સૌથી મોટું એકમ: '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 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // સાચું
ટેમ્પોરલ સમાન પ્રકારની બે વસ્તુઓ વચ્ચે સરખામણી કરવા માટે સ્થિર સરખામણી પદ્ધતિનો ઉપયોગ કરે છે. જો પ્રથમ તારીખ બીજા પહેલા આવે તો તે -1, જો તે સમાન હોય તો 0, અથવા જો પ્રથમ તારીખ બીજી પછી આવે તો 1 પરત કરે છે. નીચેનું ઉદાહરણ બે PlainDate ઑબ્જેક્ટ્સની તુલના કેવી રીતે કરવી તે બતાવે છે. Temporal.PlainDate.compare માટે બંને દલીલો PlainDate ઑબ્જેક્ટ હોવી આવશ્યક છે.
const date1 = Temporal.PlainDate.from({ વર્ષ: 2026, મહિનો: 2, દિવસ: 24 }); const date2 = Temporal.PlainDate.from({ વર્ષ: 2026, મહિનો: 3, દિવસ: 24 });
// date1 તારીખ2 પહેલા આવે છે, તેથી -1 console.log(Temporal.PlainDate.compare(date1, date2));
// જો આપણે વિવિધ પ્રકારની બે વસ્તુઓની સરખામણી કરવાનો પ્રયાસ કરીએ તો ભૂલ console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: ટેમ્પોરલ એરર: અમાન્ય PlainDate ફીલ્ડ પ્રદાન કરેલ છે.
ખાસ કરીને, આ ટેમ્પોરલ ઑબ્જેક્ટ્સની શ્રેણીને કાલક્રમિક રીતે સૉર્ટ કરવાનું સરળ બનાવે છે. // Temporal.PlainDate ઑબ્જેક્ટ્સની એરે const તારીખો = [... ];
// તુલનાકાર કાર્ય તરીકે Temporal.PlainDate.compare નો ઉપયોગ કરો dates.sort(Temporal.PlainDate.compare);
સમય ઝોન રૂપાંતરણો કોર મોમેન્ટ લાઇબ્રેરી ટાઇમ ઝોન રૂપાંતરણને સપોર્ટ કરતી નથી. જો તમને આ કાર્યક્ષમતાની જરૂર હોય, તો તમારે મોમેન્ટ-ટાઇમઝોન પેકેજ પણ ઇન્સ્ટોલ કરવાની જરૂર છે. આ પેકેજ વૃક્ષને હલાવી શકાય તેવું નથી, અને તેથી તમારા બંડલના કદમાં નોંધપાત્ર વધારો થઈ શકે છે. એકવાર તમે મોમેન્ટ-ટાઇમઝોન ઇન્સ્ટોલ કરી લો તે પછી, તમે મોમેન્ટ ઑબ્જેક્ટ્સને tz પદ્ધતિથી જુદા જુદા ટાઇમ ઝોનમાં કન્વર્ટ કરી શકો છો. અન્ય મોમેન્ટ ઑપરેશનની જેમ, આ અન્ડરલાઇંગને મ્યુટ કરે છેપદાર્થ // યુએસ પૂર્વીય સમય ધારી રહ્યા છીએ const now = moment(); console.log(હવે); // ક્ષણ<2026-02-28T20:08:20-05:00>
// પેસિફિક સમયમાં કન્વર્ટ કરો. // મૂળ પૂર્વીય સમય ખોવાઈ ગયો છે. now.tz('America/Los_Angeles'); console.log(હવે); // ક્ષણ<2026-02-28T17:08:20-08:00>
Temporal.ZonedDateTime ઑબ્જેક્ટનો ઉપયોગ કરતી વખતે સમય ઝોન કાર્યક્ષમતા ટેમ્પોરલ API માં બનેલ છે. આ ઑબ્જેક્ટ્સમાં withTimeZone પદ્ધતિનો સમાવેશ થાય છે જે સમયની સમાન ક્ષણને રજૂ કરતી નવી ZonedDateTime પરત કરે છે, પરંતુ ઉલ્લેખિત સમય ઝોનમાં. // ફરીથી, યુએસ પૂર્વીય સમય ધારી રહ્યા છીએ 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( inputString, moment.ISO_8601, // ISO 8601 સ્ટ્રિંગની અપેક્ષા રાખો સાચું, // કડક પદચ્છેદન વપરાશકર્તા ટાઈમઝોન );
// જો inputString માન્ય તારીખનું પ્રતિનિધિત્વ કરતું ન હોય તો ભૂલ ફેંકો જો (!eventTime.isValid()) { નવી ભૂલ ફેંકો ('અમાન્ય તારીખ/સમય ઇનપુટ'); }
// 2. લક્ષ્ય સમયની ગણતરી કરો // ક્રિટિકલ: આપણે ક્લોન કરવું જોઈએ, અથવા 'ઇવેન્ટટાઇમ' કાયમ બદલાય છે! const targetTime = eventTime.clone().tz(targetTimeZone);
પરત { સ્થાનિક: eventTime.format(timeFormat), લક્ષ્ય: 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 તારીખ શબ્દમાળા પસાર થાય છે, તો તે અમાન્ય તારીખ ઑબ્જેક્ટમાં પરિણમશે, અને અમે એક ભૂલ ફેંકીએ છીએ. ટેમ્પોરલ અમલીકરણ સમાન દેખાય છે, પરંતુ તેમાં કેટલાક મુખ્ય તફાવત છે.
ફંક્શન getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. ઇનપુટને સીધા જ ઇન્સ્ટન્ટમાં પાર્સ કરો, પછી બનાવો // વપરાશકર્તાના ઝોનમાં ZonedDateTime. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. લક્ષ્ય ઝોનમાં કન્વર્ટ કરો // આ આપમેળે એક નવો ઑબ્જેક્ટ પરત કરે છે; 'ઇવેન્ટ ટાઇમ' સલામત છે. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Intl (બિલ્ટ-ઇન) નો ઉપયોગ કરીને ફોર્મેટ const વિકલ્પો = { વર્ષ: 'સંખ્યાત્મક', મહિનો: 'ટૂંકા', દિવસ: 'સંખ્યાત્મક', કલાક: 'સંખ્યાત્મક', મિનિટ: '2-અંક', બીજું: '2-અંક', ટાઇમઝોન નામ: 'ટૂંકા' };
પરત { સ્થાનિક: eventTime.toLocaleString(navigator.language, વિકલ્પો), લક્ષ્ય: targetTime.toLocaleString(navigator.language, વિકલ્પો) }; }
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 તરીકે ફોર્મેટ કરવામાં આવશેબપોરે EST. ઉપરાંત, અમારે સ્પષ્ટપણે અપવાદ મૂકવાની જરૂર નથી. જો અમાન્ય સ્ટ્રિંગ 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) સમય ઉમેરો ઉમેરો(7, 'દિવસો') (પરિવર્તન) ઉમેરો ({ દિવસ: 7 }) (નવો ઑબ્જેક્ટ) તફાવત .diff(અન્ય, 'કલાક') (અન્ય).કલાકોથી સમય ઝોન .tz('ઝોન/નામ') .WithTimeZone('ઝોન/નામ')
પ્રથમ નજરમાં, તફાવત થોડો અલગ હોઈ શકે છે (અને ટેમ્પોરલના કિસ્સામાં, ક્યારેક વધુ વર્બોઝ અને વધુ કડક) વાક્યરચના, પરંતુ Moment.js પર ટેમ્પોરલનો ઉપયોગ કરવાના ઘણા મુખ્ય ફાયદા છે:
વધુ સ્પષ્ટ હોવાનો અર્થ છે ઓછા આશ્ચર્ય અને અનિચ્છનીય ભૂલો. ક્ષણ વધુ ઉદાર લાગે છે, પરંતુ તેમાં "અનુમાન"નો સમાવેશ થાય છે, જે કેટલીકવાર ખોટી તારીખોમાં પરિણમી શકે છે. જો તમે ટેમ્પોરલને કંઈક અમાન્ય આપો છો, તો તે એક ભૂલ ફેંકે છે. જો કોડ ચાલે છે, તો તમે જાણો છો કે તમારી પાસે માન્ય તારીખ છે. મોમેન્ટ એપ્લિકેશનના બંડલમાં નોંધપાત્ર કદ ઉમેરી શકે છે, ખાસ કરીને જો તમે મોમેન્ટ-ટાઇમઝોન પેકેજનો ઉપયોગ કરી રહ્યાં હોવ. ટેમ્પોરલ કંઈ ઉમેરતું નથી (એકવાર તે તમારા લક્ષ્ય બ્રાઉઝર્સમાં મોકલવામાં આવે છે). અપરિવર્તનક્ષમતા તમને વિશ્વાસ આપે છે કે તારીખ રૂપાંતરણ અને કામગીરી કરતી વખતે તમે ક્યારેય ડેટા ગુમાવશો નહીં અથવા ફરીથી લખશો નહીં. તમારી જરૂરિયાતોને આધારે સમયની વિવિધ રજૂઆતો (ઇન્સ્ટન્ટ, પ્લેનડેટ ટાઇમ, ઝોનડ ડેટ ટાઇમ), જ્યાં મોમેન્ટ હંમેશા UTC ટાઇમસ્ટેમ્પની આસપાસ રેપર હોય છે. ટેમ્પોરલ તારીખ ફોર્મેટિંગ માટે Intl API નો ઉપયોગ કરે છે, જેનો અર્થ છે કે તમે સ્પષ્ટપણે ટોકન્સનો ઉલ્લેખ કર્યા વિના લોકેલ-અવેર ફોર્મેટિંગ કરી શકો છો.
પોલીફિલ પર નોંધો અગાઉ સૂચવ્યા મુજબ, ટેમ્પોરલ પોલીફિલ ઉપલબ્ધ છે, જે @js-temporal/polyfill નામના npm પેકેજ તરીકે વિતરિત છે. જો તમે આજે ટેમ્પોરલનો ઉપયોગ કરવા માંગતા હો, તો તમારે સફારી જેવા બ્રાઉઝર્સને સપોર્ટ કરવા માટે આ પોલીફિલની જરૂર પડશે જેણે હજી સુધી API મોકલ્યા નથી. આ સાથે ખરાબ સમાચાર એ છે કે તે તમારા બંડલના કદમાં વધારો કરશે. સારા સમાચાર એ છે કે તે હજુ પણ ક્ષણ અથવા ક્ષણ-ટાઇમઝોન કરતાં નોંધપાત્ર રીતે ઓછા ઉમેરે છે. Bundlephobia.com દ્વારા નોંધાયેલા બંડલના કદની સરખામણી અહીં છે, જે npm પેકેજ માપો પર માહિતી રજૂ કરે છે (બંડલફોબિયા વિશ્લેષણ જોવા માટે દરેક પેકેજના નામ પર ક્લિક કરો):
પેકેજ લઘુત્તમ મિનિફાઇડ અને gzipped @js-temporal/polyfill 154.1 kB 44.1 kB ક્ષણ 294.4 kB 75.4 kB ક્ષણ-સમય ઝોન 1 MB 114.2 kB
પોલીફિલમાં ઐતિહાસિક રીતે મેમરી વપરાશની આસપાસના કેટલાક પ્રદર્શન સમસ્યાઓ છે, અને લેખન સમયે, તે આલ્ફા સ્થિતિમાં હોવાનું માનવામાં આવે છે. આને કારણે, જ્યાં સુધી તે વધુ પરિપક્વ સ્થિતિમાં ન પહોંચે ત્યાં સુધી તમે તેનો ઉત્પાદનમાં ઉપયોગ કરવા માંગતા નથી. અન્ય સારા સમાચાર એ છે કે આશા છે કે પોલિફિલની વધુ લાંબા સમય સુધી જરૂર રહેશે નહીં (સિવાય કે તમારે જૂના બ્રાઉઝર્સને સપોર્ટ કરવાની જરૂર છે, અલબત્ત). લેખન સમયે, ટેમ્પોરલ ક્રોમ, એજ અને ફાયરફોક્સમાં મોકલવામાં આવ્યું છે. તે હજુ સુધી સફારીમાં તદ્દન તૈયાર નથી, જો કે તે નવીનતમ ટેકનોલોજી પૂર્વાવલોકન પર રનટાઇમ ફ્લેગ સાથે ઉપલબ્ધ હોય તેવું લાગે છે.
