Как конвертировать время миллисекунды в часы, минуты, секунды в формате JavaScript?

Question

Как конвертировать время миллисекунды в часы, минуты, секунды в формате JavaScript?

У меня есть время в миллисекундах, но я хочу, чтобы время после преобразования, как 00:00:00,

Пример: в миллисекундах =86400000. Я хочу, сколько часов в этих миллисекундах, как, 00:00:00

Как получить это в JavaScript?

138

javascript datetime milliseconds

Источник

user1114546 31 окт '13 в 07:05

27 ответов

Другие вопросы по тегам javascript datetime milliseconds

user1381240 31 окт '13 в 07:11 2013-10-31 07:11 · Answer 1 · 2013-10-31 07:11

Как насчет этого, создав функцию в javascript, как показано ниже:

function msToTime(duration) {
  var milliseconds = parseInt((duration % 1000) / 100),
    seconds = parseInt((duration / 1000) % 60),
    minutes = parseInt((duration / (1000 * 60)) % 60),
    hours = parseInt((duration / (1000 * 60 * 60)) % 24);

  hours = (hours < 10) ? "0" + hours : hours;
  minutes = (minutes < 10) ? "0" + minutes : minutes;
  seconds = (seconds < 10) ? "0" + seconds : seconds;

  return hours + ":" + minutes + ":" + seconds + "." + milliseconds;
}
console.log(msToTime(300000))

user5242405 24 авг '15 в 11:10 2015-08-24 11:10 · Answer 2 · 2015-08-24 11:10

Преобразовать время в миллисекундах в удобочитаемый формат.

 function timeConversion(millisec) {

        var seconds = (millisec / 1000).toFixed(1);

        var minutes = (millisec / (1000 * 60)).toFixed(1);

        var hours = (millisec / (1000 * 60 * 60)).toFixed(1);

        var days = (millisec / (1000 * 60 * 60 * 24)).toFixed(1);

        if (seconds < 60) {
            return seconds + " Sec";
        } else if (minutes < 60) {
            return minutes + " Min";
        } else if (hours < 24) {
            return hours + " Hrs";
        } else {
            return days + " Days"
        }
    }

user3131614 25 ноя '15 в 06:04 2015-11-25 06:04 · Answer 3 · 2015-11-25 06:04

У меня была та же проблема, вот что я в итоге сделал:

function parseMillisecondsIntoReadableTime(milliseconds){
  //Get hours from milliseconds
  var hours = milliseconds / (1000*60*60);
  var absoluteHours = Math.floor(hours);
  var h = absoluteHours > 9 ? absoluteHours : '0' + absoluteHours;

  //Get remainder from hours and convert to minutes
  var minutes = (hours - absoluteHours) * 60;
  var absoluteMinutes = Math.floor(minutes);
  var m = absoluteMinutes > 9 ? absoluteMinutes : '0' +  absoluteMinutes;

  //Get remainder from minutes and convert to seconds
  var seconds = (minutes - absoluteMinutes) * 60;
  var absoluteSeconds = Math.floor(seconds);
  var s = absoluteSeconds > 9 ? absoluteSeconds : '0' + absoluteSeconds;


  return h + ':' + m + ':' + s;
}


var time = parseMillisecondsIntoReadableTime(86400000);

alert(time);

user11894391 18 авг '19 в 08:49 2019-08-18 08:49 · Answer 4 · 2019-08-18 08:49

Вот мое решение

let h,m,s;
h = Math.floor(timeInMiliseconds/1000/60/60);
m = Math.floor((timeInMiliseconds/1000/60/60 - h)*60);
s = Math.floor(((timeInMiliseconds/1000/60/60 - h)*60 - m)*60);

// чтобы получить формат времени 00:00:00

s < 10 ? s = `0${s}`: s = `${s}`
m < 10 ? m = `0${m}`: m = `${m}`
h < 10 ? h = `0${h}`: h = `${h}`


console.log(`${s}:${m}:${h}`);

25

Источник

user11894391 18 авг '19 в 08:49

user5900345 11 май '16 в 16:42 2016-05-11 16:42 · Answer 5 · 2016-05-11 16:42

