Convertir la chaîne HH: MM: SS en secondes uniquement en javascript


97

J'ai une exigence similaire à celle-ci: Convertir l'heure au format HH: MM: SS en secondes seulement?

mais en javascript. J'ai vu de nombreux exemples de conversion de secondes en différents formats mais pas de HH: MM: SS en secondes. Toute aide serait appréciée.


oups ... désolé pour la faute de frappe. oui, il est temps hh: mm: ss
Sri Reddy

Quel est le DDdans HH:MM:DD?
Brian Driscoll

2
C'est le même algorithme que dans cette question PHP.
scottheckel

Eh bien .. H (heure) == 3600 secondes, M (minute) == 60 secondes ... donc ..
MilkyWayJoe

1
La seule solution à laquelle je pense est de diviser la chaîne en tableau, puis de multiplier 3600 à l'heure et de multiplier 60 à min et d'ajouter tout avec une partie de secondes. Est-ce la solution la plus simple?
Sri Reddy

Réponses:


192

Essaye ça:

var hms = '02:04:33';   // your input string
var a = hms.split(':'); // split it at the colons

// minutes are worth 60 seconds. Hours are worth 60 minutes.
var seconds = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2]); 

console.log(seconds);

3
En voici une version prototype! String.prototype.toSeconds = function () { if (!this) return null; var hms = this.split(':'); return (+hms[0]) * 60 * 60 + (+hms[1]) * 60 + (+hms[2] || 0); } REMARQUE: le || 0à la fin est bon pour toute implémentation de ce code - il évite les problèmes avec une représentation temporelle (toujours valide) de HH: MM (les entrées de type Chrome = "time" sortiront dans ce format lorsque secondes = 0).
Fateh Khalsa

Super truc mec
Edward

j'ai seulement hh:mmpas secondsdans ce cas ce que je dois modifier ..?
Mr world wide

1
@AbdulWaheed Changer cette ligne: var seconds = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2]); envar seconds = (+a[0]) * 60 * 60 + (+a[1]) * 60;
Rova

4
L'utilisation de l'opérateur "+" pour convertir une chaîne numérique en nombre n'est pas une bonne idée. C'est court et semble "intelligent", mais c'est un code déroutant et pas propre. Utilisez plutôt parseInt (x, 10). Et évitez le one-liner. Empêchez également les erreurs par une entrée non définie. Par exemple: ce n'est pas une chaîne, n'a pas de ":" ou seulement "HH: MM". etc.
Dominik

67

Cette fonction gère "HH: MM: SS" ainsi que "MM: SS" ou "SS".

function hmsToSecondsOnly(str) {
    var p = str.split(':'),
        s = 0, m = 1;

    while (p.length > 0) {
        s += m * parseInt(p.pop(), 10);
        m *= 60;
    }

    return s;
}

Bien, je le garderai si l'exigence de temps passé est n'importe quel format. Merci!
Sri Reddy

Meilleure réponse pour moi jusqu'à présent
Rezwan Azfar Haleem

Cette réponse est utile
Mike Aron

Que dois-je changer dans votre fonction pour l'utiliser uniquement au format 'HH: MM'
noyruto88

35

Cela peut être fait de manière assez résiliente avec les éléments suivants:

'01:02:03'.split(':').reduce((acc,time) => (60 * acc) + +time);

En effet, chaque unité de temps dans les heures, les minutes et les secondes est un multiple de 60 supérieur à l'unité plus petite. Le temps est divisé en composantes heure minutes et secondes, puis réduit en secondes en utilisant la valeur cumulée des unités supérieures multipliée par 60 au fur et à mesure qu'elle traverse chaque unité.

Le +timeest utilisé pour convertir le temps en un nombre.

Cela finit par faire: (60 * ((60 * HHHH) + MM)) + SS

Si seulement quelques secondes sont passées, le résultat serait une chaîne, donc pour corriger le problème, nous pourrions convertir le résultat entier en un entier:

+('03'.split(':').reduce((acc,time) => (60 * acc) + +time));

c'est en fait assez sacrément intelligent ... la question est de savoir à quelle vitesse cela est comparé à un calcul
ThatBrianDude

4
Oui, c'est intelligent, mais c'est un bon exemple de création de code difficile à maintenir sans gain pratique. Il enregistre 4 caractères lorsqu'il est minifié par rapport à une version minifiée de la réponse acceptée. Étant donné que de nombreuses pages Web dépassent désormais 1 Mo, cette économie est un peu moins qu'insignifiante.
RobG

4
Bien que cette réponse ne soit pas aussi compréhensible, elle gère gracieusement les deux HH:MM:SSaussi bien MM:SSque la réponse acceptée ne le fait pas.
ckeeney

1
Celui-ci a un bug de conversion de type, s'il n'y a que la partie secondes. Vous devez explicitement initialiser le mémo avec 0 pour l'empêcher. Fonctionne: '03'.split(':').reduce((acc,time) => (60 * acc) + +time, 0);échoue car renvoie une chaîne inattendue:'03'.split(':').reduce((acc,time) => (60 * acc) + +time);
Felix Gertz

@FelixGertz Bien repéré, je vais éditer un correctif pour ce cas.
Paul

12

