M

MLOG

తెలుగు

జావాస్క్రిప్ట్ టెంపోరల్ APIకి సమగ్ర మార్గదర్శి, ఇది విభిన్న అంతర్జాతీయ సందర్భాలలో తేదీలు మరియు సమయాలను సమర్థవంతంగా నిర్వహించడానికి ఒక ఆధునిక పరిష్కారం.

జావాస్క్రిప్ట్ టెంపోరల్ API: ప్రపంచ ప్రేక్షకులకు ఆధునిక తేదీ మరియు సమయ నిర్వహణ

జావాస్క్రిప్ట్ `Date` ఆబ్జెక్ట్ డెవలపర్‌లకు చాలా కాలంగా నిరాశకు గురిచేస్తోంది. దాని మ్యూటబిలిటీ, అస్థిరమైన API, మరియు పేలవమైన టైమ్‌జోన్ మద్దతు వంటి సమస్యల వల్ల Moment.js మరియు date-fns వంటి అనేక లైబ్రరీలు అవసరమయ్యాయి. ఇప్పుడు, టెంపోరల్ APIతో, జావాస్క్రిప్ట్ మెరుగైన స్పష్టత మరియు కచ్చితత్వంతో తేదీలు మరియు సమయాలను నిర్వహించడానికి ఒక ఆధునిక, అంతర్నిర్మిత పరిష్కారాన్ని అందిస్తుంది. ఈ వ్యాసం టెంపోరల్ API యొక్క సమగ్ర అవలోకనాన్ని అందిస్తుంది, దాని ఫీచర్లు, ప్రయోజనాలు, మరియు విభిన్న అంతర్జాతీయ సందర్భాలలో దాని వినియోగంపై దృష్టి పెడుతుంది.

టెంపోరల్ API అంటే ఏమిటి?

టెంపోరల్ API అనేది జావాస్క్రిప్ట్‌లో `Date` ఆబ్జెక్ట్ యొక్క లోపాలను పరిష్కరించడానికి రూపొందించబడిన ఒక కొత్త, గ్లోబల్ ఆబ్జెక్ట్. ఇది తేదీలు, సమయాలు, టైమ్ జోన్‌లు, మరియు క్యాలెండర్ సిస్టమ్‌లతో పనిచేయడానికి ఒక స్వచ్ఛమైన, ఇమ్మ్యూటబుల్ APIని అందిస్తుంది. ముఖ్యంగా, ఇది నిజ-ప్రపంచ వినియోగం మరియు అంచనాలతో మరింత దగ్గరగా ఉండే విధంగా తేదీ మరియు సమయ భావనలను సూచించడాన్ని లక్ష్యంగా పెట్టుకుంది, దీనివల్ల అంతర్జాతీయీకరణ చాలా సులభతరం అవుతుంది.

ముఖ్య లక్షణాలు:

ప్రాథమిక టెంపోరల్ ఆబ్జెక్ట్స్

టెంపోరల్ API అనేక కొత్త ఆబ్జెక్ట్ రకాలను పరిచయం చేస్తుంది. ఇక్కడ కొన్ని ముఖ్యమైనవి ఉన్నాయి:

తేదీలతో పని చేయడం

ఒక `Temporal.PlainDate`ని సృష్టించడం

ఒక `Temporal.PlainDate`ని సృష్టించడానికి, మీరు కన్‌స్ట్రక్టర్‌ను ఉపయోగించవచ్చు:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // సంవత్సరం, నెల (1-12), రోజు
console.log(plainDate.toString()); // అవుట్‌పుట్: 2024-10-27

మీరు `from` పద్ధతిని కూడా ఉపయోగించవచ్చు, ఇది ISO 8601 ఫార్మాట్‌లోని స్ట్రింగ్‌ను అంగీకరిస్తుంది:

const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // అవుట్‌పుట్: 2024-10-27

తేదీ భాగాలను పొందడం

మీరు `year`, `month`, మరియు `day` వంటి ప్రాపర్టీలను ఉపయోగించి వ్యక్తిగత తేదీ భాగాలను యాక్సెస్ చేయవచ్చు:

console.log(plainDate.year); // అవుట్‌పుట్: 2024
console.log(plainDate.month); // అవుట్‌పుట్: 10
console.log(plainDate.day); // అవుట్‌పుట్: 27

