ඔබ ජාවාස්ක්‍රිප්ට් හි කාලරාමුව ලබා ගන්නේ කෙසේද?


4020

ජාවාස්ක්‍රිප්ට් හි කාලරාමුව ලබා ගන්නේ කෙසේද?

යුනික්ස් කාලරාමුව හා සමාන දෙයක් , එනම් වර්තමාන වේලාව හා දිනය නියෝජනය කරන තනි අංකයකි. එක්කෝ අංකයක් හෝ නූලක් ලෙස.


JS හි 64bit කාලරාමුව ලබා ගන්නේ කෙසේද?
ඇලෙක්සැන්ඩර් මිල්ස්

Lex ඇලෙක්සැන්ඩර්මිල්ස් ජාවාස්ක්‍රිප්ට් 64bit පූර්ණ සංඛ්‍යා සඳහා සහය නොදක්වන බැවින්, ඔබට බිට් 32 පූර්ණ සංඛ්‍යා දෙකක් ලබා ගත යුතුය. තවත් ප්‍රශ්නයක් අසන්න.
wizzwizz4

Answers:


4929

කෙටි සහ ස්නැසි:

+ new Date()

වැනි ඒකීය ක්‍රියාකරුවෙකු වස්තුවෙහි ක්‍රමය plusඅවුලුවන අතර එය කාලරාමුව නැවත ලබා දෙයි (කිසිදු වෙනස් කිරීමකින් තොරව).valueOfDate

විස්තර:

දැනට පවතින සියලුම බ්‍රව්සර්වල 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());


11
තවත් කැපී පෙනෙන ව්‍යතිරේකයක් වන්නේ node.js. මම ගූගල් වෙතින් මෙහි පැමිණියේ නෝඩ්
එකේම එය කිරීමටයි

57
නැහැ Date.now() / 1000 | 0මේ පෙළෙන 2038 වසරේ ප්රශ්නය ? new Date('Jan 1, 2039') / 1000 | 0 == -2117514496
gengkev

3
හෝ, w / Math.floor .. භාවිතා o~~(Date.now() / 1000)
Matej

14
@ මිලාන්බබුකොව් නමුත් node.js සහාය දක්වයිDate.now()
OrangeDog

51
අතර +new Dataදක්ෂ වන අතර, එය අනෙකුත් devs කියවිය හැකි නොවේ. Date.now()පැහැදිලි වන අතර සිදුවන්නේ කුමක්ද යන්න අනෙක් සියල්ලන්ම දන්නා බව සහතික කරයි.
හැරී සැඩ්ලර්

515

මම මේකට කැමතියි, එය කුඩා නිසා:

+new Date

මමත් මේකට කැමතියි, මන්ද එය කෙටි හා නවීන බ්‍රව්සර් සමඟ අනුකූල වන අතර 500 කට අධික පිරිසක් ඡන්දය ප්‍රකාශ කිරීම වඩා හොඳ බව:

Date.now()

636
මෙම විකල්පය නරක අදහසකි. එය පහසුවෙන් නොසලකා හරිනු ලැබේ, යතුරු ලියනයක සේ පෙනේ, යථාර්ථයේ දී එය භාෂාවේ අතුරු ආබාධයක් මත රඳා පවතී. මම නරක කේතයක් දකිමි.
inanutshellus

10
Ill බිලී මට මතක හැටියට, මම යෝජනා කළ විසඳුම් දෙකෙහි කාලරාමුව 1M වාරයක් ගණනය කර සාමාන්‍ය ධාවන කාලය ගණනය කළෙමි. මම එය ෆයර්ෆොක්ස් සහ ක්‍රෝම් වල ධාවනය කළෙමි, බ්‍රව්සර් දෙකෙහිම ගෙටයිම් වේගවත් විය. එයින් කියැවෙන්නේ, මා තෝරා ගන්නේ (සුළු වශයෙන්) මන්දගාමී වුවද new Date().getTime(). වාසනාවකට මෙන්, වේගවත් විසඳුම දැනටමත් පැහැදිලි විසඳුමයි!
inanutshellus

