PHP DateInterval est-il comparable à DateTime?

Semble qu'il y a un problème/demande de fonctionnalitéspas sûr que si que jamais réalisé dans le coffre. Ce n'est pas documentée (que je Peux trouver), soit, de manière probablement pas sûrs à utiliser.

Cela dit, après quelques tests, il semble qu'elles puissent être comparées, mais seulement après qu'ils ont été "évalué" en quelque sorte (var dump change le résultat). Voici mon test/résultat:

<?php
$int15 = new DateInterval('P15D');
$int20 = new DateInterval('P20D');

var_dump($int15 > $int20); //should be false;
var_dump($int20 > $int15); //should be true;

var_dump($int15 < $int20); //should be true;
var_dump($int20 < $int15); //should be false;

var_dump($int15);
var_dump($int20);

var_dump($int15 > $int20); //should be false;
var_dump($int20 > $int15); //should be true;

var_dump($int15 < $int20); //should be true;
var_dump($int20 < $int15); //should be false;

$date = new DateTime();
$diff = $date->diff(new DateTime("+10 days"));

var_dump($int15 < $diff); //should be false;
var_dump($diff < $int15); //should be true;

var_dump($int15 > $diff); //should be true;
var_dump($diff > $int15); //should be false;

var_dump($diff);

var_dump($int15 < $diff); //should be false;
var_dump($diff < $int15); //should be true;

var_dump($int15 > $diff); //should be true;
var_dump($diff > $int15); //should be false;

Résultat (j'ai omis le plein de vidages des objets interval):

bool(false) 
bool(false) 
bool(false) 
bool(false) 
objet(DateInterval)#1 (8) {...} 
objet(DateInterval)#2 (8) {...} 
bool(false) 
bool(true) 
bool(true) 
bool(false) 

bool(false) 
bool(true) 
bool(true) 
bool(false) 
objet(DateInterval)#5 (8) {...} 
bool(false) 
bool(true) 
bool(true) 
bool(false) 

EDIT:

class ComparableDateInterval extends DateInterval
{
    /** 
     * Leap-year safe comparison of DateInterval objects.
     */
    public function compare(DateInterval $oDateInterval)
    {   
        $fakeStartDate1 = date_create();
        $fakeStartDate2 = clone $fakeStartDate1;
        $fakeEndDate1   = $fakeStartDate1->add($this);
        $fakeEndDate2   = $fakeStartDate2->add($oDateInterval);

        if($fakeEndDate1 < $fakeEndDate2) {
            return -1; 
        } elseif($fakeEndDate1 == $fakeEndDate2) {
            return 0;
        }   
        return 1;
    }   
}

$int15 = new ComparableDateInterval('P15D');
$int20 = new ComparableDateInterval('P20D');

var_dump($int15->compare($int20) == -1); //should be true;

Voir @fyrye réponse à la justification (et upvote!). Ma réponse ne traite pas avec les années bissextiles en toute sécurité.

Réponse Originale À Cette Question

Alors que je upvoted à cette question, je downvoted la accepté de répondre. C'est parce qu'il n'a pas fonctionné pour moi sur un de mes scripts PHP installations et parce que fondamentalement elle est fondée sur quelque chose de cassé à l'interne.

Ce que j'ai fait, au contraire, est de migrer ladite patch qui ne l'a jamais fait dans le tronc. FWIW j'ai vérifié une version récente, PHP 5.6.5et le patch n'est toujours pas là. Le code a été négligeable au port. La seule chose, c'est un avertissement dans la façon dont il rend la comparaison

Si $this->jours a été calculé, nous savons qu'il est précis, de sorte que nous allons
l'utiliser. Si pas, nous avons besoin de faire une hypothèse sur le mois et l'année
longueur, ce qui n'est pas forcément une bonne idée. J'ai défini mois 30
les jours et les années que 365 jours complètement hors de l'air mince, puisque je n'ai pas
ont la norme ISO 8601 spec disponible pour vérifier si il y a un standard
hypothèse, mais on peut, en fait, veulent à l'erreur si nous n'avons pas
$this->jours disponibles.

Voici un exemple. Remarque, si vous avez besoin de comparer un DateInterval qui a été renvoyée par certains à un autre appel, vous aurez à create un ComparableDateInterval d'abord, si vous voulez l'utiliser comme la source de la comparaison.

$int15 = new ComparableDateInterval('P15D');
$int20 = new ComparableDateInterval('P20D');

var_dump($int15->compare($int20) == -1); //should be true;

Voici le code

/**
* The stock DateInterval never got the patch to compare.
* Let's reimplement the patch in userspace.
* See the original patch at http://www.adamharvey.name/patches/DateInterval-comparators.patch
*/
class ComparableDateInterval extends DateInterval
{
static public function create(DateInterval $oDateInterval)
{
$oDi         = new ComparableDateInterval('P1D');
$oDi->s      = $oDateInterval->s;
$oDi->i      = $oDateInterval->i;
$oDi->h      = $oDateInterval->h;
$oDi->days   = $oDateInterval->days;
$oDi->d      = $oDateInterval->d;
$oDi->m      = $oDateInterval->m;
$oDi->y      = $oDateInterval->y;
$oDi->invert = $oDateInterval->invert;
return $oDi;
}
public function compare(DateInterval $oDateInterval)
{
$oMyTotalSeconds   = $this->getTotalSeconds();
$oYourTotalSeconds = $oDateInterval->getTotalSeconds();
if($oMyTotalSeconds < $oYourTotalSeconds)
return -1;
elseif($oMyTotalSeconds == $oYourTotalSeconds)
return 0;
return 1;
}
/**
* If $this->days has been calculated, we know it's accurate, so we'll use
* that. If not, we need to make an assumption about month and year length,
* which isn't necessarily a good idea. I've defined months as 30 days and
* years as 365 days completely out of thin air, since I don't have the ISO
* 8601 spec available to check if there's a standard assumption, but we
* may in fact want to error out if we don't have $this->days available.
*/
public function getTotalSeconds()
{
$iSeconds = $this->s + ($this->i * 60) + ($this->h * 3600);
if($this->days > 0)
$iSeconds += ($this->days * 86400);
//@note Maybe you prefer to throw an Exception here per the note above
else
$iSeconds += ($this->d * 86400) + ($this->m * 2592000) + ($this->y * 31536000);
if($this->invert)
$iSeconds *= -1;
return $iSeconds;
}
}

Où $aujourdhui venir? Sûr que c'est le même que $today linguistiquement, mais PHP ne sait pas que! La modification de votre code pour utiliser $today imprime "oK"!

Si non défini, $aujourdhui->diff($release) permettra d'évaluer à 0 si votre PHP interprète ne pas abandonner avec une erreur (la mienne).