Comment calculer la différence de temps dans le script bash?

J'imprime l'Heure de début et de fin en utilisant date +"%T", ce qui entraîne quelque chose comme:

10:33:56
10:36:10

Comment puis-je calculer et imprimer la différence entre ces deux?

Je voudrais obtenir quelque chose comme:

2m 14s
176
demandé sur Misha Moroshko 2012-01-18 03:38:54

18 réponses

Bash a une variable intégrée SECONDS pratique qui suit le nombre de secondes écoulées depuis le démarrage du shell. Cette variable conserve ses propriétés lorsqu'elle est affectée à, et la valeur renvoyée après l'affectation est le nombre de secondes écoulées depuis l'affectation plus la valeur affectée.

Ainsi, vous pouvez simplement définir SECONDS à 0 avant de commencer l'événement chronométré, simplement lire SECONDS après l'événement, et faire l'arithmétique du temps avant l'affichage.

SECONDS=0
# do some work
duration=$SECONDS
echo "$(($duration / 60)) minutes and $(($duration % 60)) seconds elapsed."

Comme cette solution ne le fait pas dépend de date +%s (qui est une extension GNU), il est portable pour tous les systèmes pris en charge par Bash.

347
répondu Daniel Kamil Kozar 2015-12-12 01:12:25

Secondes

Pour mesurer le temps écoulé (en secondes), nous avons besoin de:

  • un entier qui représente le nombre de secondes écoulées, et
  • un moyen de convertir un tel entier en un format utilisable.

Une valeur entière de secondes écoulées:

  • Il existe deux méthodes internes bash pour trouver une valeur entière pour le nombre de secondes écoulées:

    1. Bash variable secondes (si secondes est désactivé, il perd son spécial propriété).

      • Réglage de la valeur de secondes à 0:

        SECONDS=0
        sleep 1  # Process to execute
        elapsedseconds=$SECONDS
        
      • Stocker la valeur de la variable SECONDS au début:

        a=$SECONDS
        sleep 1  # Process to execute
        elapsedseconds=$(( SECONDS - a ))
        
    2. Option Bash printf %(datefmt)T:

      a="$(TZ=UTC0 printf '%(%s)T\n' '-1')"    ### `-1`  is the current time
      sleep 1                                  ### Process to execute
      elapsedseconds=$(( $(TZ=UTC0 printf '%(%s)T\n' '-1') - a ))
      

Convertir entier en un format utilisable

Le bash interne printf peut le faire directement:

$ TZ=UTC0 printf '%(%H:%M:%S)T\n' 12345
03:25:45

De même

$ elapsedseconds=$((12*60+34))
$ TZ=UTC0 printf '%(%H:%M:%S)T\n' "$elapsedseconds"
00:12:34

mais cela échouera pour des durées de plus de 24 heures, comme nous imprimons en fait un temps wallclock, pas vraiment une durée:

$ hours=30;mins=12;secs=24
$ elapsedseconds=$(( ((($hours*60)+$mins)*60)+$secs ))
$ TZ=UTC0 printf '%(%H:%M:%S)T\n' "$elapsedseconds"
06:12:24

Pour les amoureux du détail, à partir de bash-hackers.org:

%(FORMAT)T affiche la chaîne date-heure résultant de L'utilisation du FORMAT comme une chaîne de format pour strftime(3). L'argument associé est le nombre de secondes depuis le Époque, ou -1 (heure actuelle) ou -2 (shell temps de démarrage). Si aucun argument correspondant n'est fourni, le courant le temps est utilisé comme défaut.

Donc, vous pouvez simplement appeler textifyDuration $elpasedsecondstextifyDuration est encore une autre implémentation de l'impression de durée:

textifyDuration() {
   local duration=$1
   local shiff=$duration
   local secs=$((shiff % 60));  shiff=$((shiff / 60));
   local mins=$((shiff % 60));  shiff=$((shiff / 60));
   local hours=$shiff
   local splur; if [ $secs  -eq 1 ]; then splur=''; else splur='s'; fi
   local mplur; if [ $mins  -eq 1 ]; then mplur=''; else mplur='s'; fi
   local hplur; if [ $hours -eq 1 ]; then hplur=''; else hplur='s'; fi
   if [[ $hours -gt 0 ]]; then
      txt="$hours hour$hplur, $mins minute$mplur, $secs second$splur"
   elif [[ $mins -gt 0 ]]; then
      txt="$mins minute$mplur, $secs second$splur"
   else
      txt="$secs second$splur"
   fi
   echo "$txt (from $duration seconds)"
}