11
@ FabrícioMatté සමඟ එකඟ විය. ඒකීය ක්‍රියාකරුගේ හැසිරීම මුලික නොවිය හැක, නමුත් ඔබ ඒ පිළිබඳව අවධානය යොමු නොකළේ නම්, කණ්ඩායම් ගණනාවක effectively ලදායී ලෙස ක්‍රියා කිරීමට හැකි වනු ඇතැයි අපේක්ෂා නොකරන්න.
ජේසන් ටී ෆෙදරිංහැම්

9
Ik නික්ලවුස් එයට හේතුව ඔබ එය වෙනත් නූලකට සම්බන්ධ කිරීමයි. එවැනි අවස්ථාවක, new Date().toString()හැඳින්වේ.
කිර්බ්

7
කුතුහලයෙන් +යුතුව එය නූලක් මෙන් පිටතට ගෙන ඒමට ක්‍රියාකරු කරන්නේ කුමක්ද?
zadubz

277

ජාවාස්ක්‍රිප්ට් යුගයේ සිට මිලි තත්පර ගණන සමඟ ක්‍රියා කරන අතර අනෙක් බොහෝ භාෂා තත්පර සමඟ ක්‍රියා කරයි. ඔබට මිලි තත්පර සමඟ වැඩ කළ හැකි නමුත් ඔබ PHP යැයි පැවසීමට අගයක් පසු කළ විට, PHP ස්වදේශීය කාර්යයන් අසාර්ථක වනු ඇත. ඒ නිසා මම සෑම විටම භාවිතා කරන්නේ තත්පර, මිලි තත්පර නොවේ.

මෙය ඔබට යුනික්ස් කාලරාමුව ලබා දෙනු ඇත (තත්පර වලින්):

var unix = Math.round(+new Date()/1000);

මෙය යුගයේ සිට මිලි තත්පර ලබා දෙනු ඇත (යුනික්ස් කාලරාමුව නොවේ):

var milliseconds = new Date().getTime();

4
PHP මිලි තත්පර සමඟ හොඳින් ක්‍රියා කළ යුතුය.
නිකෝ බර්න්ස්

5
මයික්‍රොටයිම් () පවතින අතර, පීඑච්පී හි බොහෝ කාලයට අදාළ කාර්යයන් අපේක්ෂා කරන්නේ කාලරාමුව තත්පර කිහිපයකින් මිස මිලි තත්පර වලින් නොවේ. එපමණක්ද නොව, මයික්‍රෝටයිම් () පාවෙන (ඔබ සත්‍යය පසු කළහොත්) දශම කොටස තත්පරයක භාගයක් (මයික්‍රෝ තත්පරයට නිරවද්‍ය) වන අතර නව දිනය () ලබා ගන්න. GetTime () මිලි තත්පර තත්පර ගණනක් ගණනය කරන තැනක් යුගය. උදාහරණයක් ලෙස (php) ඔබ බිම අමතන්නේ නම් (මයික්‍රෝ ටයිම් (සත්‍ය)) මෙය ඇමතුම් වේලාව () තත්පරයට තත්පරයට මිස මයික්‍රෝ හෝ මිලි තත්පරයට සමාන වේ. ඉහත පරිදි 1000 න් බෙදීම මේ සඳහා ඇති පහසුම විසඳුමයි.
gregghz

49
වටය වෙනුවට බිම භාවිතා කරන්න. 700
එම්එස්

Unix timestampඑදිරිව Seconds since the Epoch. මේ දෙදෙනා එකම දේ අදහස් කළ යුතු නොවේද?
මුදියාගා එජෙනාවි

147
var time = Date.now || function() {
  return +new Date;
};

time();

6
ඇයි || ක්‍රියාකරු? Date.now () සියලුම බ්‍රව්සර්වල නොමැතිද?
ක්‍රිස් නො