Этот возвращает время, как YouTube видео

    function getYoutubeLikeToDisplay(millisec) {
        var seconds = (millisec / 1000).toFixed(0);
        var minutes = Math.floor(seconds / 60);
        var hours = "";
        if (minutes > 59) {
            hours = Math.floor(minutes / 60);
            hours = (hours >= 10) ? hours : "0" + hours;
            minutes = minutes - (hours * 60);
            minutes = (minutes >= 10) ? minutes : "0" + minutes;
        }

        seconds = Math.floor(seconds % 60);
        seconds = (seconds >= 10) ? seconds : "0" + seconds;
        if (hours != "") {
            return hours + ":" + minutes + ":" + seconds;
        }
        return minutes + ":" + seconds;
    }

Выход:

getYoutubeLikeToDisplay (129900) = "2:10"
getYoutubeLikeToDisplay (1229900) = "20:30"
getYoutubeLikeToDisplay (21229900) = "05:53:50"

user10832108 12 ноя '19 в 23:48 2019-11-12 23:48 · Answer 6 · 2019-11-12 23:48

Извини, опоздал на вечеринку. Принятый ответ меня не устроил, поэтому я написал его сам.

Выход:

2h 59s
1h 59m
1h
1h 59s
59m 59s
59s

Код (машинописный текст):

function timeConversion(duration: number) {
  const portions: string[] = [];

  const msInHour = 1000 * 60 * 60;
  const hours = Math.trunc(duration / msInHour);
  if (hours > 0) {
    portions.push(hours + 'h');
    duration = duration - (hours * msInHour);
  }

  const msInMinute = 1000 * 60;
  const minutes = Math.trunc(duration / msInMinute);
  if (minutes > 0) {
    portions.push(minutes + 'm');
    duration = duration - (minutes * msInMinute);
  }

  const seconds = Math.trunc(duration / 1000);
  if (seconds > 0) {
    portions.push(seconds + 's');
  }

  return portions.join(' ');
}

console.log(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000) + (59 * 1000)));
console.log(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000)              ));
console.log(timeConversion((60 * 60 * 1000)                                 ));
console.log(timeConversion((60 * 60 * 1000)                    + (59 * 1000)));
console.log(timeConversion(                   (59 * 60 * 1000) + (59 * 1000)));
console.log(timeConversion(                                      (59 * 1000)));

user1409685 03 июл '18 в 13:20 2018-07-03 13:20 · Answer 7 · 2018-07-03 13:20

Вышеуказанные фрагменты не работают для случаев с более чем 1 днем (они просто игнорируются).

Для этого вы можете использовать:

function convertMS(ms) {
    var d, h, m, s;
    s = Math.floor(ms / 1000);
    m = Math.floor(s / 60);
    s = s % 60;
    h = Math.floor(m / 60);
    m = m % 60;
    d = Math.floor(h / 24);
    h = h % 24;
    h += d * 24;
    return h + ':' + m + ':' + s;
}

Благодаря https://gist.github.com/remino/1563878

user1301529 04 ноя '18 в 11:51 2018-11-04 11:51 · Answer 8 · 2018-11-04 11:51

Мне нужно было время только до одного дня, 24 часа, это было мое мнение:

const milliseconds = 5680000;

const hours = `0${new Date(milliseconds).getHours() - 1}`.slice(-2);
const minutes = `0${new Date(milliseconds).getMinutes()}`.slice(-2);
const seconds = `0${new Date(milliseconds).getSeconds()}`.slice(-2);

const time = `${hours}:${minutes}:${seconds}`
console.log(time);

Вы могли бы получить дни таким же образом, если это необходимо.

user5043056 10 май '21 в 00:47 2021-05-10 00:47 · Answer 9 · 2021-05-10 00:47

Форматировать как `hh:mm:ss` с дополнительным заполнением

( 1:59:59 или же 01:59:59)
( 1:59 или же 01:59)
(По умолчанию: без отступов)

Основываясь на ответе Чанда .

      function formatMilliseconds(milliseconds, padStart) {
    function pad(num) {
        return `${num}`.padStart(2, '0');
    }
    let asSeconds = milliseconds / 1000;

    let hours = undefined;
    let minutes = Math.floor(asSeconds / 60);
    let seconds = Math.floor(asSeconds % 60);

    if (minutes > 59) {
        hours = Math.floor(minutes / 60);
        minutes %= 60;
    }

    return hours
        ? `${padStart ? pad(hours) : hours}:${pad(minutes)}:${pad(seconds)}`
        : `${padStart ? pad(minutes) : minutes}:${pad(seconds)}`;
}