Date GNU.

Pour obtenir le temps formaté, nous devrions utiliser un outil externe (GNU date) de plusieurs façons pour obtenir jusqu'à une durée de près d'un an et y compris les nanosecondes.

Mathématiques à l'intérieur de date.

Il N'y a pas besoin d'arithmétique externe, faites-le tout en une seule étape à l'intérieur date:

date -u -d "0 $FinalDate seconds - $StartDate seconds" +"%H:%M:%S"

Oui, il y a un 0 zéro dans le chaîne de commande. Elle est nécessaire.

Cela suppose que vous pouvez changer la commande date +"%T" en une commande date +"%s" afin que les valeurs soient stockées (imprimées) en quelques secondes.

Notez que la commande est limitée à:

  • Positives valeurs de $StartDate et $FinalDate secondes.
  • La valeur dans $FinalDate est plus grande (plus tard dans le temps) de $StartDate.
  • différence de temps inférieure à 24 heures.
  • Vous Acceptez un format de sortie avec Heures, Minutes et secondes. Très facile à changement.
  • Il est acceptable d'utiliser -U UTC times. Pour éviter les corrections" DST " et l'heure locale.

Si vous devez utiliser la chaîne 10:33:56, Eh bien, convertissez-la simplement en secondes,
en outre, le mot secondes pourrait être abrégé en sec:

string1="10:33:56"
string2="10:36:10"
StartDate=$(date -u -d "$string1" +"%s")
FinalDate=$(date -u -d "$string2" +"%s")
date -u -d "0 $FinalDate sec - $StartDate sec" +"%H:%M:%S"