67
Date.now () ජාවාස්ක්‍රිප්ට් 1.5 වෙතින් වන අතර එය IE 8 හි සහය නොදක්වයි.
සෙරෙන් ලෙව්බර්ග්

9
Date.now ක්‍රමයට සහය දැක්වීම සඳහා යාවත්කාලීන කර නොමැති එන්ජින් සඳහා පහත සඳහන් ෂිම් භාවිතයෙන් එය නොමැති විට ක්‍රියා කළ හැකිය: if (! Date.now) {Date.now = දැන් ක්‍රියාත්මක වේ () {ආපසු + (නව දිනය); }; }
එක් ගවේෂණය කරන ලද ඇරොන්සන්

හෝ(Date.now||function(){return +new Date})();

130

මෙම පිළිතුරේ විස්තර සහිතව මම විවිධ විසඳුම් ලබා දෙමි.
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()@ එම්.ඩී.එන්


12
| 0 යනු Math.floor () ට සමාන වන අතර එය මඳක් ක්‍රියාත්මක වන බැවින් (එය පාවෙන සමඟ ක්‍රියා නොකරයි). සාමාන්‍යයෙන් එය Math.floor () ට වඩා වේගවත් වන අතර එය ක්‍රියාකාරී ඇමතුමක් නොවන බැවින් එය ස්වදේශීය ජාවාස්ක්‍රිප්ට් ක්‍රියාකරු වේ.
ගොට්ස්


H ක්‍රිස්ටෝෆ් ඔබ එසේ සිතන්නේ ඇයි? IE නිවැරදි කිරීම නිසාද? එම කොටස හැර එහි සරල හා අභිරුචිකරණය කළ හැකි යැයි මම සිතමි.
ගොට්ස්

5
පොලිෆිල්ස් / ෂිම්ස් සංකීර්ණ නොවේ. ඒවා විවිධ බ්‍රව්සර් අනුවාද 9 කට සහය දැක්වීමට සිදුවීම සහ කර්මාන්තය විසින් කුමන ප්‍රමිතීන් අනුගමනය කළ යුතුද යන්න සහ ඒවා හුදෙක්ම සකස් කරන්නේද යන්න තීරණය කිරීමට තීරණය කිරීමෙහි ප්‍රති result ලයකි.
rlemon

8
යොමු කිරීම සඳහා ඔබට ලබා ගත හැකි වඩාත්ම සංයුක්ත වේ new Date/1e3|0.
ඩෙරෙක් 朕 會 功夫

88
var timestamp = Number(new Date()); // current time as number

61

කාලරාමුව ලබා ගැනීම සඳහා jQuery තමන්ගේම ක්‍රමයක් සපයයි :

var timestamp = $.now();

(ඊට අමතරව (new Date).getTime()ප්‍රකාශනය ක්‍රියාත්මක කරයි)

REF: http://api.jquery.com/jQuery.now/


2
jQuery විවිධ ජාවාස්ක්‍රිප්ට් ඒපීඅයි සමඟ ඇති හරස් බ්‍රව්සර් අනුකූලතා ගැටළු පිළිබඳව ද සැලකිලිමත් වේ.
හෙන්රි හෙලීන්

4
IsVisioN මම Node.js හි කාලරාමු කිරීමට ක්‍රමයක් සෙව්වෙමි. මට ජාවාස්ක්‍රිප්ට් ප්‍රශ්නයක් ස්ටැක් ඕවර් ප්‍රවාහයෙන් හමු වූ අතර මට jQuery හි පිළිතුරක් ලැබෙනු ඇත, එය උදව් නොකරයි. Javascript සහ jQuery යනු කරුණු දෙකකි. අප එහි ඇති සෑම ජාවාස්ක්‍රිප්ට් රාමුවකටම පිළිතුරු ලබා දෙන්නේ නම්, අප අවසන් වන්නේ අසීමිත පිළිතුරු සංඛ්‍යාවක් සමඟ වන අතර එය ස්ටක් ඕවර් ප්‍රවාහයේ Q / A දර්ශනයට පටහැනිය. එසේම: i.stack.imgur.com/Ledgt.gif : D
පියරේ ආර්ලෝඩ්

