මම යුනික්ස් කාලරාමුව ලෙස MySQL දත්ත ගබඩාවක කාලය ගබඩා කර ඇති අතර එය ජාවාස්ක්‍රිප්ට් කේතයකට යවනු ලැබේ. මම එයින් කාලය පමණක් ලබා ගන්නේ කෙසේද?

උදාහරණයක් ලෙස, HH / MM / SS ආකෘතියෙන්.

let unix_timestamp = 1549312452
// Create a new JavaScript Date object based on the timestamp
// multiplied by 1000 so that the argument is in milliseconds, not seconds.
var date = new Date(unix_timestamp * 1000);
// Hours part from the timestamp
var hours = date.getHours();
// Minutes part from the timestamp
var minutes = "0" + date.getMinutes();
// Seconds part from the timestamp
var seconds = "0" + date.getSeconds();

// Will display time in 10:30:23 format
var formattedTime = hours + ':' + minutes.substr(-2) + ':' + seconds.substr(-2);

console.log(formattedTime);

දිනය වස්තුව පිළිබඳ වැඩි විස්තර සඳහා කරුණාකර MDN හෝ ECMAScript 5 පිරිවිතර බලන්න .

ජාවාස්ක්‍රිප්ට් මිලි තත්පර වලින් ක්‍රියා කරයි, එබැවින් ඔබට පළමුව යුනික්ස් කාලරාමුව තත්පර සිට මිලි තත්පර බවට පරිවර්තනය කළ යුතුය.

var date = new Date(UNIX_Timestamp * 1000);
// Manipulate JavaScript Date object here...

භාවිත:

var s = new Date(1504095567183).toLocaleDateString("en-US")
console.log(s)
// expected output "8/30/2017"  

සහ කාලය සඳහා:

var s = new Date(1504095567183).toLocaleTimeString("en-US")
console.log(s)
// expected output "3:19:27 PM"

Date.prototype.toLocaleDateString () බලන්න

මම ජේකබ් රයිට්ගේ පක්ෂග්‍රාහීයි Date.format() පුස්තකාලයට වන අතර එය ජාවාස්ක්‍රිප්ට් දින හැඩතල ගැන්වීම PHP හි date()ක්‍රියාකාරිත්වයේ ශෛලිය තුල ක්‍රියාත්මක කරයි.

new Date(unix_timestamp * 1000).format('h:i:s')

තත්පර සංයුති කිරීම සඳහා කෙටිම එක්-ලයිනර් විසඳුම මෙන්න hh:mm:ss:

/**
 * Convert seconds to time string (hh:mm:ss).
 *
 * @param Number s
 *
 * @return String
 */
function time(s) {
    return new Date(s * 1e3).toISOString().slice(-13, -5);
}

console.log( time(12345) );  // "03:25:45"

ක්රමය Date.prototype.toISOString()සරල දීර්ඝ කාලය නැවත ISO 8601 වන ආකෘතිය, හැම විටම චරිත 24 ක් හෝ 27 ක දීර්ඝ (එනම් YYYY-MM-DDTHH:mm:ss.sssZහෝ ±YYYYYY-MM-DDTHH:mm:ss.sssZපිළිවෙළින්). කාල කලාපය සැමවිටම ශුන්‍ය UTC ඕෆ්සෙට් වේ.

සැ.යු: මෙම විසඳුමට කිසිදු තෙවන පාර්ශවීය පුස්තකාල අවශ්‍ය නොවන අතර සියලු නවීන බ්‍රව්සර් සහ ජාවාස්ක්‍රිප්ට් එන්ජින් සඳහා සහය දක්වයි.

Momentjs.com වැනි පුස්තකාලයක් භාවිතා කිරීම ගැන මම සිතමි , මෙය සැබවින්ම සරල කරයි:

යුනික්ස් කාලරාමුව මත පදනම්ව:

var timestamp = moment.unix(1293683278);
console.log( timestamp.format("HH/mm/ss") );

MySQL දින නූලක් මත පදනම්ව:

var now = moment("2010-10-10 12:03:15");
console.log( now.format("HH/mm/ss") );

යුනික්ස් කාලරාමුව 1970 ජනවාරි 1 වන දින 00:00:00 යූටීසී සිට තත්පර ගණනකි ( විකිපීඩියාවට අනුව) ).

ජාවාස්ක්‍රිප්ට් හි දිනය වස්තුව පිළිබඳ තර්කය 1970 ජනවාරි 1 වන දින 00:00:00 යූටීසී සිට මිලි තත්පර ගණනකි (ඩබ්ලිව් 3 පාසල් ජාවාස්ක්‍රිප්ට් ප්‍රලේඛනයට අනුව) ).

