Comment trouver le nombre de jours entre deux dates en utilisant PHP?

$now = time(); // or your date as well
$your_date = strtotime("2010-01-31");
$datediff = $now - $your_date;

echo round($datediff / (60 * 60 * 24));

Si vous utilisez PHP 5.3 >, c'est de loin le moyen le plus précis de calculer la différence:

$earlier = new DateTime("2010-07-06");
$later = new DateTime("2010-07-09");

$diff = $later->diff($earlier)->format("%a");

Depuis PHP version 5.3 et plus, de nouvelles fonctions date / heure ont été ajoutées pour faire la différence:

$datetime1 = new DateTime("2010-06-20");

$datetime2 = new DateTime("2011-06-22");

$difference = $datetime1->diff($datetime2);

echo 'Difference: '.$difference->y.' years, ' 
                   .$difference->m.' months, ' 
                   .$difference->d.' days';

print_r($difference);

Résultat comme ci-dessous:

Difference: 1 years, 0 months, 2 days

DateInterval Object
(
    [y] => 1
    [m] => 0
    [d] => 2
    [h] => 0
    [i] => 0
    [s] => 0
    [invert] => 0
    [days] => 367
)

J'espère que cela aide !

Convertissez vos dates en horodatages Unix, puis soustrayez-les les unes des autres. Cela vous donnera la différence en secondes, que vous divisez par 86400 (quantité de secondes dans une journée) pour vous donner une quantité approximative de jours dans cette plage.

Si vos dates sont au format 25.1.2010, 01/25/2010ou 2010-01-25, vous pouvez utiliser la strtotimefonction:

$start = strtotime('2010-01-25');
$end = strtotime('2010-02-20');

$days_between = ceil(abs($end - $start) / 86400);

L'utilisation ceilarrondit le nombre de jours jusqu'au jour complet suivant. Utilisez-le à la floorplace si vous souhaitez obtenir le nombre de jours entiers entre ces deux dates.

Si vos dates sont déjà au format d'horodatage Unix, vous pouvez ignorer la conversion et simplement faire la $days_betweenpartie. Pour les formats de date plus exotiques, vous devrez peut-être effectuer une analyse personnalisée pour bien faire les choses.

TL; DR n'utilisent pas d' horodatage UNIX. Ne pas utilisertime() . Si vous le faites, soyez prêt si sa fiabilité à 98,0825% vous fait défaut. Utilisez DateTime (ou Carbon).

La bonne réponse est celle donnée par Saksham Gupta (les autres réponses sont également correctes):

$date1 = new DateTime('2010-07-06');
$date2 = new DateTime('2010-07-09');
$days  = $date2->diff($date1)->format('%a');

Ou de manière procédurale en une ligne:

/**
 * Number of days between two dates.
 *
 * @param date $dt1    First date
 * @param date $dt2    Second date
 * @return int
 */
function daysBetween($dt1, $dt2) {
    return date_diff(
        date_create($dt2),  
        date_create($dt1)
    )->format('%a');
}

Avec une mise en garde: le «% a» semble indiquer le nombre absolu de jours. Si vous le voulez comme un entier signé, c'est-à-dire négatif lorsque la deuxième date est antérieure à la première, vous devez utiliser le préfixe '% r' (c'est-à-dire format('%r%a')).

Si vous devez vraiment utiliser des horodatages UNIX, définissez le fuseau horaire sur GMT pour éviter la plupart des pièges détaillés ci-dessous.

Réponse longue: pourquoi la division par 24 * 60 * 60 (aka 86400) n'est pas sûre

La plupart des réponses utilisant les horodatages UNIX (et 86400 pour les convertir en jours) émettent deux hypothèses qui, mises ensemble, peuvent conduire à des scénarios avec des résultats incorrects et des bogues subtils qui peuvent être difficiles à suivre, et se produisent même des jours, des semaines ou des mois après un déploiement réussi. Ce n'est pas que la solution ne fonctionne pas - elle fonctionne. Aujourd'hui. Mais cela pourrait cesser de fonctionner demain.