తేదీ అంకగణితం

రోజులు, వారాలు, నెలలు, లేదా సంవత్సరాలను జోడించడానికి లేదా తీసివేయడానికి, `plus` మరియు `minus` పద్ధతులను ఉపయోగించండి. ఈ పద్ధతులు కొత్త `Temporal.PlainDate` ఆబ్జెక్ట్‌ను తిరిగి ఇస్తాయి:

const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // అవుట్‌పుట్: 2024-11-03

const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // అవుట్‌పుట్: 2024-09-27

తేదీలను పోల్చడం

మీరు `compare` పద్ధతిని ఉపయోగించి తేదీలను పోల్చవచ్చు:

const date1 = new Temporal.PlainDate(2024, 10, 27);
const date2 = new Temporal.PlainDate(2024, 11, 15);

console.log(Temporal.PlainDate.compare(date1, date2)); // అవుట్‌పుట్: -1 (date1, date2 కన్నా ముందుంది)

సమయాలతో పని చేయడం

ఒక `Temporal.PlainTime`ని సృష్టించడం

ఒక `Temporal.PlainTime`ని సృష్టించడానికి, కన్‌స్ట్రక్టర్‌ను ఉపయోగించండి:

const plainTime = new Temporal.PlainTime(10, 30, 0); // గంట, నిమిషం, సెకను
console.log(plainTime.toString()); // అవుట్‌పుట్: 10:30:00

లేదా ISO 8601 టైమ్ స్ట్రింగ్‌తో `from` పద్ధతిని ఉపయోగించండి:

const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // అవుట్‌పుట్: 10:30:00

సమయ భాగాలను పొందడం

console.log(plainTime.hour); // అవుట్‌పుట్: 10
console.log(plainTime.minute); // అవుట్‌పుట్: 30
console.log(plainTime.second); // అవుట్‌పుట్: 0

సమయ అంకగణితం

const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // అవుట్‌పుట్: 10:45:00

తేదీ మరియు సమయంతో కలిసి పని చేయడం

ఒక `Temporal.PlainDateTime`ని సృష్టించడం

మీరు నేరుగా `Temporal.PlainDateTime`ని సృష్టించవచ్చు లేదా `Temporal.PlainDate` మరియు `Temporal.PlainTime`ని కలపడం ద్వారా సృష్టించవచ్చు:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // అవుట్‌పుట్: 2024-10-27T10:30:00

const date = new Temporal.PlainDate(2024, 10, 27);
const time = new Temporal.PlainTime(10, 30, 0);
const combinedDateTime = date.toPlainDateTime(time);
console.log(combinedDateTime.toString()); // అవుట్‌పుట్: 2024-10-27T10:30:00

టైమ్ జోన్‌లు

వివిధ ప్రదేశాలలో ఉన్న వినియోగదారులతో వ్యవహరించే అప్లికేషన్‌లకు టైమ్ జోన్‌లను సరిగ్గా నిర్వహించడం చాలా ముఖ్యం. టెంపోరల్ API `Temporal.ZonedDateTime` మరియు `Temporal.TimeZone` ఆబ్జెక్ట్‌ల ద్వారా బలమైన టైమ్ జోన్ మద్దతును అందిస్తుంది.

ఒక `Temporal.ZonedDateTime`ని సృష్టించడం

ఒక `Temporal.ZonedDateTime`ని సృష్టించడానికి, మీకు `Temporal.PlainDateTime` మరియు ఒక టైమ్ జోన్ ఐడెంటిఫైయర్ అవసరం. టైమ్ జోన్ ఐడెంటిఫైయర్‌లు IANA టైమ్ జోన్ డేటాబేస్ ఆధారంగా ఉంటాయి (ఉదా., `America/Los_Angeles`, `Europe/London`, `Asia/Tokyo`).

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // అవుట్‌పుట్: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (ఆఫ్‌సెట్ DST నియమాలపై ఆధారపడి ఉంటుంది)

ప్రత్యామ్నాయంగా, `Instant` నుండి `Temporal.ZonedDateTime`ని సృష్టించండి.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // ఉదాహరణకు టైమ్‌స్టాంప్
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // 'America/Los_Angeles' వంటి టైమ్‌జోన్
console.log(zonedDateTimeFromInstant.toString());

