检查Javascript中的时差_Javascript_Date_Datetime

检查Javascript中的时差

javascript date datetime

检查Javascript中的时差,javascript,date,datetime,Javascript,Date,Datetime,如何检查Javascript中两个文本框的时差？即兴创作。减去JavaScript对象以获得它们的差异： // use a constant date (e.g. 2000-01-01) and the desired time to initialize two dates var date1 = new Date(2000, 0, 1, 9, 0); // 9:00 AM var date2 = new Date(2000, 0, 1, 17, 0); // 5:00 PM // th

如何检查Javascript中两个文本框的时差？

即兴创作。减去JavaScript对象以获得它们的差异：

// use a constant date (e.g. 2000-01-01) and the desired time to initialize two dates

var date1 = new Date(2000, 0, 1,  9, 0); // 9:00 AM
var date2 = new Date(2000, 0, 1, 17, 0); // 5:00 PM

// the following is to handle cases where the times are on the opposite side of
// midnight e.g. when you want to get the difference between 9:00 PM and 5:00 AM

if (date2 < date1) {
    date2.setDate(date2.getDate() + 1);
}

var diff = date2 - date1;

// 28800000 milliseconds (8 hours)

您可以将时间转换为字符串格式，如下所示：

var msec = diff;
var hh = Math.floor(msec / 1000 / 60 / 60);
msec -= hh * 1000 * 60 * 60;
var mm = Math.floor(msec / 1000 / 60);
msec -= mm * 1000 * 60;
var ss = Math.floor(msec / 1000);
msec -= ss * 1000;
// diff = 28800000 => hh = 8, mm = 0, ss = 0, msec = 0

function parseTime(s) {
    var part = s.match(/(\d+):(\d+)(?: )?(am|pm)?/i);
    var hh = parseInt(part[1], 10);
    var mm = parseInt(part[2], 10);
    var ap = part[3] ? part[3].toUpperCase() : null;
    if (ap === "AM") {
        if (hh == 12) {
            hh = 0;
        }
    }
    if (ap === "PM") {
        if (hh != 12) {
            hh += 12;
        }
    }
    return { hh: hh, mm: mm };
}
parseTime("12:00 AM"); // {hh:  0, mm: 0}
parseTime("12:00 PM"); // {hh: 12, mm: 0}
parseTime("01:00 PM"); // {hh: 13, mm: 0}
parseTime("23:00");    // {hh: 23, mm: 0}

一个好的解决方案在任何时候都是可行的

以所需的差分格式提供输出

天：小时：分钟：秒

下面显示了该代码的稍微修改版本

 var vdaysdiff; // difference of the dates
   var vhourDiff;
   var vmindiff;
   var vsecdiff;

   vdaysdiff = Math.floor(diff/1000/60/60/24);  // in days
   diff -= vdaysdiff*1000*60*60*24;

   vhourDiff = Math.floor(diff/1000/60/60);  // in hours
   diff -= vhourDiff*1000*60*60;

   vmindiff = Math.floor(diff/1000/60); // in minutes
   diff -= vmindiff*1000*60;

   vsecdiff= Math.floor(diff/1000);  // in seconds

   //Text formatting
   var hourtext = '00';
   if (hourDiff > 0){ hourtext = String(hourDiff);}
   if (hourtext.length == 1){hourtext = '0' + hourtext};                                                              

   var mintext = '00';                           
   if (mindiff > 0){ mintext = String(mindiff);}
   if (mintext.length == 1){mintext = '0' + mintext};

  //shows output as HH:MM ( i needed shorter duration)
   duration.value= hourtext + ':' + mintext;

这是我的演唱会……