5
IsVisioN බ්‍රව්සරයක ජාවාස්ක්‍රිප්ට් භාවිතා කළ යුතු යැයි කීවේ කවුද?
පියරේ අර්ලෝඩ්

5
@PierreArlaud තවද මෙම ප්‍රශ්නය NodeJS ගැන පමණක් යැයි කීවේ කවුද?
VisioN

2
Ing කිං රයිඩර් අවශ්‍යතාවයක් නොමැත, එහි ප්‍රති value ලයක් parseIntලෙස ලැබෙන අගය සැමවිටම a Number.
VisioN

46

console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch


4
මෙය සමානයි +new Date.. :)
19

8
කරන්නDate.now()
ඕර්ලන්ඩෝ

Or ඕර්ලන්ඩෝ අනෙක් පිළිතුරු බලන්න, දැන් () සමඟ ඇති ගැටළුව බ්‍රව්සර් සහායයි
ක්‍රිස්ටෝප්

@Christophe හුදෙක් සරල polyfill, කරන්න developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
ඔර්ලන්ඩෝ

@Christophe Date.now () දිනය වඩා වැඩි වේගයකින් (ය). ValueOf () .. jsperf.com/new-date-vs-date-now-vs-performance-now/6 ඔබ විට polyfill භාවිතා කරන්නේ නම් එසේ යහපත් වන්නේ ලබා ගත නොහැක.
ඕර්ලන්ඩෝ

43

අනෙක් විකල්ප වලට අමතරව, ඔබට දින ආකෘති ISO අවශ්‍ය නම්, ඔබට එය කෙලින්ම ලබා ගත හැකිය

console.log(new Date().toISOString());


ප්‍රශ්නය අසන ලද පූර්ණ සංඛ්‍යාවක් එය ආපසු ලබා නොදේ!
alexventuraio

අයිඑස්ඕ නූලක් සහිත ඇලෙක්ස් වෙන්චුර ඔබට දින වස්තුවක් ක්ෂණික කර ඒවා අතර අඩු කළ හැකිය. උදාහරණයක් ලෙස:new Date("2017-05-04T07:11:28.940Z") - new Date("2017-05-04T07:11:14.092Z")
ජොකිංලෙසැන්ටොස්

41

එකතු කිරීම සඳහා, ජාවාස්ක්‍රිප්ට් හි කාලරාමුව නැවත ලබා දීම සඳහා ශ්‍රිතයක් මෙහි ඇත. උදාහරණය: 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;
}

11
OP විමසන්නේ පූර්ණ සංඛ්‍යා කාලරාමුව ගැන ය; මෙය කාලයෙහි තන්තු නිරූපණයකි.
බ්‍රැඩ් කොච්

3
"යුනික්ස්ගේ කාලරාමුව හා සමානයි, එනම් වර්තමාන කාලය නියෝජනය කරන තනි අංකයක්"
බ්‍රැඩ් කොච්

කාලය ප්‍රදර්ශනය කිරීම සඳහා මට කේතයක් තිබුන නමුත් ඕස්ට්‍රේලියාවේ සමහර කොටස් සම්පූර්ණ දිනය පෙන්වූ අතර, මෙම ස්ක්‍රිප්ට් එක එය බිඳ දමා නිවැරදිව පෙන්වීමට මට උදව් විය. (ඒ සඳහා +1)
සයිෆර්

40

දිනය , ස්වදේශීය වස්තුවකි ජාවාස්ක්‍රිප්ට් වන්නේ කාලය පිළිබඳ සියලු දත්ත අපට ලැබෙන ක්‍රමයයි.