Notez que la conversion du temps en secondes (comme présenté ci-dessus) est relative au début de "ce" jour (Aujourd'hui).


Le concept pourrait être étendu à des nanosecondes, comme ce:

string1="10:33:56.5400022"
string2="10:36:10.8800056"
StartDate=$(date -u -d "$string1" +"%s.%N")
FinalDate=$(date -u -d "$string2" +"%s.%N")
date -u -d "0 $FinalDate sec - $StartDate sec" +"%H:%M:%S.%N"

Si est nécessaire pour calculer des différences de temps plus longues (jusqu'à 364 jours), nous devons utiliser le début de (certaines) années comme référence et la valeur de format %j (le numéro de jour de l'année):

Similaire à:

string1="+10 days 10:33:56.5400022"
string2="+35 days 10:36:10.8800056"
StartDate=$(date -u -d "2000/1/1 $string1" +"%s.%N")
FinalDate=$(date -u -d "2000/1/1 $string2" +"%s.%N")
date -u -d "2000/1/1 $FinalDate sec - $StartDate sec" +"%j days %H:%M:%S.%N"

Output:
026 days 00:02:14.340003400

Malheureusement, dans ce cas, nous devons soustraire manuellement 1 Un du nombre de jours. La commande date affiche le premier jour de l'année comme 1. Pas si difficile ...

a=( $(date -u -d "2000/1/1 $FinalDate sec - $StartDate sec" +"%j days %H:%M:%S.%N") )
a[0]=$((10#${a[0]}-1)); echo "${a[@]}"



L'utilisation de longue nombre de secondes est valide et documenté here:
https://www.gnu.org/software/coreutils/manual/html_node/Examples-of-date.html#Examples-of-date


Date Busybox

Un outil utilisé dans les petits appareils( un très petit exécutable à installer): Busybox.

Soit créer un lien vers busybox appelé date:

$ ln -s /bin/busybox date

Utilisez-le ensuite en appelant ceci date (placez-le dans un répertoire path included).

Ou faire un alias comme:

$ alias date='busybox date'

Busybox date a un belle option: - D pour recevoir le format de l'heure d'entrée. Qui ouvre beaucoup de formats à utiliser comme le temps. En utilisant l'option-D, nous pouvons convertir le temps 10:33:56 directement:

date -D "%H:%M:%S" -d "10:33:56" +"%Y.%m.%d-%H:%M:%S"

Et comme vous pouvez le voir à partir de la sortie de la commande ci-dessus, le jour est supposé être "aujourd'hui". Pour obtenir le temps de départ sur epoch:

$ string1="10:33:56"
$ date -u -D "%Y.%m.%d-%H:%M:%S" -d "1970.01.01-$string1" +"%Y.%m.%d-%H:%M:%S"
1970.01.01-10:33:56

Busybox date peut même recevoir l'heure (dans le format ci-dessus) sans -D:

$ date -u -d "1970.01.01-$string1" +"%Y.%m.%d-%H:%M:%S"
1970.01.01-10:33:56

Et le format de sortie pourrait même être époque.

$ date -u -d "1970.01.01-$string1" +"%s"
52436

Pour les deux fois, et un peu de mathématiques bash (busybox ne peut pas faire le calcul, Encore):

string1="10:33:56"
string2="10:36:10"
t1=$(date -u -d "1970.01.01-$string1" +"%s")
t2=$(date -u -d "1970.01.01-$string2" +"%s")
echo $(( t2 - t1 ))

Ou formaté:

$ date -u -D "%s" -d "$(( t2 - t1 ))" +"%H:%M:%S"
00:02:14
63
répondu David Tonhofer 2018-06-03 09:13:13

Voici comment je l'ai fait:

START=$(date +%s);
sleep 1; # Your stuff
END=$(date +%s);
echo $((END-START)) | awk '{print int($1/60)":"int($1%60)}'

Vraiment simple, prenez le nombre de secondes au début, puis prenez le nombre de secondes à la fin, et imprimez la différence en minutes: secondes.

30
répondu Dorian 2013-11-27 17:45:26

Une autre option consiste à utiliser datediff depuis dateutils (http://www.fresse.org/dateutils/#datediff):

$ datediff 10:33:56 10:36:10
134s
$ datediff 10:33:56 10:36:10 -f%H:%M:%S
0:2:14
$ datediff 10:33:56 10:36:10 -f%0H:%0M:%0S
00:02:14

, Vous pouvez également utiliser gawk. mawk 1.3.4 a aussi strftime et mktime, mais les anciennes versions de mawk et nawk ne l'est pas.

$ TZ=UTC0 awk 'BEGIN{print strftime("%T",mktime("1970 1 1 10 36 10")-mktime("1970 1 1 10 33 56"))}'
00:02:14

Ou voici une autre façon de le faire avec GNU date:

$ date -ud@$(($(date -ud'1970-01-01 10:36:10' +%s)-$(date -ud'1970-01-01 10:33:56' +%s))) +%T
00:02:14
12
répondu user4669748 2017-04-08 02:36:31

Je voudrais proposer une autre façon d'éviter rappelant date commande. Cela peut être utile si vous avez déjà rassemblé des horodatages au format %T date:

ts_get_sec()
{
  read -r h m s <<< $(echo $1 | tr ':' ' ' )
  echo $(((h*60*60)+(m*60)+s))
}

start_ts=10:33:56
stop_ts=10:36:10

START=$(ts_get_sec $start_ts)
STOP=$(ts_get_sec $stop_ts)
DIFF=$((STOP-START))

echo "$((DIFF/60))m $((DIFF%60))s"

Nous pouvons même gérer les millisecondes de la même manière.

ts_get_msec()
{
  read -r h m s ms <<< $(echo $1 | tr '.:' ' ' )
  echo $(((h*60*60*1000)+(m*60*1000)+(s*1000)+ms))
}

start_ts=10:33:56.104
stop_ts=10:36:10.102

START=$(ts_get_msec $start_ts)
STOP=$(ts_get_msec $stop_ts)
DIFF=$((STOP-START))

min=$((DIFF/(60*1000)))
sec=$(((DIFF%(60*1000))/1000))
ms=$(((DIFF%(60*1000))%1000))

echo "${min}:${sec}.$ms"
11
répondu Zskdan 2014-05-21 17:00:52

Voici un peu de magie:

time1=14:30
time2=$( date +%H:%M ) # 16:00
diff=$(  echo "$time2 - $time1"  | sed 's%:%+(1/60)*%g' | bc -l )
echo $diff hours
# outputs 1.5 hours

sed remplace un : par une formule à convertir en 1/60. Ensuite, le calcul du temps qui est fait par bc

6
répondu redolent 2014-03-19 20:37:11

A partir de la date (GNU coreutils) 7.4 vous pouvez maintenant utiliser -d pour faire de l'arithmétique:

$ date -d -30days
Sat Jun 28 13:36:35 UTC 2014

$ date -d tomorrow
Tue Jul 29 13:40:55 UTC 2014

Les unités que vous pouvez utiliser sont les jours, les années, les mois, les heures, les minutes et les secondes :

$ date -d tomorrow+2days-10minutes
Thu Jul 31 13:33:02 UTC 2014
3
répondu rags 2014-07-28 13:43:25

Suite à la réponse de Daniel Kamil Kozar, pour afficher heures / minutes / secondes:

echo "Duration: $(($DIFF / 3600 )) hours $((($DIFF % 3600) / 60)) minutes $(($DIFF % 60)) seconds"

Donc le script complet serait:

date1=$(date +"%s")
date2=$(date +"%s")
diff=$(($date2-$date1))
echo "Duration: $(($DIFF / 3600 )) hours $((($DIFF % 3600) / 60)) minutes $(($DIFF % 60)) seconds"
2
répondu mcaleaa 2014-03-03 08:33:23

Ou enveloppez-le un peu

alias timerstart='starttime=$(date +"%s")'
alias timerstop='echo seconds=$(($(date +"%s")-$starttime))'

Alors cela fonctionne.

timerstart; sleep 2; timerstop
seconds=2
2
répondu user3561136 2014-08-05 18:32:50
% start=$(date +%s)
% echo "Diff: $(date -d @$(($(date +%s)-$start)) +"%M minutes %S seconds")"
Diff: 00 minutes 11 seconds
1
répondu Joseph 2013-12-21 15:39:55

Avec GNU units:

$ units
2411 units, 71 prefixes, 33 nonlinear units
You have: (10hr+36min+10s)-(10hr+33min+56s)
You want: s
    * 134
    / 0.0074626866
You have: (10hr+36min+10s)-(10hr+33min+56s)
You want: min
    * 2.2333333
    / 0.44776119
1
répondu user5207022 2015-08-08 21:10:09

date peut vous donner la différence et la formater pour vous (options OS X affichées)

date -ujf%s $(($(date -jf%T "10:36:10" +%s) - $(date -jf%T "10:33:56" +%s))) +%T
# 00:02:14

date -ujf%s $(($(date -jf%T "10:36:10" +%s) - $(date -jf%T "10:33:56" +%s))) \
    +'%-Hh %-Mm %-Ss'
# 0h 2m 14s

Un traitement de chaîne peut supprimer ces valeurs vides

date -ujf%s $(($(date -jf%T "10:36:10" +%s) - $(date -jf%T "10:33:56" +%s))) \
    +'%-Hh %-Mm %-Ss' | sed "s/[[:<:]]0[hms] *//g"
# 2m 14s

Cela ne fonctionnera pas si vous placez l'époque première. Si vous avez besoin de gérer cela, changez $(($(date ...) - $(date ...))) en $(echo $(date ...) - $(date ...) | bc | tr -d -)

1
répondu Mr. Dave 2017-04-21 12:32:24

Voici une solution utilisant uniquement les capacités de commandes date en utilisant "ago" , et ne pas utiliser une seconde variable pour stocker l'Heure de fin:

#!/bin/bash

# save the current time
start_time=$( date +%s.%N )

# tested program
sleep 1

# the current time after the program has finished
# minus the time when we started, in seconds.nanoseconds
elapsed_time=$( date +%s.%N --date="$start_time seconds ago" )

echo elapsed_time: $elapsed_time

Cela donne:

$ ./time_elapsed.sh 
elapsed_time: 1.002257120
1
répondu Zoltan K. 2017-09-24 15:55:48

Je me rends compte que c'est un post plus ancien, mais je l'ai rencontré aujourd'hui en travaillant sur un script qui prendrait des dates et des heures à partir d'un fichier journal et calculerait le delta. Le script ci-dessous est certainement exagéré, et je recommande fortement de vérifier ma logique et mes mathématiques.

#!/bin/bash

dTime=""
tmp=""

#firstEntry="$(head -n 1 "$LOG" | sed 's/.*] \([0-9: -]\+\).*/\1/')"
firstEntry="2013-01-16 01:56:37"
#lastEntry="$(tac "$LOG" | head -n 1 | sed 's/.*] \([0-9: -]\+\).*/\1/')"
lastEntry="2014-09-17 18:24:02"

# I like to make the variables easier to parse
firstEntry="${firstEntry//-/ }"
lastEntry="${lastEntry//-/ }"
firstEntry="${firstEntry//:/ }"
lastEntry="${lastEntry//:/ }"

# remove the following lines in production
echo "$lastEntry"
echo "$firstEntry"

# compute days in last entry
for i in `seq 1 $(echo $lastEntry|awk '{print $2}')`; do {
  case "$i" in
   1|3|5|7|8|10|12 )
    dTime=$(($dTime+31))
    ;;
   4|6|9|11 )
    dTime=$(($dTime+30))
    ;;
   2 )
    dTime=$(($dTime+28))
    ;;
  esac
} done

# do leap year calculations for all years between first and last entry
for i in `seq $(echo $firstEntry|awk '{print $1}') $(echo $lastEntry|awk '{print $1}')`; do {
  if [ $(($i%4)) -eq 0 ] && [ $(($i%100)) -eq 0 ] && [ $(($i%400)) -eq 0 ]; then {
    if [ "$i" = "$(echo $firstEntry|awk '{print $1}')" ] && [ $(echo $firstEntry|awk '{print $2}') -lt 2 ]; then {
      dTime=$(($dTime+1))
    } elif [ $(echo $firstEntry|awk '{print $2}') -eq 2 ] && [ $(echo $firstEntry|awk '{print $3}') -lt 29 ]; then {
      dTime=$(($dTime+1))
    } fi
  } elif [ $(($i%4)) -eq 0 ] && [ $(($i%100)) -ne 0 ]; then {
    if [ "$i" = "$(echo $lastEntry|awk '{print $1}')" ] && [ $(echo $lastEntry|awk '{print $2}') -gt 2 ]; then {
      dTime=$(($dTime+1))
    } elif [ $(echo $lastEntry|awk '{print $2}') -eq 2 ] && [ $(echo $lastEntry|awk '{print $3}') -ne 29 ]; then {
      dTime=$(($dTime+1))
    } fi
  } fi
} done

# substract days in first entry
for i in `seq 1 $(echo $firstEntry|awk '{print $2}')`; do {
  case "$i" in
   1|3|5|7|8|10|12 )
    dTime=$(($dTime-31))
    ;;
   4|6|9|11 )
    dTime=$(($dTime-30))
    ;;
   2 )
    dTime=$(($dTime-28))
    ;;
  esac
} done

