it-swarm.com.de

Wie berechnet man den Zeitunterschied im Bash-Skript?

Ich drucke die Start- und Endzeit mit date +"%T", was etwa folgendes ergibt:

10:33:56
10:36:10

Wie kann ich den Unterschied zwischen diesen beiden berechnen und drucken?

Ich würde gerne etwas bekommen wie:

2m 14s
184
Misha Moroshko

Bash hat eine praktische Variable SECONDS, die die Anzahl der Sekunden seit dem Start der Shell verfolgt. Diese Variable behält ihre Eigenschaften bei, wenn sie zugewiesen wird. Der nach der Zuweisung zurückgegebene Wert ist die Anzahl von Sekunden seit der Zuweisung zuzüglich des zugewiesenen Werts.

Sie können also SECONDS vor dem Start des zeitgesteuerten Ereignisses auf 0 setzen. Lesen Sie einfach SECONDS nach dem Ereignis und führen Sie die Zeitarithmetik vor der Anzeige aus.

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

Da diese Lösung nicht von date +%s (der Erweiterung GNU) abhängt, ist sie für alle von Bash unterstützten Systeme portierbar.

376

Sekunden

Um die abgelaufene Zeit (in Sekunden) zu messen, benötigen wir:

  • eine ganze Zahl, die die Anzahl der verstrichenen Sekunden und angibt
  • eine Möglichkeit, eine solche Ganzzahl in ein verwendbares Format umzuwandeln.

Ein ganzzahliger Wert von verstrichenen Sekunden:

  • Es gibt zwei interne Methoden, um einen ganzzahligen Wert für die Anzahl der verstrichenen Sekunden zu finden:

    1. Bash-Variable SECONDS (wenn SECONDS nicht gesetzt ist, verliert sie ihre spezielle Eigenschaft).

      • Setzen Sie den Wert von SECONDS auf 0:

        SECONDS=0
        sleep 1  # Process to execute
        elapsedseconds=$SECONDS
        
      • Speichern des Wertes der Variablen SECONDS am Start:

        a=$SECONDS
        sleep 1  # Process to execute
        elapsedseconds=$(( SECONDS - a ))
        
    2. Bash-Printf-Option %(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 ))
      

Konvertieren Sie eine solche Ganzzahl in ein verwendbares Format

Die bash-interne Variable printf kann dies direkt tun:

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

ähnlich

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

but dies schlägt für Dauern von mehr als 24 Stunden fehl, da wir tatsächlich eine Wanduhrzeit drucken, nicht wirklich eine Dauer:

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

Für die Liebhaber des Details von bash-hackers.org :

%(FORMAT)T gibt die Datum/Uhrzeit-Zeichenfolge aus, die sich aus der Verwendung von FORMAT .__ ergibt. als Formatstring für strftime(3) . Das zugehörige Argument ist das Anzahl der Sekunden seit Epoch oder -1 (aktuelle Uhrzeit) oder -2 (Shell Startzeit). Wenn kein entsprechendes Argument angegeben wird, wird das aktuelle Zeit wird als Standard verwendet.

Sie können also einfach textifyDuration $elpasedseconds aufrufen, wobei textifyDuration eine weitere Implementierung des Dauerdrucks ist:

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

GNU-Datum.

Um eine formatierte Zeit zu erhalten, sollten wir ein externes Werkzeug (GNU-Datum) auf verschiedene Weise verwenden, um bis zu fast ein Jahr einschließlich Nanosekunden zu erhalten.

Mathe in Datum.

Externe Arithmetik ist nicht erforderlich, in date in einem Schritt:

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

Ja, die Befehlszeichenfolge enthält eine 0-Null. Es wird gebraucht.

Es wird davon ausgegangen, dass Sie den Befehl date +"%T" in einen Befehl date +"%s" ändern können, damit die Werte in Sekunden gespeichert (gedruckt) werden.

Beachten Sie, dass der Befehl auf Folgendes beschränkt ist:

  • Positive Werte für $StartDate und $FinalDate Sekunden.
  • Der Wert in $FinalDate ist größer (später) als $StartDate.
  • Zeitunterschied kleiner als 24 Stunden.
  • Sie akzeptieren ein Ausgabeformat mit Stunden, Minuten und Sekunden. Sehr einfach zu wechseln.
  • Es ist zulässig, -u UTC-Zeiten zu verwenden. "DST" und Ortszeitkorrekturen vermeiden.

