> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# InteractsWithTime-trait

> Uitleg en toepassing van de utility-trait voor tijdberekeningen die wordt gebruikt in queues, caching en scheduling

## Wat is InteractsWithTime

`Illuminate\Support\InteractsWithTime` is een trait die berekeningen van tijd, vertraging en verstreken tijd bundelt. Binnen het Laravel-framework doen meer dan 40 klassen `use InteractsWithTime;`; hij wordt gebruikt in uiteenlopende componenten zoals cache, queue, console en databaseverbindingen.

<Info>
  De broncode staat in `src/Illuminate/Support/InteractsWithTime.php`. De trait bestaat uitsluitend uit `protected` methodes en is bedoeld om vanuit het binnenste van een klasse te worden aangeroepen.
</Info>

## Voorbeelden van gebruik in het framework

| Klasse                                    | Doel                                              |
| ----------------------------------------- | ------------------------------------------------- |
| `Cache\ArrayStore` / `DatabaseStore` e.d. | Berekening van TTL (vervaltijd)                   |
| `Cache\RateLimiter`                       | Resettijdstip van rate limiting                   |
| `Queue\Console\RestartCommand`            | Timestamp voor het herstarten van workers         |
| `Database\Connection`                     | Meten van de uitvoeringstijd van query's          |
| `Console\View\Components\Task`            | Weergave van de uitvoeringstijd van commandotaken |
| `Redis\Limiters\DurationLimiterBuilder`   | Berekening van de duur bij Redis rate limiting    |

## Uitleg van de methodes

### `secondsUntil()` — resterende seconden ophalen

Geeft het aantal resterende seconden tot een opgegeven tijdstip of vertragingswaarde terug. Als argument kun je een `DateTimeInterface`, `DateInterval` of een geheel aantal seconden meegeven.

```php theme={null}
use Illuminate\Support\InteractsWithTime;

class MyService
{
    use InteractsWithTime;

    public function scheduleAt(\DateTime $target): int
    {
        return $this->secondsUntil($target); // Aantal seconden van nu tot $target
    }
}
```

Als je een tijdstip in het verleden meegeeft, wordt `0` teruggegeven (nooit negatief).

```php theme={null}
$seconds = $this->secondsUntil(now()->addMinutes(5)); // 300
$seconds = $this->secondsUntil(now()->subMinutes(5)); // 0 (verleden is 0)
$seconds = $this->secondsUntil(60);                   // 60 (een integer blijft gewoon seconden)
```

### `availableAt()` — de UNIX-timestamp waarop iets beschikbaar wordt

Geeft de UNIX-timestamp terug van de huidige tijd plus de vertraging. Wordt gebruikt voor het vertragen van queue-jobs en het berekenen van cachevervaltijden.

```php theme={null}
$timestamp = $this->availableAt(60);              // UNIX-timestamp over 60 seconden
$timestamp = $this->availableAt(new \DateTime('2026-12-31')); // UNIX-timestamp van het opgegeven tijdstip
$timestamp = $this->availableAt(new \DateInterval('PT5M'));    // Over 5 minuten
```

Zonder argument (standaard `0`) geeft hij de timestamp van de huidige tijd terug.

### `parseDateInterval()` — DateInterval omzetten naar DateTime

Als je een `DateInterval`-instantie meegeeft, wordt die omgezet naar een `Carbon`-instantie door hem bij de huidige tijd op te tellen. Een `DateTimeInterface` of integer wordt ongewijzigd teruggegeven.

```php theme={null}
$delay = $this->parseDateInterval(new \DateInterval('P1D')); // Carbon van morgen
$delay = $this->parseDateInterval(now()->addHour());         // DateTimeInterface blijft ongewijzigd
$delay = $this->parseDateInterval(3600);                     // 3600 (integers blijven ongewijzigd)
```

`secondsUntil()` en `availableAt()` roepen deze methode intern aan.

### `currentTime()` — UNIX-timestamp van de huidige tijd

Een eenvoudige wrapper die `Carbon::now()->getTimestamp()` teruggeeft. Wordt gebruikt als referentietijd voor `secondsUntil()`.