function get_time_difference(earlierDate, laterDate) 
{
    var oDiff = new Object();

    //  Calculate Differences
    //  -------------------------------------------------------------------  //
    var nTotalDiff = laterDate.getTime() - earlierDate.getTime();

    oDiff.days = Math.floor(nTotalDiff / 1000 / 60 / 60 / 24);
    nTotalDiff -= oDiff.days * 1000 * 60 * 60 * 24;

    oDiff.hours = Math.floor(nTotalDiff / 1000 / 60 / 60);
    nTotalDiff -= oDiff.hours * 1000 * 60 * 60;

    oDiff.minutes = Math.floor(nTotalDiff / 1000 / 60);
    nTotalDiff -= oDiff.minutes * 1000 * 60;

    oDiff.seconds = Math.floor(nTotalDiff / 1000);
    //  -------------------------------------------------------------------  //

    //  Format Duration
    //  -------------------------------------------------------------------  //
    //  Format Hours
    var hourtext = '00';
    if (oDiff.days > 0){ hourtext = String(oDiff.days);}
    if (hourtext.length == 1){hourtext = '0' + hourtext};

    //  Format Minutes
    var mintext = '00';
    if (oDiff.minutes > 0){ mintext = String(oDiff.minutes);}
    if (mintext.length == 1) { mintext = '0' + mintext };

    //  Format Seconds
    var sectext = '00';
    if (oDiff.seconds > 0) { sectext = String(oDiff.seconds); }
    if (sectext.length == 1) { sectext = '0' + sectext };

    //  Set Duration
    var sDuration = hourtext + ':' + mintext + ':' + sectext;
    oDiff.duration = sDuration;
    //  -------------------------------------------------------------------  //

    return oDiff;
}

此函数返回一个与datetime字符串和当前datetime不同的字符串

function get_time_diff( datetime )
{
    var datetime = typeof datetime !== 'undefined' ? datetime : "2014-01-01 01:02:03.123456";

    var datetime = new Date( datetime ).getTime();
    var now = new Date().getTime();

    if( isNaN(datetime) )
    {
        return "";
    }

    console.log( datetime + " " + now);

    if (datetime < now) {
        var milisec_diff = now - datetime;
    }else{
        var milisec_diff = datetime - now;
    }

    var days = Math.floor(milisec_diff / 1000 / 60 / (60 * 24));

    var date_diff = new Date( milisec_diff );

    return days + " Days "+ date_diff.getHours() + " Hours " + date_diff.getMinutes() + " Minutes " + date_diff.getSeconds() + " Seconds";
}

当我尝试相同时间戳之间的差异时，它给出了0天5小时30分钟

所以为了精确地得到它，我减去了5小时30分钟

function get_time_diff( datetime )
{
var datetime = typeof datetime !== 'undefined' ? datetime : "2014-01-01 01:02:03.123456";

var datetime = new Date(datetime).getTime();
var now = new Date().getTime();

if( isNaN(datetime) )
{
    return "";
}

console.log( datetime + " " + now);

if (datetime < now) {
    var milisec_diff = now - datetime;
}else{
    var milisec_diff = datetime - now;
}

var days = Math.floor(milisec_diff / 1000 / 60 / (60 * 24));

var date_diff = new Date( milisec_diff );

return days + "d "+ (date_diff.getHours() - 5) + "h " + (date_diff.getMinutes() - 30) + "m";
}

函数get\u time\u diff（datetime） { var datetime=typeof datetime！=“未定义”？datetime:“2014-01-01 01:02:03.123456”； var datetime=新日期（datetime）.getTime（）； var now=new Date（）.getTime（）； if（isNaN（日期时间）） { 返回“”； } console.log（datetime+“”+现在）；如果（日期时间<现在）{ var miliesec_diff=现在-日期时间； }否则{ var milisec_diff=日期时间-现在； } var天数=数学下限（毫微秒差值/1000/60/（60*24））； var date_diff=新日期（毫秒_diff）；返回天数+“d”+（日期差异获取小时数（）-5）+“h”+（日期差异获取分钟数（）-30）+“m”； }

这是对dmd733答案的补充。我修好了程序错误（我希望我能做到，但我还没能测试每一种情况）。p> 我还快速地在结果中添加了一个字符串属性，用于保存经过的一般时间（很抱歉，嵌套的ifs错误！！）。例如，如果用于UI并指示何时更新某些内容（如RSS提要）。有点不合时宜，但很高兴拥有：

