# Convert seconds to Hour:Minute:Second

Solution for Convert seconds to Hour:Minute:Second
is Given Below:

I need to convert seconds to “Hour:Minute:Second”.

For example: “685” converted to “00:11:25”

How can I achieve this?

You can use the `gmdate()` function:

``````echo gmdate("H:i:s", 685);
``````

One hour is 3600sec, one minute is 60sec so why not:

``````<?php

\$init = 685;
\$hours = floor(\$init / 3600);
\$minutes = floor((\$init / 60) % 60);
\$seconds = \$init % 60;

echo "\$hours:\$minutes:\$seconds";

?>
``````

which produces:

``````\$ php file.php
0:11:25
``````

(I’ve not tested this much, so there might be errors with floor or so)

here you go

``````function format_time(\$t,\$f=":") // t = seconds, f = separator
{
return sprintf("%02d%s%02d%s%02d", floor(\$t/3600), \$f, (\$t/60)%60, \$f, \$t%60);
}

echo format_time(685); // 00:11:25
``````

Use function `gmdate()` only if seconds are less than `86400` (1 day) :

``````\$seconds = 8525;
echo gmdate('H:i:s', \$seconds);
# 02:22:05
``````

See: gmdate()

Run the Demo

Convert seconds to format by ‘foot’ no limit* :

``````\$seconds = 8525;
\$H = floor(\$seconds / 3600);
\$i = (\$seconds / 60) % 60;
\$s = \$seconds % 60;
echo sprintf("%02d:%02d:%02d", \$H, \$i, \$s);
# 02:22:05
``````

Run the Demo

Example use of `DateTime` extension:

``````\$seconds = 8525;
\$zero    = new DateTime("@0");
\$offset  = new DateTime("@\$seconds");
\$diff    = \$zero->diff(\$offset);
echo sprintf("%02d:%02d:%02d", \$diff->days * 24 + \$diff->h, \$diff->i, \$diff->s);
# 02:22:05
``````

Run the Demo

MySQL example range of the result is constrained to that of the TIME data type, which is from `-838:59:59` to `838:59:59` :

``````SELECT SEC_TO_TIME(8525);
# 02:22:05
``````

See: SEC_TO_TIME

Run the Demo

PostgreSQL example:

``````SELECT TO_CHAR('8525 second'::interval, 'HH24:MI:SS');
# 02:22:05
``````

Run the Demo

Other solutions use `gmdate`, but fail in edge cases where you have more than 86400 seconds. To get around this, we can simply compute the number of hours ourselves, then let `gmdate` compute the remaining seconds into minutes/seconds.

``````echo floor(\$seconds / 3600) . gmdate(":i:s", \$seconds % 3600);
``````

Input: `6030`
Output: `1:40:30`

Input: `2000006030`
Output: `555557:13:50`

``````// TEST
// 1 Day 6 Hours 50 Minutes 31 Seconds ~ 111031 seconds

\$time = 111031; // time duration in seconds

\$days = floor(\$time / (60 * 60 * 24));
\$time -= \$days * (60 * 60 * 24);

\$hours = floor(\$time / (60 * 60));
\$time -= \$hours * (60 * 60);

\$minutes = floor(\$time / 60);
\$time -= \$minutes * 60;

\$seconds = floor(\$time);
\$time -= \$seconds;

echo "{\$days}d {\$hours}h {\$minutes}m {\$seconds}s"; // 1d 6h 50m 31s
``````

``````gmdate("H:i:s", no_of_seconds);
``````

Will not give time in `H:i:s` format if `no_of_seconds` is greater than 1 day (seconds in a day).
It will neglect day value and give only `Hour:Min:Seconds`

For example:

``````gmdate("H:i:s", 89922); // returns 0:58:42 not (1 Day 0:58:42) or 24:58:42
``````

If you don’t like accepted answer or popular ones, then try this one