dTime=$(($dTime+$(echo $lastEntry|awk '{print $3}')-$(echo $firstEntry|awk '{print $3}')))

# The above gives number of days for sample. Now we need hours, minutes, and seconds
# As a bit of hackery I just put the stuff in the best order for use in a for loop
dTime="$(($(echo $lastEntry|awk '{print $6}')-$(echo $firstEntry|awk '{print $6}'))) $(($(echo $lastEntry|awk '{print $5}')-$(echo $firstEntry|awk '{print $5}'))) $(($(echo $lastEntry|awk '{print $4}')-$(echo $firstEntry|awk '{print $4}'))) $dTime"
tmp=1
for i in $dTime; do {
  if [ $i -lt 0 ]; then {
    case "$tmp" in
     1 )
      tmp="$(($(echo $dTime|awk '{print $1}')+60)) $(($(echo $dTime|awk '{print $2}')-1))"
      dTime="$tmp $(echo $dTime|awk '{print $3" "$4}')"
      tmp=1
      ;;
     2 )
      tmp="$(($(echo $dTime|awk '{print $2}')+60)) $(($(echo $dTime|awk '{print $3}')-1))"
      dTime="$(echo $dTime|awk '{print $1}') $tmp $(echo $dTime|awk '{print $4}')"
      tmp=2
      ;;
     3 )
      tmp="$(($(echo $dTime|awk '{print $3}')+24)) $(($(echo $dTime|awk '{print $4}')-1))"
      dTime="$(echo $dTime|awk '{print $1" "$2}') $tmp"
      tmp=3
      ;;
    esac
  } fi
  tmp=$(($tmp+1))
} done