උදාහරණයක් ලෙස පහත කේතය බලන්න:

    function tm(unix_tm) {
        var dt = new Date(unix_tm*1000);
        document.writeln(dt.getHours() + '/' + dt.getMinutes() + '/' + dt.getSeconds() + ' -- ' + dt + '<br>');

    }

tm(60);
tm(86400);

ලබා දෙයි:

1/1/0 -- Thu Jan 01 1970 01:01:00 GMT+0100 (Central European Standard Time)
1/0/0 -- Fri Jan 02 1970 01:00:00 GMT+0100 (Central European Standard Time)

තත්පර hh: mm: ss: ප්‍රභේදය ලෙස හැඩගස්වා ගැනීමට කෙටිම එක්-ලයිනර් විසඳුම

console.log(new Date(1549312452 * 1000).toISOString().slice(0, 19).replace('T', ' '));
// "2019-02-04 20:34:12"

Moment.js භාවිතා කිරීමෙන් ඔබට කාලය හා දිනය මේ ආකාරයෙන් ලබා ගත හැකිය:

var dateTimeString = moment(1439198499).format("DD-MM-YYYY HH:mm:ss");

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

var timeString = moment(1439198499).format("HH:mm:ss");

ඉහත සඳහන් විසඳුම් සමඟ ඇති ගැටළුව නම්, පැයට, මිනිත්තුවට හෝ තත්පරයට ඇත්තේ එක් ඉලක්කම් (එනම් 0-9) නම්, කාලය වැරදියි, උදා: එය 2: 3: 9 විය හැකිය, නමුත් එය 02: විය යුතුය. 03:09.

මෙම පිටුවට අනුව දිනයෙහි "toLocaleTimeString" ක්‍රමය භාවිතා කිරීම වඩා හොඳ විසඳුමක් බව පෙනේ.

තවත් ක්‍රමයක් - ISO 8601 දිනයක සිට.

var timestamp = 1293683278;
var date = new Date(timestamp * 1000);
var iso = date.toISOString().match(/(\d{2}:\d{2}:\d{2})/)
alert(iso[1]);

මොහොතකින් ඔබ යුනික්ස් කාලරාමුව භාවිතා කළ යුතුය:

const dateTimeString = moment.unix(1466760005).format("DD-MM-YYYY HH:mm:ss");

@ ෂොම්රාත්ගේ පිළිතුර මත පදනම්ව, මෙන්න මේ වගේ ස්වයංක්‍රීයව දිවා කාලය ලියන ස්නිපටයක් (පිළිතුරු සඳහා ස්ටැක් ඕවර්ෆ්ලෝගේ දිනයට ටිකක් සමානයි :) answered Nov 6 '16 at 11:51:

today, 11:23

හෝ

yersterday, 11:23

හෝ (අදට වඩා වෙනස් නමුත් එකම වසර නම්)

6 Nov, 11:23

හෝ (අදට වඩා තවත් වසරක් නම්)

6 Nov 2016, 11:23

function timeConverter(t) {     
    var a = new Date(t * 1000);
    var today = new Date();
    var yesterday = new Date(Date.now() - 86400000);
    var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
    var year = a.getFullYear();
    var month = months[a.getMonth()];
    var date = a.getDate();
    var hour = a.getHours();
    var min = a.getMinutes();
    if (a.setHours(0,0,0,0) == today.setHours(0,0,0,0))
        return 'today, ' + hour + ':' + min;
    else if (a.setHours(0,0,0,0) == yesterday.setHours(0,0,0,0))
        return 'yesterday, ' + hour + ':' + min;
    else if (year == today.getFullYear())
        return date + ' ' + month + ', ' + hour + ':' + min;
    else
        return date + ' ' + month + ' ' + year + ', ' + hour + ':' + min;
}

40 KB පුස්තකාලයක් අවශ්‍ය නොවන නවීන විසඳුම:

Intl.DateTimeFormat යනු දිනයක් / වේලාවක් සංයුති කිරීම සඳහා සංස්කෘතික නොවන අධිරාජ්‍යවාදී ක්‍රමයකි.

// Setup once
var options = {
    //weekday: 'long',
    //month: 'short',
    //year: 'numeric',
    //day: 'numeric',
    hour: 'numeric',
    minute: 'numeric',
    second: 'numeric'
},
intlDate = new Intl.DateTimeFormat( undefined, options );