Тесты:

      let s = 1000;
let m = 60*s;
let h = 60*m;
console.log(formatMilliseconds(1*h));               // 1:00:00
console.log(formatMilliseconds(1*h, true));         // 01:00:00
console.log(formatMilliseconds(59*m + 59*s));       // 59:59
console.log(formatMilliseconds(59*m + 59*s, true)); // 59:59
console.log(formatMilliseconds(9*m + 9*s));         // 9:09
console.log(formatMilliseconds(9*m + 9*s, true));   // 09:09
console.log(formatMilliseconds(5*s));               // 0:05
console.log(formatMilliseconds(5*s, true));         // 00:05
console.log(formatMilliseconds(2400*s));            // 40:00
console.log(formatMilliseconds(2400*s, true));      // 40:00

.
.
.
Если вам нужна точность до миллисекунды, вы можете получить дробную часть, используя следующее:

      (asSeconds % 1).toFixed(3).substring(1)

Ваши возвраты в конечном итоге будут выглядеть следующим образом (при необходимости разбейте его для удобочитаемости):

      `${padStart ? pad(hours) : hours}:${pad(minutes)}:${pad(seconds)}${(asSeconds % 1).toFixed(3).substring(1)}`

Вероятно, есть более эффективные способы сделать это, но это наивное решение выполняет свою работу.

Контрольная работа:

      let asSeconds = 59.5219;
let seconds = Math.floor(asSeconds);
console.log(`${pad(seconds)}${(asSeconds % 1).toFixed(3).substring(1)}`);
// Equivalent to above, without using `pad()`:
//console.log(`${String(seconds).padStart(2, '0')}${(asSeconds % 1).toFixed(3).substring(1)}`);

// Output: 59.522

user5093961 30 окт '18 в 13:24 2018-10-30 13:24 · Answer 10 · 2018-10-30 13:24

Это решение использует один function разделить миллисекунды на parts object, и другой function отформатировать parts object,

Я создал 2 функции форматирования, по вашему запросу, и еще одну, которая печатает дружественную строку и учитывает единственное / множественное число, и включает опцию для отображения миллисекунд.

function parseDuration(duration) {
  let remain = duration

  let days = Math.floor(remain / (1000 * 60 * 60 * 24))
  remain = remain % (1000 * 60 * 60 * 24)

  let hours = Math.floor(remain / (1000 * 60 * 60))
  remain = remain % (1000 * 60 * 60)

  let minutes = Math.floor(remain / (1000 * 60))
  remain = remain % (1000 * 60)

  let seconds = Math.floor(remain / (1000))
  remain = remain % (1000)

  let milliseconds = remain

  return {
    days,
    hours,
    minutes,
    seconds,
    milliseconds
  };
}

function formatTime(o, useMilli = false) {
  let parts = []
  if (o.days) {
    let ret = o.days + ' day'
    if (o.days !== 1) {
      ret += 's'
    }
    parts.push(ret)
  }
  if (o.hours) {
    let ret = o.hours + ' hour'
    if (o.hours !== 1) {
      ret += 's'
    }
    parts.push(ret)
  }
  if (o.minutes) {
    let ret = o.minutes + ' minute'
    if (o.minutes !== 1) {
      ret += 's'
    }
    parts.push(ret)

  }
  if (o.seconds) {
    let ret = o.seconds + ' second'
    if (o.seconds !== 1) {
      ret += 's'
    }
    parts.push(ret)
  }
  if (useMilli && o.milliseconds) {
    let ret = o.milliseconds + ' millisecond'
    if (o.milliseconds !== 1) {
      ret += 's'
    }
    parts.push(ret)
  }
  if (parts.length === 0) {
    return 'instantly'
  } else {
    return parts.join(' ')
  }
}

function formatTimeHMS(o) {
  let hours = o.hours.toString()
  if (hours.length === 1) hours = '0' + hours

  let minutes = o.minutes.toString()
  if (minutes.length === 1) minutes = '0' + minutes

  let seconds = o.seconds.toString()
  if (seconds.length === 1) seconds = '0' + seconds

  return hours + ":" + minutes + ":" + seconds
}

