3v4l.org

run code in 500+ PHP versions simultaneously
<?php $ss = 'first day of last month midnight'; $es = 'first day of this month midnight - 1 second'; $s = new DateTime($ss); $e = new DateTime($es); $d= $e->diff($s); var_dump($d->days); // 0 ... but should be 30 $s = (new DateTime(null))->setTimestamp(strtotime($ss)); // verbose setup method $e = (new DateTime(null))->setTimestamp(strtotime($es)); // verbose setup method $d = $e->diff($s); var_dump($d->days); // 30 ... and should be 30 /* Next we will try mix/match the code to see what happens, surprisingly it seems that the end date ($e) is the important one, if it uses the verbose method it returns the correct values. */ $s = (new DateTime(null))->setTimestamp(strtotime($ss)); // verbose setup method $e = new DateTime($es); $d= $e->diff($s); var_dump($d->days); // 0 ... but should be 30 $s = new DateTime($ss); $e = (new DateTime(null))->setTimestamp(strtotime($es)); // verbose setup method $d= $e->diff($s); var_dump($d->days); // 30 ... and should be 30 /* This test just proves that the $e date is important BUT NOT because it's the one we call the diff() method on, that's just coincidental that seems to imply that the "- 1 second" in the date string is the problem. */ $s = new DateTime($ss); $e = (new DateTime(null))->setTimestamp(strtotime($es)); // verbose setup method $d= $s->diff($e); var_dump($d->days); // 30 ... and should be 30 /* [Workaround] This final test seems to prove that the input string is important and that the "- 1 secord" has a negative knock-on effect on the results of the diff. By modifying the datetime with ->modify everything works as expected ... it just means you have to be careful of how we work with DateTimes . */ $s = new DateTime($ss); $e = new DateTime('first day of this month midnight'); $e->modify('- 1 second'); var_dump($e->diff($s)->days); // 30 ... and should be 30 echo "\n\n Same stuff with DateTimeImmutable\n"; $ss = 'first day of last month midnight'; $es = 'first day of this month midnight - 1 second'; $s = new DateTimeImmutable($ss); $e = new DateTimeImmutable($es); $d= $e->diff($s); var_dump($d->days); // 0 ... but should be 30 $s = (new DateTimeImmutable(null))->setTimestamp(strtotime($ss)); // verbose setup method $e = (new DateTimeImmutable(null))->setTimestamp(strtotime($es)); // verbose setup method $d = $e->diff($s); var_dump($d->days); // 30 ... and should be 30 /* Next we will try mix/match the code to see what happens, surprisingly it seems that the end date ($e) is the important one, if it uses the verbose method it returns the correct values. */ $s = (new DateTimeImmutable(null))->setTimestamp(strtotime($ss)); // verbose setup method $e = new DateTimeImmutable($es); $d= $e->diff($s); var_dump($d->days); // 0 ... but should be 30 $s = new DateTimeImmutable($ss); $e = (new DateTimeImmutable(null))->setTimestamp(strtotime($es)); // verbose setup method $d= $e->diff($s); var_dump($d->days); // 30 ... and should be 30 /* This test just proves that the $e date is important BUT NOT because it's the one we call the diff() method on, that's just coincidental that seems to imply that the "- 1 second" in the date string is the problem. */ $s = new DateTimeImmutable($ss); $e = (new DateTimeImmutable(null))->setTimestamp(strtotime($es)); // verbose setup method $d= $s->diff($e); var_dump($d->days); // 30 ... and should be 30 /* [Workaround] This final test seems to prove that the input string is important and that the "- 1 secord" has a negative knock-on effect on the results of the diff. By modifying the datetime with ->modify everything works as expected ... it just means you have to be careful of how we work with DateTimes . */ $s = new DateTimeImmutable($ss); $e = new DateTimeImmutable('first day of this month midnight'); $e->modify('- 1 second'); var_dump($e->diff($s)->days); // 30 ... and should be 30
Finding entry points
Branch analysis from position: 0
1 jumps found. (Code = 62) Position 1 = -2
filename:       /in/6Zjq5
function name:  (null)
number of ops:  262
compiled vars:  !0 = $ss, !1 = $es, !2 = $s, !3 = $e, !4 = $d
line      #* E I O op                               fetch          ext  return  operands
-----------------------------------------------------------------------------------------
    3     0  E >   ASSIGN                                                       !0, 'first+day+of+last+month+midnight'
    4     1        ASSIGN                                                       !1, 'first+day+of+this+month+midnight+-+1+second'
    5     2        NEW                                                  $7      'DateTime'
          3        SEND_VAR_EX                                                  !0
          4        DO_FCALL                                          0          
          5        ASSIGN                                                       !2, $7
    6     6        NEW                                                  $10     'DateTime'
          7        SEND_VAR_EX                                                  !1
          8        DO_FCALL                                          0          
          9        ASSIGN                                                       !3, $10
    7    10        INIT_METHOD_CALL                                             !3, 'diff'
         11        SEND_VAR_EX                                                  !2
         12        DO_FCALL                                          0  $13     
         13        ASSIGN                                                       !4, $13
    8    14        INIT_FCALL                                                   'var_dump'
         15        FETCH_OBJ_R                                          ~15     !4, 'days'
         16        SEND_VAL                                                     ~15
         17        DO_ICALL                                                     
    9    18        NEW                                                  $17     'DateTime'
         19        SEND_VAL_EX                                                  null
         20        DO_FCALL                                          0          
         21        INIT_METHOD_CALL                                             $17, 'setTimestamp'
         22        INIT_FCALL                                                   'strtotime'
         23        SEND_VAR                                                     !0
         24        DO_ICALL                                             $19     
         25        SEND_VAR_NO_REF_EX                                           $19
         26        DO_FCALL                                          0  $20     
         27        ASSIGN                                                       !2, $20
   10    28        NEW                                                  $22     'DateTime'
         29        SEND_VAL_EX                                                  null
         30        DO_FCALL                                          0          
         31        INIT_METHOD_CALL                                             $22, 'setTimestamp'
         32        INIT_FCALL                                                   'strtotime'
         33        SEND_VAR                                                     !1
         34        DO_ICALL                                             $24     
         35        SEND_VAR_NO_REF_EX                                           $24
         36        DO_FCALL                                          0  $25     
         37        ASSIGN                                                       !3, $25
   11    38        INIT_METHOD_CALL                                             !3, 'diff'
         39        SEND_VAR_EX                                                  !2
         40        DO_FCALL                                          0  $27     
         41        ASSIGN                                                       !4, $27
   12    42        INIT_FCALL                                                   'var_dump'
         43        FETCH_OBJ_R                                          ~29     !4, 'days'
         44        SEND_VAL                                                     ~29
         45        DO_ICALL                                                     
   17    46        NEW                                                  $31     'DateTime'
         47        SEND_VAL_EX                                                  null
         48        DO_FCALL                                          0          
         49        INIT_METHOD_CALL                                             $31, 'setTimestamp'
         50        INIT_FCALL                                                   'strtotime'
         51        SEND_VAR                                                     !0
         52        DO_ICALL                                             $33     
         53        SEND_VAR_NO_REF_EX                                           $33
         54        DO_FCALL                                          0  $34     
         55        ASSIGN                                                       !2, $34
   18    56        NEW                                                  $36     'DateTime'
         57        SEND_VAR_EX                                                  !1
         58        DO_FCALL                                          0          
         59        ASSIGN                                                       !3, $36
   19    60        INIT_METHOD_CALL                                             !3, 'diff'
         61        SEND_VAR_EX                                                  !2
         62        DO_FCALL                                          0  $39     
         63        ASSIGN                                                       !4, $39
   20    64        INIT_FCALL                                                   'var_dump'
         65        FETCH_OBJ_R                                          ~41     !4, 'days'
         66        SEND_VAL                                                     ~41
         67        DO_ICALL                                                     
   21    68        NEW                                                  $43     'DateTime'
         69        SEND_VAR_EX                                                  !0
         70        DO_FCALL                                          0          
         71        ASSIGN                                                       !2, $43
   22    72        NEW                                                  $46     'DateTime'
         73        SEND_VAL_EX                                                  null
         74        DO_FCALL                                          0          
         75        INIT_METHOD_CALL                                             $46, 'setTimestamp'
         76        INIT_FCALL                                                   'strtotime'
         77        SEND_VAR                                                     !1
         78        DO_ICALL                                             $48     
         79        SEND_VAR_NO_REF_EX                                           $48
         80        DO_FCALL                                          0  $49     
         81        ASSIGN                                                       !3, $49
   23    82        INIT_METHOD_CALL                                             !3, 'diff'
         83        SEND_VAR_EX                                                  !2
         84        DO_FCALL                                          0  $51     
         85        ASSIGN                                                       !4, $51
   24    86        INIT_FCALL                                                   'var_dump'
         87        FETCH_OBJ_R                                          ~53     !4, 'days'
         88        SEND_VAL                                                     ~53
         89        DO_ICALL                                                     
   29    90        NEW                                                  $55     'DateTime'
         91        SEND_VAR_EX                                                  !0
         92        DO_FCALL                                          0          
         93        ASSIGN                                                       !2, $55
   30    94        NEW                                                  $58     'DateTime'
         95        SEND_VAL_EX                                                  null
         96        DO_FCALL                                          0          
         97        INIT_METHOD_CALL                                             $58, 'setTimestamp'
         98        INIT_FCALL                                                   'strtotime'
         99        SEND_VAR                                                     !1
        100        DO_ICALL                                             $60     
        101        SEND_VAR_NO_REF_EX                                           $60
        102        DO_FCALL                                          0  $61     
        103        ASSIGN                                                       !3, $61
   31   104        INIT_METHOD_CALL                                             !2, 'diff'
        105        SEND_VAR_EX                                                  !3
        106        DO_FCALL                                          0  $63     
        107        ASSIGN                                                       !4, $63
   32   108        INIT_FCALL                                                   'var_dump'
        109        FETCH_OBJ_R                                          ~65     !4, 'days'
        110        SEND_VAL                                                     ~65
        111        DO_ICALL                                                     
   39   112        NEW                                                  $67     'DateTime'
        113        SEND_VAR_EX                                                  !0
        114        DO_FCALL                                          0          
        115        ASSIGN                                                       !2, $67
   40   116        NEW                                                  $70     'DateTime'
        117        SEND_VAL_EX                                                  'first+day+of+this+month+midnight'
        118        DO_FCALL                                          0          
        119        ASSIGN                                                       !3, $70
   41   120        INIT_METHOD_CALL                                             !3, 'modify'
        121        SEND_VAL_EX                                                  '-+1+second'
        122        DO_FCALL                                          0          
   42   123        INIT_FCALL                                                   'var_dump'
        124        INIT_METHOD_CALL                                             !3, 'diff'
        125        SEND_VAR_EX                                                  !2
        126        DO_FCALL                                          0  $74     
        127        FETCH_OBJ_R                                          ~75     $74, 'days'
        128        SEND_VAL                                                     ~75
        129        DO_ICALL                                                     
   45   130        ECHO                                                         '%0A%0A+Same+stuff+with+DateTimeImmutable%0A'
   47   131        ASSIGN                                                       !0, 'first+day+of+last+month+midnight'
   48   132        ASSIGN                                                       !1, 'first+day+of+this+month+midnight+-+1+second'
   49   133        NEW                                                  $79     'DateTimeImmutable'
        134        SEND_VAR_EX                                                  !0
        135        DO_FCALL                                          0          
        136        ASSIGN                                                       !2, $79
   50   137        NEW                                                  $82     'DateTimeImmutable'
        138        SEND_VAR_EX                                                  !1
        139        DO_FCALL                                          0          
        140        ASSIGN                                                       !3, $82
   51   141        INIT_METHOD_CALL                                             !3, 'diff'
        142        SEND_VAR_EX                                                  !2
        143        DO_FCALL                                          0  $85     
        144        ASSIGN                                                       !4, $85
   52   145        INIT_FCALL                                                   'var_dump'
        146        FETCH_OBJ_R                                          ~87     !4, 'days'
        147        SEND_VAL                                                     ~87
        148        DO_ICALL                                                     
   53   149        NEW                                                  $89     'DateTimeImmutable'
        150        SEND_VAL_EX                                                  null
        151        DO_FCALL                                          0          
        152        INIT_METHOD_CALL                                             $89, 'setTimestamp'
        153        INIT_FCALL                                                   'strtotime'
        154        SEND_VAR                                                     !0
        155        DO_ICALL                                             $91     
        156        SEND_VAR_NO_REF_EX                                           $91
        157        DO_FCALL                                          0  $92     
        158        ASSIGN                                                       !2, $92
   54   159        NEW                                                  $94     'DateTimeImmutable'
        160        SEND_VAL_EX                                                  null
        161        DO_FCALL                                          0          
        162        INIT_METHOD_CALL                                             $94, 'setTimestamp'
        163        INIT_FCALL                                                   'strtotime'
        164        SEND_VAR                                                     !1
        165        DO_ICALL                                             $96     
        166        SEND_VAR_NO_REF_EX                                           $96
        167        DO_FCALL                                          0  $97     
        168        ASSIGN                                                       !3, $97
   55   169        INIT_METHOD_CALL                                             !3, 'diff'
        170        SEND_VAR_EX                                                  !2
        171        DO_FCALL                                          0  $99     
        172        ASSIGN                                                       !4, $99
   56   173        INIT_FCALL                                                   'var_dump'
        174        FETCH_OBJ_R                                          ~101    !4, 'days'
        175        SEND_VAL                                                     ~101
        176        DO_ICALL                                                     
   61   177        NEW                                                  $103    'DateTimeImmutable'
        178        SEND_VAL_EX                                                  null
        179        DO_FCALL                                          0          
        180        INIT_METHOD_CALL                                             $103, 'setTimestamp'
        181        INIT_FCALL                                                   'strtotime'
        182        SEND_VAR                                                     !0
        183        DO_ICALL                                             $105    
        184        SEND_VAR_NO_REF_EX                                           $105
        185        DO_FCALL                                          0  $106    
        186        ASSIGN                                                       !2, $106
   62   187        NEW                                                  $108    'DateTimeImmutable'
        188        SEND_VAR_EX                                                  !1
        189        DO_FCALL                                          0          
        190        ASSIGN                                                       !3, $108
   63   191        INIT_METHOD_CALL                                             !3, 'diff'
        192        SEND_VAR_EX                                                  !2
        193        DO_FCALL                                          0  $111    
        194        ASSIGN                                                       !4, $111
   64   195        INIT_FCALL                                                   'var_dump'
        196        FETCH_OBJ_R                                          ~113    !4, 'days'
        197        SEND_VAL                                                     ~113
        198        DO_ICALL                                                     
   65   199        NEW                                                  $115    'DateTimeImmutable'
        200        SEND_VAR_EX                                                  !0
        201        DO_FCALL                                          0          
        202        ASSIGN                                                       !2, $115
   66   203        NEW                                                  $118    'DateTimeImmutable'
        204        SEND_VAL_EX                                                  null
        205        DO_FCALL                                          0          
        206        INIT_METHOD_CALL                                             $118, 'setTimestamp'
        207        INIT_FCALL                                                   'strtotime'
        208        SEND_VAR                                                     !1
        209        DO_ICALL                                             $120    
        210        SEND_VAR_NO_REF_EX                                           $120
        211        DO_FCALL                                          0  $121    
        212        ASSIGN                                                       !3, $121
   67   213        INIT_METHOD_CALL                                             !3, 'diff'
        214        SEND_VAR_EX                                                  !2
        215        DO_FCALL                                          0  $123    
        216        ASSIGN                                                       !4, $123
   68   217        INIT_FCALL                                                   'var_dump'
        218        FETCH_OBJ_R                                          ~125    !4, 'days'
        219        SEND_VAL                                                     ~125
        220        DO_ICALL                                                     
   73   221        NEW                                                  $127    'DateTimeImmutable'
        222        SEND_VAR_EX                                                  !0
        223        DO_FCALL                                          0          
        224        ASSIGN                                                       !2, $127
   74   225        NEW                                                  $130    'DateTimeImmutable'
        226        SEND_VAL_EX                                                  null
        227        DO_FCALL                                          0          
        228        INIT_METHOD_CALL                                             $130, 'setTimestamp'
        229        INIT_FCALL                                                   'strtotime'
        230        SEND_VAR                                                     !1
        231        DO_ICALL                                             $132    
        232        SEND_VAR_NO_REF_EX                                           $132
        233        DO_FCALL                                          0  $133    
        234        ASSIGN                                                       !3, $133
   75   235        INIT_METHOD_CALL                                             !2, 'diff'
        236        SEND_VAR_EX                                                  !3
        237        DO_FCALL                                          0  $135    
        238        ASSIGN                                                       !4, $135
   76   239        INIT_FCALL                                                   'var_dump'
        240        FETCH_OBJ_R                                          ~137    !4, 'days'
        241        SEND_VAL                                                     ~137
        242        DO_ICALL                                                     
   83   243        NEW                                                  $139    'DateTimeImmutable'
        244        SEND_VAR_EX                                                  !0
        245        DO_FCALL                                          0          
        246        ASSIGN                                                       !2, $139
   84   247        NEW                                                  $142    'DateTimeImmutable'
        248        SEND_VAL_EX                                                  'first+day+of+this+month+midnight'
        249        DO_FCALL                                          0          
        250        ASSIGN                                                       !3, $142
   85   251        INIT_METHOD_CALL                                             !3, 'modify'
        252        SEND_VAL_EX                                                  '-+1+second'
        253        DO_FCALL                                          0          
   86   254        INIT_FCALL                                                   'var_dump'
        255        INIT_METHOD_CALL                                             !3, 'diff'
        256        SEND_VAR_EX                                                  !2
        257        DO_FCALL                                          0  $146    
        258        FETCH_OBJ_R                                          ~147    $146, 'days'
        259        SEND_VAL                                                     ~147
        260        DO_ICALL                                                     
        261      > RETURN                                                       1

Generated using Vulcan Logic Dumper, using php 8.5.0


preferences:
150.93 ms | 2767 KiB | 15 Q