Réponses:
Vous pouvez utiliser la gmdate()
fonction:
echo gmdate("H:i:s", 685);
datetime
... donc si nous nous attendons à un résultat> 24 heures, cela ne fonctionnera pas. De plus, si nous avons besoin d'un résultat négatif (par exemple, travailler avec un décalage), cela ne fonctionnera pas. -1
pour l'alouette des détails
echo gmdate("z H:i:s", 685);
z est le nombre de jours de l'année commençant par 0. Vous pouvez évidemment consulter le manuel de la date php pour répondre à vos besoins spécifiques.
Une heure est 3600sec, une minute est 60sec alors pourquoi pas:
<?php
$init = 685;
$hours = floor($init / 3600);
$minutes = floor(($init / 60) % 60);
$seconds = $init % 60;
echo "$hours:$minutes:$seconds";
?>
qui produit:
$ php file.php
0:11:25
(Je n'ai pas beaucoup testé, donc il pourrait y avoir des erreurs avec le sol ou plus)
printf("%02d:%02d:%02d", $hours, $minutes, $seconds);
sprintf
pour renvoyer la valeur au lieu de l'imprimer.
Voici
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
return ($t< 0 ? '-' : '') . sprintf("%02d%s%02d%s%02d", floor(abs($t)/3600), $f, (abs($t)/60)%60, $f, abs($t)%60); }
Utilisez la fonction gmdate()
uniquement si les secondes sont inférieures à 86400
(1 jour) :
$seconds = 8525;
echo gmdate('H:i:s', $seconds);
# 02:22:05
Voir: gmdate ()
Convertissez les secondes au format par 'pied' sans limite * :
$seconds = 8525;
$H = floor($seconds / 3600);
$i = ($seconds / 60) % 60;
$s = $seconds % 60;
echo sprintf("%02d:%02d:%02d", $H, $i, $s);
# 02:22:05
Voir: floor () , sprintf () , opérateurs arithmétiques
Exemple d'utilisation de l' 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
Voir: DateTime :: __ construct () , DateTime :: modify () , clone , sprintf ()
La plage d'-838:59:59
838:59:59
exemples MySQL du résultat est limitée à celle du type de données TIME, qui va de à :
SELECT SEC_TO_TIME(8525);
# 02:22:05
Voir: SEC_TO_TIME
Exemple PostgreSQL:
SELECT TO_CHAR('8525 second'::interval, 'HH24:MI:SS');
# 02:22:05
D'autres solutions utilisent gmdate
, mais échouent dans les cas limites où vous disposez de plus de 86400 secondes. Pour contourner cela, nous pouvons simplement calculer le nombre d'heures nous-mêmes, puis laisser gmdate
calculer les secondes restantes en minutes / secondes.
echo floor($seconds / 3600) . gmdate(":i:s", $seconds % 3600);
Entrée: 6030
Sortie:1:40:30
Entrée: 2000006030
Sortie: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);
Ne donnera pas l'heure au H:i:s
format si elle no_of_seconds
est supérieure à 1 jour (secondes dans une journée).
Il négligera la valeur journalière et ne donnera queHour:Min:Seconds
Par exemple:
gmdate("H:i:s", 89922); // returns 0:58:42 not (1 Day 0:58:42) or 24:58:42
Voici une doublure qui gère les secondes négatives et plus de 1 jour de secondes.
sprintf("%s:%'02s:%'02s\n", intval($seconds/60/60), abs(intval(($seconds%3600) / 60)), abs($seconds%60));
Par exemple:
$seconds= -24*60*60 - 2*60*60 - 3*60 - 4; // minus 1 day 2 hours 3 minutes 4 seconds
echo sprintf("%s:%'02s:%'02s\n", intval($seconds/60/60), abs(intval(($seconds%3600) / 60)), abs($seconds%60));
sorties: -26: 03: 04
Si vous n'aimez pas les réponses acceptées ou les réponses populaires, essayez celle-ci
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
écrire une fonction comme celle-ci pour retourner un tableau
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;
}
puis appelez simplement la fonction comme ceci:
secondsToTime(100);
la sortie est
Array ( [h] => 0 [m] => 1 [s] => 40 )
Voir:
/**
* 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;
$secondsInADay = 24 * $secondsInAnHour;
// extract days
$days = floor($inputSeconds / $secondsInADay);
// extract hours
$hourSeconds = $inputSeconds % $secondsInADay;
$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;
}
De: convertir les secondes en jours, heures, minutes et secondes
Essaye ça:
date("H:i:s",-57600 + 685);
Tiré de
http://bytes.com/topic/php/answers/3917-seconds-converted-hh-mm-ss
La fonction gmtdate () n'a pas fonctionné pour moi car je suivais les heures travaillées sur un projet et si c'est plus de 24 heures, vous obtenez le montant restant après 24 heures est soustrait. En d'autres termes, 37 heures deviennent 13 heures. (tout comme indiqué ci-dessus par Glavic - merci pour vos exemples!) Celui-ci a bien fonctionné:
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
Cette fonction peut être utile, vous pouvez l'étendre:
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) {
$fmt .= str_pad($hours, 2, '0', STR_PAD_LEFT).":";
$seconds %= 3600;
}
$mins = floor($seconds / 60 );
if($mins) {
$fmt .= str_pad($mins, 2, '0', STR_PAD_LEFT).":";
$seconds %= 60;
}
$fmt .= str_pad($seconds, 2, '0', STR_PAD_LEFT);
return $fmt;}
Solution de: https://gist.github.com/SteveJobzniak/c91a8e2426bac5cb9b0cbc1bdbc45e4b
Ce code évite autant que possible les appels de fonctions fastidieux et la construction de chaînes pièce par pièce, et les fonctions importantes et encombrantes que les gens font pour cela.
Il produit le format "1h05m00s" et utilise des zéros non significatifs pendant les minutes et les secondes, tant qu'un autre composant temporel non nul les précède.
Et il saute tous les principaux composants vides pour éviter de vous donner des informations inutiles comme "0h00m01s" (à la place, cela apparaîtra comme "1s").
Exemples de résultats: "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'; }
Si vous souhaitez rendre le code encore plus court (mais moins lisible), vous pouvez éviter le $converted
tableau et placer les valeurs directement dans l'appel sprintf (), comme suit:
$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'; }
La durée doit être égale ou supérieure à 0 dans les deux éléments de code ci-dessus. Les durées négatives ne sont pas prises en charge. Mais vous pouvez gérer des durées négatives en utilisant à la place le code alternatif suivant:
$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"
gmdate()
hack est encore plus court que cela, mais ne prend en charge que des durées allant jusqu'à 24 heures. Tout ce qui dépasse 24 heures échouera si vous utilisez l'astuce gmdate!
Un moyen simple d'utiliser DateTime pour cela est:
$time = 60; //sec.
$now = time();
$rep = new DateTime('@'.$now);
$diff = new DateTime('@'.($now+$time));
$return = $diff->diff($rep)->format($format);
//output: 01:04:65
C'est une solution simple qui vous donne la possibilité d'utiliser la méthode de format de DateTime.
En java, vous pouvez utiliser cette méthode.
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;
}
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);
}
Eh bien, j'avais besoin de quelque chose qui réduirait les secondes en heures minutes et secondes, mais dépasserait 24 heures, et ne se réduirait pas davantage en jours.
Voici une fonction simple qui fonctionne. Vous pouvez probablement l'améliorer ... Mais le voici:
function formatSeconds($seconds)
{
$hours = 0;$minutes = 0;
while($seconds >= 60){$seconds -= 60;$minutes++;}
while($minutes >= 60){$minutes -=60;$hours++;}
$hours = str_pad($hours, 2, '0', STR_PAD_LEFT);
$minutes = str_pad($minutes, 2, '0', STR_PAD_LEFT);
$seconds = str_pad($seconds, 2, '0', STR_PAD_LEFT);
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;
Pour le convertir en fonction:
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;
}
Si vous devez le faire en javascript, vous pouvez le faire en une seule ligne de code comme indiqué ici Convertissez les secondes en HH-MM-SS avec JavaScript . Remplacez SECONDES par ce que vous souhaitez convertir.
var time = new Date(SECONDS * 1000).toISOString().substr(11, 8);
Si vous souhaitez créer une chaîne de durée audio / vidéo comme YouTube, etc., vous pouvez faire:
($seconds >= 60) ? ltrim(gmdate("H:i:s", $seconds), ":0") : gmdate("0:s", $seconds)
Renvoie des chaînes comme:
55.55 => '0:55'
100 => '1:40'
Ne fonctionnera probablement pas bien pendant un temps> = 24 heures.
C'est une jolie façon de le faire:
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;
}
Juste au cas où quelqu'un d'autre chercherait une fonction simple pour renvoyer ce format bien (je sais que ce n'est pas le format demandé par l'OP), c'est ce que je viens de trouver. Merci à @mughal pour le code sur lequel il était basé.
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;
}
Quiconque cherche cela à l'avenir, cela donne le format demandé par l'affiche initiale.
$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, ";
}
seconds
en undate/time
ou en un nombre d'heures: Minute: Secondes?