두 날짜 사이의 시간 차이를 가져옵니다.

두 날짜 사이의 시간 차이를 가져옵니다.

난 뭐든 할 수 있고 모멘티즈로 데이트도 좀 더 즐길 수 있어하지만 당황스럽게도, 나는 단순해 보이는 것을 하려고 노력하는데 어려움을 겪고 있다: 두 번의 차이를 얻는 것이다.

예:

var now  = "04/09/2013 15:00:00";
var then = "04/09/2013 14:20:30";

//expected result:
"00:39:30"

내가 시도한 것:

var now = moment("04/09/2013 15:00:00");
var then = moment("04/09/2013 14:20:30");

console.log(moment(moment.duration(now.diff(then))).format("hh:mm:ss"))
//outputs 10:39:30  

나는 저기에 있는 10이 무엇인지 이해할 수 없다.저는 브라질에 살고 있기 때문에, 가능하다면 utc-0300입니다.

의 moment.duration(now.diff(then))입니다.

 days: 0
 hours: 0
 milliseconds: 0
 minutes: 39
 months: 0
 seconds: 30
 years: 0

그래서 제 질문은 어떻게 모멘트의 지속시간을 시간 간격으로 변환할 것인가 하는 것입니다.물론 쓸 수 있다

duration.get("hours") +":"+ duration.get("minutes") +:+ duration.get("seconds")

뭔가 더 우아한 게 있는 것 같아요.전혀두고 싶은 게 있어요

보면, 에서는, 「」를 참조해 주세요.now 말합니다.

Tue Apr 09 2013 15:00:00 GMT-0300 (E. South America Standard Time)…}

★★★★★★★★★★★★★★★★★」moment(moment.duration(now.diff(then))) 말합니다

Wed Dec 31 1969 22:39:30 GMT-0200 (E. South America Daylight Time)…}

두 번째 값이 여름 시간(-0200)인 이유를 알 수 없습니다.하지만 저는 데이트를 좋아하지 않는다고 확신합니다.

업데이트 2

음, 값은 -0200 이에요.아마 31/12/190이 여름 시간이 사용된 날짜이기 때문일 거예요.그게 바로 그거죠.

이 접근방식은 총 지속시간이 24시간 미만인 경우에만 유효합니다.

var now  = "04/09/2013 15:00:00";
var then = "04/09/2013 14:20:30";

moment.utc(moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"))).format("HH:mm:ss")

// outputs: "00:39:30"

24시간 이상인 경우 위의 방법으로는 시간이 0으로 리셋되므로 이상적이지 않습니다.

24시간 이상 유효한 응답을 받으려면 대신 다음과 같은 작업을 수행해야 합니다.

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);
var s = Math.floor(d.asHours()) + moment.utc(ms).format(":mm:ss");

// outputs: "48:39:30"

시 note note 。d.minutes() ★★★★★★★★★★★★★★★★★」d.seconds()따로따로하지만제로파딩도해야합니다.

는 형식을 지정할 수 입니다.duration이의가 현재 없습니다.여기에 요청하셨습니다.단, 다음과 같은 목적을 위해 특별히 moment-duration-format이라는 서드파티 플러그인이 있습니다.

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);
var s = d.format("hh:mm:ss");

// outputs: "48:39:30"

문제는 moment.duration()의 결과를 포맷하기 전에 moment()로 되돌리는 것입니다.이것에 의해, 모멘트()는 그것을 Unix 에폭에 상대적인 시간으로 해석합니다.

원하는 포맷은 아니지만

moment.duration(now.diff(then)).humanize()

'40분'과 같은 유용한 형식을 얻을 수 있습니다.특정 포맷에 관심이 있다면 직접 새로운 스트링을 작성해야 합니다.저렴한 방법은

[diff.asHours(), diff.minutes(), diff.seconds()].join(':')

서 ''는var diff = moment.duration(now.diff(then)). 이것은 한 자리 값에 제로 패딩을 제공하지 않습니다.그러기 위해서는 언더스코어.string과 같은 것을 고려해 보는 것이 좋을지도 모릅니다.단, 몇 개의 추가 제로로 가기에는 너무 먼 것 같습니다.:)

var a = moment([2007, 0, 29]);
var b = moment([2007, 0, 28]);
a.diff(b, 'days') //[days, years, months, seconds, ...]
//Result 1 

나에게 효과가 있었다

자세한 내용은 http://momentjs.com/docs/ #/displaying/discription/discriptions/를 참조하십시오.

2개의 타임스탬프를 월이나 연도가 아닌 일, 시간, 분 단위로만 다른 경우.

var now  = "01/08/2016 15:00:00";
var then = "04/02/2016 14:20:30";
var diff = moment.duration(moment(then).diff(moment(now)));

diff에는 2개월, 23일, 23시간 20분이 포함됩니다.단, 몇 일, 몇 시간, 몇 분 안에 결과를 얻을 수 있기 때문에, 심플한 솔루션은 다음과 같습니다.

var days = parseInt(diff.asDays()); //84