ජාවාස්ක්‍රිප්ට් හි ප්‍රවේශම් වන්න කාලරාමුව සේවාදායක පරිගණක කට්ටලය මත රඳා පවතී, එබැවින් එය 100% නිවැරදි කාලරාමුව නොවේ. හොඳම ප්‍රති result ලය ලබා ගැනීම සඳහා, ඔබ සේවාදායකයාගේ පැත්තෙන් කාලරාමුව ලබා ගත යුතුය .

කෙසේ වෙතත්, මම කැමතිම ක්‍රමය වන්නේ වැනිලා භාවිතා කිරීමයි. මෙය ජාවාස්ක්‍රිප්ට් හි පොදු ක්‍රමයක් වේ:

Date.now(); //return 1495255666921

එම්ඩීඑන් හි එය පහත පරිදි වේ:

Date.now () ක්‍රමය මඟින් 1970 ජනවාරි 1 වන දින සිට ගත වූ මිලි තත්පර ගණන නැවත ලබා දෙයි 00:00:00 UTC.
දැන් () දිනයෙහි ස්ථිතික ක්‍රමයක් වන නිසා, ඔබ එය සැමවිටම භාවිතා කරන්නේ Date.now () ලෙස ය.

ඔබ ES5 ට පහළින් අනුවාදයක් භාවිතා කරන්නේ නම්, Date.now();ක්‍රියා නොකරන අතර ඔබ භාවිතා කළ යුත්තේ:

new Date().getTime();

29

මම තවම දැක නැති එකක්

Math.floor(Date.now() / 1000); // current time in seconds

මම තවම දැක නැති තවත් එකක්

var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();

1
Date.now() /1000 |0මීට පෙරද පිළිතුරු දී ඇත
ගොට්ස්

3
හොඳින්. මට විශ්වාසයි Math.floor()එය සංස්කරණය කර ඇති නමුත් එය සමාන බලපෑමක් ඇති බව පැහැදිලි කිරීමට පමණි |0. මට ඔබට හෝ කිසිම දෙයකට රිදවීමට අවශ්‍ය නොවීය. මට ඔබට කියන්නට අවශ්‍ය වූයේ ඔබේ පිළිතුර යම් ආකාරයකින් දැනටමත් පවතින බවයි. ලබා දී ඇති සියලුම පිළිතුරු දෙස බැලීමෙන් යම් ආකාරයකින් දැනුම් දෙන සමහරක් තිබේ.
ගොට්ස්

මම හිතන්නේ මුළු ලොඩාෂ් පුස්තකාලයම භාවිතා _.now()කිරීම සඳහා ආනයනය කිරීම ටිකක් අධික ලෙස මරා දැමීමකි . මම නිර්දේශ කරන්නේ ඔබ භාවිතා කිරීමට අවශ්‍ය ලොඩාෂ් ක්‍රියාකාරිත්වය ආනයනය කිරීම පමණි (මේ අවස්ථාවේ දී, එන්පීඑම් හි _.now () ), නමුත් ඔවුන් පවා ඔවුන්ගේ පැකේජය නිකම්ම භාවිතා කිරීමට අකමැති වී ඇත Date.now().
mgthomas99

27

මෙම Date.getTime()ක්‍රමය කුඩා වෙනස් කිරීමකින් භාවිතා කළ හැකිය:

GetTime ක්‍රමවේදය මඟින් ලබා දුන් අගය 1970 ජනවාරි 1 සිට මිලි තත්පර ගණන වේ 00:00:00 UTC.

floorඅවශ්‍ය නම් යුනික්ස් කාලරාමුව ලබා ගැනීම සඳහා ප්‍රති result ලය 1000 න් බෙදන්න :

(new Date).getTime() / 1000

මෙම Date.valueOf()ක්‍රමය ක්‍රියාකාරීව සමාන Date.getTime()වන අතර එමඟින් සමාන ප්‍රති .ල ලබා ගැනීම සඳහා දින වස්තුව මත අංක ගණිත ක්‍රියාකරුවන් භාවිතා කළ හැකිය. මගේ මතය අනුව, මෙම ප්‍රවේශය කියවීමේ හැකියාව කෙරෙහි බලපායි.


