ජාවාස්ක්රිප්ට් හි කාලරාමුව ලබා ගන්නේ කෙසේද?
යුනික්ස් කාලරාමුව හා සමාන දෙයක් , එනම් වර්තමාන වේලාව හා දිනය නියෝජනය කරන තනි අංකයකි. එක්කෝ අංකයක් හෝ නූලක් ලෙස.
ජාවාස්ක්රිප්ට් හි කාලරාමුව ලබා ගන්නේ කෙසේද?
යුනික්ස් කාලරාමුව හා සමාන දෙයක් , එනම් වර්තමාන වේලාව හා දිනය නියෝජනය කරන තනි අංකයකි. එක්කෝ අංකයක් හෝ නූලක් ලෙස.
Answers:
+ new Date()
වැනි ඒකීය ක්රියාකරුවෙකු වස්තුවෙහි ක්රමය plus
අවුලුවන අතර එය කාලරාමුව නැවත ලබා දෙයි (කිසිදු වෙනස් කිරීමකින් තොරව).valueOf
Date
විස්තර:
දැනට පවතින සියලුම බ්රව්සර්වල Date.now()
යූටීසී කාලරාමුව මිලි තත්පර වලින් ලබා ගැනීමට ඔබට භාවිතා කළ හැකිය ; මෙයට සැලකිය යුතු ව්යතිරේකයක් වන්නේ IE8 සහ ඊට පෙර ( අනුකූලතා වගුව බලන්න ).
ඔබට පහසුවෙන් මේ සඳහා දිලිසීමක් කළ හැකිය, නමුත්:
if (!Date.now) {
Date.now = function() { return new Date().getTime(); }
}
තත්පර කිහිපයකින් කාලරාමුව ලබා ගැනීම සඳහා , ඔබට මෙය භාවිතා කළ හැකිය:
Math.floor(Date.now() / 1000)
හෝ විකල්පයක් ලෙස ඔබට භාවිතා කළ හැකිය:
Date.now() / 1000 | 0
ඒවා තරමක් වේගවත් විය යුතු අතර කියවිය නොහැකි තරම් අඩු විය යුතුය ( මෙම පිළිතුරද බලන්න ).
භාවිතා කිරීමට මම නිර්දේශ කරමි Date.now()
(අනුකූලතා ෂිම් සමඟ). එය කෙටි නිසා නව Date
වස්තුවක් නිර්මාණය නොවන නිසා එය තරමක් හොඳය . කෙසේ වෙතත්, ඔබට ෂිම් සහ උපරිම අනුකූලතාවයක් අවශ්ය නොවන්නේ නම්, කාලරාමුව මිලි තත්පර වලින් ලබා ගැනීමට ඔබට "පැරණි" ක්රමය භාවිතා කළ හැකිය :
new Date().getTime()
ඔබට මේ වගේ තත්පර වලට පරිවර්තනය කළ හැකි:
Math.round(new Date().getTime()/1000)
valueOf
අප ඉහත පෙන්වා දුන් ක්රමයද ඔබට භාවිතා කළ හැකිය :
new Date().valueOf()
මිලි තත්පරවල කාලරාමුව
var timeStampInMs = window.performance && window.performance.now && window.performance.timing && window.performance.timing.navigationStart ? window.performance.now() + window.performance.timing.navigationStart : Date.now();
console.log(timeStampInMs, Date.now());
Date.now() / 1000 | 0
මේ පෙළෙන 2038 වසරේ ප්රශ්නය ? new Date('Jan 1, 2039') / 1000 | 0 == -2117514496
~~(Date.now() / 1000)
Date.now()
+new Data
දක්ෂ වන අතර, එය අනෙකුත් devs කියවිය හැකි නොවේ. Date.now()
පැහැදිලි වන අතර සිදුවන්නේ කුමක්ද යන්න අනෙක් සියල්ලන්ම දන්නා බව සහතික කරයි.
මම මේකට කැමතියි, එය කුඩා නිසා:
+new Date
මමත් මේකට කැමතියි, මන්ද එය කෙටි හා නවීන බ්රව්සර් සමඟ අනුකූල වන අතර 500 කට අධික පිරිසක් ඡන්දය ප්රකාශ කිරීම වඩා හොඳ බව:
Date.now()
new Date().getTime()
. වාසනාවකට මෙන්, වේගවත් විසඳුම දැනටමත් පැහැදිලි විසඳුමයි!
new Date().toString()
හැඳින්වේ.
+
යුතුව එය නූලක් මෙන් පිටතට ගෙන ඒමට ක්රියාකරු කරන්නේ කුමක්ද?
ජාවාස්ක්රිප්ට් යුගයේ සිට මිලි තත්පර ගණන සමඟ ක්රියා කරන අතර අනෙක් බොහෝ භාෂා තත්පර සමඟ ක්රියා කරයි. ඔබට මිලි තත්පර සමඟ වැඩ කළ හැකි නමුත් ඔබ PHP යැයි පැවසීමට අගයක් පසු කළ විට, PHP ස්වදේශීය කාර්යයන් අසාර්ථක වනු ඇත. ඒ නිසා මම සෑම විටම භාවිතා කරන්නේ තත්පර, මිලි තත්පර නොවේ.
මෙය ඔබට යුනික්ස් කාලරාමුව ලබා දෙනු ඇත (තත්පර වලින්):
var unix = Math.round(+new Date()/1000);
මෙය යුගයේ සිට මිලි තත්පර ලබා දෙනු ඇත (යුනික්ස් කාලරාමුව නොවේ):
var milliseconds = new Date().getTime();
Unix timestamp
එදිරිව Seconds since the Epoch
. මේ දෙදෙනා එකම දේ අදහස් කළ යුතු නොවේද?
var time = Date.now || function() {
return +new Date;
};
time();
මෙම පිළිතුරේ විස්තර සහිතව මම විවිධ විසඳුම් ලබා දෙමි.
PS අපැහැදිලි යමක් තිබේ නම් ප්රශ්න ඇසීමට නිදහස් වන්න .
ඉක්මන් හා අපිරිසිදු විසඳුම:
Date.now() /1000 |0
අවවාදයයි : එය 2038 දී බිඳී ඔබ මැජික් කළහොත් negative ණ සංඛ්යා ආපසු ලබා දිය හැකිය
|0
.Math.floor()
ඒ වන විට ඒ වෙනුවට භාවිතා කරන්න
Math.floor()
විසඳුමක්:
Math.floor(Date.now() /1000);
ඩෙරෙක් විසින් කරන ලද සමහර අශෝභන විකල්පයන් 朕 this this මෙම පිළිතුරට පහත දැක්වෙන අදහස් වලින් ලබාගෙන ඇත:
new Date/1e3|0
Date.now()
වැඩ කිරීමට පොලිෆිල් :
එය IE හි වැඩ කිරීම සඳහා ඔබට මෙය කළ හැකිය ( MDN වෙතින් පොලිෆිල් ):
if (!Date.now) {
Date.now = function now() {
return new Date().getTime();
};
}
සතියේ වර්ෂය / දිනය / දිවා ආලෝකය ඉතිරි කිරීමේ කාලය ගැන ඔබ තැකීමක් නොකරන්නේ නම් ඔබට එය ඉවත් කර 2038 න් පසු මෙය භාවිතා කළ හැකිය:
var now = (function () {
var year = new Date(new Date().getFullYear().toString()).getTime();
return function () {
return Date.now() - year
}
})();
එය පෙනෙන්නේ කෙසේද යන්න පිළිබඳ සමහර ප්රතිදානය:
new Date() Thu Oct 29 2015 08:46:30 GMT+0100 (Mitteleuropäische Zeit ) new Date(now()) Thu Oct 29 1970 09:46:30 GMT+0100 (Mitteleuropäische Zeit )
ඇත්ත වශයෙන්ම එය දිවා ආලෝකය ඉතිරි කිරීමේ කාලය බිඳ දමනු ඇති නමුත් ඔබ ගොඩනඟන දේ අනුව 2038 දී int32 බිඳී යාමෙන් පසු කාලරාමු මත ද්විමය මෙහෙයුම් කිරීමට ඔබට අවශ්ය නම් මෙය ඔබට ප්රයෝජනවත් වනු ඇත.
මෙයද negative ණාත්මක අගයන් ලබා දෙනු ඇත, නමුත් ඔබ ඔබේ කේතය ක්රියාත්මක කරන පරිගණකයේ පරිශීලකයා ඔවුන්ගේ පරිගණකයේ ඔරලෝසුව අවම වශයෙන් පෙර වසරේ දෙසැම්බර් 31 වනදා දක්වා වෙනස් කරන්නේ නම් පමණි.
කේතය මුලින් ක්රියාත්මක වූ මොහොතේ සිට ඔබට සාපේක්ෂ වේලාව දැන ගැනීමට අවශ්ය නම් ඔබට මේ වගේ දෙයක් භාවිතා කළ හැකිය:
var relativeTime = (function () {
var start = Date.now();
return function () {
return Date.now() - start
}
})();
ඔබ jQuery භාවිතා $.now()
කරන්නේ නම්, jQuery හි ලියකියවිලි වල විස්තර කර ඇති පරිදි භාවිතා කළ හැකි අතර එමඟින් $.now()
අභ්යන්තරව එකම දේ කරන බැවින් පොලිෆිල් යල් පැන යයි .(new Date).getTime()
JQuery හි අනුවාදය ගැන ඔබ සතුටු වන්නේ නම්, මෙම පිළිතුර මා විසින්ම සොයා නොගත් බැවින් එය ඉහළ නැංවීම ගැන සලකා බලන්න .
දැන් |0
කරන්නේ කුමක්ද යන්න පිළිබඳ කුඩා පැහැදිලි කිරීමක්:
ලබා දීමෙන් |
, ඔබ ද්විමය හෝ මෙහෙයුමක් කිරීමට පරිවර්තකයාට කියයි. බිට් මෙහෙයුම් සඳහා දශම Date.now() / 1000
ප්රති result ලය පූර්ණ සංඛ්යාවක් බවට හරවන නිරපේක්ෂ සංඛ්යා අවශ්ය වේ .
එම පරිවර්තනය අතරතුර, දශම ඉවත් කරනු ලැබේ, එහි ප්රති result ලය වන්නේ Math.floor()
අඩු කේතයක් භාවිතා කිරීමයි.
කෙසේ වෙතත් අනතුරු අඟවන්න: එය බිට් 64 ද්විත්ව ද්විත්ව 32 බිටු සංඛ්යාවක් බවට පරිවර්තනය කරයි. මෙය විශාල සංඛ්යාවක් සමඟ ගනුදෙනු කිරීමේදී තොරතුරු නැතිවීමට හේතු වේ. බිට් 32 පූර්ණ සංඛ්යා පිටාර ගැලීම හේතුවෙන් 2038 න් පසු කාලරාමු කැඩී යනු ඇත.
Date.now
මෙම සබැඳිය අනුගමනය කිරීම පිළිබඳ වැඩි විස්තර සඳහා : Date.now()
@ එම්.ඩී.එන්
Date.now()
විමර්ශන developer.mozilla.org/en-US/docs/JavaScript/Reference/...
new Date/1e3|0
.
කාලරාමුව ලබා ගැනීම සඳහා jQuery තමන්ගේම ක්රමයක් සපයයි :
var timestamp = $.now();
(ඊට අමතරව (new Date).getTime()
ප්රකාශනය ක්රියාත්මක කරයි)
parseInt
ලෙස ලැබෙන අගය සැමවිටම a Number
.
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
+new Date
.. :)
Date.now()
අනෙක් විකල්ප වලට අමතරව, ඔබට දින ආකෘති ISO අවශ්ය නම්, ඔබට එය කෙලින්ම ලබා ගත හැකිය
console.log(new Date().toISOString());
new Date("2017-05-04T07:11:28.940Z") - new Date("2017-05-04T07:11:14.092Z")
එකතු කිරීම සඳහා, ජාවාස්ක්රිප්ට් හි කාලරාමුව නැවත ලබා දීම සඳහා ශ්රිතයක් මෙහි ඇත. උදාහරණය: 15:06:38 ප.ව.
function displayTime() {
var str = "";
var currentTime = new Date()
var hours = currentTime.getHours()
var minutes = currentTime.getMinutes()
var seconds = currentTime.getSeconds()
if (minutes < 10) {
minutes = "0" + minutes
}
if (seconds < 10) {
seconds = "0" + seconds
}
str += hours + ":" + minutes + ":" + seconds + " ";
if(hours > 11){
str += "PM"
} else {
str += "AM"
}
return str;
}
දිනය , ස්වදේශීය වස්තුවකි ජාවාස්ක්රිප්ට් වන්නේ කාලය පිළිබඳ සියලු දත්ත අපට ලැබෙන ක්රමයයි.
ජාවාස්ක්රිප්ට් හි ප්රවේශම් වන්න කාලරාමුව සේවාදායක පරිගණක කට්ටලය මත රඳා පවතී, එබැවින් එය 100% නිවැරදි කාලරාමුව නොවේ. හොඳම ප්රති result ලය ලබා ගැනීම සඳහා, ඔබ සේවාදායකයාගේ පැත්තෙන් කාලරාමුව ලබා ගත යුතුය .
කෙසේ වෙතත්, මම කැමතිම ක්රමය වන්නේ වැනිලා භාවිතා කිරීමයි. මෙය ජාවාස්ක්රිප්ට් හි පොදු ක්රමයක් වේ:
Date.now(); //return 1495255666921
එම්ඩීඑන් හි එය පහත පරිදි වේ:
Date.now () ක්රමය මඟින් 1970 ජනවාරි 1 වන දින සිට ගත වූ මිලි තත්පර ගණන නැවත ලබා දෙයි 00:00:00 UTC.
දැන් () දිනයෙහි ස්ථිතික ක්රමයක් වන නිසා, ඔබ එය සැමවිටම භාවිතා කරන්නේ Date.now () ලෙස ය.
ඔබ ES5 ට පහළින් අනුවාදයක් භාවිතා කරන්නේ නම්, Date.now();
ක්රියා නොකරන අතර ඔබ භාවිතා කළ යුත්තේ:
new Date().getTime();
මම තවම දැක නැති එකක්
Math.floor(Date.now() / 1000); // current time in seconds
මම තවම දැක නැති තවත් එකක්
var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();
Date.now() /1000 |0
මීට පෙරද පිළිතුරු දී ඇත
Math.floor()
එය සංස්කරණය කර ඇති නමුත් එය සමාන බලපෑමක් ඇති බව පැහැදිලි කිරීමට පමණි |0
. මට ඔබට හෝ කිසිම දෙයකට රිදවීමට අවශ්ය නොවීය. මට ඔබට කියන්නට අවශ්ය වූයේ ඔබේ පිළිතුර යම් ආකාරයකින් දැනටමත් පවතින බවයි. ලබා දී ඇති සියලුම පිළිතුරු දෙස බැලීමෙන් යම් ආකාරයකින් දැනුම් දෙන සමහරක් තිබේ.
_.now()
කිරීම සඳහා ආනයනය කිරීම ටිකක් අධික ලෙස මරා දැමීමකි . මම නිර්දේශ කරන්නේ ඔබ භාවිතා කිරීමට අවශ්ය ලොඩාෂ් ක්රියාකාරිත්වය ආනයනය කිරීම පමණි (මේ අවස්ථාවේ දී, එන්පීඑම් හි _.now () ), නමුත් ඔවුන් පවා ඔවුන්ගේ පැකේජය නිකම්ම භාවිතා කිරීමට අකමැති වී ඇත Date.now()
.
මෙම Date.getTime()
ක්රමය කුඩා වෙනස් කිරීමකින් භාවිතා කළ හැකිය:
GetTime ක්රමවේදය මඟින් ලබා දුන් අගය 1970 ජනවාරි 1 සිට මිලි තත්පර ගණන වේ 00:00:00 UTC.
floor
අවශ්ය නම් යුනික්ස් කාලරාමුව ලබා ගැනීම සඳහා ප්රති result ලය 1000 න් බෙදන්න :
(new Date).getTime() / 1000
මෙම Date.valueOf()
ක්රමය ක්රියාකාරීව සමාන Date.getTime()
වන අතර එමඟින් සමාන ප්රති .ල ලබා ගැනීම සඳහා දින වස්තුව මත අංක ගණිත ක්රියාකරුවන් භාවිතා කළ හැකිය. මගේ මතය අනුව, මෙම ප්රවේශය කියවීමේ හැකියාව කෙරෙහි බලපායි.
new Date().getTime() / 1000
()
පසු new Date
හා .getTime()
සිට /
කැමැත්ත කෙසේ හෝ ගණනාවක් බවට දිනය වස්තුව වීසි කළේය.
කේතය Math.floor(new Date().getTime() / 1000)
කෙටි කළ හැකිය new Date / 1E3 | 0
.
සෘජු getTime()
ආයාචනය මඟ හැරීම සහ ක්රියාකාරිත්වය | 0
සඳහා ආදේශකයක් ලෙස භාවිතා කිරීම සලකා බලන්න Math.floor()
. එය මතක තබා ගැනීමට ද හොඳ දෙයක් 1E3
සඳහා කෙටි හා සමාන වේ 1000
(ඊ දැක්වීමට සිම්පල් වඩා යෝග්ය වන්නේ ලොකු අකුරු 1E3
නියත ලෙස).
එහි ප්රති result ලයක් ලෙස ඔබට පහත දේ ලැබේ:
var ts = new Date / 1E3 | 0;
console.log(ts);
"Math.floor(new Date().getTime()/1000)".length == 37;
"new Date/1E3|0".length == 14;
37 -14 = බයිට් 23 ;
Math.floor()
විසින් |0
මෙම කේතය කරමින් සිටී "පැහැදිලි සහ තේරුම්". ආදේශ 1000
කිරීමෙන් බයිට් 1 ක් ඉතිරි කර ගත යුතු කාරණය කුමක්දැයි මට පැහැදිලි කරන්න 1E3
. මෙය හාස්යජනකය. මම නරක කේතයක් දකිමි.
අද - 2020.04.23 තෝරාගත් විසඳුම් සඳහා මම පරීක්ෂණ සිදු කරමි. මම ක්රෝම් 81.0, සෆාරි 13.1, ෆයර්ෆොක්ස් 75.0 හි මැකෝස් හයි සියෙරා 10.13.6 හි පරීක්ෂා කළෙමි
Date.now()
(ඊ) ක්රෝම් සහ සෆාරි මත වේගවත්ම වන අතර ෆයර්ෆොක්ස් හි දෙවන වේගවත් වේ. මෙය වේගවත් හරස් බ්රව්සර් විසඳුම සඳහා හොඳම තේරීම වේ.performance.now()
(ජී), පුදුමයට කරුණක් නම්, ෆයර්ෆොක්ස් හි අනෙකුත් විසඳුම් වලට වඩා 100x වඩා වේගවත් නමුත් ක්රෝම් හි මන්දගාමී වේක්රෝම් සඳහා ප්රති Results ල
ඔබ ඔබේ පරිගණකයේ ටෙස්ට් ඉටු කළ හැකි , මෙන්න
පරීක්ෂණ සඳහා භාවිතා කරන කේතය පහත දැක්වෙන ස්නිපටයේ දක්වා ඇත
performance.now()
මුද්දරය අනුව එය වඩාත් නිවැරදි යැයි ඔබ පරීක්ෂා කළහොත් මම උනන්දු වෙමි .
privacy.reduceTimerPrecision
එය ප්රති the ල ළඟම මිලි තත්පරයට වට කරයි. එය පෙරනිමියෙන් සක්රීය කර ඇති නමුත් අක්රිය කළ හැකිය. developer.mozilla.org/en-US/docs/Web/API/Performance/now
භාවිතා කිරීම මම තරයේ නිර්දේශ කරමි moment.js
. යුනික්ස් යුගයේ සිට මිලි තත්පර ගණන ලබා ගැනීමට, කරන්න
moment().valueOf()
යුනික්ස් යුගයේ සිට තත්පර ගණන ලබා ගැනීමට, කරන්න
moment().unix()
ඔබට එවැනි වේලාවන් පරිවර්තනය කළ හැකිය:
moment('2015-07-12 14:59:23', 'YYYY-MM-DD HH:mm:ss').valueOf()
මම ඒක හැම වෙලේම කරනවා. ද pun ුවමක් අදහස් නොකෙරේ.
moment.js
බ්රව්සරයේ භාවිතා කිරීමට:
<script src="moment.js"></script>
<script>
moment().valueOf();
</script>
MomentJS ස්ථාපනයට හා භාවිතයට කළ හැකි වෙනත් ක්රම ඇතුළු තවත් විස්තර සඳහා ඔවුන්ගේ බලන්න ලේඛන
මයික්රෝ තත්පර විභේදනය සහිත කාලරාමුව සඳහා, තිබේ performance.now
:
function time() {
return performance.now() + performance.timing.navigationStart;
}
මෙය උදාහරණයක් ලෙස අස්වැන්නක් ලබා දිය හැකි 1436140826653.139
අතර Date.now
ලබා දෙයි 1436140826653
.
ඔබට භාවිතා කළ හැක්කේ පමණි
var timestamp = new Date().getTime();
console.log(timestamp);
වත්මන් කාලරාමුව ලබා ගැනීමට. අමතර කිසිවක් කිරීමට අවශ්ය නැත.
කාලරාමුව ජනනය කිරීම සඳහා සරල ශ්රිතයක් මෙන්න: mm / dd / yy hh: mi: ss
function getTimeStamp() {
var now = new Date();
return ((now.getMonth() + 1) + '/' +
(now.getDate()) + '/' +
now.getFullYear() + " " +
now.getHours() + ':' +
((now.getMinutes() < 10)
? ("0" + now.getMinutes())
: (now.getMinutes())) + ':' +
((now.getSeconds() < 10)
? ("0" + now.getSeconds())
: (now.getSeconds())));
}
(new (chain (-date) (to-i-s-o-string)))
.
// The Current Unix Timestamp
// 1443534720 seconds since Jan 01 1970. (UTC)
// seconds
console.log(Math.floor(new Date().valueOf() / 1000)); // 1443534720
console.log(Math.floor(Date.now() / 1000)); // 1443534720
console.log(Math.floor(new Date().getTime() / 1000)); // 1443534720
// milliseconds
console.log(Math.floor(new Date().valueOf())); // 1443534720087
console.log(Math.floor(Date.now())); // 1443534720087
console.log(Math.floor(new Date().getTime())); // 1443534720087
// jQuery
// seconds
console.log(Math.floor($.now() / 1000)); // 1443534720
// milliseconds
console.log($.now()); // 1443534720087
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
Date.now සඳහා සහය නොදක්වන ඕනෑම බ්රව්සරයක්, වත්මන් දිනය ලබා ගැනීම සඳහා ඔබට මෙය භාවිතා කළ හැකිය:
currentTime = Date.now() || +new Date()
Date.now
එය ක්රියාත්මක කිරීමට උත්සාහ කිරීමට පෙර සත්ය වශයෙන්ම පවතින (සහ ශ්රිතයක්) බව තහවුරු කිරීම සඳහා ත්රිමාණ ක්රියාකරුවෙකු භාවිතා කිරීමයි : currentTime = typeof Date.now === "function" ? Date.now() : +new Date()
.
මෙයට විසඳුමක් ඇත: ඒකීය මුද්දරය js හි කාලයට පරිවර්තනය කරයි
var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();
මම ලබා දුන් දින වස්තුව යුනික්ස් කාලරාමුවකට පරිවර්තනය කිරීමේ නියම ක්රමයක් JQuery කුකීගේ ප්රභව කේතයෙන් පෙර දින ඉගෙන ගත්තා .
මෙන්න උදාහරණයක්:
var date = new Date();
var timestamp = +date;
Node.js හි කාලරාමුව ජනනය කිරීමට මූලික ක්රමයක් අවශ්ය නම් මෙය හොඳින් ක්රියාත්මක වේ.
var time = process.hrtime();
var timestamp = Math.round( time[ 0 ] * 1e3 + time[ 1 ] / 1e6 );
අපගේ කණ්ඩායම මෙය භාවිතා කරන්නේ දේශීය හොස්ට් පරිසරයක හැඹිලිය බිඳ දැමීමට ය. ප්රතිදානය යනු ජනනය කරන කාලරාමුව /dist/css/global.css?v=245521377
කොතැනද 245521377
යන්නයි hrtime()
.
මෙය උපකාරී වනු ඇතැයි අපේක්ෂා කරමු, ඉහත ක්රම ද ක්රියාත්මක විය හැකි නමුත් මෙය Node.js හි අපගේ අවශ්යතා සඳහා සරලම ප්රවේශය බව මට පෙනී ගියේය.
මෙය ක්රියාත්මක වන බව පෙනේ.
console.log(clock.now);
// returns 1444356078076
console.log(clock.format(clock.now));
//returns 10/8/2015 21:02:16
console.log(clock.format(clock.now + clock.add(10, 'minutes')));
//returns 10/8/2015 21:08:18
var clock = {
now:Date.now(),
add:function (qty, units) {
switch(units.toLowerCase()) {
case 'weeks' : val = qty * 1000 * 60 * 60 * 24 * 7; break;
case 'days' : val = qty * 1000 * 60 * 60 * 24; break;
case 'hours' : val = qty * 1000 * 60 * 60; break;
case 'minutes' : val = qty * 1000 * 60; break;
case 'seconds' : val = qty * 1000; break;
default : val = undefined; break;
}
return val;
},
format:function (timestamp){
var date = new Date(timestamp);
var year = date.getFullYear();
var month = date.getMonth() + 1;
var day = date.getDate();
var hours = date.getHours();
var minutes = "0" + date.getMinutes();
var seconds = "0" + date.getSeconds();
// Will display time in xx/xx/xxxx 00:00:00 format
return formattedTime = month + '/' +
day + '/' +
year + ' ' +
hours + ':' +
minutes.substr(-2) +
':' + seconds.substr(-2);
}
};
සඳහා lodash හා underscore පරිශීලකයන්, භාවිතය _.now
.
var timestamp = _.now(); // in milliseconds
Moment.js හට ජාවාස්ක්රිප්ට් දිනයන් සමඟ කටයුතු කිරීමේදී ඇති වන වේදනාව බොහෝ දුරට වළක්වා ගත හැකිය.
බලන්න: http://momentjs.com/docs/#/displaying/unix-timestamp/
moment().unix();
moment().valueOf()
. මගේ පිළිතුර බලන්න.
මෙය ලිවීමේදී, ඉහළම පිළිතුර අවුරුදු 9 ක් වන අතර එතැන් සිට බොහෝ දේ වෙනස් වී ඇත - අවම වශයෙන්, අනවසර විසඳුමක් සඳහා අපට විශ්වීය සහයෝගයක් ඇත:
Date.now()
සමහර පුරාණ (පෙර එනම් 9) බ්රව්සරයක මෙය කැඩී නොයන බවට ඔබට නිශ්චිතවම දැන ගැනීමට අවශ්ය නම්, ඔබට එය චෙක්පතක් පිටුපස තැබිය හැකිය.
const currentTimestamp = (!Date.now ? +new Date() : Date.now());
මෙය යුග යුගයේ සිට තත්පර ගණනක් නොව මිලි තත්පර නැවත ලබා දෙනු ඇත.
වඩාත් සරල ක්රමය:
var timeStamp=event.timestamp || new Date().getTime();
event
. ඔබ පිළිතුරක් ලිවීම වෙනුවට එය විසඳන ආකාරය පිළිබඳ වඩා හොඳ පැහැදිලි කිරීමක් ලබා දිය යුතුය. කරුණාකර!