function formatDurationHMS(duration) {
  let time = parseDuration(duration)
  return formatTimeHMS(time)
}

function formatDuration(duration, useMilli = false) {
  let time = parseDuration(duration)
  return formatTime(time, useMilli)
}


console.log(formatDurationHMS(57742343234))

console.log(formatDuration(57742343234))
console.log(formatDuration(5423401000))
console.log(formatDuration(500))
console.log(formatDuration(500, true))
console.log(formatDuration(1000 * 30))
console.log(formatDuration(1000 * 60 * 30))
console.log(formatDuration(1000 * 60 * 60 * 12))
console.log(formatDuration(1000 * 60 * 60 * 1))

user5675729 06 авг '21 в 00:31 2021-08-06 00:31 · Answer 11 · 2021-08-06 00:31

Я недавно столкнулся с такой ситуацией. Я сосредоточился на чистой читаемости и возможности повторного использования.

Использовать

(См. Определение функции ниже)

      timeUnits(86400000) // {days: 1, hours: 0, minutes: 0, seconds: 0, ms: 0}

Затем вы можете использовать данные, чтобы делать все, что захотите (например, строить строку).

Другие примеры:

      timeUnits(214870123) // {days: 2, hours: 11, minutes: 41, seconds: 10, ms: 123}

      timeUnits('70123') // null

Функция

      /**
 * Converts milliseconds into greater time units as possible
 * @param {int} ms - Amount of time measured in milliseconds
 * @return {Object|null} Reallocated time units. NULL on failure.
 */
function timeUnits( ms ) {
    if ( !Number.isInteger(ms) ) {
        return null
    }
    /**
     * Takes as many whole units from the time pool (ms) as possible
     * @param {int} msUnit - Size of a single unit in milliseconds
     * @return {int} Number of units taken from the time pool
     */
    const allocate = msUnit => {
        const units = Math.trunc(ms / msUnit)
        ms -= units * msUnit
        return units
    }
    // Property order is important here.
    // These arguments are the respective units in ms.
    return {
        // weeks: (604800000), // Uncomment for weeks
        days: allocate(86400000),
        hours: allocate(3600000),
        minutes: allocate(60000),
        seconds: allocate(1000),
        ms: ms // remainder
    }
}

Он написан таким образом, чтобы вы могли легко реализовать другие модули (например, там, где я комментировал реализацию в течение нескольких недель), если вы знаете их ценность в миллисекундах.

user11018641 12 янв '21 в 06:19 2021-01-12 06:19 · Answer 12 · 2021-01-12 06:19

// Следующее написано на Typescript, должно быть легко переведено на JS

      function humanReadableDuration(msDuration: int): string {
    const h = Math.floor(msDuration / 1000 / 60 / 60);
    const m = Math.floor((msDuration / 1000 / 60 / 60 - h) * 60);
    const s = Math.floor(((msDuration / 1000 / 60 / 60 - h) * 60 - m) * 60);

    // To get time format 00:00:00
    const seconds: string = s < 10 ? `0${s}` : `${s}`;
    const minutes: string = m < 10 ? `0${m}` : `${m}`;
    const hours: string = h < 10 ? `0${h}` : `${h}`;

    return `${hours}h ${minutes}m ${seconds}s`;
}

user7094524 16 авг '19 в 16:36 2019-08-16 16:36 · Answer 13 · 2019-08-16 16:36

Работал для меня

msToTime(milliseconds) {
    //Get hours from milliseconds
    var hours = milliseconds / (1000*60*60);
    var absoluteHours = Math.floor(hours);
    var h = absoluteHours > 9 ? absoluteHours : '0' + absoluteHours;

    //Get remainder from hours and convert to minutes
    var minutes = (hours - absoluteHours) * 60;
    var absoluteMinutes = Math.floor(minutes);
    var m = absoluteMinutes > 9 ? absoluteMinutes : '0' +  absoluteMinutes;

    //Get remainder from minutes and convert to seconds
    var seconds = (minutes - absoluteMinutes) * 60;
    var absoluteSeconds = Math.floor(seconds);
    var s = absoluteSeconds > 9 ? absoluteSeconds : '0' + absoluteSeconds;

    return h == "00" ? m + ':' + s : h + ':' + m + ':' + s;
}