// Reusable formatter
var timeStamp = 1412743273;
console.log( intlDate.format( new Date( 1000 * timeStamp ) ) );

function getTIMESTAMP() {
  var date = new Date();
  var year = date.getFullYear();
  var month = ("0" + (date.getMonth() + 1)).substr(-2);
  var day = ("0" + date.getDate()).substr(-2);
  var hour = ("0" + date.getHours()).substr(-2);
  var minutes = ("0" + date.getMinutes()).substr(-2);
  var seconds = ("0" + date.getSeconds()).substr(-2);

  return year + "-" + month + "-" + day + " " + hour + ":" + minutes + ":" + seconds;
}

//2016-01-14 02:40:01

මෙය PHP කාලරාමු සමඟ ක්‍රියා කරයි

var d = 1541415288860;
//var d =val.timestamp;

//NB: use + before variable name
var date = new Date(+d);

console.log(d);
console.log(date.toDateString());
console.log(date.getFullYear());
console.log(date.getMinutes());
console.log(date.getSeconds());
console.log(date.getHours());
console.log(date.toLocaleTimeString());

var d =val.timestamp;
var date=new Date(+d); //NB: use + before variable name

console.log(d);
console.log(date.toDateString());
console.log(date.getFullYear());
console.log(date.getMinutes());
console.log(date.getSeconds());
console.log(date.getHours());
console.log(date.toLocaleTimeString());

ඉහත ක්‍රම මඟින් මෙම ප්‍රති .ල ජනනය වේ

1541415288860
Mon Nov 05 2018 
2018 
54 
48 
13
1:54:48 PM

කාලරාමු සමඟ පරිපූර්ණව ක්‍රියා කරන ක්‍රම රාශියක් ඇත. ඒවා සියල්ලම ලැයිස්තු ගත කළ නොහැක

සමහර පිළිතුරු සමඟ ඇති ශුන්‍ය ගැටලුව කෙරෙහි අවධානය යොමු කරන්න. උදාහරණයක් ලෙස, කාලරාමුව 1439329773වැරදීමකින් පරිවර්තනය වේ 12/08/2015 0:49.

මෙම ගැටළුව මඟහරවා ගැනීම සඳහා පහත සඳහන් දෑ භාවිතා කිරීමට මම යෝජනා කරමි:

var timestamp = 1439329773; // replace your timestamp
var date = new Date(timestamp * 1000);
var formattedDate = ('0' + date.getDate()).slice(-2) + '/' + ('0' + (date.getMonth() + 1)).slice(-2) + '/' + date.getFullYear() + ' ' + ('0' + date.getHours()).slice(-2) + ':' + ('0' + date.getMinutes()).slice(-2);
console.log(formattedDate);

දැන් ප්‍රති results ල:

12/08/2015 00:49

// Format value as two digits 0 => 00, 1 => 01
function twoDigits(value) {
   if(value < 10) {
    return '0' + value;
   }
   return value;
}

var date = new Date(unix_timestamp*1000);
// display in format HH:MM:SS
var formattedTime = twoDigits(date.getHours()) 
      + ':' + twoDigits(date.getMinutes()) 
      + ':' + twoDigits(date.getSeconds());

function timeConverter(UNIX_timestamp){
 var a = new Date(UNIX_timestamp*1000);
     var hour = a.getUTCHours();
     var min = a.getUTCMinutes();
     var sec = a.getUTCSeconds();
     var time = hour+':'+min+':'+sec ;
     return time;
 }

දිනය / යුගය පරිවර්තකය බලන්න .

ඔබට අවශ්‍යයි ParseInt, එසේ නොමැති නම් එය ක්‍රියා නොකරනු ඇත:

if (!window.a)
    window.a = new Date();

var mEpoch = parseInt(UNIX_timestamp);

if (mEpoch < 10000000000)
    mEpoch *= 1000;

------
a.setTime(mEpoch);
var year = a.getFullYear();
...
return time;

ඔබේ කාලරාමුව HH:MM:SSආකෘතියට පරිවර්තනය කිරීම සඳහා ඔබට පහත ශ්‍රිතය භාවිතා කළ හැකිය :

var convertTime = function(timestamp, separator) {
    var pad = function(input) {return input < 10 ? "0" + input : input;};
    var date = timestamp ? new Date(timestamp * 1000) : new Date();
    return [
        pad(date.getHours()),
        pad(date.getMinutes()),
        pad(date.getSeconds())
    ].join(typeof separator !== 'undefined' ?  separator : ':' );
}