echo "The sample time is $(echo $dTime|awk '{print $4}') days, $(echo $dTime|awk '{print $3}') hours, $(echo $dTime|awk '{print $2}') minutes, and $(echo $dTime|awk '{print $1}') seconds."

Vous obtiendrez la sortie comme suit.

2012 10 16 01 56 37
2014 09 17 18 24 02
The sample time is 700 days, 16 hours, 27 minutes, and 25 seconds.

J'ai un peu modifié le script pour le rendre autonome (ie. il suffit de définir des valeurs variables), mais peut-être que l'idée générale apparaît également. Vous pourriez vouloir une erreur supplémentaire vérification des valeurs négatives.

0
répondu Daniel Blackmon 2014-09-18 16:09:51

J'ai besoin d'une différence de temps de script pour une utilisation avec mencoder (son --endpos est relatif), et ma solution est d'appeler un script Python:

$ ./timediff.py 1:10:15 2:12:44
1:02:29

Les Fractions de secondes sont également prises en charge:

$ echo "diff is `./timediff.py 10:51.6 12:44` (in hh:mm:ss format)"
diff is 0:01:52.4 (in hh:mm:ss format)

Et il peut vous dire que la différence entre 200 et 120 est 1h 20m:

$ ./timediff.py 120:0 200:0
1:20:0