user303623 25 май '20 в 00:17 2020-05-25 00:17 · Answer 14 · 2020-05-25 00:17

Человекочитаемый код для удобочитаемого вывода, и вы можете расширить его до световых лет, наносекунд или чего-то еще, очень интуитивно. Очевидно, вы захотите преобразовать это в функцию и повторно использовать некоторые из этих промежуточных вызовов по модулю.

second = 1000 
minute = second * 60
hour = minute * 60 
day = hour * 24

test = 3 * day + 2 * hour + 11 * minute + 58 * second

console.log(Math.floor(test / day))
console.log(Math.floor(test % day / hour))
console.log(Math.floor(test % day % hour / minute))
console.log(Math.floor(test % day % hour % minute / second))

user10992166 21 дек '20 в 14:56 2020-12-21 14:56 · Answer 15 · 2020-12-21 14:56

Продолжая ответ @Rick, я предпочитаю что-то вроде этого:

      function msToReadableTime(time){
  const second = 1000;
  const minute = second * 60;
  const hour = minute * 60;

  let hours = Math.floor(time / hour % 24);
  let minutes = Math.floor(time / minute % 60);
  let seconds = Math.floor(time / second % 60);
 

  return hours + ':' + minutes + ":" + seconds;
}

3

Источник

user10992166 21 дек '20 в 14:56

user2594854 22 фев '18 в 16:49 2018-02-22 16:49 · Answer 16 · 2018-02-22 16:49

На основании @Chand ответа. Это реализация в Typescript. Немного безопаснее, чем типы принуждения в JS. При удалении аннотации типа должен быть действителен JS. Также используются новые строковые функции для нормализации времени.

function displayTime(millisec: number) {
 const normalizeTime = (time: string): string => (time.length === 1) ? time.padStart(2, '0') : time;

 let seconds: string = (millisec / 1000).toFixed(0);
 let minutes: string = Math.floor(parseInt(seconds) / 60).toString();
 let hours: string = '';

 if (parseInt(minutes) > 59) {
   hours = normalizeTime(Math.floor(parseInt(minutes) / 60).toString());
   minutes = normalizeTime((parseInt(minutes) - (parseInt(hours) * 60)).toString());
 }
 seconds = normalizeTime(Math.floor(parseInt(seconds) % 60).toString());

 if (hours !== '') {
    return `${hours}:${minutes}:${seconds}`;
 }
   return `${minutes}:${seconds}`;
}

user418150 12 май '22 в 15:48 2022-05-12 15:48 · Answer 17 · 2022-05-12 15:48

Объект Date может быть построен из миллисекунд:

      const date = new Date(0, 0, 0, 0, 0, 0, milliseconds);

Затем время может быть получено в любом количестве форматов. Тот, который вам нужен, соответствует тому, который используется в Соединенном Королевстве, локаль en-GB:

      const hms = d.toLocaleTimeString('en-GB');

user6204133 03 фев '18 в 08:26 2018-02-03 08:26 · Answer 18 · 2018-02-03 08:26

Мое решение

var sunriseMills = 1517573074000;         // sunrise in NewYork on Feb 3, 2018  - UTC time
var offsetCityMills = -5 * 3600 * 1000;   // NewYork delay to UTC 
var offsetDeviceMills =  new Date().getTimezoneOffset() * 60 * 1000 ;  // eg. I live in Romania (UTC+2) >> getTimezoneOffset() = 120

var textTime = new Date(sunriseMills + offsetCityMills + offsetDeviceMills) 
    .toLocaleTimeString('en-US', { hour: 'numeric', minute: 'numeric' });

textTime станет '7.04 AM'

Xx-Mohit-xX 23 сен '22 в 06:36 2022-09-23 06:36 · Answer 19 · 2022-09-23 06:36