టైమ్ జోన్‌ల మధ్య మార్పిడి

మీరు `withTimeZone` పద్ధతిని ఉపయోగించి ఒక `Temporal.ZonedDateTime`ని వేరే టైమ్ జోన్‌కు మార్చవచ్చు:

const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // అవుట్‌పుట్: 2024-10-27T18:30:00+01:00[Europe/London]

టైమ్ జోన్ ఆఫ్‌సెట్‌లతో పని చేయడం

`Temporal.TimeZone` ఆబ్జెక్ట్ యొక్క `getOffsetStringFor` పద్ధతి ఒక నిర్దిష్ట `Temporal.Instant` కోసం ఆఫ్‌సెట్ స్ట్రింగ్‌ను అందిస్తుంది:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // అవుట్‌పుట్: -07:00 (DST నియమాలపై ఆధారపడి ఉంటుంది)

కచ్చితమైన గణనల కోసం సరైన IANA టైమ్ జోన్ ఐడెంటిఫైయర్‌లను ఉపయోగించడం చాలా అవసరం. ఈ ఐడెంటిఫైయర్‌లు డేలైట్ సేవింగ్ టైమ్ మరియు టైమ్ జోన్ సరిహద్దులలో మార్పులను ప్రతిబింబించడానికి క్రమం తప్పకుండా నిర్వహించబడతాయి మరియు నవీకరించబడతాయి.

వ్యవధులు (Durations)

`Temporal.Duration` ఆబ్జెక్ట్ ఒక సమయ వ్యవధిని సూచిస్తుంది. దీనిని తేదీలు మరియు సమయాలకు జోడించడానికి లేదా తీసివేయడానికి ఉపయోగించవచ్చు.

ఒక `Temporal.Duration`ని సృష్టించడం

మీరు సంవత్సరాలు, నెలలు, రోజులు, గంటలు, నిమిషాలు, సెకన్లు, మిల్లీసెకన్లు, మైక్రోసెకన్లు, మరియు నానోసెకన్లను పేర్కొంటూ కన్‌స్ట్రక్టర్‌ను ఉపయోగించి `Temporal.Duration`ని సృష్టించవచ్చు:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // సంవత్సరాలు, నెలలు, రోజులు, గంటలు, నిమిషాలు, సెకన్లు, మిల్లీసెకన్లు, మైక్రోసెకన్లు, నానోసెకన్లు
console.log(duration.toString()); // అవుట్‌పుట్: P1Y2M3DT4H5M6.007008009S

లేదా ISO 8601 వ్యవధి స్ట్రింగ్‌ను ఉపయోగించడం ద్వారా:

const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // అవుట్‌పుట్: P1Y2M3DT4H5M6S

తేదీలు మరియు సమయాలకు వ్యవధులను జోడించడం

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 రోజులు
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // అవుట్‌పుట్: 2024-11-03

ఒక నెలలో లేదా సంవత్సరంలో రోజుల సంఖ్య మారవచ్చు కాబట్టి, నెలలు లేదా సంవత్సరాలతో కూడిన వ్యవధులను తేదీలకు జోడించేటప్పుడు జాగ్రత్తగా పరిగణించాల్సి ఉంటుంది.

క్యాలెండర్ సిస్టమ్స్

టెంపోరల్ API గ్రెగోరియన్ క్యాలెండర్‌కు మించి విభిన్న క్యాలెండర్ సిస్టమ్‌లకు మద్దతు ఇస్తుంది. వివిధ సాంస్కృతిక సందర్భాలలో తేదీలను నిర్వహించాల్సిన అప్లికేషన్‌లకు ఇది చాలా ముఖ్యం. మద్దతు ఇంకా అభివృద్ధి చెందుతున్నప్పటికీ, భవిష్యత్ విస్తరణకు ఇది ఒక పునాదిని అందిస్తుంది.

ప్రత్యామ్నాయ క్యాలెండర్‌లను ఉపయోగించడం