La première erreur n'est pas de considérer que lorsqu'on lui demande "Combien de jours se sont écoulés depuis hier?", Un ordinateur peut répondre à zéro si entre le présent et l'instant indiqué par "hier" moins d' une journée entière s'est écoulée.

Généralement, lors de la conversion d'un «jour» en horodatage UNIX, ce qui est obtenu est l'horodatage pour minuit de ce jour particulier.

Ainsi, entre la nuit du 1er octobre et le 15 octobre, quinze jours se sont écoulés. Mais entre 13h00 du 1er octobre et 14h55 du 15 octobre, quinze jours moins 5 minutes se sont écoulés, et la plupart des solutions utilisant floor()ou faisant une conversion implicite d'entiers rapporteront un jour de moins que prévu .

Donc, "il y a combien de jours Ymd H: i: s"? donnera la mauvaise réponse .

La deuxième erreur équivaut à un jour à 86400 secondes. C'est presque toujours vrai - cela arrive assez souvent pour ignorer les moments où cela ne se produit pas. Mais la distance en secondes entre deux minuit consécutifs n'est sûrement pas de 86400 au moins deux fois par an lorsque l'heure d'été entre en jeu. La comparaison de deux dates à travers une limite d'heure d'été donnera la mauvaise réponse.

Donc, même si vous utilisez le "hack" de forcer tous les horodatages de date à une heure fixe, disons minuit (cela est également implicitement fait par divers langages et frameworks lorsque vous spécifiez uniquement jour-mois-année et pas également heure-minute-seconde; même chose avec le type DATE dans les bases de données telles que MySQL), la formule largement utilisée

 (unix_timestamp(DATE2) - unix_timestamp(DATE1)) / 86400

ou

 floor(time() - strtotime($somedate)) / 86400

retournera, disons, 17 lorsque DATE1 et DATE2 sont dans le même segment DST de l'année; mais il peut renvoyer 17,042, et pire encore, 16,958. L'utilisation de floor () ou de toute troncature implicite en entier convertira alors ce qui aurait dû être un 17 en 16. Dans d'autres circonstances, des expressions comme "$ days> 17" truerenverront pour 17.042 même si cela indique que le nombre de jours écoulés a 18 ans.

Et les choses deviennent encore plus laides car un tel code n'est pas portable sur toutes les plates-formes, car certaines d'entre elles peuvent appliquer des secondes intercalaires et d'autres pas . Sur ces plates-formes qui le font , la différence entre deux dates ne sera pas 86400 mais 86401, ou peut-être 86399. Ainsi, le code qui a fonctionné en mai et qui a effectivement passé tous les tests se cassera en juin prochain lorsque 12,99999 jours sont considérés comme 12 jours au lieu de 13. Deux dates qui a fonctionné en 2015 ne fonctionnera pas en 2017 - les mêmes dates, et aucune des deux années n'est bissextile. Mais entre le 01/03/2018 et le 01/03/2017, sur ces plateformes qui s'en soucient, 366 jours se seront écoulés au lieu de 365, faisant de 2018 une année bissextile (ce qui n'est pas le cas).

Donc, si vous voulez vraiment utiliser les horodatages UNIX:

• utiliser la round()fonction à bon escient, non floor().

• comme alternative, ne calculez pas les différences entre D1-M1-YYY1 et D2-M2-YYY2. Ces dates seront réellement considérées comme D1-M1-YYY1 00:00:00 et D2-M2-YYY2 00:00:00. Convertissez plutôt entre D1-M1-YYY1 22:30:00 et D2-M2-YYY2 04:30:00. Vous obtiendrez toujours un reste d'une vingtaine d'heures. Cela peut devenir vingt et une heures ou dix-neuf, et peut-être dix-huit heures, cinquante-neuf minutes trente-six secondes. Peu importe. C'est une grande marge qui restera là et restera positive dans un avenir prévisible. Vous pouvez maintenant le tronquer floor()en toute sécurité.

La bonne solution, cependant, pour éviter les constantes magiques, les arrondis et les dettes de maintenance, consiste à

• utiliser une bibliothèque de temps (Datetime, Carbon, peu importe); ne roule pas toi-même