Puisque la fonction getTime de l'objet Date obtient les millisecondes depuis le 01/01/1970, nous pouvons faire ceci:

var time = '12:23:00';
var seconds = new Date('1970-01-01T' + time + 'Z').getTime() / 1000;

1
Juste réalisé, cela ne fonctionne pas avec l'heure d'été. Besoin d'utiliser la date réelle
Yablargo

1
@Yablargo Merci. La version précédente ne fonctionnait pas très bien avec le fuseau horaire local, je l'ai donc modifiée pour utiliser le format datetime utc iso 8601.
boskop

12

Convertit la hh:mm:sschaîne en secondes sur une seule ligne. h:m:sFormat également autorisé et mm:ss, m:setc.

'08:45:20'.split(':').reverse().reduce((prev, curr, i) => prev + curr*Math.pow(60, i), 0)

4
Veuillez expliquer votre réponse
B001 ᛦ

Convertit la hh:mm:sschaîne en secondes sur une seule ligne. Également autorisé h:m:sformat et mm:ss, m:setc.
Paul Hide

Bonne réponse! Mais vous pouvez ignorer reverse(): '00: 01: 11'.split (':'). Reduction ((val, entry, i) => val + entry * (3600 / Math.pow (60, i)), 0 ) === 71
CMR

@CMR, approche intéressante, mais dans le cas où mm:sscela ne fonctionnera pas correctement.
Paul Hide

Math.pow est très lent et peut être évité comme le montrent d'autres réponses basées sur réduire
Alejadro Xalabarder

8

essayer

time="12:12:12";
tt=time.split(":");
sec=tt[0]*3600+tt[1]*60+tt[2]*1;

5
ah, que * 1 est un moyen intelligent de ne pas faire de concaténation de chaînes :)
Dagg Nabbit

5

La méthode statique de Javascript Date.UTC()fait l'affaire:

alert(getSeconds('00:22:17'));

function getSeconds(time)
{
    var ts = time.split(':');
    return Date.UTC(1970, 0, 1, ts[0], ts[1], ts[2]) / 1000;
}

4

Voici peut-être un formulaire un peu plus lisible sur la réponse originale approuvée.

const getSeconds = (hms: string) : number => {
  const [hours, minutes, seconds] = hms.split(':');
  return (+hours) * 60 * 60 + (+minutes) * 60 + (+seconds);
};

2
new Date(moment('23:04:33', "HH:mm")).getTime()

Sortie: 1499755980000 (en milliseconde) (1499755980000/1000) (en seconde)

Remarque: cette sortie calcule la différence entre 1970-01-01 12: 0: 0 et maintenant et nous devons implémenter moment.js


OP a demandé des secondes et non des millisecondes
user7294900

Salut user7294900, Merci pour votre commentaire, je vais mettre à jour ma réponse, jst nous devons diviser par 1000
ITsDEv

1

Cette fonction fonctionne également pour MM: SS:

const convertTime = (hms) => {
        if (hms.length <3){
         return hms
        } else if (hms.length <6){
          const a = hms.split(':')
          return hms = (+a[0]) * 60 + (+a[1])
        } else {
          const a = hms.split(':')
          return hms = (+a[0]) * 60 * 60 + (+a[1]) * 60 + (+a[2])
        }
      }


1

Tiré de la solution donnée par Paul https://stackoverflow.com/a/45292588/1191101 mais en utilisant l'ancienne notation de fonction afin qu'elle puisse également être utilisée dans d'autres moteurs js (par exemple java Rhino)

function strToSeconds (stime)
{
   return +(stime.split(':').reduce(function (acc,time) { return +(60 * acc) + +time }));
}

ou juste celui-ci plus lisible

function strToSeconds (stime)
{
  var tt = stime.split(':').reverse ();
  return ((tt.length >= 3) ? (+tt[2]): 0)*60*60 + 
         ((tt.length >= 2) ? (+tt[1]): 0)*60 + 
         ((tt.length >= 1) ? (+tt[0]): 0);
}

0

function parsehhmmsst(arg) {
	var result = 0, arr = arg.split(':')
	if (arr[0] < 12) {
		result = arr[0] * 3600 // hours
	}
	result += arr[1] * 60 // minutes
	result += parseInt(arr[2]) // seconds
	if (arg.indexOf('P') > -1) {  // 8:00 PM > 8:00 AM
		result += 43200
	}
	return result
}
$('body').append(parsehhmmsst('12:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('1:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('2:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('3:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('4:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('5:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('6:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('7:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('8:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('9:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('10:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('11:00:00 AM') + '<br>')
$('body').append(parsehhmmsst('12:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('1:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('2:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('3:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('4:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('5:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('6:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('7:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('8:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('9:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('10:00:00 PM') + '<br>')
$('body').append(parsehhmmsst('11:00:00 PM') + '<br>')
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>


0

Vous pouvez le faire de manière dynamique - au cas où vous rencontriez non seulement: HH: mm: ss, mais aussi, mm: ss, ou même ss seul.

var str = '12:99:07';
var times = str.split(":");
times.reverse();
var x = times.length, y = 0, z;
for (var i = 0; i < x; i++) {
    z = times[i] * Math.pow(60, i);
    y += z;
}
console.log(y);
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.