Et peut convertir n'importe quel nombre (probablement fractionnaire) de secondes ou de minutes ou d'heures en hh:mm:ss

$ ./timediff.py 0 3600
1:00:0
$ ./timediff.py 0 3.25:0:0
3:15:0

timediff.py:

#!/usr/bin/python

import sys

def x60(h,m):
    return 60*float(h)+float(m)

def seconds(time):
    try:
       h,m,s = time.split(':')
       return x60(x60(h,m),s)
    except ValueError:
       try:
          m,s = time.split(':')
          return x60(m,s)
       except ValueError:
          return float(time)

def difftime(start, end):
    d = seconds(end) - seconds(start)
    print '%d:%02d:%s' % (d/3600,d/60%60,('%02f' % (d%60)).rstrip('0').rstrip('.'))

if __name__ == "__main__":
   difftime(sys.argv[1],sys.argv[2])
0
répondu 18446744073709551615 2015-07-09 15:14:42

Généraliser la solution de @nisetama en utilisant GNU date (trusty Ubuntu 14.04 LTS):

start=`date`
# <processing code>
stop=`date`
duration=`date -ud@$(($(date -ud"$stop" +%s)-$(date -ud"$start" +%s))) +%T`

echo $start
echo $stop
echo $duration

Rendement:

Wed Feb 7 12:31:16 CST 2018
Wed Feb 7 12:32:25 CST 2018
00:01:09
0
répondu Bill Gale 2018-02-07 19:02:13

Je ne peux pas commenter la réponse de mcaleaa, donc je poste ceci ici. La variable "diff" devrait être sur un petit cas. Ici est un exemple.

[root@test ~]# date1=$(date +"%s"); date
Wed Feb 21 23:00:20 MYT 2018
[root@test ~]# 
[root@test ~]# date2=$(date +"%s"); date
Wed Feb 21 23:00:33 MYT 2018
[root@test ~]# 
[root@test ~]# diff=$(($date2-$date1))
[root@test ~]# 

La variable précédente a été déclarée en minuscules. C'est ce qui s'est passé lorsque les majuscules sont utilisées.

[root@test ~]# echo "Duration: $(($DIFF / 3600 )) hours $((($DIFF % 3600) / 60)) minutes $(($DIFF % 60)) seconds"
-bash: / 3600 : syntax error: operand expected (error token is "/ 3600 ")
[root@test ~]# 

Donc, quick fix serait comme ceci

[root@test ~]# echo "Duration: $(($diff / 3600 )) hours $((($diff % 3600) / 60)) minutes $(($diff % 60)) seconds"
Duration: 0 hours 0 minutes 13 seconds
[root@test ~]# 
0
répondu Sabrina 2018-02-21 15:09:43

Voici mon implémentation bash (avec des bits pris d'autres SO; -)

function countTimeDiff() {
    timeA=$1 # 09:59:35
    timeB=$2 # 17:32:55

    # feeding variables by using read and splitting with IFS
    IFS=: read ah am as <<< "$timeA"
    IFS=: read bh bm bs <<< "$timeB"

    # Convert hours to minutes.
    # The 10# is there to avoid errors with leading zeros
    # by telling bash that we use base 10
    secondsA=$((10#$ah*60*60 + 10#$am*60 + 10#$as))
    secondsB=$((10#$bh*60*60 + 10#$bm*60 + 10#$bs))
    DIFF_SEC=$((secondsB - secondsA))
    echo "The difference is $DIFF_SEC seconds.";

    SEC=$(($DIFF_SEC%60))
    MIN=$((($DIFF_SEC-$SEC)%3600/60))
    HRS=$((($DIFF_SEC-$MIN*60)/3600))
    TIME_DIFF="$HRS:$MIN:$SEC";
    echo $TIME_DIFF;
}

$ countTimeDiff 2:15:55 2:55:16
The difference is 2361 seconds.
0:39:21

Non testé, peut être bogué.

-1
répondu Ondra Žižka 2016-10-08 03:42:59