എന്തെങ്കിലും രണ്ട് തീയതികളും സമയങ്ങൾക്കിടയിലെ കൃത്യമായ സമയം വ്യത്യാസം കണക്കാക്കുക. ഈ ലളിതമായ സമയ ഇടവേള കണക്കാക്കലിലൂടെ സെക്കൻഡുകൾ, മിനിറ്റുകൾ, മണിക്കൂറുകൾ, ദിവസങ്ങൾ എന്നിവയിൽ ഫലങ്ങൾ നേടുക.
സമയം ഇടവേള കണക്കുകൂട്ടി എന്നത് രണ്ട് പ്രത്യേക തീയതികളും സമയങ്ങളും തമ്മിലുള്ളElapsed time കൃത്യമായി കണക്കാക്കാൻ രൂപകൽപ്പന ചെയ്ത ശക്തമായ ഉപകരണം ആണ്. നിങ്ങൾക്ക് പ്രോജക്ട് ദൈർഘ്യം നിർണയിക്കേണ്ടതായിരിക്കുകയോ, പ്രായം കണക്കാക്കേണ്ടതായിരിക്കുകയോ, ബില്ലിംഗ് ആവശ്യങ്ങൾക്കായുള്ള സമയ വ്യത്യാസങ്ങൾ അളക്കേണ്ടതായിരിക്കുകയോ, അല്ലെങ്കിൽ ഒരു വരാനിരിക്കുന്ന സംഭവത്തിന് എത്ര സമയം ബാക്കി ഉണ്ടെന്ന് കണ്ടെത്തേണ്ടതായിരിക്കുകയോ ചെയ്യുമ്പോൾ, ഈ കണക്കുകൂട്ടി പല യൂണിറ്റുകളിലായി കൃത്യമായ സമയ ഇടവേളകൾ നൽകുന്നു. ദിവസങ്ങൾ, മാസങ്ങൾ, അല്ലെങ്കിൽ വർഷങ്ങൾക്കിടയിലെ സമയ വ്യത്യാസങ്ങൾ കണക്കാക്കുന്നതിൽ Manual effort ഉം സാധ്യതയുള്ള പിഴവുകളും ഒഴിവാക്കാൻ ഈ ഉപകരണം സങ്കീർണ്ണമായ സമയ കണക്കുകൾ എളുപ്പത്തിൽ വായിക്കാവുന്ന ഫലങ്ങളിലേക്ക് മാറ്റുന്നു.
സമയം ഇടവേള കണക്കാക്കൽ നിരവധി മേഖലകളിൽ ആവശ്യമാണ്, അതിൽ പ്രോജക്ട് മാനേജ്മെന്റ്, ഇവന്റ് പ്ലാനിംഗ്, ബില്ലിംഗ് സിസ്റ്റങ്ങൾ, വ്യക്തിഗത സമയം ട്രാക്കിംഗ് എന്നിവ ഉൾപ്പെടുന്നു. കാൽണ്ടർ സിസ്റ്റങ്ങളുടെ എല്ലാ സങ്കീർണ്ണതകളും, leap years, മാസത്തിന്റെ ദൈർഘ്യ വ്യത്യാസങ്ങൾ, daylight saving time പരിഗണനകൾ എന്നിവയെല്ലാം കണക്കാക്കാൻ നമ്മുടെ കണക്കുകൂട്ടി എപ്പോഴും കൃത്യമായ ഫലങ്ങൾ നൽകുന്നു.
സമയം ഇടവേള കണക്കുകൂട്ടി ഉപയോഗിക്കുന്നത് നേരിയവും മനോഹരവുമായതാണ്:
ആരംഭ തീയതി & സമയം നൽകുക: ആദ്യ ഇൻപുട്ട് ഫീൽഡിൽ ആരംഭിക്കുന്ന തീയതി & സമയം തിരഞ്ഞെടുക്കുക അല്ലെങ്കിൽ ടൈപ്പ് ചെയ്യുക. ഫോർമാറ്റ് YYYY-MM-DD HH:MM (വർഷം-മാസം-ദിവസം മണിക്കൂർ:മിനിറ്റ്) ആയിരിക്കണം.
അവസാന തീയതി & സമയം നൽകുക: രണ്ടാം ഇൻപുട്ട് ഫീൽഡിൽ അവസാന തീയതി & സമയം തിരഞ്ഞെടുക്കുക അല്ലെങ്കിൽ ടൈപ്പ് ചെയ്യുക, ഒരേ ഫോർമാറ്റ് ഉപയോഗിച്ച്.
കണക്കാക്കുക: നിങ്ങളുടെ ഇൻപുട്ടുകൾ പ്രോസസ്സ് ചെയ്യാൻ "കണക്കാക്കുക" ബട്ടൺ ക്ലിക്കുചെയ്യുക. കണക്കുകൂട്ടി ഈ രണ്ട് പോയിന്റുകൾക്കിടയിലെ സമയ വ്യത്യാസം സ്വയം നിർണയിക്കും.
ഫലങ്ങൾ കാണുക: ഫലങ്ങൾ പല യൂണിറ്റുകളിലായി സമയ ഇടവേള കാണിക്കും:
ഫലങ്ങൾ വ്യാഖ്യാനം ചെയ്യുക: സൗകര്യത്തിനായി, ഒരു മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റ് (ഉദാഹരണം, "1 ദിവസം, 5 മണിക്കൂർ, 30 മിനിറ്റ്") നൽകുന്നു.
ഫലങ്ങൾ പകർപ്പിക്കുക: കണക്കാക്കിയ ഫലങ്ങൾ മറ്റ് ആപ്ലിക്കേഷനുകളിലേക്കോ രേഖകളിലേക്കോ എളുപ്പത്തിൽ മാറ്റാൻ പകർപ്പ് ബട്ടൺ ഉപയോഗിക്കുക.
പുനഃസജ്ജമാക്കുക: പുതിയ കണക്കാക്കലുകൾ നടത്താൻ, നിലവിലുള്ള ഇൻപുട്ടുകൾ മാറ്റിയെടുക്കാം അല്ലെങ്കിൽ "പുനഃസജ്ജമാക്കുക" ബട്ടൺ ക്ലിക്കുചെയ്യുക എല്ലാ ഫീൽഡുകളും ക്ലിയർ ചെയ്യാൻ.
കൃത്യമായ കണക്കുകൾക്കായി, നിങ്ങളുടെ തീയതിയും സമയവും നൽകുന്ന ഇൻപുട്ടുകൾ ഈ മാർഗ്ഗനിർദ്ദേശങ്ങൾ പാലിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുക:
കണക്കുകൂട്ടി നിങ്ങളുടെ ഇൻപുട്ടുകൾ സാധുവാണെന്ന് സ്ഥിരീകരിക്കും, ഫോർമാറ്റ് തെറ്റായെങ്കിൽ അല്ലെങ്കിൽ അവസാന തീയതി ആരംഭ തീയതിയേക്കാൾ മുമ്പായാൽ ഒരു പിഴവ് സന്ദേശം കാണിക്കും.
സമയം ഇടവേളകളുടെ കണക്കാക്കൽ ഒരു നേരിയ ഗണിതശാസ്ത്ര സിദ്ധാന്തത്തെ പിന്തുടരുന്നു, എന്നാൽ കാൽണ്ടർ നിയമങ്ങളും സമയ യൂണിറ്റുകൾക്കായുള്ള ശ്രദ്ധാപൂർവമായ കൈകാര്യം ആവശ്യമാണ്. അതിന്റെ അടിസ്ഥാനത്തിൽ, ഫോർമുലയാണ്:
എന്നാൽ, ഈ ലളിതമായ കുറവുകൾ മാസങ്ങളുടെ വ്യത്യാസങ്ങൾ, leap years, വിവിധ സമയ യൂണിറ്റുകൾ എന്നിവ കൈകാര്യം ചെയ്യുമ്പോൾ സങ്കീർണ്ണമാകുന്നു. കണക്കാക്കൽ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ വിശദമായ വിശദീകരണം:
ഒരു സാധാരണ അടിസ്ഥാന യൂണിറ്റിലേക്ക് പരിവർത്തനം ചെയ്യുക: രണ്ട് തീയതികളും ഒരു റഫറൻസ് പോയിന്റ് (സാധാരണയായി 1970 ജനുവരി 1, 00:00:00 UTC, Unix Epoch എന്നറിയപ്പെടുന്നു) മുതൽ മില്ലിസെക്കൻഡുകളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു.
കുറവുകൾ നടത്തുക: രണ്ട് ടൈംസ്റ്റാമ്പുകൾക്കിടയിലെ മില്ലിസെക്കൻഡുകളുടെ വ്യത്യാസം കണക്കാക്കുക.
ആവശ്യമായ യൂണിറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുക:
കണക്കുകൂട്ടി നിരവധി എഡ്ജ് കേസുകൾക്കും പ്രത്യേക പരിഗണനകൾക്കും കൈകാര്യം ചെയ്യുന്നു:
Leap Years: leap years, ഓരോ നാലു വർഷം കൂടെ ഒരു അധിക ദിവസം (ഫെബ്രുവരി 29) കാൽണ്ടറിൽ ചേർക്കുന്നു, കണക്കുകൂട്ടി സ്വയം കൈകാര്യം ചെയ്യുന്നു.
Daylight Saving Time: daylight saving time മാറ്റങ്ങൾക്കിടയിൽ കണക്കാക്കുമ്പോൾ, ഈ മാറ്റങ്ങൾക്കിടയിൽ നഷ്ടമായ മണിക്കൂർ കണക്കാക്കാൻ കണക്കുകൂട്ടി ക്രമീകരിക്കുന്നു.
സമയം മേഖലകൾ: കണക്കുകൂട്ടി നിങ്ങളുടെ ഉപകരണത്തിന്റെ പ്രാദേശിക സമയ മേഖല ഉപയോഗിക്കുന്നു. ക്രോസ്-ടൈം-സോൺ കണക്കാക്കലുകൾക്കായി, എല്ലാ സമയങ്ങളും ഒരു ഏക റഫറൻസ് സമയ മേഖലയിൽ മാറ്റാൻ ശുപാർശ ചെയ്യുന്നു.
നഗATIVE INTERVALS: അവസാന തീയതി ആരംഭ തീയതിയേക്കാൾ മുമ്പായാൽ, കണക്കുകൂട്ടി നിങ്ങൾക്ക് അവസാന തീയതി ആരംഭ തീയതിയേക്കാൾ വൈകിയിരിക്കണമെന്ന് ഉറപ്പാക്കാൻ ഒരു പിഴവ് സന്ദേശം കാണിക്കും.
സമയം ഇടവേള കണക്കുകൂട്ടി വിവിധ മേഖലകളിലും ദൈനംദിന സാഹചര്യങ്ങളിലും നിരവധി പ്രായോഗിക ആവശ്യങ്ങൾക്കായി സേവിക്കുന്നു:
ഞങ്ങളുടെ സമയ ഇടവേള കണക്കുകൂട്ടി, ഏറ്റവും കൂടുതൽ ആവശ്യങ്ങൾക്കായി സമഗ്രമായ പ്രവർത്തനക്ഷമത നൽകുന്നു, എന്നാൽ ചില പ്രത്യേക ആവശ്യങ്ങൾക്കായി മാറ്റങ്ങൾ ഉണ്ട്:
കാൽണ്ടർ ആപ്ലിക്കേഷനുകൾ: നിരവധി കാൽണ്ടർ ആപ്പുകൾ (Google Calendar, Microsoft Outlook) ഇവന്റുകളുടെ ദൈർഘ്യം കണക്കാക്കാൻ കഴിയും, എന്നാൽ സാധാരണയായി കൂടുതൽ വിശദമായ കണക്കുകൾ നൽകുന്നില്ല.
സ്പ്രഡ്‌ഷീറ്റ് ഫോർമുലകൾ: Excel അല്ലെങ്കിൽ Google Sheets പോലുള്ള പ്രോഗ്രാമുകൾ തീയതി/സമയം പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് കസ്റ്റം സമയ കണക്കുകൾ അനുവദിക്കുന്നു, എന്നാൽ മാനുവൽ ഫോർമുല നിർമ്മാണം ആവശ്യമാണ്.
പ്രോഗ്രാമിംഗ് ലൈബ്രറികൾ: ഡെവലപ്പർമാർക്കായി, Moment.js (JavaScript), datetime (Python), അല്ലെങ്കിൽ Joda-Time (Java) പോലുള്ള ലൈബ്രറികൾ ആധുനിക സമയം കൈകാര്യം ചെയ്യൽ കഴിവുകൾ നൽകുന്നു.
വിദിഷ്യമായ വ്യവസായ ഉപകരണങ്ങൾ: ചില വ്യവസായങ്ങൾക്ക് അവരുടെ ആവശ്യങ്ങൾക്ക് പ്രത്യേകിച്ചും സമയ കണക്കുകൾ ഉൾപ്പെടുന്ന ഉപകരണങ്ങൾ ഉണ്ട് (ഉദാഹരണം, പ്രോജക്ട് മാനേജ്മെന്റ് സോഫ്റ്റ്വെയർ, ബില്ലിംഗ് സിസ്റ്റങ്ങൾ).
ശാരീരിക കണക്കുകൂട്ടികൾ: ചില ശാസ്ത്രീയ കണക്കുകൂട്ടികൾ തീയതി കണക്കാക്കൽ പ്രവർത്തനങ്ങൾ ഉൾക്കൊള്ളുന്നു, എന്നാൽ ഡിജിറ്റൽ പരിഹാരങ്ങൾക്കേക്കാൾ കുറവായ സവിശേഷതകൾ നൽകുന്നു.
വിവിധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ സമയ ഇടവേളകൾ കണക്കാക്കുന്നതിന്റെ ഉദാഹരണങ്ങൾ ഇവിടെ ഉണ്ട്:
1' Excel ഫോർമുല, A1 & B1 ൽ തീയതികൾക്കിടയിലെ സമയം വ്യത്യാസം കണക്കാക്കാൻ
2' A1 & B1 ൽ തീയതികൾക്കിടയിലെ വ്യത്യാസം കണക്കാക്കാൻ സെല്ലുകളിൽ ഇടുക
3
4' ദിവസങ്ങൾ:
5=INT(B1-A1)
6
7' മണിക്കൂറുകൾ:
8=INT((B1-A1)*24)
9
10' മിനിറ്റുകൾ:
11=INT((B1-A1)*24*60)
12
13' സെക്കൻഡുകൾ:
14=INT((B1-A1)*24*60*60)
15
16' കൂടുതൽ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റിനായി:
17=INT(B1-A1) & " ദിവസങ്ങൾ, " &
18 HOUR(MOD(B1-A1,1)) & " മണിക്കൂറുകൾ, " &
19 MINUTE(MOD(B1-A1,1)) & " മിനിറ്റുകൾ, " &
20 SECOND(MOD(B1-A1,1)) & " സെക്കൻഡുകൾ"
211// രണ്ട് തീയതികൾക്കിടയിലെ സമയ ഇടവേള കണക്കാക്കാൻ JavaScript ഫംഗ്ഷൻ
2function calculateTimeInterval(startDate, endDate) {
3 // ആവശ്യമായാൽ, സ്റ്റ്രിംഗ് ഇൻപുട്ടുകൾ Date ഒബ്ജക്റ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുക
4 if (typeof startDate === 'string') {
5 startDate = new Date(startDate);
6 }
7 if (typeof endDate === 'string') {
8 endDate = new Date(endDate);
9 }
10
11 // മില്ലിസെക്കൻഡുകളിൽ വ്യത്യാസം കണക്കാക്കുക
12 const diffInMs = endDate - startDate;
13
14 // മറ്റ് യൂണിറ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുക
15 const seconds = Math.floor(diffInMs / 1000);
16 const minutes = Math.floor(seconds / 60);
17 const hours = Math.floor(minutes / 60);
18 const days = Math.floor(hours / 24);
19
20 // മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റിനായി ശേഷിക്കുന്ന മൂല്യങ്ങൾ കണക്കാക്കുക
21 const remainderHours = hours % 24;
22 const remainderMinutes = minutes % 60;
23 const remainderSeconds = seconds % 60;
24
25 // വിവിധ ഫോർമാറ്റുകളിൽ ഫലങ്ങൾ നൽകുക
26 return {
27 milliseconds: diffInMs,
28 seconds: seconds,
29 minutes: minutes,
30 hours: hours,
31 days: days,
32 humanReadable: `${days} ദിവസങ്ങൾ, ${remainderHours} മണിക്കൂറുകൾ, ${remainderMinutes} മിനിറ്റുകൾ, ${remainderSeconds} സെക്കൻഡുകൾ`
33 };
34}
35
36// ഉദാഹരണ ഉപയോഗം:
37const start = new Date('2023-05-20T10:00:00');
38const end = new Date('2023-05-25T16:30:45');
39const interval = calculateTimeInterval(start, end);
40console.log(interval.humanReadable); // "5 ദിവസങ്ങൾ, 6 മണിക്കൂറുകൾ, 30 മിനിറ്റുകൾ, 45 സെക്കൻഡുകൾ"
411from datetime import datetime
2
3def calculate_time_interval(start_datetime, end_datetime):
4 """
5 രണ്ട് datetime ഒബ്ജക്റ്റുകൾക്കിടയിലെ സമയ ഇടവേള കണക്കാക്കുക.
6
7 Args:
8 start_datetime (datetime): ആരംഭിക്കുന്ന തീയതി & സമയം
9 end_datetime (datetime): അവസാന തീയതി & സമയം
10
11 Returns:
12 dict: വിവിധ യൂണിറ്റുകളിൽ സമയ ഇടവേളയും മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റും
13 """
14 # വ്യത്യാസം കണക്കാക്കുക
15 time_diff = end_datetime - start_datetime
16
17 # ഘടകങ്ങൾ എടുക്കുക
18 total_seconds = time_diff.total_seconds()
19 days = time_diff.days
20
21 # മണിക്കൂറുകൾ, മിനിറ്റുകൾ, സെക്കൻഡുകൾ കണക്കാക്കുക
22 hours = total_seconds // 3600
23 minutes = total_seconds // 60
24
25 # മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റിനായി ശേഷിക്കുന്ന മൂല്യങ്ങൾ കണക്കാക്കുക
26 remainder_hours = int((total_seconds % 86400) // 3600)
27 remainder_minutes = int((total_seconds % 3600) // 60)
28 remainder_seconds = int(total_seconds % 60)
29
30 # മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന സ്റ്റ്രിംഗ് നിർമ്മിക്കുക
31 human_readable = f"{days} ദിവസങ്ങൾ, {remainder_hours} മണിക്കൂറുകൾ, {remainder_minutes} മിനിറ്റുകൾ, {remainder_seconds} സെക്കൻഡുകൾ"
32
33 return {
34 "seconds": total_seconds,
35 "minutes": minutes,
36 "hours": hours,
37 "days": days,
38 "human_readable": human_readable
39 }
40
41# ഉദാഹരണ ഉപയോഗം
42start = datetime(2023, 5, 20, 10, 0, 0)
43end = datetime(2023, 5, 25, 16, 30, 45)
44interval = calculate_time_interval(start, end)
45print(interval["human_readable"]) # "5 ദിവസങ്ങൾ, 6 മണിക്കൂറുകൾ, 30 മിനിറ്റുകൾ, 45 സെക്കൻഡുകൾ"
461import java.time.Duration;
2import java.time.LocalDateTime;
3import java.time.format.DateTimeFormatter;
4
5public class TimeIntervalCalculator {
6 public static void main(String[] args) {
7 // ഉദാഹരണ ഉപയോഗം
8 LocalDateTime startDateTime = LocalDateTime.parse("2023-05-20T10:00:00");
9 LocalDateTime endDateTime = LocalDateTime.parse("2023-05-25T16:30:45");
10
11 TimeInterval interval = calculateTimeInterval(startDateTime, endDateTime);
12 System.out.println(interval.getHumanReadable());
13 }
14
15 public static TimeInterval calculateTimeInterval(LocalDateTime startDateTime, LocalDateTime endDateTime) {
16 // രണ്ട് തീയതികൾക്കിടയിലെ ദൈർഘ്യം കണക്കാക്കുക
17 Duration duration = Duration.between(startDateTime, endDateTime);
18
19 // വ്യത്യാസത്തിലെ മൂല്യങ്ങൾ എടുക്കുക
20 long totalSeconds = duration.getSeconds();
21 long days = totalSeconds / (24 * 3600);
22 long hours = (totalSeconds % (24 * 3600)) / 3600;
23 long minutes = (totalSeconds % 3600) / 60;
24 long seconds = totalSeconds % 60;
25
26 // മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റ് നിർമ്മിക്കുക
27 String humanReadable = String.format("%d ദിവസങ്ങൾ, %d മണിക്കൂറുകൾ, %d മിനിറ്റുകൾ, %d സെക്കൻഡുകൾ",
28 days, hours, minutes, seconds);
29
30 // എല്ലാ കണക്കാക്കിയ മൂല്യങ്ങൾ അടങ്ങിയ ഒരു കസ്റ്റം ഒബ്ജക്റ്റ് തിരിച്ചറിയുക
31 return new TimeInterval(
32 totalSeconds,
33 totalSeconds / 60.0,
34 totalSeconds / 3600.0,
35 totalSeconds / (24.0 * 3600),
36 humanReadable
37 );
38 }
39
40 // ഫലത്തെ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഇൻർ ക്ലാസ്
41 static class TimeInterval {
42 private final double seconds;
43 private final double minutes;
44 private final double hours;
45 private final double days;
46 private final String humanReadable;
47
48 public TimeInterval(double seconds, double minutes, double hours, double days, String humanReadable) {
49 this.seconds = seconds;
50 this.minutes = minutes;
51 this.hours = hours;
52 this.days = days;
53 this.humanReadable = humanReadable;
54 }
55
56 // ഗേറ്റർസ്
57 public double getSeconds() { return seconds; }
58 public double getMinutes() { return minutes; }
59 public double getHours() { return hours; }
60 public double getDays() { return days; }
61 public String getHumanReadable() { return humanReadable; }
62 }
63}
641<?php
2/**
3 * രണ്ട് തീയതികൾക്കിടയിലെ സമയ ഇടവേള കണക്കാക്കുക
4 *
5 * @param string|DateTime $startDateTime ആരംഭിക്കുന്ന തീയതി & സമയം
6 * @param string|DateTime $endDateTime അവസാന തീയതി & സമയം
7 * @return array വിവിധ യൂണിറ്റുകളിൽ സമയ ഇടവേള
8 */
9function calculateTimeInterval($startDateTime, $endDateTime) {
10 // ആവശ്യമായാൽ, സ്റ്റ്രിംഗ് ഇൻപുട്ടുകൾ DateTime ഒബ്ജക്റ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുക
11 if (is_string($startDateTime)) {
12 $startDateTime = new DateTime($startDateTime);
13 }
14 if (is_string($endDateTime)) {
15 $endDateTime = new DateTime($endDateTime);
16 }
17
18 // വ്യത്യാസം കണക്കാക്കുക
19 $interval = $endDateTime->diff($startDateTime);
20
21 // വ്യത്യാസത്തിലെ മൂല്യങ്ങൾ കണക്കാക്കുക
22 $totalSeconds = $interval->days * 24 * 60 * 60 +
23 $interval->h * 60 * 60 +
24 $interval->i * 60 +
25 $interval->s;
26 $totalMinutes = $totalSeconds / 60;
27 $totalHours = $totalMinutes / 60;
28 $totalDays = $totalHours / 24;
29
30 // മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റ് നിർമ്മിക്കുക
31 $humanReadable = sprintf(
32 "%d ദിവസങ്ങൾ, %d മണിക്കൂറുകൾ, %d മിനിറ്റുകൾ, %d സെക്കൻഡുകൾ",
33 $interval->days,
34 $interval->h,
35 $interval->i,
36 $interval->s
37 );
38
39 return [
40 'seconds' => $totalSeconds,
41 'minutes' => $totalMinutes,
42 'hours' => $totalHours,
43 'days' => $totalDays,
44 'human_readable' => $humanReadable
45 ];
46}
47
48// ഉദാഹരണ ഉപയോഗം
49$start = '2023-05-20 10:00:00';
50$end = '2023-05-25 16:30:45';
51$interval = calculateTimeInterval($start, $end);
52echo $interval['human_readable']; // "5 ദിവസങ്ങൾ, 6 മണിക്കൂറുകൾ, 30 മിനിറ്റുകൾ, 45 സെക്കൻഡുകൾ"
53?>
54സമയം ഇടവേള കണക്കുകൂട്ടി മില്ലിസെക്കൻഡ് കൃത്യതയോടെ ഫലങ്ങൾ നൽകുന്നു. leap years, മാസത്തിന്റെ ദൈർഘ്യ വ്യത്യാസങ്ങൾ, daylight saving time മാറ്റങ്ങൾ എന്നിവയെല്ലാം പരിഗണിച്ച് കൃത്യമായ കണക്കുകൾ ഉറപ്പാക്കുന്നു.
കണക്കുകൂട്ടി എല്ലാ കണക്കുകളിലും നിങ്ങളുടെ ഉപകരണത്തിന്റെ പ്രാദേശിക സമയ മേഖല ഉപയോഗിക്കുന്നു. ക്രോസ്-ടൈം-സോൺ കണക്കാക്കലുകൾക്കായി, രണ്ട് സമയങ്ങളും ഒരേ സമയ മേഖലയിൽ പരിവർത്തനം ചെയ്യേണ്ടതുണ്ട്. അല്ലെങ്കിൽ, രണ്ട് ഇൻപുട്ടുകൾക്കും UTC (Coordinated Universal Time) ഉപയോഗിക്കുന്നത് സമയ മേഖല വ്യത്യാസങ്ങൾ ഒഴിവാക്കാൻ ശുപാർശ ചെയ്യുന്നു.
daylight saving time മാറ്റങ്ങൾക്കിടയിൽ കണക്കാക്കുമ്പോൾ, കണക്കുകൂട്ടി ഈ മാറ്റങ്ങൾക്കിടയിൽ നഷ്ടമായ മണിക്കൂർ കണക്കാക്കാൻ ക്രമീകരിക്കുന്നു. daylight saving time മാറ്റങ്ങൾക്കിടയിൽ കണക്കാക്കുമ്പോൾ, കണക്കുകൂട്ടി ഈ മാറ്റങ്ങൾക്കിടയിൽ നഷ്ടമായ മണിക്കൂർ കണക്കാക്കാൻ ക്രമീകരിക്കുന്നു.
1970 ജനുവരി 1 മുതൽ 2099 ഡിസംബർ 31 വരെ തീയതികൾ കണക്കാക്കാൻ കണക്കുകൂട്ടി 130 വർഷത്തിലധികം ദൈർഘ്യം നൽകുന്നു. ഇത് കൃത്യതയോടെ മുഴുവൻ പരിധി ഉൾക്കൊള്ളുന്നു.
അതെ, നിങ്ങൾക്ക് ജനന തീയതി & സമയത്തെ ആരംഭ തീയതിയായി നൽകുകയും നിലവിലെ തീയതി & സമയത്തെ അവസാന തീയതിയായി നൽകുകയും ചെയ്യുന്നതിലൂടെ ആരെയെങ്കിലും കൃത്യമായ പ്രായം കണക്കാക്കാൻ കഴിയും. ഫലം വർഷങ്ങൾ, മാസങ്ങൾ, ദിവസങ്ങൾ, മണിക്കൂറുകൾ, സെക്കൻഡുകൾ എന്നിവയിൽ പ്രായം കാണിക്കും.
കണക്കുകൂട്ടി അവസാന തീയതി ആരംഭ തീയതിയേക്കാൾ മുമ്പായിരിക്കണം. നിങ്ങൾക്ക് "നെഗറ്റീവ്" ഇടവേള (അഥവാ, ഒരു നൽകിയ തീയതിക്ക് മുമ്പുള്ള എത്ര സമയം) കണക്കാക്കേണ്ടതുണ്ടെങ്കിൽ, ആരംഭ & അവസാന തീയതികൾ മാറ്റുക, ഫലത്തെ നെഗറ്റീവ് മൂല്യം എന്ന നിലയിൽ വ്യാഖ്യാനിക്കുക.
കണക്കുകൂട്ടി leap seconds പരിഗണിക്കുന്നില്ല, Earth's irregular rotation നയിക്കുന്നതിനാൽ UTC-യിൽ ഇടയ്ക്കിടെ ചേർക്കപ്പെടുന്ന സെക്കൻഡുകൾ. എന്നാൽ, കൂടുതൽ പ്രായോഗിക ആവശ്യങ്ങൾക്കായി, ഈ ഒഴിവാക്കലിന് ഫലങ്ങളിൽ ലഘുവായ സ്വാധീനം ഉണ്ടാകും.
അടിസ്ഥാന കണക്കുകൂട്ടി കാലണ്ടർ സമയത്തിൽ (വാരാന്ത്യങ്ങളും അവധികളും ഉൾപ്പെടുന്നു) ഫലങ്ങൾ നൽകുന്നു. ജോലി ദിവസങ്ങൾക്കായുള്ള കണക്കുകൾക്കായി, അവധി ദിവസങ്ങളും അവധി ദിവസങ്ങളും ഒഴിവാക്കുന്ന പ്രത്യേക ബിസിനസ് ദിവസ കണക്കുകൂട്ടിയെ ഉപയോഗിക്കാൻ ശുപാർശ ചെയ്യുന്നു.
Fractional days ഭാഗിക ദിവസങ്ങളെ പ്രതിനിധീകരിക്കുന്നു. ഉദാഹരണത്തിന്, 5.5 ദിവസങ്ങൾ 5 ദിവസം & 12 മണിക്കൂർ (അർദ്ധ ദിവസം) എന്നതിനെ സൂചിപ്പിക്കുന്നു. കൂടുതൽ മനോഹരമായ മനസ്സിലാക്കലിന്, ഫലങ്ങളോടൊപ്പം നൽകിയ മനുഷ്യൻ വായിക്കാൻ കഴിയുന്ന ഫോർമാറ്റ് കാണുക.
കണക്കുകൂട്ടി നേരിട്ട് സെക്കൻഡുകൾ, മിനിറ്റുകൾ, മണിക്കൂറുകൾ, ദിവസങ്ങൾ എന്നിവയിൽ ഫലങ്ങൾ നൽകുന്നു. ഇത് ആഴ്ചകൾ, മാസങ്ങൾ, അല്ലെങ്കിൽ വർഷങ്ങൾ വ്യക്തമാക്കുന്നില്ല, എന്നാൽ നിങ്ങൾ ഈ മൂല്യങ്ങൾ കണ്ടെത്താൻ കഴിയും:
മാസങ്ങൾ & വർഷങ്ങൾ വ്യത്യാസമുള്ള മാസ ദൈർഘ്യങ്ങൾ & leap year പരിഗണനകൾ കാരണം ഏകദേശം കണക്കാക്കപ്പെടുന്നു.
Dershowitz, N., & Reingold, E. M. (2008). Calendrical Calculations. Cambridge University Press.
Seidelmann, P. K. (Ed.). (1992). Explanatory Supplement to the Astronomical Almanac. University Science Books.
Richards, E. G. (2013). Mapping Time: The Calendar and its History. Oxford University Press.
National Institute of Standards and Technology. (2022). Time and Frequency Division. https://www.nist.gov/time-distribution
International Earth Rotation and Reference Systems Service. (2021). Leap Seconds. https://www.iers.org/IERS/EN/Science/EarthRotation/LeapSecond.html
ഇന്ന് നമ്മുടെ സമയം ഇടവേള കണക്കുകൂട്ടി പരീക്ഷിക്കൂ, ഏതൊരു രണ്ട് തീയതികളും സമയങ്ങൾക്കിടയിലെ സമയം കൃത്യമായി & എളുപ്പത്തിൽ നിർണയിക്കാൻ. പ്രൊഫഷണൽ പ്രോജക്ട് മാനേജ്മെന്റ്, വ്യക്തിഗത പ്ലാനിംഗ്, അല്ലെങ്കിൽ സമയ ഇടവേളകളെക്കുറിച്ച് നിങ്ങളുടെ ആഗ്രഹം നിറവേറ്റാൻ, ഈ ഉപകരണം നിങ്ങൾക്ക് ആവശ്യമായ കൃത്യമായ ഉത്തരങ്ങൾ നൽകുന്നു, പല എളുപ്പത്തിൽ വായിക്കാവുന്ന ഫോർമാറ്റുകളിൽ.
നിങ്ങളുടെ പ്രവർത്തനത്തിന് ഉപയോഗപ്പെടുന്ന കൂടുതൽ ഉപകരണങ്ങൾ കണ്ടെത്തുക.