``````function secondsToTime(\$seconds_time)
{
if (\$seconds_time < 24 * 60 * 60) {
return gmdate('H:i:s', \$seconds_time);
} else {
\$hours = floor(\$seconds_time / 3600);
\$minutes = floor((\$seconds_time - \$hours * 3600) / 60);
\$seconds = floor(\$seconds_time - (\$hours * 3600) - (\$minutes * 60));
return "\$hours:\$minutes:\$seconds";
}
}

secondsToTime(108620); // 30:10:20
``````

Here is a one liner that handles negative seconds and more than 1 day worth of seconds.

``````sprintf("%s:%'02s:%'02sn", intval(\$seconds/60/60), abs(intval((\$seconds%3600) / 60)), abs(\$seconds%60));
``````

For Example:

``````\$seconds= -24*60*60 - 2*60*60 - 3*60 - 4; // minus 1 day 2 hours 3 minutes 4 seconds
echo sprintf("%s:%'02s:%'02sn", intval(\$seconds/60/60), abs(intval((\$seconds%3600) / 60)), abs(\$seconds%60));
``````

outputs: -26:03:04

write function like this to return an array

``````function secondsToTime(\$seconds) {

// extract hours
\$hours = floor(\$seconds / (60 * 60));

// extract minutes
\$divisor_for_minutes = \$seconds % (60 * 60);
\$minutes = floor(\$divisor_for_minutes / 60);

// extract the remaining seconds
\$divisor_for_seconds = \$divisor_for_minutes % 60;
\$seconds = ceil(\$divisor_for_seconds);

// return the final array
\$obj = array(
"h" => (int) \$hours,
"m" => (int) \$minutes,
"s" => (int) \$seconds,
);

return \$obj;
}
``````

then simply call the function like this:

``````secondsToTime(100);
``````

output is

``````Array ( [h] => 0 [m] => 1 [s] => 40 )
``````

See:

``````    /**
* Convert number of seconds into hours, minutes and seconds
* and return an array containing those values
*
* @param integer \$inputSeconds Number of seconds to parse
* @return array
*/

function secondsToTime(\$inputSeconds) {

\$secondsInAMinute = 60;
\$secondsInAnHour  = 60 * \$secondsInAMinute;

// extract days

// extract hours
\$hours = floor(\$hourSeconds / \$secondsInAnHour);

// extract minutes
\$minuteSeconds = \$hourSeconds % \$secondsInAnHour;
\$minutes = floor(\$minuteSeconds / \$secondsInAMinute);

// extract the remaining seconds
\$remainingSeconds = \$minuteSeconds % \$secondsInAMinute;
\$seconds = ceil(\$remainingSeconds);

// return the final array
\$obj = array(
'd' => (int) \$days,
'h' => (int) \$hours,
'm' => (int) \$minutes,
's' => (int) \$seconds,
);
return \$obj;
}
``````

From: Convert seconds into days, hours, minutes and seconds

This function my be useful, you could extend it:

``````function formatSeconds(\$seconds) {

if(!is_integer(\$seconds)) {
return FALSE;
}

\$fmt = "";

\$days = floor(\$seconds / 86400);
if(\$days) {
\$fmt .= \$days."D ";
\$seconds %= 86400;
}

\$hours = floor(\$seconds / 3600);
if(\$hours) {
\$seconds %= 3600;
}

\$mins = floor(\$seconds / 60 );
if(\$mins) {
\$seconds %= 60;
}

return \$fmt;}
``````

Try this:

``````date("H:i:s",-57600 + 685);
``````

The gmtdate() function didn’t work for me as I was tracking hours worked on a project and if it’s over 24 hours, you get amount left over after 24 hours is subtracted. In other words 37 hours becomes 13 hours. (all as stated above by Glavic – thanks for your examples!)
This one worked well:

``````Convert seconds to format by 'foot' no limit :
\$seconds = 8525;
\$H = floor(\$seconds / 3600);
\$i = (\$seconds / 60) % 60;
\$s = \$seconds % 60;
echo sprintf("%02d:%02d:%02d", \$H, \$i, \$s);
# 02:22:05
``````

# Here is a very clean and short method!

This code avoids as much as possible of the tedious function calls and piece-by-piece string-building, and the big and bulky functions people are making for this.