var hours = parseInt(diff.asHours()); //2039 hours, but it gives total hours in given miliseconds which is not expacted.

hours = hours - days*24;  // 23 hours

var minutes = parseInt(diff.asMinutes()); //122360 minutes,but it gives total minutes in given miliseconds which is not expacted.

minutes = minutes - (days*24*60 + hours*60); //20 minutes.

최종 결과는 84일 23시간 20분입니다.

했을 때diff 단위로 합니다.가 「」에 .duration올바른 지속시간을 계산하기 위해 사용됩니다.를 「」에 .moment()에폭/유닉스 시간 1970년1월 1일(미드나이트 UTC/GMT)로부터 밀리초 단위로 계산됩니다.그래서 1969년을 잘못된 시간과 함께 해로 받는 것이다.

duration.get("hours") +":"+ duration.get("minutes") +":"+ duration.get("seconds")

이 될 것 는 이 순간부터 이렇게 하면 안 돼요.js는 안 요.format 더 꾸밈없이 쓸 수도 요.또는 간단한 래퍼를 작성하여 알기 쉽게 만들 수도 있습니다.

이거면 잘 될 거예요.

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);

console.log(d.days() + ':' + d.hours() + ':' + d.minutes() + ':' + d.seconds());

hh:mm:ss만 필요한 경우 다음과 같은 함수를 사용할 수 있습니다.

//param: duration in milliseconds
MillisecondsToTime: function(duration) {
    var seconds = parseInt((duration/1000)%60)
        , minutes = parseInt((duration/(1000*60))%60)
        , hours = parseInt((duration/(1000*60*60))%24)
        , days  = parseInt(duration/(1000*60*60*24));

    var hoursDays = parseInt(days*24);
    hours += hoursDays;
    hours = (hours < 10) ? "0" + hours : hours;
    minutes = (minutes < 10) ? "0" + minutes : minutes;
    seconds = (seconds < 10) ? "0" + seconds : seconds;
    return hours + ":" + minutes + ":" + seconds;
}

사용방법:

var duration = moment.duration(endDate.diff(startDate));
var aa = duration.asHours();

대신

Math.floor(duration.asHours()) + moment.utc(duration.asMilliseconds()).format(":mm:ss")

하는 것이 좋다

moment.utc(total.asMilliseconds()).format("HH:mm:ss");

이것은 YYY-MM-DD HH:mm:ss 형식의 날짜에 적용됩니다.

const moment=require("moment");
let startDate=moment("2020-09-16 08:39:27");
const endDate=moment();


const duration=moment.duration(endDate.diff(startDate))
console.log(duration.asSeconds());
 console.log(duration.asHours());

ES8에서는 모멘트를 사용하고 있습니다.지금부터 모멘트 오브젝트가 되기 시작합니다.

const duration = moment.duration(now.diff(start));
const timespan = duration.get("hours").toString().padStart(2, '0') +":"+ duration.get("minutes").toString().padStart(2, '0') +":"+ duration.get("seconds").toString().padStart(2, '0');

타이프스크립트:다음은기능합니다.

export const getTimeBetweenDates = ({
  until,
  format
}: {
  until: number;
  format: 'seconds' | 'minutes' | 'hours' | 'days';
}): number => {
  const date = new Date();
  const remainingTime = new Date(until * 1000);
  const getFrom = moment([date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()]);
  const getUntil = moment([remainingTime.getUTCFullYear(), remainingTime.getUTCMonth(), remainingTime.getUTCDate()]);
  const diff = getUntil.diff(getFrom, format);
  return !isNaN(diff) ? diff : null;
};

날짜 시간 기반 입력

    var dt1 = new Date("2019-1-8 11:19:16");
    var dt2 = new Date("2019-1-8 11:24:16");


    var diff =(dt2.getTime() - dt1.getTime()) ;
    var hours = Math.floor(diff / (1000 * 60 * 60));
    diff -= hours * (1000 * 60 * 60);
    var mins = Math.floor(diff / (1000 * 60));
    diff -= mins * (1000 * 60);


    var response = {
        status : 200,
        Hour : hours,
        Mins : mins
    }

산출량

{
"status": 200,
"Hour": 0,
"Mins": 5
}

이렇게 하면 (4초, 2분, 1시간, 2일, 3주, 4개월, 5년)과 같은 가장 큰 시간 차이가 반환됩니다.최근 알림용으로 사용하고 있습니다.

function dateDiff(startDate, endDate) {
    let arrDate = ["seconds", "minutes", "hours", "days", "weeks", "months", "years"];
    let dateMap = arrDate.map(e => moment(endDate).diff(startDate, e));
    let index = 6 - dateMap.filter(e => e == 0).length;
    return {
        type: arrDate[index] ?? "seconds",
        value: dateMap[index] ?? 0
    };
}

§:

dateDiff("2021-06-09 01:00:00", "2021-06-09 04:01:01")

{type: "hours", value: 3}

dateDiff("2021-06-09 01:00:00", "2021-06-12 04:01:01")