function getTimeDiffAndPrettyText(oDatePublished) {

  var oResult = {};

  var oToday = new Date();

  var nDiff = oToday.getTime() - oDatePublished.getTime();

  // Get diff in days
  oResult.days = Math.floor(nDiff / 1000 / 60 / 60 / 24);
  nDiff -= oResult.days * 1000 * 60 * 60 * 24;

  // Get diff in hours
  oResult.hours = Math.floor(nDiff / 1000 / 60 / 60);
  nDiff -= oResult.hours * 1000 * 60 * 60;

  // Get diff in minutes
  oResult.minutes = Math.floor(nDiff / 1000 / 60);
  nDiff -= oResult.minutes * 1000 * 60;

  // Get diff in seconds
  oResult.seconds = Math.floor(nDiff / 1000);

  // Render the diffs into friendly duration string

  // Days
  var sDays = '00';
  if (oResult.days > 0) {
      sDays = String(oResult.days);
  }
  if (sDays.length === 1) {
      sDays = '0' + sDays;
  }

  // Format Hours
  var sHour = '00';
  if (oResult.hours > 0) {
      sHour = String(oResult.hours);
  }
  if (sHour.length === 1) {
      sHour = '0' + sHour;
  }

  //  Format Minutes
  var sMins = '00';
  if (oResult.minutes > 0) {
      sMins = String(oResult.minutes);
  }
  if (sMins.length === 1) {
      sMins = '0' + sMins;
  }

  //  Format Seconds
  var sSecs = '00';
  if (oResult.seconds > 0) {
      sSecs = String(oResult.seconds);
  }
  if (sSecs.length === 1) {
      sSecs = '0' + sSecs;
  }

  //  Set Duration
  var sDuration = sDays + ':' + sHour + ':' + sMins + ':' + sSecs;
  oResult.duration = sDuration;

  // Set friendly text for printing
  if(oResult.days === 0) {

      if(oResult.hours === 0) {

          if(oResult.minutes === 0) {
              var sSecHolder = oResult.seconds > 1 ? 'Seconds' : 'Second';
              oResult.friendlyNiceText = oResult.seconds + ' ' + sSecHolder + ' ago';
          } else { 
              var sMinutesHolder = oResult.minutes > 1 ? 'Minutes' : 'Minute';
              oResult.friendlyNiceText = oResult.minutes + ' ' + sMinutesHolder + ' ago';
          }

      } else {
          var sHourHolder = oResult.hours > 1 ? 'Hours' : 'Hour';
          oResult.friendlyNiceText = oResult.hours + ' ' + sHourHolder + ' ago';
      }
  } else { 
      var sDayHolder = oResult.days > 1 ? 'Days' : 'Day';
      oResult.friendlyNiceText = oResult.days + ' ' + sDayHolder + ' ago';
  }

  return oResult;
}

以下是对我有效的解决方案：

var date1 = new Date("08/05/2015 23:41:20");
var date2 = new Date("08/06/2015 02:56:32");

var diff = date2.getTime() - date1.getTime();

var msec = diff;
var hh = Math.floor(msec / 1000 / 60 / 60);
msec -= hh * 1000 * 60 * 60;
var mm = Math.floor(msec / 1000 / 60);
msec -= mm * 1000 * 60;
var ss = Math.floor(msec / 1000);
msec -= ss * 1000;

alert(hh + ":" + mm + ":" + ss);

我喜欢通过Epoch做这件事

var now = new Date();
var future = new Date(now.setMinutes(15));

var futureEpoch = moment(future).unix();
var nowEpoch = moment(now).unix();
var differenceInEpoch = nowEpoch - scheduledEpoch ;

console.log("futureEpoch        : " + futureEpoch);
console.log("nowEpoch              : " + nowEpoch);
console.log("differenceInEpoch     : " + differenceInEpoch);

var diffTime = new Date(0); // The 0 there is the key, which sets the date to the epoch
diffTime.setUTCSeconds(differenceInEpoch);
console.log("new diffTime : " + diffTime);

在php中获取表单提交后的输入值

$start_time = $_POST('start_time');
$end_time =$_POST('end_time');
$start = $start_time;
$end = $end_time;
$datetime1 = new DateTime($end);
$datetime2 = new DateTime($start);
//echo $datetime1->format('H:i:s');
$interval = $datetime1->diff($datetime2);
$elapsed = $interval->format('%h:%i');
$time = explode(":",$elapsed);
$hours = $time[0];
$minutes = $time[1];
$tminutes = $minutes + ($hours*60);

变量$tminutes是以分钟为单位的总差异，工作时间是$hour .

此代码用于php使用此逻辑并将此代码转换为js时间差（以毫秒为单位）

firstDate.getTime() - secondDate.getTime()

在我的例子中，我将在chrome存储器中以毫秒为单位存储时间，并在数小时后尝试查找差异

function timeDiffInHours(milliseconds){
    time_diff = (new Date).getTime() - milliseconds
    return parseInt((time_diff/(1000*60*60)) % 24)
}

// This is again sending current time and diff would be 0.
timeDiffInHours((new Date).getTime());