7
ඔබට වරහන් අවශ්‍ය නොවේ:new Date().getTime() / 1000
රයි-

14
ඔබට ඒවා අවශ්‍ය නැත, නමුත් ඒවා කේතය වඩාත් කියවිය හැකි (IMHO) කරයි. රසයේ වැදගත්කම මම අනුමාන කරමි.
ජොහෙන්ඩෝ

ඔබ පවා අවශ්ය නැත ()පසු new Dateහා .getTime()සිට /කැමැත්ත කෙසේ හෝ ගණනාවක් බවට දිනය වස්තුව වීසි කළේය.
ඩෙරෙක් 朕 會 功夫

25

කේතය 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);


3
chedchest "Math.floor(new Date().getTime()/1000)".length == 37; "new Date/1E3|0".length == 14; 37 -14 = බයිට් 23 ;
වැලන්ටින් පොඩ්කමේනි

AtMatthieuCharbonnier කියවිය නොහැකි දේ කුමක්ද? බෙදීම් ලකුණ, 1E3, පයිප්ප හෝ ශුන්‍යද? කරුණාකර ඉහත මගේ පිළිතුරේ කේත ස්නිපටය බලන්න.
වැලන්ටින් පොඩ්කමේනි

1
@ වැලන්ටින් ඔබ කිසිදු ප්‍රතිලාභයක් නොමැතිව සරල කේතය අවම කිරීම / සංකීර්ණ කිරීම. මට ඒක කරන්න තේරුමක් නැහැ. අපි කේත ගොල්ෆ් ක්‍රීඩාවේ නැහැ!
මැතිව් චාර්බෝනියර්

AtMatthieuCharbonnier, සංකීර්ණ කිසිවක් නොමැත, මූලික සින්ටැක්ස් සහ ක්‍රියාකරුවන් පමණි. ප්රධාන කාරණය වන්නේ කෙටි, පැහැදිලි සහ තේරුම්ගත හැකි කේතයක් ලිවීමයි.
වැලන්ටින් පොඩ්කමේනි

2
@Valentin වෙනුවට කොහොමද කියලා මට පැහැදිලි කරන්න Math.floor()විසින් |0මෙම කේතය කරමින් සිටී "පැහැදිලි සහ තේරුම්". ආදේශ 1000කිරීමෙන් බයිට් 1 ක් ඉතිරි කර ගත යුතු කාරණය කුමක්දැයි මට පැහැදිලි කරන්න 1E3. මෙය හාස්‍යජනකය. මම නරක කේතයක් දකිමි.
මැතිව් චාර්බෝනියර්

25

කාර්ය සාධනය

අද - 2020.04.23 තෝරාගත් විසඳුම් සඳහා මම පරීක්ෂණ සිදු කරමි. මම ක්‍රෝම් 81.0, සෆාරි 13.1, ෆයර්ෆොක්ස් 75.0 හි මැකෝස් හයි සියෙරා 10.13.6 හි පරීක්ෂා කළෙමි

නිගමන

  • විසඳුම Date.now()(ඊ) ක්‍රෝම් සහ සෆාරි මත වේගවත්ම වන අතර ෆයර්ෆොක්ස් හි දෙවන වේගවත් වේ. මෙය වේගවත් හරස් බ්‍රව්සර් විසඳුම සඳහා හොඳම තේරීම වේ.
  • විසඳුම performance.now()(ජී), පුදුමයට කරුණක් නම්, ෆයර්ෆොක්ස් හි අනෙකුත් විසඳුම් වලට වඩා 100x වඩා වේගවත් නමුත් ක්‍රෝම් හි මන්දගාමී වේ
  • සී, ඩී, එෆ් විසඳුම් සියලු බ්‍රව්සර්වල තරමක් මන්දගාමී වේ