• écrire des cas de test complets en utilisant des choix de date vraiment mauvais - au-delà des limites de l'heure d'été, des années bissextiles, des secondes bissextiles, etc., ainsi que des dates courantes. Idéalement (les appels à datetime sont rapides !) Génèrent quatre années entières (et un jour) de dates en les assemblant à partir de chaînes, séquentiellement, et garantissent que la différence entre le premier jour et le jour testé augmente régulièrement de un. Cela garantira que si quelque chose change dans les routines de bas niveau et les corrections de secondes intercalaires, essayez de faire des ravages, au moins vous le saurez .

• exécutez ces tests régulièrement avec le reste de la suite de tests. Ils sont une question de millisecondes et peuvent vous sauver littéralement des heures de grattage de tête.

Quelle que soit votre solution, testez-la!

La fonction funcdiffci-dessous implémente l'une des solutions (en l'occurrence, la solution acceptée) dans un scénario du monde réel.

<?php
$tz         = 'Europe/Rome';
$yearFrom   = 1980;
$yearTo     = 2020;
$verbose    = false;

function funcdiff($date2, $date1) {
    $now        = strtotime($date2);
    $your_date  = strtotime($date1);
    $datediff   = $now - $your_date;
    return floor($datediff / (60 * 60 * 24));
}
########################################

date_default_timezone_set($tz);
$failures   = 0;
$tests      = 0;

$dom = array ( 0, 31, 28, 31, 30,
                  31, 30, 31, 31,
                  30, 31, 30, 31 );
(array_sum($dom) === 365) || die("Thirty days hath September...");
$last   = array();
for ($year = $yearFrom; $year < $yearTo; $year++) {
    $dom[2] = 28;
    // Apply leap year rules.
    if ($year % 4 === 0)   { $dom[2] = 29; }
    if ($year % 100 === 0) { $dom[2] = 28; }
    if ($year % 400 === 0) { $dom[2] = 29; }
    for ($month = 1; $month <= 12; $month ++) {
        for ($day = 1; $day <= $dom[$month]; $day++) {
            $date = sprintf("%04d-%02d-%02d", $year, $month, $day);
            if (count($last) === 7) {
                $tests ++;
                $diff = funcdiff($date, $test = array_shift($last));
                if ((double)$diff !== (double)7) {
                    $failures ++;
                    if ($verbose) {
                        print "There seem to be {$diff} days between {$date} and {$test}\n";
                    }
                }
            }
            $last[] = $date;
        }
    }
}

print "This function failed {$failures} of its {$tests} tests between {$yearFrom} and {$yearTo}.\n";

Le résultat est,

This function failed 280 of its 14603 tests

Histoire d'horreur: le coût du «gain de temps»

C'est arrivé il y a quelques mois. Un ingénieux programmeur a décidé d'économiser plusieurs microsecondes sur un calcul qui prenait environ trente secondes au maximum, en branchant le fameux code "(MidnightOfDateB-MidnightOfDateA) / 86400" à plusieurs endroits. C'était une optimisation si évidente qu'il ne l'a même pas documentée, et l'optimisation a passé les tests d'intégration et s'est cachée dans le code pendant plusieurs mois, tout cela sans être remarqué.

Cela s'est produit dans un programme qui calcule les salaires de plusieurs vendeurs les plus vendus, dont le moins a une influence beaucoup plus terrible qu'une humble équipe de programmeurs de cinq personnes réunies. Il y a un jour, il y a quelques mois, pour des raisons qui importent peu, le bug a frappé - et certains de ces gars ont été lésés une journée entière de grosses commissions. Ils n'étaient certainement pas amusés.

Infiniment pire, ils ont perdu la confiance (déjà très faible) qu'ils avaient dans le programme qui n'était pas conçu pour les manipuler subrepticement, et ont prétendu - et obtenu - une revue de code complète et détaillée avec des cas de test exécutés et commentés en termes simples (plus beaucoup) de traitement sur tapis rouge dans les semaines suivantes).