Если кому-то все еще нужна модифицированная версия одного из фрагментов кода, опубликованных выше в js, /questions/11824531/kak-konvertirovat-vremya-millisekundyi-v-chasyi-minutyi-sekundyi-v-formate-javascript/55015929#55015929

      function timeConversion(duration) { 
    var portions = []; 
    var msInDay = 1000 * 60 * 60 * 24
    var days = Math.trunc(duration / msInDay);
    if (days > 0 ) {
        portions.push(days + (days === 1 ? " day" : " days"))
        duration = duration - (days * msInDay)
    }
    var msInHour = 1000 * 60 * 60; 
    var hours = Math.trunc(duration / msInHour);
    if (hours > 0) {
    portions.push(hours + (hours === 1 ? ' hour' : ' hours'));
    duration = duration - (hours * msInHour);
} 
var msInMinute = 1000 * 60; 
var minutes = Math.trunc(duration / msInMinute); 
if (minutes > 0) {
    portions.push(minutes + (minutes === 1 ? ' minute' : ' minutes'));
    duration = duration - (minutes * msInMinute);
}
var seconds = Math.trunc(duration / 1000); 
if (seconds > 0) {
    portions.push(seconds + (seconds === 1 ? ' second' : ' seconds'));
}
return portions.join(' ');
}
console.log(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000) + (59 * 1000)));
console.log(timeConversion((60 * 60 * 1000) + (59 * 60 * 1000)));
console.log(timeConversion((60 * 60 * 1000)));
console.log(timeConversion((60 * 60 * 1000) + (59 * 1000)));
console.log(timeConversion((59 * 60 * 1000) + (59 * 1000)));
console.log(timeConversion((59 * 1000)));

user7357420 18 мар '19 в 16:26 2019-03-18 16:26 · Answer 20 · 2019-03-18 16:26

Если вы используете машинопись, это может быть полезно для вас

enum ETime {
  Seconds = 1000,
  Minutes = 60000,
  Hours = 3600000,
  SecInMin = 60,
  MinInHours = 60,
  HoursMod = 24,
  timeMin = 10,
}

interface ITime {
  millis: number
  modulo: number
}

const Times = {
  seconds: {
    millis: ETime.Seconds,
    modulo: ETime.SecInMin,
  },
  minutes: {
    millis: ETime.Minutes,
    modulo: ETime.MinInHours,
  },
  hours: {
    millis: ETime.Hours,
    modulo: ETime.HoursMod,
  },
}

const dots: string = ":"

const msToTime = (duration: number, needHours: boolean = true): string => {
  const getCorrectTime = (divider: ITime): string => {
    const timeStr: number = Math.floor(
      (duration / divider.millis) % divider.modulo,
    )

    return timeStr < ETime.timeMin ? "0" + timeStr : String(timeStr)
  }

  return (
    (needHours ? getCorrectTime(Times.hours) + dots : "") +
    getCorrectTime(Times.minutes) +
    dots +
    getCorrectTime(Times.seconds)
  )
}

user13211449 27 фев '23 в 22:46 2023-02-27 22:46 · Answer 21 · 2023-02-27 22:46

«Язык Go» Реализация форматирования длительности в Typescript

      const sec = 1000
const min = sec * 60
const hour = min * 60
const day = hour * 24

export function msToDuration(ms: number): string {
    if (ms == 0) {
        return "0s"
    }

    let sign = ''
    if (ms < 0) {
        ms *= -1
        sign = '-'
    }

    const days = ms / day;
    ms = ms % day

    const hours = ms / hour;
    ms = ms % hour

    const minutes = ms / min;
    ms = ms % min

    const seconds = ms / sec;


    let time = seconds.toFixed(3) + "s"

    if (minutes >= 1) {
        time = minutes.toFixed(0) + "m" + time
    }

    if (hours >= 1) {
        time = hours.toFixed(0) + "h" + time
    }

    if (days >= 1) {
        time = days.toFixed(0) + "d" + time
    }

    return sign + time
}

Наши примеры:

      3d1h10m15.123s
1h10m15.123s
10m15.123s
15.123s
0.123s
0s

user5068409 20 май '22 в 15:29 2022-05-20 15:29 · Answer 22 · 2022-05-20 15:29

      let dateTimeStr = new Date(1949778000);
dateTimeStr = Math.floor(dateTimeStr/86400000) +' days '+ dateTimeStr.getHours() +' hours '+ dateTimeStr.getMinutes() +' minutes '+ dateTimeStr.getSeconds() +' seconds';
console.log(dateTimeStr);

Вам не нужно считать дни, если они вам не нужны