```php theme={null}
$now = $this->currentTime(); // int (UNIX-timestamp)
```

### `runTimeForHumans()` — uitvoeringstijd in leesbaar formaat

Zet het verschil tussen een met `microtime(true)` vastgelegde start- en eindtijd om in een leesbare string.

```php theme={null}
$start = microtime(true);

// ... verwerking ...

echo $this->runTimeForHumans($start); // Bijv. "42.15ms" of "1s 234ms"
```

Onder de 1000 ms krijg je milliseconden met decimalen, zoals `42.15ms`; vanaf 1000 ms krijg je het verkorte `forHumans()`-formaat van CarbonInterval (zoals `1s 234ms`).

Door als tweede argument een eindtijd mee te geven, kun je ook een al gemeten interval omzetten.

```php theme={null}
$elapsed = $this->runTimeForHumans($start, $end);
```

## Toepassing in pakketontwikkeling

### Uniforme TTL voor een cachedriver

Handig als je een methode wilt maken die als `ttl` van `put(key, value, ttl)` zowel een `int`, `DateInterval` als `DateTime` accepteert.

```php theme={null}
use Illuminate\Support\InteractsWithTime;

class MyStore
{
    use InteractsWithTime;

    public function put(string $key, mixed $value, mixed $ttl): void
    {
        $seconds = $this->secondsUntil($ttl);

        // Opslaan in de echte storage met $seconds (int)
        $this->storage[$key] = [
            'value'      => $value,
            'expires_at' => $this->availableAt($ttl),
        ];
    }
}
```

### Verwerkingstijd tonen in consolecommando's

Handig wanneer je in de `handle()` van een `Artisan`-commando de verwerkingstijd aan de gebruiker wilt tonen.

```php theme={null}
use Illuminate\Console\Command;
use Illuminate\Support\InteractsWithTime;

class ProcessDataCommand extends Command
{
    use InteractsWithTime;

    public function handle(): void
    {
        $start = microtime(true);

        // ... verwerking ...

        $this->info("Klaar: {$this->runTimeForHumans($start)}");
    }
}
```

## InteractsWithTime voor tests

`Illuminate\Foundation\Testing\Concerns\InteractsWithTime` is iets anders: die levert de `travel*()`-methodes om in testcases de tijd te manipuleren (wordt automatisch opgenomen in `TestCase`).

```php theme={null}
// De tijd vooruitzetten in een test (Testing\Concerns\InteractsWithTime)
$this->travel(5)->days();
$this->travelTo(now()->addMonth());
$this->travelBack();
```

De namespace verschilt van `Illuminate\Support\InteractsWithTime` (het onderwerp van deze pagina), dus let op dat je ze niet door elkaar haalt.

## Samenvatting

| Methode                          | Returnwaarde             | Belangrijkste toepassing                 |
| -------------------------------- | ------------------------ | ---------------------------------------- |
| `secondsUntil($delay)`           | `int`                    | Resterende seconden ophalen              |
| `availableAt($delay)`            | `int`                    | Timestamp van beschikbaarheid berekenen  |
| `parseDateInterval($delay)`      | `DateTimeInterface\|int` | Omzetting van DateInterval naar Carbon   |
| `currentTime()`                  | `int`                    | Huidige UNIX-timestamp                   |
| `runTimeForHumans($start, $end)` | `string`                 | Leesbare weergave van de uitvoeringstijd |

Als je een methode wilt maken die zowel een `int`, `DateInterval` als `DateTimeInterface` accepteert, hoef je met een simpele `use` van deze trait de conversielogica niet zelf opnieuw te implementeren.

## Gerelateerde pagina's

* [Pakketontwikkeling](/nl/advanced/package-development)
* [InteractsWithData-trait](/nl/advanced/interacts-with-data)
* [Conditionable-trait](/nl/advanced/conditionable)


## Related topics

- [InteractsWithData-trait](/nl/advanced/interacts-with-data.md)
- [Broadcasting](/nl/broadcasting.md)
- [Fluent-klasse](/nl/advanced/fluent.md)
- [PHP-attributes](/nl/advanced/php-attributes.md)
- [进阶主题](/zh-CN/advanced/index.md)