Que puis-je dire: du côté positif, nous nous sommes débarrassés de beaucoup de dettes techniques et avons été en mesure de réécrire et de remanier plusieurs morceaux d'un gâchis de spaghetti qui ont fait écho à une infestation de COBOL dans les années 90. Le programme fonctionne sans aucun doute mieux maintenant, et il y a beaucoup plus d'informations de débogage pour se concentrer rapidement lorsque quelque chose semble louche. J'estime que cette dernière chose permettra peut-être d'économiser un ou deux jours-homme par mois dans un avenir prévisible.

Du côté négatif, l'ensemble du brouhaha a coûté à l'entreprise environ 200 000 € à l'avance - plus le visage, plus sans aucun doute un certain pouvoir de négociation (et, par conséquent, encore plus d'argent).

Le gars responsable de "l'optimisation" avait changé d'emploi il y a un an, avant la catastrophe, mais il y avait toujours des discussions pour le poursuivre en dommages et intérêts. Et cela ne s'est pas bien passé avec les échelons supérieurs que c'était "la faute du dernier gars" - cela ressemblait à une configuration pour que nous puissions résoudre le problème, et à la fin, nous sommes toujours dans la niche. et l'un des membres de l'équipe prévoit de quitter.

Quatre-vingt-dix-neuf fois sur cent, le "hack 86400" fonctionnera parfaitement. (Par exemple, en PHP, strtotime()ignorera l'heure d'été et signalera qu'entre le milieu du dernier samedi d'octobre et celui du lundi suivant, exactement 2 * 24 * 60 * 60 secondes se sont écoulées, même si ce n'est manifestement pas vrai ... et deux torts feront heureusement un bien).

Mesdames et Messieurs, ce fut un cas où cela n'a pas été le cas. Comme avec les airbags et les ceintures de sécurité, vous n'aurez peut-être jamais vraiment besoin de la complexité (et de la facilité d'utilisation) de DateTimeou Carbon. Mais le jour où vous pourriez (ou le jour où vous devrez prouver que vous y avez pensé) viendra comme un voleur dans la nuit. Soyez prêt.

Date_diff facile à utiliser

$from=date_create(date('Y-m-d'));
$to=date_create("2013-03-15");
$diff=date_diff($to,$from);
print_r($diff);
echo $diff->format('%R%a days');

• Voir plus à: http://blog.innovsystems.com/php/get-number-days-between-two-dates-php

Style orienté objet:

$datetime1 = new DateTime('2009-10-11');
$datetime2 = new DateTime('2009-10-13');
$interval = $datetime1->diff($datetime2);
echo $interval->format('%R%a days');

Style procédural:

$datetime1 = date_create('2009-10-11');
$datetime2 = date_create('2009-10-13');
$interval = date_diff($datetime1, $datetime2);
echo $interval->format('%R%a days');

Utilisé ceci :)

$days = (strtotime($endDate) - strtotime($startDate)) / (60 * 60 * 24);
print $days;

Maintenant ça marche

Eh bien, la réponse sélectionnée n'est pas la plus correcte car elle échouera en dehors de l'UTC. Selon le fuseau horaire ( liste ), il pourrait y avoir des ajustements de temps créant des jours "sans" 24 heures, ce qui entraînera l'échec du calcul (60 * 60 * 24).

En voici un exemple:

date_default_timezone_set('europe/lisbon');
$time1 = strtotime('2016-03-27');
$time2 = strtotime('2016-03-29');
echo floor( ($time2-$time1) /(60*60*24));
 ^-- the output will be **1**

La bonne solution sera donc d'utiliser DateTime

date_default_timezone_set('europe/lisbon');
$date1 = new DateTime("2016-03-27");
$date2 = new DateTime("2016-03-29");

echo $date2->diff($date1)->format("%a");
 ^-- the output will be **2**

Calculez la différence entre deux dates:

$date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");

$diff=date_diff($date1,$date2);

echo $diff->format("%R%a days");

Sortie: +272 jours

La fonction date_diff () renvoie la différence entre deux objets DateTime.

$start = '2013-09-08';
$end = '2013-09-15';
$diff = (strtotime($end)- strtotime($start))/24/3600; 
echo $diff;

J'utilise Carbon dans mes projets de compositeur à cette fin et à des fins similaires.

Ce serait aussi simple que ça:

$dt = Carbon::parse('2010-01-01');
echo $dt->diffInDays(Carbon::now());

Vous pouvez trouver des dates simplement en

<?php
$start  = date_create('1988-08-10');
$end    = date_create(); // Current time and date
$diff   = date_diff( $start, $end );

echo 'The difference is ';
echo  $diff->y . ' years, ';
echo  $diff->m . ' months, ';
echo  $diff->d . ' days, ';
echo  $diff->h . ' hours, ';
echo  $diff->i . ' minutes, ';
echo  $diff->s . ' seconds';
// Output: The difference is 28 years, 5 months, 19 days, 20 hours, 34 minutes, 36 seconds

echo 'The difference in days : ' . $diff->days;
// Output: The difference in days : 10398

$datediff = floor(strtotime($date1)/(60*60*24)) - floor(strtotime($date2)/(60*60*24));

et, si nécessaire:

$datediff=abs($datediff);

Si vous avez les heures en secondes (horodatage IE unix), vous pouvez simplement soustraire les heures et diviser par 86400 (secondes par jour)

nombre de jours entre deux dates en PHP

      function dateDiff($date1, $date2)  //days find function
        { 
            $diff = strtotime($date2) - strtotime($date1); 
            return abs(round($diff / 86400)); 
        } 
       //start day
       $date1 = "11-10-2018";        
       // end day
       $date2 = "31-10-2018";    
       // call the days find fun store to variable 
       $dateDiff = dateDiff($date1, $date2); 

       echo "Difference between two dates: ". $dateDiff . " Days "; 

Vous pouvez essayer le code ci-dessous:

$dt1 = strtotime("2019-12-12"); //Enter your first date
$dt2 = strtotime("12-12-2020"); //Enter your second date
echo abs(($dt1 - $dt2) / (60 * 60 * 24));

function howManyDays($startDate,$endDate) {

    $date1  = strtotime($startDate." 0:00:00");
    $date2  = strtotime($endDate." 23:59:59");
    $res    =  (int)(($date2-$date1)/86400);        

return $res;
} 

Si vous voulez faire écho tous les jours entre la date de début et la date de fin, j'ai trouvé ceci:

$startdatum = $_POST['start']; // starting date
$einddatum = $_POST['eind']; // end date

$now = strtotime($startdatum);
$your_date = strtotime($einddatum);
$datediff = $your_date - $now;
$number = floor($datediff/(60*60*24));

for($i=0;$i <= $number; $i++)
{
    echo date('d-m-Y' ,strtotime("+".$i." day"))."<br>";
}

Le moyen le plus simple de trouver la différence de jours entre deux dates

$date1 = strtotime("2019-05-25"); 
$date2 = strtotime("2010-06-23");

$date_difference = $date2 - $date1;

$result =  round( $date_difference / (60 * 60 * 24) );

echo $result;

    // Change this to the day in the future
$day = 15;

// Change this to the month in the future
$month = 11;

// Change this to the year in the future
$year = 2012;

// $days is the number of days between now and the date in the future
$days = (int)((mktime (0,0,0,$month,$day,$year) - time(void))/86400);

echo "There are $days days until $day/$month/$year";

Voici ma version améliorée qui montre 1 an (s) 2 mois (s) 25 jour (s) si le 2ème paramètre est passé.

class App_Sandbox_String_Util {
    /**
     * Usage: App_Sandbox_String_Util::getDateDiff();
     * @param int $your_date timestamp
     * @param bool $hr human readable. e.g. 1 year(s) 2 day(s)
     * @see http://stackoverflow.com/questions/2040560/finding-the-number-of-days-between-two-dates
     * @see http://qSandbox.com
     */
    static public function getDateDiff($your_date, $hr = 0) {
        $now = time(); // or your date as well
        $datediff = $now - $your_date;
        $days = floor( $datediff / ( 3600 * 24 ) );

        $label = '';

        if ($hr) {
            if ($days >= 365) { // over a year
                $years = floor($days / 365);
                $label .= $years . ' Year(s)';
                $days -= 365 * $years;
            }

            if ($days) {
                $months = floor( $days / 30 );
                $label .= ' ' . $months . ' Month(s)';
                $days -= 30 * $months;
            }

            if ($days) {
                $label .= ' ' . $days . ' day(s)';
            }
        } else {
            $label = $days;
        }

        return $label;
    }
}

$early_start_date = date2sql($_POST['early_leave_date']);


$date = new DateTime($early_start_date);
$date->modify('+1 day');


$date_a = new DateTime($early_start_date . ' ' . $_POST['start_hr'] . ':' . $_POST['start_mm']);
$date_b = new DateTime($date->format('Y-m-d') . ' ' . $_POST['end_hr'] . ':' . $_POST['end_mm']);

$interval = date_diff($date_a, $date_b);


$time = $interval->format('%h:%i');
$parsed = date_parse($time);
$seconds = $parsed['hour'] * 3600 + $parsed['minute'] * 60;
//        display_error($seconds);

$second3 = $employee_information['shift'] * 60 * 60;

if ($second3 < $seconds)
    display_error(_('Leave time can not be greater than shift time.Please try again........'));
    set_focus('start_hr');
    set_focus('end_hr');
    return FALSE;
}