රූප විස්තරය මෙහි ඇතුළත් කරන්න

විස්තර

ක්‍රෝම් සඳහා ප්‍රති Results ල

රූප විස්තරය මෙහි ඇතුළත් කරන්න

ඔබ ඔබේ පරිගණකයේ ටෙස්ට් ඉටු කළ හැකි , මෙන්න

පරීක්ෂණ සඳහා භාවිතා කරන කේතය පහත දැක්වෙන ස්නිපටයේ දක්වා ඇත


performance.now()මුද්දරය අනුව එය වඩාත් නිවැරදි යැයි ඔබ පරීක්‍ෂා කළහොත් මම උනන්දු වෙමි .
SamsonTheBrave

CommentSamsonTheBrave ඔබගේ අදහස් දැක්වීමට ස්තූතියි - මම පිළිතුර යාවත්කාලීන කරමි
Kamil Kiełczewski

නියමයි, ඔබගේ යාවත්කාලයට ස්තූතියි! ෆයර්ෆොක්ස් හි වේගයේ කාර්ය සාධනයේ වෙනසක් ඔබ දකින බව මම දුටුවෙමි. මෙය ෆයර්ෆොක්ස් හි ප්‍රති result ලයක් විය හැකි අතර privacy.reduceTimerPrecisionඑය ප්‍රති the ල ළඟම මිලි තත්පරයට වට කරයි. එය පෙරනිමියෙන් සක්‍රීය කර ඇති නමුත් අක්‍රිය කළ හැකිය. developer.mozilla.org/en-US/docs/Web/API/Performance/now
SamsonTheBrave

22

භාවිතා කිරීම මම තරයේ නිර්දේශ කරමි 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 ස්ථාපනයට හා භාවිතයට කළ හැකි වෙනත් ක්රම ඇතුළු තවත් විස්තර සඳහා ඔවුන්ගේ බලන්න ලේඛන


21

මයික්‍රෝ තත්පර විභේදනය සහිත කාලරාමුව සඳහා, තිබේ performance.now:

function time() { 
  return performance.now() + performance.timing.navigationStart;
}

මෙය උදාහරණයක් ලෙස අස්වැන්නක් ලබා දිය හැකි 1436140826653.139අතර Date.nowලබා දෙයි 1436140826653.


21

ඔබට භාවිතා කළ හැක්කේ පමණි

    var timestamp = new Date().getTime();
    console.log(timestamp);

වත්මන් කාලරාමුව ලබා ගැනීමට. අමතර කිසිවක් කිරීමට අවශ්‍ය නැත.


20

කාලරාමුව ජනනය කිරීම සඳහා සරල ශ්‍රිතයක් මෙන්න: 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())));
}

10
@ b123400 - මෙන්න ළිස්ප් අනුවාදය මෙසේය: (new (chain (-date) (to-i-s-o-string))).
ඉනයිමති

20

// 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>


16

Date.now සඳහා සහය නොදක්වන ඕනෑම බ්‍රව්සරයක්, වත්මන් දිනය ලබා ගැනීම සඳහා ඔබට මෙය භාවිතා කළ හැකිය:

currentTime = Date.now() || +new Date()

3
(මගේ අදහස නැවත මුද්‍රණය කිරීම) ඔබේ කේතයට ගැටළුවක් ඇත: එය මුලින්ම එහි සහාය පරීක්ෂා කිරීම වෙනුවට Date.now ක්‍රමය ක්‍රියාත්මක කරයි. පැරණි බ්‍රව්සර් වල එය Date.now ක්‍රියාකාරී දෝෂයක් නොවේ.
සල්මාන් ඒ

සමහර විට වඩා හොඳ විකල්පයක් වනුයේ Date.nowඑය ක්‍රියාත්මක කිරීමට උත්සාහ කිරීමට පෙර සත්‍ය වශයෙන්ම පවතින (සහ ශ්‍රිතයක්) බව තහවුරු කිරීම සඳහා ත්‍රිමාණ ක්‍රියාකරුවෙකු භාවිතා කිරීමයි : currentTime = typeof Date.now === "function" ? Date.now() : +new Date().
mgthomas99

