Wie konvertiere ich Zeit Millisekunden in Stunden, Minuten, Sekunden Format in JavaScript?

79

Ich habe die Zeit als Millisekunden, aber ich möchte die Zeit nach der Konvertierung wie 00:00:00.

Beispiel: In Millisekunden = 86400000. Ich möchte, wie viele Stunden in diesen Millisekunden mögen,00:00:00

Wie bekomme ich es in JavaScript?

Cheliyan
quelle

Antworten:

118

Wie wäre es damit, indem Sie eine Funktion in Javascript erstellen, wie unten gezeigt:

function msToTime(duration) {
  var milliseconds = parseInt((duration % 1000) / 100),
    seconds = Math.floor((duration / 1000) % 60),
    minutes = Math.floor((duration / (1000 * 60)) % 60),
    hours = Math.floor((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))

Dusht
quelle
Ich habe diese Methode zum Konvertieren von Millisekunden in Stunden: Minuten: Sekunden verwendet. Aber ich habe es nicht richtig verstanden. Es gibt nur 21:11:05 für alle Millisekunden. Wie kann ich das implementieren?
Cheliyan
1
var s = st_date + '' + start; var e = end_date + '' + end; var bits = s.split (/ \ D /); var bits1 = e.split (/ \ D /); var date = new Date (Bits [0], - Bits [1], Bits [2], Bits [3], Bits [4], Bits [5]); var date1 = neues Datum (Bits1 [0], - Bits1 [1], Bits1 [2], Bits1 [3], Bits1 [4], Bits1 [5]);
Cheliyan
var t1 = date.getTime () var t2 = date1.getTime () var t3 = date1.getTime () - date.getTime (); var Sekunden; var Minuten; var Millisekunden = parseInt ((t3% 1000) / 100), Sekunden = parseInt ((t3 / 1000)% 60), Minuten = parseInt ((t3 / (1000 * 60))% 60), Stunden = parseInt ((t3) / (1000 * 60 * 60))% 24); Stunden = (Stunden <10)? "0" + Stunden: Stunden; Minuten = (Minuten <10)? "0" + Minuten: Minuten; Sekunden = (Sekunden <10)? "0" + Sekunden: Sekunden; Dauer = Stunden + ":" + Minuten + ":" + Sekunden; alert ('dur ::' + t3); Alarm ('Dauer:' + Dauer);
Cheliyan
5
parseInt (string) ist nicht der optimale Weg zum Boden. Zum Beispiel können Sie es nicht in Typoskript verwenden. Auch warum ms / 100? Dies ist überhaupt keine gute Antwort.
Dominik
1
jsperf.com/test-parseint-and-math-floor Floor ist viel schneller als ParseInt
Matthieu Riegler
52

Konvertieren der Zeit in Millisekunden in ein für Menschen lesbares Format.

 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"
        }
    }

"Out Put Sample"

Nofi
quelle
4
Ich fand dies am nützlichsten, die Top-Antwort schien Stunden in meinen Tests nicht sehr gut zu verarbeiten, und dies gibt Ihnen auch die Optionen für Tage.
Ak85
21

Ich hatte das gleiche Problem, das habe ich letztendlich getan:

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

xno
quelle
16

Dieser gibt Zeit wie YouTube-Videos zurück

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

Ausgabe:

  • getYoutubeLikeToDisplay (129900) = "2:10"
  • getYoutubeLikeToDisplay (1229900) = "20:30"
  • getYoutubeLikeToDisplay (21229900) = "05:53:50"
Chand
quelle
Kommentar - funktioniert nicht richtig für negative Zeit zum Beispiel -3000sollte zeigen, -00:03aber es kehrt zurück -1:0-03.
Anu
16

Hier ist meine Lösung

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