බෙදුම්කරුවෙකු පසු නොකර, එය :(පෙරනිමි) බෙදුම්කරු ලෙස භාවිතා කරයි :

time = convertTime(1061351153); // --> OUTPUT = 05:45:53

ඔබට /බෙදුම්කරුවෙකු ලෙස භාවිතා කිරීමට අවශ්‍ය නම් , එය දෙවන පරාමිතිය ලෙස සම්මත කරන්න:

time = convertTime(920535115, '/'); // --> OUTPUT = 09/11/55

නිරූපණය

var convertTime = function(timestamp, separator) {
    var pad = function(input) {return input < 10 ? "0" + input : input;};
    var date = timestamp ? new Date(timestamp * 1000) : new Date();
    return [
        pad(date.getHours()),
        pad(date.getMinutes()),
        pad(date.getSeconds())
    ].join(typeof separator !== 'undefined' ?  separator : ':' );
}

document.body.innerHTML = '<pre>' + JSON.stringify({
    920535115 : convertTime(920535115, '/'),
    1061351153 : convertTime(1061351153, ':'),
    1435651350 : convertTime(1435651350, '-'),
    1487938926 : convertTime(1487938926),
    1555135551 : convertTime(1555135551, '.')
}, null, '\t') +  '</pre>';

මෙම ෆෙඩෙල් ද බලන්න .

ඔබට යුනික්ස් කාල සීමාව සැබෑ පැය, මිනිත්තු සහ තත්පර බවට පරිවර්තනය කිරීමට අවශ්‍ය නම්, ඔබට පහත කේතය භාවිතා කළ හැකිය:

var hours = Math.floor(timestamp / 60 / 60);
var minutes = Math.floor((timestamp - hours * 60 * 60) / 60);
var seconds = Math.floor(timestamp - hours * 60 * 60 - minutes * 60 );
var duration = hours + ':' + minutes + ':' + seconds;

function getDateTime(unixTimeStamp) {

    var d = new Date(unixTimeStamp);
    var h = (d.getHours().toString().length == 1) ? ('0' + d.getHours()) : d.getHours();
    var m = (d.getMinutes().toString().length == 1) ? ('0' + d.getMinutes()) : d.getMinutes();
    var s = (d.getSeconds().toString().length == 1) ? ('0' + d.getSeconds()) : d.getSeconds();

    var time = h + '/' + m + '/' + s;

    return time;
}

var myTime = getDateTime(1435986900000);
console.log(myTime); // output 01/15/00

පහත කේතය ඉලක්කම් 3 මිලිසෙක්ස් ද සපයයි, එය කොන්සෝල ලොග් උපසර්ග සඳහා වඩාත් සුදුසු වේ:

const timeStrGet = date => {
    const milliSecsStr = date.getMilliseconds().toString().padStart(3, '0') ;
    return `${date.toLocaleTimeString('it-US')}.${milliSecsStr}`;
};

setInterval(() => console.log(timeStrGet(new Date())), 299);

moment.js

කාලරාමු js හි අද දිනට පරිවර්තනය කරන්න

https://momentjs.com/

moment().format('YYYY-MM-DD hh:mm:ss');
// "2020-01-10 11:55:43"

moment(1578478211000).format('YYYY-MM-DD hh:mm:ss');
// "2020-01-08 06:10:11"

@ ඇරොන් විසින් දෙන ලද පිළිතුර, නමුත් 1980 සිට කාලරාමුව පරිවර්තනය කිරීමට උත්සාහ කරන බැවින් එය මට සාර්ථක වූයේ නැත. එබැවින් මම පහත සඳහන් වෙනස්කම් කිහිපයක් සිදු කළෙමි

function ConvertUnixTimeToDateForLeap(UNIX_Timestamp) {
    var dateObj = new Date(1980, 0, 1, 0, 0, 0, 0);
    dateObj.setSeconds(dateObj.getSeconds() + UNIX_Timestamp);
    return dateObj;  
}

document.body.innerHTML = 'TimeStamp : ' + ConvertUnixTimeToDateForLeap(1269700200);

ඔබට තවත් දශකයක සිට ආරම්භ වන කාලරාමුව තිබේ නම්, මෙය භාවිතා කරන්න. එය මට විශාල හිසරදයක් ඉතිරි කළේය.

කෙටිම

(new Date(ts*1000)+'').slice(16,24)

let ts = 1549312452;
let time = (new Date(ts*1000)+'').slice(16,24);

console.log(time);