我对计时器计数器做了一些增强

//example return : 01:23:02:02
//               : 1 Day 01:23:02:02
//               : 2 Days 01:23:02:02 


function get_timeDifference(strtdatetime) {
    var datetime = new Date(strtdatetime).getTime();
    var now = new Date().getTime();

    if (isNaN(datetime)) {
        return "";
    }

    //console.log(datetime + " " + now);

    if (datetime < now) {
        var milisec_diff = now - datetime;
    } else {
        var milisec_diff = datetime - now;
    }

    var days = Math.floor(milisec_diff / 1000 / 60 / (60 * 24));

    var date_diff = new Date(milisec_diff);





    var msec = milisec_diff;
    var hh = Math.floor(msec / 1000 / 60 / 60);
    msec -= hh * 1000 * 60 * 60;
    var mm = Math.floor(msec / 1000 / 60);
    msec -= mm * 1000 * 60;
    var ss = Math.floor(msec / 1000);
    msec -= ss * 1000


    var daylabel = "";
    if (days > 0) {
        var grammar = " ";
        if (days > 1) grammar = "s " 
        var hrreset = days * 24;
        hh = hh - hrreset;
        daylabel = days + " Day" + grammar ;
    }


    //  Format Hours
    var hourtext = '00';
    hourtext = String(hh);
    if (hourtext.length == 1) { hourtext = '0' + hourtext };

    //  Format Minutes
    var mintext = '00';
    mintext = String(mm); 
    if (mintext.length == 1) { mintext = '0' + mintext };

    //  Format Seconds
    var sectext = '00';
    sectext = String(ss); 
    if (sectext.length == 1) { sectext = '0' + sectext };

    var msectext = '00';
    msectext = String(msec);
    msectext = msectext.substring(0, 1);
    if (msectext.length == 1) { msectext = '0' + msectext };

    return daylabel + hourtext + ":" + mintext + ":" + sectext + ":" + msectext;
}

//返回示例：01:23:02:02
//：1天01:23:02:02
//：2天01:23:02:02
函数get_时差（strtdatetime）{
var datetime=新日期（strtdatetime）.getTime（）；
var now=new Date（）.getTime（）；
if（isNaN（日期时间））{
返回“”；
}
//console.log（datetime+“”+现在）；
如果（日期时间<现在）{
var miliesec_diff=现在-日期时间；
}否则{
var milisec_diff=日期时间-现在；
}
var天数=数学下限（毫微秒差值/1000/60/（60*24））；
var date_diff=新日期（毫秒_diff）；
var msec=毫微秒差值；
var hh=数学地板（毫秒/1000/60/60）；
msec-=hh*1000*60*60；
var mm=数学地板（毫秒/1000/60）；
msec-=mm*1000*60；
var ss=数学下限（毫秒/1000）；
毫秒-=ss*1000
var daylab=“”；
如果（天数>0）{
var语法=”；
如果（天>1）语法=“s”
var hrreset=天*24；
hh=hh-hrreset；
daylabel=天+天+语法；
}
//格式小时数
var hourtext='00'；
hourtext=字符串（hh）；
如果（hourtext.length==1）{hourtext='0'+hourtext}；
//格式会议记录
var mintext='00'；
mintext=字符串（毫米）；
如果（mintext.length==1）{mintext='0'+mintext}；
//格式化秒数
var sectext='00'；
sectext=字符串（ss）；
如果（sectext.length==1）{sectext='0'+sectext}；
var msectext='00'；
msectext=字符串（毫秒）；
msectext=msectext.substring（0,1）；
如果（msectext.length==1）{msectext='0'+msectext}；
返回daylabel+hourtext+”：“+mintext+”：“+sectext+”：“+msectext；
}

我只会使用

getTime（）

和例如

Date.now（）

以毫秒为单位返回差值：

 //specified date:

var oneDate = new Date("November 02, 2017 06:00:00");

//number of milliseconds since midnight Jan 1 1970 till specified date

var oneDateMiliseconds = oneDate.getTime();

////number of milliseconds since midnight Jan 1 1970 till now

var currentMiliseconds = Date.now(); 

//return time difference in miliseconds

alert(currentMiliseconds-oneDateMiliseconds);

试试这个：