// um das Zeitformat 00:00:00 zu erhalten

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}`);
Zinn Pritišanac
quelle
HERRLICH. Vielen Dank.
Andy
Sauberste Antwort auf diese Frage.
Muad-Dweeb
1
Ich würde den Wert außerhalb des ternären Operators auf s setzen:s = `${s < 10 ? '0': ''}${s}`
Seniorpreacher
8

Entschuldigung, spät zur Party. Die akzeptierte Antwort hat es nicht für mich geschnitten, also habe ich es selbst geschrieben.

Ausgabe:

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

Code (Typoskript):

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)));
anonimito
quelle
Danke Mann, das wollte ich. Musste
mich
Ich fing an, meine eigenen zu schreiben, dann dachte ich, jemand muss das schon getan haben :). Vielen Dank!
Ben S
6

Die oben genannten Schnipsel funktionieren nicht für Fälle mit mehr als einem Tag (sie werden einfach ignoriert).

Hierfür können Sie verwenden:

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

Geben Sie hier die Bildbeschreibung ein

Vielen Dank an https://gist.github.com/remino/1563878

Frank Adrian
quelle
1
Um eine humanisiertere Ausgabe zu erhalten, können Sie Folgendes zurückgeben: return ((h + '') .length === 1? '0' + h: h) + ':' + ('0' + m) .substr (- 2) + ':' + ('0' + s) & spplus; (-2);
Vitall
@Vitall Nur verwenden return (h < 10 ? "0" + h : h) + ":" + (m < 10 ? "0" + m : m) + ":" + (s < 10 ? "0" + s : s);, weil es viel besser ist, dies mit Mathematik zu tun, als eine Reihe von String-Manipulationen.
Mitch McMabers
2

Basierend auf @ Hand Antwort. Dies ist die Implementierung in Typescript. Ein bisschen sicherer als das Erzwingen von Typen in JS. Wenn Sie die Typanmerkung entfernen, sollte JS gültig sein. Verwenden Sie auch neue Zeichenfolgenfunktionen, um die Zeit zu normalisieren.

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}`;
}
KevinOrfas
quelle
1
Jemand könnte es nützlich finden.
KevinOrfas
1
JS entwickelt sich in Richtung TypeScript. Dies wird wahrscheinlich bald gültig sein JS. :-)
N8allan
2

Ich brauchte nur bis zu einem Tag, 24 Stunden, das war meine Einstellung:

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

Auf diese Weise können Sie bei Bedarf auch Tage erhalten.

Goran Jakovljevic
quelle
2

Diese Lösung verwendet eine function, um Millisekunden in a aufzuteilen parts object, und eine andere, um die functionzu formatieren parts object.

Ich habe zwei Formatfunktionen erstellt, eine, wie Sie es gewünscht haben, und eine, die eine freundliche Zeichenfolge druckt und Singular / Plural berücksichtigt, sowie eine Option zum Anzeigen von Millisekunden.

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

Steven Spungin
quelle
2

Hat für mich gearbeitet

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;
}
Hassan
quelle
2

Vom Menschen lesbarer Code für die vom Menschen lesbare Ausgabe, und Sie können diesen auf Lichtjahre oder Nanosekunden erweitern oder was Sie sehr intuitiv haben. Natürlich möchten Sie dies in eine Funktion konvertieren und einige dieser modulo-Zwischenaufrufe wiederverwenden.

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))
Rick O'Shea
quelle
1

meine Lösung

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 wird zu ' 7.04 AM '

Dan Alboteanu
quelle
1

Ich arbeite für mich, wenn ich Millisekunden = 1592380675409 mit der Javascript-Methode getTime () erhalte, die die Anzahl der Millisekunden zwischen Mitternacht des 1. Januar 1970 und dem angegebenen Datum zurückgibt.

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
}
Sneha Morye
quelle
Erklären Sie Ihren Code, Code ohne Erklärung ist schlechter Code.
Islam Elshobokshy
Vielen Dank für den Vorschlag, ich erkläre definitiv meine Lösung
Sneha Morye
0

Wenn Sie Typoskript verwenden, könnte dies eine gute Sache für Sie sein

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)
  )
}
Jonathan Biteau
quelle
0

In meiner Implementierung habe ich Moment.js verwendet:

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`;

  ...
}

Nachdem ich die Saiten bekommen hatte, komponierte ich sie, wie ich wollte.

lucataglia
quelle