<?php
$date1=date_create("2013-03-15");
$date2=date_create("2013-12-12");
$diff=date_diff($date1,$date2);
echo $diff->format("%R%a days");
?>

utilisé le code ci-dessus très simple. Merci.

function get_daydiff($end_date,$today)
{
    if($today=='')
    {
        $today=date('Y-m-d');
    }
    $str = floor(strtotime($end_date)/(60*60*24)) - floor(strtotime($today)/(60*60*24));
    return $str;
}
$d1 = "2018-12-31";
$d2 = "2018-06-06";
echo get_daydiff($d1, $d2);

Utilisation de cette fonction simple. Déclarer la fonction

<?php
function dateDiff($firstDate,$secondDate){
    $firstDate = strtotime($firstDate);
    $secondDate = strtotime($secondDate);

    $datediff = $firstDate - $secondDate;
    $output = round($datediff / (60 * 60 * 24));
    return $output;
}
?>

et appelez cette fonction comme ça où vous voulez

<?php
    echo dateDiff("2018-01-01","2018-12-31");    

// OR

    $firstDate = "2018-01-01";
    $secondDate = "2018-01-01";
    echo dateDiff($firstDate,$secondDate);    
?>

$diff = strtotime('2019-11-25') - strtotime('2019-11-10');
echo abs(round($diff / 86400));