函数SumHours（）{
var smon=document.getElementById（'smon'）.value；
var fmon=document.getElementById（'fmon'）。值；
var-diff=0；
if（smon和fmon）{
smon=转换秒（smon）；
fmon=转换秒（fmon）；
diff=Math.abs（fmon-smon）；
log（'时差为：'+secondsTohhmmss（diff））；
}
函数ConvertToSeconds（时间）{
var splitTime=time.split（“：”）；
返回拆分时间[0]*3600+拆分时间[1]*60；
}
功能秒至hhmms（秒）{
var小时=parseInt（秒/3600）；
var seconds=parseInt（秒%3600）；
var分钟=parseInt（秒/60）；
返回时数+小时数：+分钟数+分钟数；
}
}

您可以使用矩js来实现此目的。momentJs“fromNow（）”将提供与当前时间的任何时间差

var m1 = any date time on moment format;

console.log(m1.fromNow());

/**
*两次不同
*@param-join
*@param lastSeen
*@param现在
*@返回{string}
*/
函数getTimeDiff（join，lastSeen，now=false）
{
设t1=new Date（join）.getTime（），t2=new Date（lastSeen）.getTime（），毫秒=0，时间=“”；
如果（现在）t2=Date.now（）；
if（isNaN（t1）| isNaN（t2））返回“”；
如果（t10）时间+=天+'d'；
如果（date_diff.getHours（）>0）time+=date_diff.getHours（）+'h'；
如果（date_diff.getMinutes（）>0）time+=date_diff.getMinutes（）+'m'；
如果（date_diff.getSeconds（）>0）time+=date_diff.getSeconds（）+'s'；
返回时间；
}
日志（getTimeDiff（1578852606081579530945513））；

您可以通过在中插入值来设置自定义差异

var m1 = any date time on moment format;

console.log(m1.fromNow());

You can Get Two Time Different with this function.

var moment = require("moment");
var momentDurationFormatSetup = require("moment-duration-format")

var now  = "2015-07-16T16:33:39.113Z";
var then = "2015-06-16T22:33:39.113Z";

var ms = moment(now,"YYYY-MM-DD'T'HH:mm:ss:SSSZ").diff(moment(then,"YYYY-MM-DD'T'HH:mm:ss:SSSZ"));
var d = moment.duration(ms);
var s = d.format("dd:hh:mm:ss");
console.log(s);

getDifference(theDate: string): string {
let end = moment(moment(moment()).valueOf());
let updatedAt = moment(new Date(theDate).valueOf());
let diff = end.diff(updatedAt, "hour", false);
if (diff > 8760) {
  diff = end.diff(updatedAt, "years", false);
  return diff > 1 ? diff + " years ago" : diff + " year ago";
} else if (diff > 730) {
  diff = end.diff(updatedAt, "months", false);
  return diff > 1 ? diff + " months ago" : diff + " month ago";
} else if (diff > 24) {
  diff = end.diff(updatedAt, "days", false);
  return diff > 1 ? diff + " days ago" : diff + " day ago";
} else if (diff <= 0) {
  diff = end.diff(updatedAt, "minutes", false);
  return diff > 1 ? diff + " minutes ago" : diff + " minute ago";
} else return diff > 1 ? diff + " hours ago" : diff + " hour ago";

let MILISECONDS = 1000
let YEAR_IN_SECONDS = 31536000
let MONTHS_IN_SECONDS = 2592000
let DAY_IN_SECONDS = 86400
let HOUR_IN_SECONDS = 3600
let MINUTES_IN_SECONDS = 60

let TIME_LENGTHS = [
  {seconds: YEAR_IN_SECONDS, term: 'years'},
  {seconds: MONTHS_IN_SECONDS, term: 'months'},
  {seconds: DAY_IN_SECONDS, term: 'days'},
  {seconds: HOUR_IN_SECONDS, term: 'hours'},
  {seconds: MINUTES_IN_SECONDS, term: 'minutes'},
  {seconds: 1, term: 'seconds'}
]
  const timeInUnitsFormat = function (start) {
  let messageJoins = []
  let now = new Date()
  let diffInSeconds = parseInt((now.getTime() - start.getTime()) / MILISECONDS)
  for (let tl of TIME_LENGTHS) {
    if (diffInSeconds >= tl.seconds) {
      let num_of_times = diffInSeconds / tl.seconds
      diffInSeconds = diffInSeconds % tl.seconds
      messageJoins.push(`${num_of_times} ${tl.term}`)
    }
  }
  return messageJoins.join(',')
}