14

මෙයට විසඳුමක් ඇත: ඒකීය මුද්දරය js හි කාලයට පරිවර්තනය කරයි

var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();

14

මම ලබා දුන් දින වස්තුව යුනික්ස් කාලරාමුවකට පරිවර්තනය කිරීමේ නියම ක්‍රමයක් JQuery කුකීගේ ප්‍රභව කේතයෙන් පෙර දින ඉගෙන ගත්තා .

මෙන්න උදාහරණයක්:

var date = new Date();
var timestamp = +date;

මම නව දිනය () වස්තුව ලිවීමට සූදානම්ව සිටියෙමි .ඔබට ලොග් (නව දිනය ()) කොන්සෝලය කර නව දිනය () වස්තුව / ශ්‍රිතය යටතේ අදාළ ක්‍රම හරහා ගමන් කළ හැකිය
sg28

14

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 හි අපගේ අවශ්‍යතා සඳහා සරලම ප්‍රවේශය බව මට පෙනී ගියේය.


13

මෙය ක්‍රියාත්මක වන බව පෙනේ.

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);
            }
};

13

එය ලොග් වීමේ අරමුණු සඳහා නම්, ඔබට ISOString භාවිතා කළ හැකිය

new Date().toISOString()

"2019-05-18T20: 02: 36.694Z"



10

Moment.js හට ජාවාස්ක්‍රිප්ට් දිනයන් සමඟ කටයුතු කිරීමේදී ඇති වන වේදනාව බොහෝ දුරට වළක්වා ගත හැකිය.

බලන්න: http://momentjs.com/docs/#/displaying/unix-timestamp/

moment().unix();

2
මෙය යුනික්ස් යුගයේ සිට තත්පර ගණන (මිලි තත්පර නොවේ) ලබා දෙන බව සලකන්න. ඔබට මිලි තත්පර අවශ්‍ය නම් භාවිතා කරන්න moment().valueOf(). මගේ පිළිතුර බලන්න.
ෆුල්ස්ටැක්

9

මෙය ලිවීමේදී, ඉහළම පිළිතුර අවුරුදු 9 ක් වන අතර එතැන් සිට බොහෝ දේ වෙනස් වී ඇත - අවම වශයෙන්, අනවසර විසඳුමක් සඳහා අපට විශ්වීය සහයෝගයක් ඇත:

Date.now()

සමහර පුරාණ (පෙර එනම් 9) බ්‍රව්සරයක මෙය කැඩී නොයන බවට ඔබට නිශ්චිතවම දැන ගැනීමට අවශ්‍ය නම්, ඔබට එය චෙක්පතක් පිටුපස තැබිය හැකිය.

const currentTimestamp = (!Date.now ? +new Date() : Date.now());

මෙය යුග යුගයේ සිට තත්පර ගණනක් නොව මිලි තත්පර නැවත ලබා දෙනු ඇත.

Date.now හි MDN ප්‍රලේඛනය


8

වඩාත් සරල ක්‍රමය:

var timeStamp=event.timestamp || new Date().getTime();

කොහෙන්දැයි දැන ගන්න event. ඔබ පිළිතුරක් ලිවීම වෙනුවට එය විසඳන ආකාරය පිළිබඳ වඩා හොඳ පැහැදිලි කිරීමක් ලබා දිය යුතුය. කරුණාකර!
alexventuraio

මම නව දිනය () වස්තුව ලිවීමට සූදානම්ව සිටියෙමි .ඔබට ලොග් (නව දිනය ()) කොන්සෝලය කර නව දිනය () වස්තුව / ශ්‍රිතය යටතේ අදාළ ක්‍රම හරහා යා හැකිය
sg28
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.