ఒక నిర్దిష్ట క్యాలెండర్‌ను ఉపయోగించడానికి, మీరు టెంపోరల్ ఆబ్జెక్ట్‌లను సృష్టించేటప్పుడు దానిని పేర్కొనవచ్చు:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // అమలు మరియు ఫార్మాటింగ్‌పై ఆధారపడి నిర్దిష్ట అవుట్‌పుట్ మారవచ్చు. ఇది వ్రాసే సమయానికి అనేక పరిసరాలలో పాలిఫిల్ అవసరం.

ముఖ్య గమనిక: గ్రెగోరియన్ కాని క్యాలెండర్‌లకు మద్దతుకు పాలిఫిల్స్ లేదా నిర్దిష్ట బ్రౌజర్/ఎన్విరాన్‌మెంట్ మద్దతు అవసరం కావచ్చు. తాజా సమాచారం కోసం టెంపోరల్ API డాక్యుమెంటేషన్ మరియు బ్రౌజర్ అనుకూలత పట్టికలను తనిఖీ చేయండి.

తేదీలు మరియు సమయాలను ఫార్మాటింగ్ చేయడం

టెంపోరల్ API తేదీ మరియు సమయ మార్పులపై దృష్టి కేంద్రీకరించినప్పటికీ, ఫార్మాటింగ్ సాధారణంగా `Intl.DateTimeFormat` ఆబ్జెక్ట్ ద్వారా నిర్వహించబడుతుంది, ఇది ఇంటర్నేషనలైజేషన్ APIలో భాగం. టెంపోరల్ ఆబ్జెక్ట్‌లు `Intl.DateTimeFormat`తో సజావుగా పనిచేస్తాయి.

`Intl.DateTimeFormat`ని ఉపయోగించడం

`Intl.DateTimeFormat`ని ఉపయోగించి `Temporal.PlainDate`ని ఎలా ఫార్మాట్ చేయాలో ఇక్కడ ఉంది:

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatter.format(plainDate)); // అవుట్‌పుట్: October 27, 2024

const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // అవుట్‌పుట్: 27. Oktober 2024

మీ అవసరాలకు అనుగుణంగా మీరు ఫార్మాట్ ఆప్షన్‌లను అనుకూలీకరించవచ్చు. `Intl.DateTimeFormat`కి మొదటి ఆర్గ్యుమెంట్ లోకేల్, ఇది ఫార్మాటింగ్ కోసం ఉపయోగించే భాష మరియు ప్రాంతీయ సంప్రదాయాలను నిర్ణయిస్తుంది. విభిన్న లోకేల్‌లను (ఉదా., 'en-US', 'de-DE', 'fr-FR', 'ja-JP') ఉపయోగించడం వలన విభిన్న అవుట్‌పుట్ ఫార్మాట్‌లు వస్తాయి.

`Temporal.ZonedDateTime`ని ఫార్మాటింగ్ చేయడం

`Temporal.ZonedDateTime`ని ఫార్మాటింగ్ చేయడం కూడా ఇలాంటిదే, కానీ మీరు అవుట్‌పుట్‌లో టైమ్ జోన్ సమాచారాన్ని కూడా చేర్చవచ్చు:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);

const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZoneName: 'short' });
console.log(formatter.format(zonedDateTime)); // అవుట్‌పుట్: October 27, 2024, 10:30 AM PDT (టైమ్ జోన్ సంక్షిప్తీకరణ DST నియమాలపై ఆధారపడి ఉంటుంది)

అంతర్జాతీయీకరణ ఉత్తమ పద్ధతులు

ప్రపంచ సందర్భంలో తేదీలు మరియు సమయాలతో పనిచేసేటప్పుడు, ఈ క్రింది ఉత్తమ పద్ధతులను గుర్తుంచుకోండి:

టెంపోరల్ APIని పాత `Date` ఆబ్జెక్ట్‌తో పోల్చడం

పాత `Date` ఆబ్జెక్ట్‌తో పోలిస్తే టెంపోరల్ API యొక్క ముఖ్య వ్యత్యాసాలు మరియు ప్రయోజనాలను హైలైట్ చేసే పట్టిక ఇక్కడ ఉంది:

ఫీచర్ పాత `Date` ఆబ్జెక్ట్ టెంపోరల్ API
మ్యూటబిలిటీ మ్యూటబుల్ (అసలు ఆబ్జెక్ట్‌ను సవరిస్తుంది) ఇమ్మ్యూటబుల్ (కొత్త ఆబ్జెక్ట్‌లను తిరిగి ఇస్తుంది)
టైమ్ జోన్ మద్దతు పరిమితంగా మరియు తరచుగా సమస్యాత్మకంగా ఉంటుంది IANA టైమ్ జోన్ డేటాబేస్ ఆధారంగా దృఢమైన మరియు కచ్చితమైనది
API అస్థిరమైన మరియు ఉపయోగించడానికి కష్టమైనది స్పష్టమైన, స్థిరమైన, మరియు సహజమైనది
కచ్చితత్వం మిల్లీసెకండ్ నానోసెకండ్
క్యాలెండర్ సిస్టమ్స్ గ్రెగోరియన్‌కు పరిమితం ప్రత్యామ్నాయ క్యాలెండర్ సిస్టమ్‌లకు మద్దతు ఇస్తుంది (అభివృద్ధి చెందుతున్న మద్దతుతో)
అంతర్జాతీయీకరణ దృఢమైన అంతర్జాతీయీకరణ కోసం బాహ్య లైబ్రరీలు అవసరం అంతర్నిర్మిత మద్దతు మరియు `Intl.DateTimeFormat`తో సజావుగా ఏకీకరణ

బ్రౌజర్ మద్దతు మరియు పాలిఫిల్స్

ఇది సాపేక్షంగా కొత్త API అయినందున, టెంపోరల్ APIకి బ్రౌజర్ మద్దతు ఇంకా అభివృద్ధి చెందుతోంది. ఏయే బ్రౌజర్‌లు మరియు ఎన్విరాన్‌మెంట్‌లు దీనికి స్థానికంగా మద్దతు ఇస్తాయో చూడటానికి తాజా బ్రౌజర్ అనుకూలత పట్టికలను (ఉదా., MDN వెబ్ డాక్స్‌లో) తనిఖీ చేయండి. స్థానిక మద్దతు లేని పాత బ్రౌజర్‌లు లేదా ఎన్విరాన్‌మెంట్‌ల కోసం, మీరు టెంపోరల్ API కార్యాచరణను అందించడానికి పాలిఫిల్స్‌ను ఉపయోగించవచ్చు. తగిన ఎంపికలను కనుగొనడానికి వెబ్‌లో "టెంపోరల్ API పాలిఫిల్" కోసం శోధించండి.

ముగింపు

జావాస్క్రిప్ట్‌లో తేదీలు మరియు సమయాలను నిర్వహించడంలో జావాస్క్రిప్ట్ టెంపోరల్ API ఒక ముఖ్యమైన ముందడుగును సూచిస్తుంది. దాని ఇమ్మ్యూటబిలిటీ, స్పష్టమైన API, దృఢమైన టైమ్ జోన్ మద్దతు, మరియు క్యాలెండర్ సిస్టమ్ సామర్థ్యాలు విభిన్న అంతర్జాతీయ సందర్భాలలో తేదీలు మరియు సమయాలతో కచ్చితంగా మరియు విశ్వసనీయంగా పనిచేయవలసిన అప్లికేషన్‌లను రూపొందించే డెవలపర్‌లకు ఇది ఒక శక్తివంతమైన సాధనంగా చేస్తుంది. బ్రౌజర్ మద్దతు ఇంకా అభివృద్ధి చెందుతున్నప్పటికీ, టెంపోరల్ API యొక్క ప్రయోజనాలు కొత్త ప్రాజెక్ట్‌ల కోసం నేర్చుకోవడానికి మరియు స్వీకరించడానికి విలువైనవి. టెంపోరల్ APIని స్వీకరించడం మరియు అంతర్జాతీయీకరణ ఉత్తమ పద్ధతులను అనుసరించడం ద్వారా, మీరు ప్రపంచవ్యాప్తంగా ఉన్న వినియోగదారులకు సజావుగా మరియు కచ్చితమైన తేదీ మరియు సమయ అనుభవాన్ని అందించే అప్లికేషన్‌లను సృష్టించవచ్చు.

మరింత నేర్చుకోవడం కోసం