mirror of
https://github.com/Neetpone/ponepaste.git
synced 2025-03-13 07:00:08 +01:00
1141 lines
51 KiB
PHP
1141 lines
51 KiB
PHP
<?php
|
|
|
|
/**
|
|
* This file is part of the Carbon package.
|
|
*
|
|
* (c) Brian Nesbitt <brian@nesbot.com>
|
|
*
|
|
* For the full copyright and license information, please view the LICENSE
|
|
* file that was distributed with this source code.
|
|
*/
|
|
namespace Carbon\Traits;
|
|
|
|
use Carbon\Carbon;
|
|
use Carbon\CarbonImmutable;
|
|
use Carbon\CarbonInterface;
|
|
use Carbon\CarbonInterval;
|
|
use Carbon\CarbonPeriod;
|
|
use Carbon\Translator;
|
|
use Closure;
|
|
use DateInterval;
|
|
use DateTimeInterface;
|
|
use ReturnTypeWillChange;
|
|
|
|
/**
|
|
* Trait Difference.
|
|
*
|
|
* Depends on the following methods:
|
|
*
|
|
* @method bool lessThan($date)
|
|
* @method static copy()
|
|
* @method static resolveCarbon($date = null)
|
|
* @method static Translator translator()
|
|
*/
|
|
trait Difference
|
|
{
|
|
/**
|
|
* @codeCoverageIgnore
|
|
*
|
|
* @param CarbonInterval $diff
|
|
*/
|
|
protected static function fixNegativeMicroseconds(CarbonInterval $diff)
|
|
{
|
|
if ($diff->s !== 0 || $diff->i !== 0 || $diff->h !== 0 || $diff->d !== 0 || $diff->m !== 0 || $diff->y !== 0) {
|
|
$diff->f = (round($diff->f * 1000000) + 1000000) / 1000000;
|
|
$diff->s--;
|
|
|
|
if ($diff->s < 0) {
|
|
$diff->s += 60;
|
|
$diff->i--;
|
|
|
|
if ($diff->i < 0) {
|
|
$diff->i += 60;
|
|
$diff->h--;
|
|
|
|
if ($diff->h < 0) {
|
|
$diff->h += 24;
|
|
$diff->d--;
|
|
|
|
if ($diff->d < 0) {
|
|
$diff->d += 30;
|
|
$diff->m--;
|
|
|
|
if ($diff->m < 0) {
|
|
$diff->m += 12;
|
|
$diff->y--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
$diff->f *= -1;
|
|
$diff->invert();
|
|
}
|
|
|
|
/**
|
|
* @param DateInterval $diff
|
|
* @param bool $absolute
|
|
*
|
|
* @return CarbonInterval
|
|
*/
|
|
protected static function fixDiffInterval(DateInterval $diff, $absolute)
|
|
{
|
|
$diff = CarbonInterval::instance($diff);
|
|
|
|
// Work-around for https://bugs.php.net/bug.php?id=77145
|
|
// @codeCoverageIgnoreStart
|
|
if ($diff->f > 0 && $diff->y === -1 && $diff->m === 11 && $diff->d >= 27 && $diff->h === 23 && $diff->i === 59 && $diff->s === 59) {
|
|
$diff->y = 0;
|
|
$diff->m = 0;
|
|
$diff->d = 0;
|
|
$diff->h = 0;
|
|
$diff->i = 0;
|
|
$diff->s = 0;
|
|
$diff->f = (1000000 - round($diff->f * 1000000)) / 1000000;
|
|
$diff->invert();
|
|
} elseif ($diff->f < 0) {
|
|
static::fixNegativeMicroseconds($diff);
|
|
}
|
|
// @codeCoverageIgnoreEnd
|
|
|
|
if ($absolute && $diff->invert) {
|
|
$diff->invert();
|
|
}
|
|
|
|
return $diff;
|
|
}
|
|
|
|
/**
|
|
* Get the difference as a DateInterval instance.
|
|
* Return relative interval (negative if
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return DateInterval
|
|
*/
|
|
#[ReturnTypeWillChange]
|
|
public function diff($date = null, $absolute = false)
|
|
{
|
|
$other = $this->resolveCarbon($date);
|
|
|
|
// Can be removed if https://github.com/derickr/timelib/pull/110
|
|
// is merged
|
|
// @codeCoverageIgnoreStart
|
|
if (version_compare(PHP_VERSION, '8.1.0-dev', '>=') && $other->tz !== $this->tz) {
|
|
$other = $other->avoidMutation()->tz($this->tz);
|
|
}
|
|
// @codeCoverageIgnoreEnd
|
|
|
|
return parent::diff($other, (bool) $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference as a CarbonInterval instance.
|
|
* Return absolute interval (always positive) unless you pass false to the second argument.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return CarbonInterval
|
|
*/
|
|
public function diffAsCarbonInterval($date = null, $absolute = true)
|
|
{
|
|
return static::fixDiffInterval($this->diff($this->resolveCarbon($date), $absolute), $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in years
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInYears($date = null, $absolute = true)
|
|
{
|
|
return (int) $this->diff($this->resolveCarbon($date), $absolute)->format('%r%y');
|
|
}
|
|
|
|
/**
|
|
* Get the difference in quarters rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInQuarters($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInMonths($date, $absolute) / static::MONTHS_PER_QUARTER);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in months rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInMonths($date = null, $absolute = true)
|
|
{
|
|
$date = $this->resolveCarbon($date);
|
|
|
|
return $this->diffInYears($date, $absolute) * static::MONTHS_PER_YEAR + (int) $this->diff($date, $absolute)->format('%r%m');
|
|
}
|
|
|
|
/**
|
|
* Get the difference in weeks rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInWeeks($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInDays($date, $absolute) / static::DAYS_PER_WEEK);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in days rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInDays($date = null, $absolute = true)
|
|
{
|
|
return (int) $this->diff($this->resolveCarbon($date), $absolute)->format('%r%a');
|
|
}
|
|
|
|
/**
|
|
* Get the difference in days using a filter closure rounded down.
|
|
*
|
|
* @param Closure $callback
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInDaysFiltered(Closure $callback, $date = null, $absolute = true)
|
|
{
|
|
return $this->diffFiltered(CarbonInterval::day(), $callback, $date, $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in hours using a filter closure rounded down.
|
|
*
|
|
* @param Closure $callback
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInHoursFiltered(Closure $callback, $date = null, $absolute = true)
|
|
{
|
|
return $this->diffFiltered(CarbonInterval::hour(), $callback, $date, $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference by the given interval using a filter closure.
|
|
*
|
|
* @param CarbonInterval $ci An interval to traverse by
|
|
* @param Closure $callback
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffFiltered(CarbonInterval $ci, Closure $callback, $date = null, $absolute = true)
|
|
{
|
|
$start = $this;
|
|
$end = $this->resolveCarbon($date);
|
|
$inverse = false;
|
|
|
|
if ($end < $start) {
|
|
$start = $end;
|
|
$end = $this;
|
|
$inverse = true;
|
|
}
|
|
|
|
$options = CarbonPeriod::EXCLUDE_END_DATE | ($this->isMutable() ? 0 : CarbonPeriod::IMMUTABLE);
|
|
$diff = $ci->toPeriod($start, $end, $options)->filter($callback)->count();
|
|
|
|
return $inverse && !$absolute ? -$diff : $diff;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in weekdays rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInWeekdays($date = null, $absolute = true)
|
|
{
|
|
return $this->diffInDaysFiltered(function (CarbonInterface $date) {
|
|
return $date->isWeekday();
|
|
}, $date, $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in weekend days using a filter rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInWeekendDays($date = null, $absolute = true)
|
|
{
|
|
return $this->diffInDaysFiltered(function (CarbonInterface $date) {
|
|
return $date->isWeekend();
|
|
}, $date, $absolute);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in hours rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInHours($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInSeconds($date, $absolute) / static::SECONDS_PER_MINUTE / static::MINUTES_PER_HOUR);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in hours rounded down using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInRealHours($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInRealSeconds($date, $absolute) / static::SECONDS_PER_MINUTE / static::MINUTES_PER_HOUR);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in minutes rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInMinutes($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInSeconds($date, $absolute) / static::SECONDS_PER_MINUTE);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in minutes rounded down using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInRealMinutes($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInRealSeconds($date, $absolute) / static::SECONDS_PER_MINUTE);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in seconds rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInSeconds($date = null, $absolute = true)
|
|
{
|
|
$diff = $this->diff($date);
|
|
|
|
if ($diff->days === 0) {
|
|
$diff = static::fixDiffInterval($diff, $absolute);
|
|
}
|
|
|
|
$value = (((($diff->m || $diff->y ? $diff->days : $diff->d) * static::HOURS_PER_DAY) +
|
|
$diff->h) * static::MINUTES_PER_HOUR +
|
|
$diff->i) * static::SECONDS_PER_MINUTE +
|
|
$diff->s;
|
|
|
|
return $absolute || !$diff->invert ? $value : -$value;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in microseconds.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInMicroseconds($date = null, $absolute = true)
|
|
{
|
|
$diff = $this->diff($date);
|
|
$value = (int) round(((((($diff->m || $diff->y ? $diff->days : $diff->d) * static::HOURS_PER_DAY) +
|
|
$diff->h) * static::MINUTES_PER_HOUR +
|
|
$diff->i) * static::SECONDS_PER_MINUTE +
|
|
($diff->f + $diff->s)) * static::MICROSECONDS_PER_SECOND);
|
|
|
|
return $absolute || !$diff->invert ? $value : -$value;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in milliseconds rounded down.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInMilliseconds($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInMicroseconds($date, $absolute) / static::MICROSECONDS_PER_MILLISECOND);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in seconds using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInRealSeconds($date = null, $absolute = true)
|
|
{
|
|
/** @var CarbonInterface $date */
|
|
$date = $this->resolveCarbon($date);
|
|
$value = $date->getTimestamp() - $this->getTimestamp();
|
|
|
|
return $absolute ? abs($value) : $value;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in microseconds using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInRealMicroseconds($date = null, $absolute = true)
|
|
{
|
|
/** @var CarbonInterface $date */
|
|
$date = $this->resolveCarbon($date);
|
|
$value = ($date->timestamp - $this->timestamp) * static::MICROSECONDS_PER_SECOND +
|
|
$date->micro - $this->micro;
|
|
|
|
return $absolute ? abs($value) : $value;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in milliseconds rounded down using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return int
|
|
*/
|
|
public function diffInRealMilliseconds($date = null, $absolute = true)
|
|
{
|
|
return (int) ($this->diffInRealMicroseconds($date, $absolute) / static::MICROSECONDS_PER_MILLISECOND);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in seconds as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInSeconds($date = null, $absolute = true)
|
|
{
|
|
return $this->diffInMicroseconds($date, $absolute) / static::MICROSECONDS_PER_SECOND;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in minutes as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInMinutes($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInSeconds($date, $absolute) / static::SECONDS_PER_MINUTE;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in hours as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInHours($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInMinutes($date, $absolute) / static::MINUTES_PER_HOUR;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in days as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInDays($date = null, $absolute = true)
|
|
{
|
|
$hoursDiff = $this->floatDiffInHours($date, $absolute);
|
|
$interval = $this->diff($date, $absolute);
|
|
|
|
if ($interval->y === 0 && $interval->m === 0 && $interval->d === 0) {
|
|
return $hoursDiff / static::HOURS_PER_DAY;
|
|
}
|
|
|
|
$daysDiff = (int) $interval->format('%r%a');
|
|
|
|
return $daysDiff + fmod($hoursDiff, static::HOURS_PER_DAY) / static::HOURS_PER_DAY;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in weeks as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInWeeks($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInDays($date, $absolute) / static::DAYS_PER_WEEK;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in months as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInMonths($date = null, $absolute = true)
|
|
{
|
|
$start = $this;
|
|
$end = $this->resolveCarbon($date);
|
|
$ascending = ($start <= $end);
|
|
$sign = $absolute || $ascending ? 1 : -1;
|
|
if (!$ascending) {
|
|
[$start, $end] = [$end, $start];
|
|
}
|
|
$monthsDiff = $start->diffInMonths($end);
|
|
/** @var Carbon|CarbonImmutable $floorEnd */
|
|
$floorEnd = $start->avoidMutation()->addMonths($monthsDiff);
|
|
|
|
if ($floorEnd >= $end) {
|
|
return $sign * $monthsDiff;
|
|
}
|
|
|
|
/** @var Carbon|CarbonImmutable $startOfMonthAfterFloorEnd */
|
|
$startOfMonthAfterFloorEnd = $floorEnd->avoidMutation()->addMonth()->startOfMonth();
|
|
|
|
if ($startOfMonthAfterFloorEnd > $end) {
|
|
return $sign * ($monthsDiff + $floorEnd->floatDiffInDays($end) / $floorEnd->daysInMonth);
|
|
}
|
|
|
|
return $sign * ($monthsDiff + $floorEnd->floatDiffInDays($startOfMonthAfterFloorEnd) / $floorEnd->daysInMonth + $startOfMonthAfterFloorEnd->floatDiffInDays($end) / $end->daysInMonth);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in year as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInYears($date = null, $absolute = true)
|
|
{
|
|
$start = $this;
|
|
$end = $this->resolveCarbon($date);
|
|
$ascending = ($start <= $end);
|
|
$sign = $absolute || $ascending ? 1 : -1;
|
|
if (!$ascending) {
|
|
[$start, $end] = [$end, $start];
|
|
}
|
|
$yearsDiff = $start->diffInYears($end);
|
|
/** @var Carbon|CarbonImmutable $floorEnd */
|
|
$floorEnd = $start->avoidMutation()->addYears($yearsDiff);
|
|
|
|
if ($floorEnd >= $end) {
|
|
return $sign * $yearsDiff;
|
|
}
|
|
|
|
/** @var Carbon|CarbonImmutable $startOfYearAfterFloorEnd */
|
|
$startOfYearAfterFloorEnd = $floorEnd->avoidMutation()->addYear()->startOfYear();
|
|
|
|
if ($startOfYearAfterFloorEnd > $end) {
|
|
return $sign * ($yearsDiff + $floorEnd->floatDiffInDays($end) / $floorEnd->daysInYear);
|
|
}
|
|
|
|
return $sign * ($yearsDiff + $floorEnd->floatDiffInDays($startOfYearAfterFloorEnd) / $floorEnd->daysInYear + $startOfYearAfterFloorEnd->floatDiffInDays($end) / $end->daysInYear);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in seconds as float (microsecond-precision) using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealSeconds($date = null, $absolute = true)
|
|
{
|
|
return $this->diffInRealMicroseconds($date, $absolute) / static::MICROSECONDS_PER_SECOND;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in minutes as float (microsecond-precision) using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealMinutes($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInRealSeconds($date, $absolute) / static::SECONDS_PER_MINUTE;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in hours as float (microsecond-precision) using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealHours($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInRealMinutes($date, $absolute) / static::MINUTES_PER_HOUR;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in days as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealDays($date = null, $absolute = true)
|
|
{
|
|
$date = $this->resolveUTC($date);
|
|
$utc = $this->avoidMutation()->utc();
|
|
$hoursDiff = $utc->floatDiffInRealHours($date, $absolute);
|
|
|
|
return ($hoursDiff < 0 ? -1 : 1) * $utc->diffInDays($date) + fmod($hoursDiff, static::HOURS_PER_DAY) / static::HOURS_PER_DAY;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in weeks as float (microsecond-precision).
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealWeeks($date = null, $absolute = true)
|
|
{
|
|
return $this->floatDiffInRealDays($date, $absolute) / static::DAYS_PER_WEEK;
|
|
}
|
|
|
|
/**
|
|
* Get the difference in months as float (microsecond-precision) using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealMonths($date = null, $absolute = true)
|
|
{
|
|
$start = $this;
|
|
$end = $this->resolveCarbon($date);
|
|
$ascending = ($start <= $end);
|
|
$sign = $absolute || $ascending ? 1 : -1;
|
|
if (!$ascending) {
|
|
[$start, $end] = [$end, $start];
|
|
}
|
|
$monthsDiff = $start->diffInMonths($end);
|
|
/** @var Carbon|CarbonImmutable $floorEnd */
|
|
$floorEnd = $start->avoidMutation()->addMonths($monthsDiff);
|
|
|
|
if ($floorEnd >= $end) {
|
|
return $sign * $monthsDiff;
|
|
}
|
|
|
|
/** @var Carbon|CarbonImmutable $startOfMonthAfterFloorEnd */
|
|
$startOfMonthAfterFloorEnd = $floorEnd->avoidMutation()->addMonth()->startOfMonth();
|
|
|
|
if ($startOfMonthAfterFloorEnd > $end) {
|
|
return $sign * ($monthsDiff + $floorEnd->floatDiffInRealDays($end) / $floorEnd->daysInMonth);
|
|
}
|
|
|
|
return $sign * ($monthsDiff + $floorEnd->floatDiffInRealDays($startOfMonthAfterFloorEnd) / $floorEnd->daysInMonth + $startOfMonthAfterFloorEnd->floatDiffInRealDays($end) / $end->daysInMonth);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in year as float (microsecond-precision) using timestamps.
|
|
*
|
|
* @param \Carbon\CarbonInterface|\DateTimeInterface|string|null $date
|
|
* @param bool $absolute Get the absolute of the difference
|
|
*
|
|
* @return float
|
|
*/
|
|
public function floatDiffInRealYears($date = null, $absolute = true)
|
|
{
|
|
$start = $this;
|
|
$end = $this->resolveCarbon($date);
|
|
$ascending = ($start <= $end);
|
|
$sign = $absolute || $ascending ? 1 : -1;
|
|
if (!$ascending) {
|
|
[$start, $end] = [$end, $start];
|
|
}
|
|
$yearsDiff = $start->diffInYears($end);
|
|
/** @var Carbon|CarbonImmutable $floorEnd */
|
|
$floorEnd = $start->avoidMutation()->addYears($yearsDiff);
|
|
|
|
if ($floorEnd >= $end) {
|
|
return $sign * $yearsDiff;
|
|
}
|
|
|
|
/** @var Carbon|CarbonImmutable $startOfYearAfterFloorEnd */
|
|
$startOfYearAfterFloorEnd = $floorEnd->avoidMutation()->addYear()->startOfYear();
|
|
|
|
if ($startOfYearAfterFloorEnd > $end) {
|
|
return $sign * ($yearsDiff + $floorEnd->floatDiffInRealDays($end) / $floorEnd->daysInYear);
|
|
}
|
|
|
|
return $sign * ($yearsDiff + $floorEnd->floatDiffInRealDays($startOfYearAfterFloorEnd) / $floorEnd->daysInYear + $startOfYearAfterFloorEnd->floatDiffInRealDays($end) / $end->daysInYear);
|
|
}
|
|
|
|
/**
|
|
* The number of seconds since midnight.
|
|
*
|
|
* @return int
|
|
*/
|
|
public function secondsSinceMidnight()
|
|
{
|
|
return $this->diffInSeconds($this->avoidMutation()->startOfDay());
|
|
}
|
|
|
|
/**
|
|
* The number of seconds until 23:59:59.
|
|
*
|
|
* @return int
|
|
*/
|
|
public function secondsUntilEndOfDay()
|
|
{
|
|
return $this->diffInSeconds($this->avoidMutation()->endOfDay());
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from current instance to an other
|
|
* instance given (or now if null given).
|
|
*
|
|
* @example
|
|
* ```
|
|
* echo Carbon::tomorrow()->diffForHumans() . "\n";
|
|
* echo Carbon::tomorrow()->diffForHumans(['parts' => 2]) . "\n";
|
|
* echo Carbon::tomorrow()->diffForHumans(['parts' => 3, 'join' => true]) . "\n";
|
|
* echo Carbon::tomorrow()->diffForHumans(Carbon::yesterday()) . "\n";
|
|
* echo Carbon::tomorrow()->diffForHumans(Carbon::yesterday(), ['short' => true]) . "\n";
|
|
* ```
|
|
*
|
|
* @param Carbon|\DateTimeInterface|string|array|null $other if array passed, will be used as parameters array, see $syntax below;
|
|
* if null passed, now will be used as comparison reference;
|
|
* if any other type, it will be converted to date and used as reference.
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* - 'other' entry (see above)
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single unit)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function diffForHumans($other = null, $syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
/* @var CarbonInterface $this */
|
|
if (\is_array($other)) {
|
|
$other['syntax'] = \array_key_exists('syntax', $other) ? $other['syntax'] : $syntax;
|
|
$syntax = $other;
|
|
$other = $syntax['other'] ?? null;
|
|
}
|
|
|
|
$intSyntax = &$syntax;
|
|
if (\is_array($syntax)) {
|
|
$syntax['syntax'] = $syntax['syntax'] ?? null;
|
|
$intSyntax = &$syntax['syntax'];
|
|
}
|
|
$intSyntax = (int) ($intSyntax === null ? static::DIFF_RELATIVE_AUTO : $intSyntax);
|
|
$intSyntax = $intSyntax === static::DIFF_RELATIVE_AUTO && $other === null ? static::DIFF_RELATIVE_TO_NOW : $intSyntax;
|
|
|
|
$parts = min(7, max(1, (int) $parts));
|
|
|
|
return $this->diffAsCarbonInterval($other, false)
|
|
->setLocalTranslator($this->getLocalTranslator())
|
|
->forHumans($syntax, (bool) $short, $parts, $options ?? $this->localHumanDiffOptions ?? static::getHumanDiffOptions());
|
|
}
|
|
|
|
/**
|
|
* @alias diffForHumans
|
|
*
|
|
* Get the difference in a human readable format in the current locale from current instance to an other
|
|
* instance given (or now if null given).
|
|
*
|
|
* @param Carbon|\DateTimeInterface|string|array|null $other if array passed, will be used as parameters array, see $syntax below;
|
|
* if null passed, now will be used as comparison reference;
|
|
* if any other type, it will be converted to date and used as reference.
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* - 'other' entry (see above)
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single unit)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function from($other = null, $syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
return $this->diffForHumans($other, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* @alias diffForHumans
|
|
*
|
|
* Get the difference in a human readable format in the current locale from current instance to an other
|
|
* instance given (or now if null given).
|
|
*/
|
|
public function since($other = null, $syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
return $this->diffForHumans($other, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from an other
|
|
* instance given (or now if null given) to current instance.
|
|
*
|
|
* When comparing a value in the past to default now:
|
|
* 1 hour from now
|
|
* 5 months from now
|
|
*
|
|
* When comparing a value in the future to default now:
|
|
* 1 hour ago
|
|
* 5 months ago
|
|
*
|
|
* When comparing a value in the past to another value:
|
|
* 1 hour after
|
|
* 5 months after
|
|
*
|
|
* When comparing a value in the future to another value:
|
|
* 1 hour before
|
|
* 5 months before
|
|
*
|
|
* @param Carbon|\DateTimeInterface|string|array|null $other if array passed, will be used as parameters array, see $syntax below;
|
|
* if null passed, now will be used as comparison reference;
|
|
* if any other type, it will be converted to date and used as reference.
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* - 'other' entry (see above)
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single unit)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function to($other = null, $syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
if (!$syntax && !$other) {
|
|
$syntax = CarbonInterface::DIFF_RELATIVE_TO_NOW;
|
|
}
|
|
|
|
return $this->resolveCarbon($other)->diffForHumans($this, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* @alias to
|
|
*
|
|
* Get the difference in a human readable format in the current locale from an other
|
|
* instance given (or now if null given) to current instance.
|
|
*
|
|
* @param Carbon|\DateTimeInterface|string|array|null $other if array passed, will be used as parameters array, see $syntax below;
|
|
* if null passed, now will be used as comparison reference;
|
|
* if any other type, it will be converted to date and used as reference.
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* - 'other' entry (see above)
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single unit)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function until($other = null, $syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
return $this->to($other, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from current
|
|
* instance to now.
|
|
*
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single unit)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function fromNow($syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
$other = null;
|
|
|
|
if ($syntax instanceof DateTimeInterface) {
|
|
[$other, $syntax, $short, $parts, $options] = array_pad(\func_get_args(), 5, null);
|
|
}
|
|
|
|
return $this->from($other, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from an other
|
|
* instance given to now
|
|
*
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single part)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function toNow($syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
return $this->to(null, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from an other
|
|
* instance given to now
|
|
*
|
|
* @param int|array $syntax if array passed, parameters will be extracted from it, the array may contains:
|
|
* - 'syntax' entry (see below)
|
|
* - 'short' entry (see below)
|
|
* - 'parts' entry (see below)
|
|
* - 'options' entry (see below)
|
|
* - 'join' entry determines how to join multiple parts of the string
|
|
* ` - if $join is a string, it's used as a joiner glue
|
|
* ` - if $join is a callable/closure, it get the list of string and should return a string
|
|
* ` - if $join is an array, the first item will be the default glue, and the second item
|
|
* ` will be used instead of the glue for the last item
|
|
* ` - if $join is true, it will be guessed from the locale ('list' translation file entry)
|
|
* ` - if $join is missing, a space will be used as glue
|
|
* if int passed, it add modifiers:
|
|
* Possible values:
|
|
* - CarbonInterface::DIFF_ABSOLUTE no modifiers
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_NOW add ago/from now modifier
|
|
* - CarbonInterface::DIFF_RELATIVE_TO_OTHER add before/after modifier
|
|
* Default value: CarbonInterface::DIFF_ABSOLUTE
|
|
* @param bool $short displays short format of time units
|
|
* @param int $parts maximum number of parts to display (default value: 1: single part)
|
|
* @param int $options human diff options
|
|
*
|
|
* @return string
|
|
*/
|
|
public function ago($syntax = null, $short = false, $parts = 1, $options = null)
|
|
{
|
|
$other = null;
|
|
|
|
if ($syntax instanceof DateTimeInterface) {
|
|
[$other, $syntax, $short, $parts, $options] = array_pad(\func_get_args(), 5, null);
|
|
}
|
|
|
|
return $this->from($other, $syntax, $short, $parts, $options);
|
|
}
|
|
|
|
/**
|
|
* Get the difference in a human readable format in the current locale from current instance to an other
|
|
* instance given (or now if null given).
|
|
*
|
|
* @return string
|
|
*/
|
|
public function timespan($other = null, $timezone = null)
|
|
{
|
|
if (!$other instanceof DateTimeInterface) {
|
|
$other = static::parse($other, $timezone);
|
|
}
|
|
|
|
return $this->diffForHumans($other, [
|
|
'join' => ', ',
|
|
'syntax' => CarbonInterface::DIFF_ABSOLUTE,
|
|
'options' => CarbonInterface::NO_ZERO_DIFF,
|
|
'parts' => -1,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Returns either day of week + time (e.g. "Last Friday at 3:30 PM") if reference time is within 7 days,
|
|
* or a calendar date (e.g. "10/29/2017") otherwise.
|
|
*
|
|
* Language, date and time formats will change according to the current locale.
|
|
*
|
|
* @param Carbon|\DateTimeInterface|string|null $referenceTime
|
|
* @param array $formats
|
|
*
|
|
* @return string
|
|
*/
|
|
public function calendar($referenceTime = null, array $formats = [])
|
|
{
|
|
/** @var CarbonInterface $current */
|
|
$current = $this->avoidMutation()->startOfDay();
|
|
/** @var CarbonInterface $other */
|
|
$other = $this->resolveCarbon($referenceTime)->avoidMutation()->setTimezone($this->getTimezone())->startOfDay();
|
|
$diff = $other->diffInDays($current, false);
|
|
$format = $diff < -6 ? 'sameElse' : (
|
|
$diff < -1 ? 'lastWeek' : (
|
|
$diff < 0 ? 'lastDay' : (
|
|
$diff < 1 ? 'sameDay' : (
|
|
$diff < 2 ? 'nextDay' : (
|
|
$diff < 7 ? 'nextWeek' : 'sameElse'
|
|
)
|
|
)
|
|
)
|
|
)
|
|
);
|
|
$format = array_merge($this->getCalendarFormats(), $formats)[$format];
|
|
if ($format instanceof Closure) {
|
|
$format = $format($current, $other) ?? '';
|
|
}
|
|
|
|
return $this->isoFormat((string) $format);
|
|
}
|
|
}
|