Wenn Sie müssen den String 10:33:56 verwenden, konvertieren Sie ihn einfach in Sekunden.
auch die Word-Sekunden könnten als sec abgekürzt werden:

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"

Beachten Sie, dass die Sekundenumwandlung (wie oben dargestellt) relativ zum Beginn dieses Tages (Heute) ist.


Das Konzept kann wie folgt auf Nanosekunden erweitert werden:

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"

Wenn längere Zeitdifferenzen (bis zu 364 Tage) berechnet werden müssen, müssen wir den Beginn eines (einigen) Jahres als Referenz und den Formatwert %j (die Tagesnummer im Jahr) verwenden:

Ähnlich zu:

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

Leider müssen wir in diesem Fall 1 ONE manuell von der Anzahl der Tage subtrahieren. Der Date-Befehl zeigt den ersten Tag des Jahres als 1 .. an. Nicht so schwierig ...

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[@]}"



Die Verwendung einer langen Anzahl von Sekunden ist gültig und hier dokumentiert:
https://www.gnu.org/software/coreutils/manual/html_node/Examples-of-date.html#Examples-of-date


Busybox-Datum

Ein in kleineren Geräten verwendetes Werkzeug (eine sehr kleine zu installierende ausführbare Datei): Busybox.

Machen Sie entweder einen Link zu busybox mit dem Namen date:

$ ln -s /bin/busybox date

Verwenden Sie es dann, indem Sie diese date aufrufen (platzieren Sie es in einem mit PATH enthaltenen Verzeichnis).

Oder machen Sie einen Alias ​​wie:

$ alias date='busybox date'

Busybox Date hat eine Nice-Option: -D, um das Format der Eingabezeit zu erhalten . Dadurch werden viele Formate geöffnet, die als Uhrzeit verwendet werden können . Mit der Option -D können wir die Uhrzeit 10:33 konvertieren : 56 direkt:

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

Und wie Sie anhand der Ausgabe des Befehls oben sehen können, wird angenommen, dass der Tag "heute" ist. Um die Zeit ab Epoche zu bekommen:

$ 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-Datum kann sogar die Uhrzeit (im obigen Format) ohne -D empfangen:

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

Und das Ausgabeformat könnte sogar Sekunden nach Epoche sein.

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

Für beide Zeiten und ein wenig bash math (busybox kann noch nicht rechnen):

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

Oder formatiert:

$ date -u -D "%s" -d "$(( t2 - t1 ))" +"%H:%M:%S"
00:02:14
67
user2350426

So habe ich es gemacht:

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

Wirklich einfach, nehmen Sie sich die Anzahl der Sekunden am Anfang, dann die Anzahl der Sekunden am Ende und drucken Sie die Differenz in Minuten: Sekunden.

30
Dorian

Eine andere Option ist die Verwendung von datediff von 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

Sie können auch gawk verwenden. mawk 1.3.4 hat auch strftime und mktime, ältere Versionen von mawk und nawk jedoch nicht.

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

Oder Sie können dies auch mit GNU date tun:

$ date [email protected]$(($(date -ud'1970-01-01 10:36:10' +%s)-$(date -ud'1970-01-01 10:33:56' +%s))) +%T
00:02:14
13
nisetama

Ich möchte einen anderen Weg vorschlagen, um den Aufruf von date zu vermeiden. Dies kann hilfreich sein, wenn Sie bereits Zeitstempel im %T-Datumsformat gesammelt haben:

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"

wir können sogar mit Millisekunden auf dieselbe Weise umgehen.

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
Zskdan

Hier ist etwas 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 ersetzt einen : durch eine Formel, die in 1/60 umgewandelt werden soll. Dann die Zeitberechnung von bc

6
redolent

Folgen Sie der Antwort von Daniel Kamil Kozar, um Stunden/Minuten/Sekunden anzuzeigen:

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

Das vollständige Skript wäre also:

date1=$(date +"%s")
date2=$(date +"%s")
diff=$(($date2-$date1))
echo "Duration: $(($DIFF / 3600 )) hours $((($DIFF % 3600) / 60)) minutes $(($DIFF % 60)) seconds"
3
mcaleaa

Zum Datum (GNU coreutils) 7.4 können Sie jetzt -d verwenden, um Arithmetik auszuführen:

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

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

Die Einheiten, die Sie verwenden können, sind Tage, Jahre, Monate, Stunden, Minuten und Sekunden:

$ date -d tomorrow+2days-10minutes
Thu Jul 31 13:33:02 UTC 2014
3
rags

Oder ein bisschen einpacken

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

Dann funktioniert das.

timerstart; sleep 2; timerstop
seconds=2
2
user3561136

Mit 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
user5207022

date kann Ihnen den Unterschied geben und für Sie formatieren (OS X-Optionen werden angezeigt)

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

Bei einer Zeichenfolgenverarbeitung können diese leeren Werte entfernt werden

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

Dies funktioniert nicht, wenn Sie das frühere Mal zuerst platzieren. Wenn Sie damit umgehen müssen, ändern Sie $(($(date ...) - $(date ...))) in $(echo $(date ...) - $(date ...) | bc | tr -d -).

1
Dave

Hier ist eine Lösung, die nur die date-Befehlsfunktionen mit "ago" verwendet und keine zweite Variable zum Speichern der Endzeit verwendet:

#!/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

das gibt:

$ ./time_elapsed.sh 
elapsed_time: 1.002257120
1
Zoltan K.
% start=$(date +%s)
% echo "Diff: $(date -d @$(($(date +%s)-$start)) +"%M minutes %S seconds")"
Diff: 00 minutes 11 seconds
1
Joseph

Die Lösung von @ nisetama mit dem Datum GNU verallgemeinern (vertrauenswürdig Ubuntu 14.04 LTS):

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

echo $start
echo $stop
echo $duration

nachgebend:

Wed Feb 7 12:31:16 CST 2018
Wed Feb 7 12:32:25 CST 2018
00:01:09
0
Bill Gale

Ich brauchte ein Zeitdifferenz-Skript zur Verwendung mit mencoder (dessen --endpos ist relativ), und meine Lösung besteht darin, ein Python-Skript aufzurufen:

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

sekundenbruchteile werden ebenfalls unterstützt:

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

und es kann Ihnen sagen, dass der Unterschied zwischen 200 und 120 1h 20m beträgt:

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

und kann jede (wahrscheinlich gebrochene) Anzahl von Sekunden oder Minuten oder Stunden in hh: mm: ss umwandeln

$ ./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 __== "__main__":
   difftime(sys.argv[1],sys.argv[2])

Ich weiß, dass dies ein älterer Beitrag ist, aber ich bin heute auf ihn gestoßen, als ich an einem Skript arbeitete, das Datums- und Zeitangaben aus einer Protokolldatei nahm und das Delta berechnet. Das folgende Skript ist sicherlich übertrieben, und ich empfehle dringend, meine Logik und Mathematik zu überprüfen.

#!/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."

Sie erhalten die Ausgabe wie folgt.

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.

Ich habe das Skript ein wenig modifiziert, um es eigenständig zu machen (dh, einfach nur Variablenwerte setzen), aber vielleicht kommt auch die allgemeine Idee dazu. Möglicherweise möchten Sie einige zusätzliche Fehler auf negative Werte prüfen.

0
Daniel Blackmon

Ich kann die Antwort von mcaleaa nicht kommentieren, deshalb poste ich dies hier. Die Variable "diff" sollte auf einem kleinen Fall stehen. Hier ist ein Beispiel.

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

Vorherige Variable wurde in Kleinschreibung deklariert. Dies ist der Fall, wenn Großbuchstaben verwendet werden.

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

Eine schnelle Lösung wäre also so

[[email protected] ~]# echo "Duration: $(($diff / 3600 )) hours $((($diff % 3600) / 60)) minutes $(($diff % 60)) seconds"
Duration: 0 hours 0 minutes 13 seconds
[[email protected] ~]# 
0
Sabrina