«22 дня 16 часов 36 минут 18 секунд»

0

Источник

user5068409 20 май '22 в 15:29

user11067065 31 мар '22 в 13:03 2022-03-31 13:03 · Answer 23 · 2022-03-31 13:03

Рефакторинг с @dusht на ES6+ и более функциональный:

      const addPrefix = time => time < 10 ? '0' + time : time;
const toHours = time => addPrefix(Math.floor((time / (1000 * 60 * 60)) % 24));
const toMinutes = time => addPrefix(Math.floor((time / (1000 * 60)) % 60));
const toSeconds = (ime => addPrefix(Math.floor((time / 1000) % 60));
const toMiliseconds = time => Math.floor((time % 1000) / 100);


const milisecondToHoursAndMinute = time => {
  const hours = toHours(time);
  const minutes = toMinutes(time);
  const seconds = toSeconds(time);
  const miliseconds = toMiliseconds(time);

  return `${hours}:${minutes}:${seconds}.${miliseconds}`
}

user8087223 02 мар '23 в 06:00 2023-03-02 06:00 · Answer 24 · 2023-03-02 06:00

Удобочитаемый вывод:

например, 21 день, 14 часов, 18 минут, 18 секунд, 753 миллисекунды.

Опираясь на потрясающий ответ @Nofi для удобочитаемого вывода, я сделал более удобочитаемую (на мой взгляд) и точную версию (и менее сложную, чем ответ @Steven Spungin, хотя их ответ действительно классный) для личного использования, и я подумал, что я поделюсь здесь.

user10474 03 авг '22 в 19:49 2022-08-03 19:49 · Answer 25 · 2022-08-03 19:49

Я не вижу необходимости усложнять все эти ответы, легко добавить нули, добавив степень 10:

      function timeToString(t) {
  const value =
    ((t / 3600_000 % 24) | 0) * 10000 +
    ((t / 60_000 % 60) | 0) * 100 +
    ((t / 1_000 % 60) | 0);
  return (1000000 + value).toString().replace(/1(..)(..)(..)/, '$1:$2:$3');
}

0

Источник

user10474 03 авг '22 в 19:49

user9099269 04 июл '19 в 10:51 2019-07-04 10:51 · Answer 26 · 2019-07-04 10:51

В моей реализации я использовал Moment.js:

export default (value) => 
  const duration = moment.duration(value);

  const milliseconds = duration.milliseconds();
  const seconds = duration.seconds();
  const minutes = duration.minutes();
  const hours = duration.hours();
  const day = duration.days();

  const sDay = `${day}d `;
  const sHours = (hours < 10) ? `0${hours}h ` : `${hours}h `;
  const sMinutes = (minutes < 10) ? `0${minutes}' ` : `${minutes}' `;
  const sSeconds = (seconds < 10) ? `0${seconds}" ` : `${seconds}" `;
  const sMilliseconds = `${milliseconds}ms`;

  ...
}

Получив струны, я сочинил их как хочу.

user13756621 16 июн '20 в 17:30 2020-06-16 17:30 · Answer 27 · 2020-06-16 17:30

Я работаю на себя, так как получаю миллисекунды =1592380675409, используя метод javascript getTime(), который возвращает количество миллисекунд между полуночью 1 января 1970 года и указанной датой.

var d = new Date();//Wed Jun 17 2020 13:27:55 GMT+0530 (India Standard Time)
var n = d.getTime();//1592380675409 this value is store somewhere

//function call 
console.log(convertMillisecToHrMinSec(1592380675409));

var convertMillisecToHrMinSec = (time) => {
  let date = new Date(time);
  let hr = date.getHours();
  let min = date.getMinutes();
  let sec = date.getSeconds();

  hr = (hr < 10) ? "0"+ hr : hr;
  min = (min < 10) ? "0"+ min : min;
  sec = (sec < 10) ? "0"+ sec : sec;

  return hr + ':' + min + ":" + sec;//01:27:55
}

Как конвертировать время миллисекунды в часы, минуты, секунды в формате JavaScript?

27 ответов

Форматировать как hh:mm:ss с дополнительным заполнением

Использовать

Функция

Удобочитаемый вывод:

Форматировать как `hh:mm:ss` с дополнительным заполнением