It produces “1h05m00s” format and uses leading zeroes for minutes and seconds, as long as another non-zero time component precedes them.

And it skips all empty leading components to avoid giving you useless info like “0h00m01s” (instead that will show up as “1s”).

Example results: “1s”, “1m00s”, “19m08s”, “1h00m00s”, “4h08m39s”.

``````\$duration = 1; // values 0 and higher are supported!
\$converted = [
'hours' => floor( \$duration / 3600 ),
'minutes' => floor( ( \$duration / 60 ) % 60 ),
'seconds' => ( \$duration % 60 )
];
\$result = ltrim( sprintf( '%02dh%02dm%02ds', \$converted['hours'], \$converted['minutes'], \$converted['seconds'] ), '0hm' );
if( \$result == 's' ) { \$result="0s"; }
``````

If you want to make the code even shorter (but less readable), you can avoid the `\$converted` array and instead put the values directly in the sprintf() call, as follows:

``````\$duration = 1; // values 0 and higher are supported!
\$result = ltrim( sprintf( '%02dh%02dm%02ds', floor( \$duration / 3600 ), floor( ( \$duration / 60 ) % 60 ), ( \$duration % 60 ) ), '0hm' );
if( \$result == 's' ) { \$result="0s"; }
``````

Duration must be 0 or higher in both of the code pieces above. Negative durations are not supported. But you can handle negative durations by using the following alternative code instead:

``````\$duration = -493; // negative values are supported!
\$wasNegative = FALSE;
if( \$duration < 0 ) { \$wasNegative = TRUE; \$duration = abs( \$duration ); }
\$converted = [
'hours' => floor( \$duration / 3600 ),
'minutes' => floor( ( \$duration / 60 ) % 60 ),
'seconds' => ( \$duration % 60 )
];
\$result = ltrim( sprintf( '%02dh%02dm%02ds', \$converted['hours'], \$converted['minutes'], \$converted['seconds'] ), '0hm' );
if( \$result == 's' ) { \$result="0s"; }
if( \$wasNegative ) { \$result = "-{\$result}"; }
// \$result is now "-8m13s"
``````

A simple way to use DateTime for this is:

``````    \$time = 60; //sec.
\$now = time();
\$rep = new DateTime('@'.\$now);
\$diff = new DateTime('@'.(\$now+\$time));
\$return = \$diff->diff(\$rep)->format(\$format);

//output:  01:04:65
``````

It’s a simple solution wich gives you the ability to use the format Method of DateTime.

In java you can use this way.

``````   private String getHmaa(long seconds) {
String string;
int hours = (int) seconds / 3600;
int remainder = (int) seconds - hours * 3600;
int mins = remainder / 60;
//remainder = remainder - mins * 60;
//int secs = remainder;

if (hours < 12 && hours > 0) {
if (mins < 10) {
string = String.valueOf((hours < 10 ? "0" + hours : hours) + ":" + (mins > 0 ? "0" + mins : "0") + " AM");
} else {
string = String.valueOf((hours < 10 ? "0" + hours : hours) + ":" + (mins > 0 ? mins : "0") + " AM");
}
} else if (hours >= 12) {
if (mins < 10) {
string = String.valueOf(((hours - 12) < 10 ? "0" + (hours - 12) : ((hours - 12) == 12 ? "0" : (hours - 12))) + ":" + (mins > 0 ? "0" + mins : "0") + ((hours - 12) == 12 ? " AM" : " PM"));
} else {
string = String.valueOf(((hours - 12) < 10 ? "0" + (hours - 12) : ((hours - 12) == 12 ? "0" : (hours - 12))) + ":" + (mins > 0 ? mins : "0") + ((hours - 12) == 12 ? " AM" : " PM"));
}
} else {
if (mins < 10) {
string = String.valueOf("0" + ":" + (mins > 0 ? "0" + mins : "0") + " AM");
} else {
string = String.valueOf("0" + ":" + (mins > 0 ? mins : "0") + " AM");
}
}
return string;
}
``````

I have already explained this here
pasting that answer here as well