{type: "days", value: 3}

dateDiff("2021-06-09 01:00:00", "2021-06-09 01:00:10")

{type: "seconds", value: 10}

타이프 스크립트로 간단한 함수를 만듭니다.

const diffDuration: moment.Duration = moment.duration(moment('2017-09-04 12:55').diff(moment('2017-09-02 13:26')));
setDiffTimeString(diffDuration);

function setDiffTimeString(diffDuration: moment.Duration) {
  const str = [];
  diffDuration.years() > 0 ? str.push(`${diffDuration.years()} year(s)`) : null;
  diffDuration.months() > 0 ? str.push(`${diffDuration.months()} month(s)`) : null;
  diffDuration.days() > 0 ? str.push(`${diffDuration.days()} day(s)`) : null;
  diffDuration.hours() > 0 ? str.push(`${diffDuration.hours()} hour(s)`) : null;
  diffDuration.minutes() > 0 ? str.push(`${diffDuration.minutes()} minute(s)`) : null;
  console.log(str.join(', '));
} 
// output: 1 day(s), 23 hour(s), 29 minute(s)

javascript 생성 https://www.typescriptlang.org/play/index.html

InTime=06:38, OutTime=15:40

 calTimeDifference(){
        this.start = dailyattendance.InTime.split(":");
        this.end = dailyattendance.OutTime.split(":");
        var time1 = ((parseInt(this.start[0]) * 60) + parseInt(this.start[1]))
        var time2 = ((parseInt(this.end[0]) * 60) + parseInt(this.end[1]));
        var time3 = ((time2 - time1) / 60);
        var timeHr = parseInt(""+time3);
        var  timeMin = ((time2 - time1) % 60);
    }

MOEMENTJS를 사용한 에폭 시차:

두 에폭 시간 간의 차이를 구하려면:

구문: moment.duration(moment(moment(date1).diff(moment(date2)))).asHours()

시간 차이: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asHours()

분 단위 차이: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asMinutes().toFixed()

주의: 삭제할 수 있습니다..toFixed()정확한 값이 필요한 경우.

코드:

const moment = require('moment')

console.log('Date 1',moment(1590597909877).toISOString())
console.log('Date 2',moment(1590597744551).toISOString())
console.log('Date1 - Date 2 time diffrence is : ',moment.duration(moment(moment(1590597909877).diff(moment(1590597744551)))).asMinutes().toFixed()+' minutes')

여기서 작업 예를 참조하십시오. https://repl.it/repls/MoccasinDearDimension

두 순간의 형식 날짜 또는 javascript 날짜 형식의 무관심(분)을 구별하기 위해 가장 적합한 솔루션은 다음과 같습니다.

const timeDiff = moment.duration((moment(apptDetails.end_date_time).diff(moment(apptDetails.date_time)))).asMinutes()

asMinutes() 함수를 바꾸는 것만으로 필요에 따라 차분 포맷을 변경할 수 있습니다.

사이에 ( 「」 「」 「」 「」 「」startDate,endDate):

var currentLocaleData = moment.localeData("en");
var duration = moment.duration(endDate.diff(startDate));
var nbDays = Math.floor(duration.asDays()); // complete days
var nbDaysStr = currentLocaleData.relativeTime(returnVal.days, false, "dd", false);

nbDaysStr'3일' 정도 포함;

예를 들어, 시간 또는 월의 표시 방법에 대해서는, https://momentjs.com/docs/#/i18n/changing-module/ 를 참조해 주세요.

다음 접근법은 모든 경우에 유효합니다(24시간 미만 날짜와 24시간 이상 차이).

// Defining start and end variables
let start = moment('04/09/2013 15:00:00', 'DD/MM/YYYY hh:mm:ss');
let end   = moment('04/09/2013 14:20:30', 'DD/MM/YYYY hh:mm:ss');

// Getting the difference: hours (h), minutes (m) and seconds (s)
let h  = end.diff(start, 'hours');
let m  = end.diff(start, 'minutes') - (60 * h);
let s  = end.diff(start, 'seconds') - (60 * 60 * h) - (60 * m);

// Formating in hh:mm:ss (appends a left zero when num < 10)
let hh = ('0' + h).slice(-2);
let mm = ('0' + m).slice(-2);
let ss = ('0' + s).slice(-2);

console.log(`${hh}:${mm}:${ss}`); // 00:39:30

매우 간단합니다. 코드 아래 모멘트는 현재 시간과의 차이를 시간 단위로 반환합니다.

moment().diff('2021-02-17T14:03:55.811000Z', "h")

const getRemainingTime = (t2) => {
  const t1 = new Date().getTime();
  let ts = (t1-t2.getTime()) / 1000;

  var d = Math.floor(ts / (3600*24));
  var h = Math.floor(ts % (3600*24) / 3600);
  var m = Math.floor(ts % 3600 / 60);
  var s = Math.floor(ts % 60);

  console.log(d, h, m, s)

}

언급URL : https://stackoverflow.com/questions/18623783/get-the-time-difference-between-two-datetimes