Si vous utilisez MySql

function daysSince($date, $date2){
$q = "SELECT DATEDIFF('$date','$date2') AS days;";
$result = execQ($q);
$row = mysql_fetch_array($result,MYSQL_BOTH);
return ($row[0]);

}

function execQ($q){
$result = mysql_query( $q);
if(!$result){echo ('Database error execQ' . mysql_error());echo $q;}    
return $result;

}

Essayez d'utiliser Carbon

$d1 = \Carbon\Carbon::now()->subDays(92);
$d2 = \Carbon\Carbon::now()->subDays(10);
$days_btw = $d1->diffInDays($d2);

Vous pouvez également utiliser

\Carbon\Carbon::parse('')

pour créer un objet de date Carbon en utilisant une chaîne d'horodatage donnée.

En regardant toutes les réponses je compose la fonction universelle ce qui fonctionne sur toutes les versions PHP.

if(!function_exists('date_between')) :
    function date_between($date_start, $date_end)
    {
        if(!$date_start || !$date_end) return 0;

        if( class_exists('DateTime') )
        {
            $date_start = new DateTime( $date_start );
            $date_end   = new DateTime( $date_end );
            return $date_end->diff($date_start)->format('%a');
        }
        else
        {           
            return abs( round( ( strtotime($date_start) - strtotime($date_end) ) / 86400 ) );
        }
    }
endif;

En général, j'utilise 'DateTime' pour trouver des jours entre 2 dates. Mais si pour une raison quelconque, la configuration de certains serveurs n'a pas activé 'DateTime', il utilisera un calcul simple (mais pas sûr) avec 'strtotime ()'.