For till `23:59:59` hours you can use PHP default function

``````echo gmdate("H:i:s", 86399);
``````

Which will only return the result till `23:59:59`

If your seconds is more than 86399 than
with the help of @VolkerK answer

``````\$time = round(\$seconds);
echo sprintf('%02d:%02d:%02d', (\$time/3600),(\$time/60%60), \$time%60);
``````

will be the best options to use …

``````function timeToSecond(\$time){
\$time_parts=explode(":",\$time);
\$seconds= (\$time_parts[0]*86400) + (\$time_parts[1]*3600) + (\$time_parts[2]*60) + \$time_parts[3] ;
return \$seconds;
}

function secondToTime(\$time){
\$seconds  = \$time % 60;
\$seconds<10 ? "0".\$seconds : \$seconds;
if(\$seconds<10) {
\$seconds="0".\$seconds;
}
\$time     = (\$time - \$seconds) / 60;
\$minutes  = \$time % 60;
if(\$minutes<10) {
\$minutes="0".\$minutes;
}
\$time     = (\$time - \$minutes) / 60;
\$hours    = \$time % 24;
if(\$hours<10) {
\$hours="0".\$hours;
}
\$days     = (\$time - \$hours) / 24;
if(\$days<10) {
\$days="0".\$days;
}

\$time_arr = array(\$days,\$hours,\$minutes,\$seconds);
return implode(":",\$time_arr);
}
``````

Well I needed something that would reduce seconds into hours minutes and seconds, but would exceed 24 hours, and not reduce further down into days.

Here is a simple function that works. You can probably improve it… But here it is:

``````function formatSeconds(\$seconds)
{
\$hours = 0;\$minutes = 0;
while(\$seconds >= 60){\$seconds -= 60;\$minutes++;}
while(\$minutes >= 60){\$minutes -=60;\$hours++;}
return \$hours.":".\$minutes.":".\$seconds;
}
``````

``````\$given = 685;

/*
* In case \$given == 86400, gmdate( "H" ) will convert it into '00' i.e. midnight.
* We would need to take this into consideration, and so we will first
* check the ratio of the seconds i.e. \$given:\$number_of_sec_in_a_day
* and then after multiplying it by the number of hours in a day (24), we
* will just use "floor" to get the number of hours as the rest would
* be the minutes and seconds anyways.
*
* We can also have minutes and seconds combined in one variable,
* e.g. \$min_sec = gmdate( "i:s", \$given );
* But for versatility sake, I have taken them separately.
*/

\$hours = ( \$given > 86399 ) ? '0'.floor( ( \$given / 86400 ) * 24 )-gmdate( "H", \$given ) : gmdate("H", \$given );

\$min = gmdate( "i", \$given );

\$sec = gmdate( "s", \$given );

echo \$formatted_string = \$hours.':'.\$min.':'.\$sec;
``````

To convert it into a function:

``````function getHoursFormat( \$given ){

\$hours = ( \$given > 86399 ) ? '0'.floor( ( \$given / 86400 ) * 24 )-gmdate( "H", \$given ) : gmdate("H", \$given );

\$min = gmdate( "i", \$given );

\$sec = gmdate( "s", \$given );

\$formatted_string = \$hours.':'.\$min.':'.\$sec;

return \$formatted_string;

}
``````

If you need to do that in javascript, you can do it in just one line of code as answered here Convert seconds to HH-MM-SS with JavaScript. Replace SECONDS with what you want to convert.

``````var time = new Date(SECONDS * 1000).toISOString().substr(11, 8);
``````

If you want to create a audio/video duration string like YouTube, etc. you can do:

`(\$seconds >= 60) ? ltrim(gmdate("H:i:s", \$seconds), ":0") : gmdate("0:s", \$seconds)`

Will return strings like:

``````55.55 => '0:55'
100   => '1:40'
``````

Probably won’t work well for time >= 24 hours.

This is a pretty way to do that:

``````function time_converter(\$sec_time, \$format="h:m:s"){
\$hour = intval(\$sec_time / 3600) >= 10 ? intval(\$sec_time / 3600) : '0'.intval(\$sec_time / 3600);
\$minute = intval((\$sec_time % 3600) / 60) >= 10 ? intval((\$sec_time % 3600) / 60) : '0'.intval((\$sec_time % 3600) / 60);
\$sec = intval((\$sec_time % 3600) % 60)  >= 10 ? intval((\$sec_time % 3600) % 60) : '0'.intval((\$sec_time % 3600) % 60);

\$format = str_replace('h', \$hour, \$format);
\$format = str_replace('m', \$minute, \$format);
\$format = str_replace('s', \$sec, \$format);

return \$format;
}
``````

The following codes can display total hours plus minutes and seconds accurately

``````\$duration_in_seconds = 86401;
if(\$duration_in_seconds>0)
{
echo floor(\$duration_in_seconds/3600).gmdate(":i:s", \$duration_in_seconds%3600);
}
else
{
echo "00:00:00";
}
``````

Just in case anyone else is looking for a simple function to return this nicely formatted (I know it is not the format the OP asked for), this is what I’ve just come up with. Thanks to @mughal for the code this was based on.

``````function format_timer_result(\$time_in_seconds){
\$time_in_seconds = ceil(\$time_in_seconds);

// Check for 0
if (\$time_in_seconds == 0){
return 'Less than a second';
}

// Days
\$days = floor(\$time_in_seconds / (60 * 60 * 24));
\$time_in_seconds -= \$days * (60 * 60 * 24);

// Hours
\$hours = floor(\$time_in_seconds / (60 * 60));
\$time_in_seconds -= \$hours * (60 * 60);

// Minutes
\$minutes = floor(\$time_in_seconds / 60);
\$time_in_seconds -= \$minutes * 60;

// Seconds
\$seconds = floor(\$time_in_seconds);

// Format for return
\$return = '';
if (\$days > 0){
\$return .= \$days . ' day' . (\$days == 1 ? '' : 's'). ' ';
}
if (\$hours > 0){
\$return .= \$hours . ' hour' . (\$hours == 1 ? '' : 's') . ' ';
}
if (\$minutes > 0){
\$return .= \$minutes . ' minute' . (\$minutes == 1 ? '' : 's') . ' ';
}
if (\$seconds > 0){
\$return .= \$seconds . ' second' . (\$seconds == 1 ? '' : 's') . ' ';
}
\$return = trim(\$return);

return \$return;
}
``````

Anyone whose looking for this in the future, this gives the format the initial poster asked for.

``````\$init = 685;
\$hours = floor(\$init / 3600);
\$hrlength=strlen(\$hours);
if (\$hrlength==1) {\$hrs="0".\$hours;}
else {\$hrs=\$hours;}

\$minutes = floor((\$init / 60) % 60);
\$minlength=strlen(\$minutes);
if (\$minlength==1) {\$mins="0".\$minutes;}
else {\$mins=\$minutes;}

\$seconds = \$init % 60;
\$seclength=strlen(\$seconds);
if (\$seclength==1) {\$secs="0".\$seconds;}
else {\$secs=\$seconds;}

echo "\$hrs:\$mins:\$secs";
``````

``````<?php
\$time=3*3600 + 30*60;

\$year=floor(\$time/(365*24*60*60));
\$time-=\$year*(365*24*60*60);

\$month=floor(\$time/(30*24*60*60));
\$time-=\$month*(30*24*60*60);

\$day=floor(\$time/(24*60*60));
\$time-=\$day*(24*60*60);

\$hour=floor(\$time/(60*60));
\$time-=\$hour*(60*60);

\$minute=floor(\$time/(60));
\$time-=\$minute*(60);

\$second=floor(\$time);
\$time-=\$second;
if(\$year>0){
echo \$year." year, ";
}
if(\$month>0){
echo \$month." month, ";
}
if(\$day>0){
echo \$day." day, ";
}
if(\$hour>0){
echo \$hour." hour, ";
}
if(\$minute>0){
echo \$minute." minute, ";
}
if(\$second>0){
echo \$second." second, ";
}
``````