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

# Helperfuncties

> Uitleg over de globale helperfuncties van Laravel en de klassen Arr en Number, met praktische voorbeelden.

## Wat zijn helperfuncties

Laravel biedt een groot aantal globale PHP-functies (helpers). De meeste worden intern door het framework zelf gebruikt, maar je kunt ze ook vrij in je eigen applicatie inzetten.

De helpers vallen grofweg in de volgende categorieën:

* **Arrays en objecten** — de `Arr::`-klasse en functies zoals `data_get()`
* **Getallen** — de `Number::`-klasse
* **Paden** — padfuncties zoals `app_path()` en `storage_path()`
* **URL's** — URL-generatiefuncties zoals `route()`, `url()` en `asset()`
* **Overig** — veelgebruikte utilities zoals `config()`, `collect()` en `auth()`

<Info>
  Helperfuncties kun je overal aanroepen zonder `use`-declaratie. Gebruik je de klassen `Arr` of `Number`, dan is een import zoals `use Illuminate\Support\Arr;` wel nodig.
</Info>

## Array-helpers (de Arr-klasse)

### `Arr::get()` — geneste waarden ophalen met dot-notatie

Haalt veilig een geneste waarde op uit een multidimensionale array met dot-notatie (`foo.bar.baz`). Bestaat de sleutel niet, dan wordt de standaardwaarde teruggegeven.

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

$config = [
    'database' => [
        'connections' => [
            'mysql' => ['host' => '127.0.0.1', 'port' => 3306],
        ],
    ],
];

$host = Arr::get($config, 'database.connections.mysql.host');
// '127.0.0.1'

// Standaardwaarde wanneer de sleutel niet bestaat
$charset = Arr::get($config, 'database.connections.mysql.charset', 'utf8mb4');
// 'utf8mb4'
```

<Tip>
  De globale functie `data_get()` biedt dezelfde functionaliteit. Omdat die ook werkt met `Arrayable`-objecten zoals Eloquent-relaties, is hij breder inzetbaar.
</Tip>

### `Arr::set()` — een waarde instellen in een geneste array

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

$array = ['products' => ['desk' => ['price' => 100]]];

Arr::set($array, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 200]]]
```

### `Arr::has()` — controleren of een sleutel bestaat

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

$array = ['product' => ['name' => 'Desk', 'price' => 100]];

$hasName = Arr::has($array, 'product.name');
// true

// Controleren of alle opgegeven sleutels aanwezig zijn
$hasAll = Arr::has($array, ['product.name', 'product.price']);
// true
```

### `Arr::only()` / `Arr::except()` — sleutels selecteren of uitsluiten

Handig wanneer je uit requestdata of configuratie-arrays alleen de benodigde sleutels wilt halen, of juist ongewenste sleutels wilt verwijderen.

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

$user = [
    'id' => 1,
    'name' => 'Taro Yamada',
    'email' => 'yamada@example.com',
    'password' => 'secret',
    'role' => 'admin',
];

// Alleen de benodigde sleutels eruit halen
$safe = Arr::only($user, ['id', 'name', 'email']);
// ['id' => 1, 'name' => 'Taro Yamada', 'email' => 'yamada@example.com']

// Alleen password uitsluiten
$public = Arr::except($user, ['password']);
// ['id' => 1, 'name' => 'Taro Yamada', 'email' => '...', 'role' => 'admin']
```

### `Arr::pluck()` — een specifieke sleutel uit een geneste array halen

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

$records = [
    ['user' => ['id' => 1, 'name' => 'Taro Yamada']],
    ['user' => ['id' => 2, 'name' => 'Hanako Suzuki']],
];

$names = Arr::pluck($records, 'user.name');
// ['Taro Yamada', 'Hanako Suzuki']

// De sleutel opgeven via het derde argument
$nameById = Arr::pluck($records, 'user.name', 'user.id');
// [1 => 'Taro Yamada', 2 => 'Hanako Suzuki']
```

### `Arr::first()` / `Arr::last()` — eerste of laatste element dat aan een voorwaarde voldoet

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

$prices = [150, 80, 200, 50, 120];

// De eerste prijs van 100 of hoger
$first = Arr::first($prices, fn ($price) => $price >= 100);
// 150

// Standaardwaarde wanneer niets aan de voorwaarde voldoet
$first = Arr::first($prices, fn ($price) => $price >= 500, 0);
// 0

// Laatste element (zonder voorwaarde)
$last = Arr::last($prices);
// 120
```

### `Arr::flatten()` — een multidimensionale array afvlakken naar één dimensie

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

$tags = [
    'frontend' => ['html', 'css', 'javascript'],
    'backend'  => ['php', 'laravel', 'mysql'],
];

$allTags = Arr::flatten($tags);
// ['html', 'css', 'javascript', 'php', 'laravel', 'mysql']
```

### `Arr::wrap()` — een waarde gegarandeerd in een array veranderen

Wikkelt een waarde in een array als het geen array is. `null` wordt een lege array. Handig wanneer een functie flexibel argumenten moet accepteren.

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

Arr::wrap('Laravel');
// ['Laravel']

Arr::wrap(['Laravel', 'PHP']);
// ['Laravel', 'PHP']

Arr::wrap(null);
// []
```

### `Arr::sort()` — sorteren op waarde

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

$fruits = ['banana', 'apple', 'cherry'];
$sorted = Arr::sort($fruits);
// ['apple', 'banana', 'cherry']

// De sorteersleutel opgeven met een closure
$products = [
    ['name' => 'Laptop', 'price' => 120000],
    ['name' => 'Muis', 'price' => 3500],
    ['name' => 'Toetsenbord', 'price' => 8000],
];

$byPrice = Arr::sort($products, fn ($product) => $product['price']);
// In de volgorde: muis, toetsenbord, laptop
```

### `Arr::dot()` / `Arr::undot()` — omzetten naar dot-notatie en terug

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

$nested = [
    'user' => [
        'profile' => ['name' => 'Taro Yamada', 'age' => 28],
    ],
];

$dotted = Arr::dot($nested);
// ['user.profile.name' => 'Taro Yamada', 'user.profile.age' => 28]

// Terug naar de oorspronkelijke structuur
$restored = Arr::undot($dotted);
// ['user' => ['profile' => ['name' => 'Taro Yamada', 'age' => 28]]]
```

### `Arr::join()` — een array samenvoegen tot een string

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

$items = ['PHP', 'Laravel', 'MySQL'];

Arr::join($items, ', ');
// 'PHP, Laravel, MySQL'

// Een andere string alleen vóór het laatste element gebruiken
Arr::join($items, ', ', ' en ');
// 'PHP, Laravel en MySQL'
```

## `data_get()` — toegang tot geneste data

De generieke variant van `Arr::get()`. Werkt niet alleen met arrays, maar ook met objecten, Eloquent-modellen en collections.

```php theme={null}
$users = [
    ['name' => 'Taro Yamada', 'address' => ['city' => 'Tokio']],
    ['name' => 'Hanako Suzuki', 'address' => ['city' => 'Osaka']],
];

// Toegang met dot-notatie
$city = data_get($users, '0.address.city');
// 'Tokio'

// Met een wildcard uit alle elementen ophalen
$cities = data_get($users, '*.address.city');
// ['Tokio', 'Osaka']
```

## Getalhelpers (de Number-klasse)

### `Number::format()` — getallen leesbaar formatteren

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

Number::format(1234567.89);
// '1,234,567.89'

Number::format(1234567.89, precision: 0, locale: 'ja');
// '1,234,568'
```

### `Number::currency()` — valutanotatie

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

Number::currency(10000, 'JPY', locale: 'ja');
// '￥10,000'

Number::currency(29.99, 'USD');
// '$29.99'
```

### `Number::fileSize()` — bestandsgroottes in een leesbaar formaat

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

Number::fileSize(1024);
// '1 KB'

Number::fileSize(1024 * 1024 * 2.5);
// '2.5 MB'
```

### `Number::abbreviate()` — grote getallen afkorten

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

Number::abbreviate(1000);
// '1K'

Number::abbreviate(1500000);
// '1.5M'
```

### `Number::percentage()` — percentages weergeven

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

Number::percentage(75.5, precision: 1);
// '75.5%'
```

## Padhelpers

Halen directorypaden binnen de applicatie op. Ze geven het juiste pad terug, ook als de omgeving of deploylocatie verandert.

```php theme={null}
// Het absolute pad naar de app-directory
app_path();
// /var/www/html/app

// Het pad naar app/Http/Controllers/UserController.php
app_path('Http/Controllers/UserController.php');

// Een pad relatief ten opzichte van de projectroot
base_path('composer.json');

// De config-directory
config_path('database.php');

// De database-directory
database_path('migrations');

// De storage-directory
storage_path('app/uploads');

// De public-directory
public_path('css/app.css');

// De resources-directory
resource_path('views/welcome.blade.php');
```

## URL-helpers

### `route()` — URL's genereren voor benoemde routes

```php theme={null}
// Routedefinitie
// Route::get('/users/{user}', [UserController::class, 'show'])->name('users.show');

// Absolute URL (standaard)
$url = route('users.show', ['user' => 1]);
// 'https://example.com/users/1'

// Relatieve URL
$url = route('users.show', ['user' => 1], false);
// '/users/1'
```

### `url()` — absolute URL's voor willekeurige paden genereren

```php theme={null}
$url = url('user/profile');
// 'https://example.com/user/profile'

// Een instantie van de URL-generator ophalen
$current  = url()->current();   // De huidige URL
$full     = url()->full();      // De huidige URL inclusief querystring
$previous = url()->previous();  // De vorige URL
```

### `asset()` — URL's voor statische assets genereren

```php theme={null}
$url = asset('img/logo.png');
// 'https://example.com/img/logo.png'
```

### `to_route()` — redirecten naar een benoemde route

```php theme={null}
return to_route('users.show', ['user' => 1]);

// Je kunt ook een HTTP-status en headers opgeven
return to_route('users.show', ['user' => 1], 302, ['X-Custom' => 'value']);
```

## Overige veelgebruikte helpers

### `config()` — configuratiewaarden ophalen en instellen

```php theme={null}
// Configuratiewaarden ophalen met dot-notatie
$timezone = config('app.timezone');
// 'Asia/Tokyo'

// Met standaardwaarde
$debug = config('app.debug', false);

// De configuratie tijdens runtime wijzigen (alleen binnen dat proces)
config(['app.locale' => 'ja']);
```

### `collect()` — een collection maken

```php theme={null}
$collection = collect([1, 2, 3, 4, 5]);

$sum = collect([1, 2, 3])->sum(); // 6
```

<Tip>
  `collect()` is de belangrijkste helper als toegangspoort tot collections. Zie [Collections](/nl/collections) voor meer informatie.
</Tip>

### `auth()` — de geauthenticeerde gebruiker ophalen

```php theme={null}
// De huidige gebruiker ophalen
$user = auth()->user();

// Controleren of iemand is ingelogd
if (auth()->check()) {
    // Logica voor ingelogde gebruikers
}

// Een specifieke guard gebruiken
$admin = auth('admin')->user();
```

### `blank()` / `filled()` — controleren op leegte

`blank()` beschouwt `null`, een lege string, alleen witruimte en lege collections/arrays als `true`. `filled()` is het omgekeerde.

```php theme={null}
blank('');         // true
blank('   ');      // true
blank(null);       // true
blank(collect()); // true

blank(0);      // false (0 is niet "leeg")
blank(false);  // false

filled('hello'); // true
filled(0);       // true
```

### `abort()` / `abort_if()` / `abort_unless()` — HTTP-excepties

```php theme={null}
// Direct een HTTP-fout gooien
abort(404);
abort(403, 'Je hebt geen toegang tot deze pagina.');

// Fout wanneer de voorwaarde true is
abort_if(! auth()->user()->isAdmin(), 403);

// Fout wanneer de voorwaarde false is
abort_unless(auth()->check(), 401);
```

### `dd()` / `dump()` — debuggen

```php theme={null}
// Variabelen uitprinten en het script beëindigen
dd($user);
dd($user, $orders, $config);

// Uitprinten zonder het script te beëindigen
dump($query);
```

### `dispatch()` — een job op de queue zetten

```php theme={null}
dispatch(new App\Jobs\SendWelcomeEmail($user));

// Direct uitvoeren (synchroon)
dispatch_sync(new App\Jobs\GenerateReport($data));
```

### `encrypt()` / `decrypt()` — versleuteling

```php theme={null}
$encrypted = encrypt('sensitive-value');
$decrypted = decrypt($encrypted);
```

### `env()` — omgevingsvariabelen ophalen

```php theme={null}
$debug = env('APP_DEBUG', false);
$dbHost = env('DB_HOST', '127.0.0.1');
```

<Warning>
  Roep `env()` niet rechtstreeks aan in controllers of serviceklassen; de best practice is om `env()` alleen in `config/`-bestanden te gebruiken en de waarden via `config()` te benaderen. Wanneer de configuratiecache (`php artisan config:cache`) actief is, kan `env()` niet de verwachte waarde teruggeven.
</Warning>

## Wanneer gebruik je collect()

De `Arr::`-klasse werkt op gewone PHP-arrays; `collect()` geeft een collection-object terug.

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

// Wil je met arrays blijven werken → de Arr-klasse
$filtered = Arr::where($items, fn ($v) => $v > 0);
// Het resultaat is een array

// Wil je meerdere bewerkingen chainen → collect()
$result = collect($items)
    ->filter(fn ($v) => $v > 0)
    ->map(fn ($v) => $v * 2)
    ->values()
    ->all();
// Het resultaat is een array (via all() eruit gehaald)
```

<Info>
  Eloquent-resultaten worden automatisch als collections teruggegeven, dus die hoef je niet in `collect()` te wikkelen. Volstaat een eenvoudige arraybewerking, dan houd je het simpel met `Arr::`.
</Info>

## Samenvatting

<AccordionGroup>
  <Accordion title="Overzicht van veelgebruikte helpers">
    | Helper                                | Doel                                                 |
    | ------------------------------------- | ---------------------------------------------------- |
    | `Arr::get($array, 'a.b.c', $default)` | Veilig ophalen uit een geneste array                 |
    | `Arr::only($array, $keys)`            | Alleen opgegeven sleutels behouden                   |
    | `Arr::except($array, $keys)`          | Opgegeven sleutels uitsluiten                        |
    | `Arr::pluck($array, 'key')`           | Een lijst waarden van een specifieke sleutel ophalen |
    | `Arr::flatten($array)`                | Multidimensionale array afvlakken                    |
    | `Arr::wrap($value)`                   | Gegarandeerd een array maken                         |
    | `data_get($target, 'a.*.b')`          | Ophalen met wildcards                                |
    | `Number::format($n)`                  | Getallen leesbaar formatteren                        |
    | `Number::currency($n, 'JPY')`         | Valutanotatie                                        |
    | `Number::fileSize($bytes)`            | Bestandsgrootte weergeven                            |
    | `route('name', $params)`              | URL van een benoemde route                           |
    | `url('path')`                         | Absolute URL genereren                               |
    | `asset('path')`                       | URL van statische assets                             |
    | `config('key', $default)`             | Configuratiewaarden ophalen                          |
    | `collect($array)`                     | Collection maken                                     |
    | `auth()->user()`                      | De huidige gebruiker ophalen                         |
    | `blank($value)`                       | Controleren op leegte                                |
    | `filled($value)`                      | Controleren of iets niet leeg is                     |
    | `abort(403)`                          | HTTP-exceptie gooien                                 |
    | `dispatch($job)`                      | Job op de queue zetten                               |
    | `env('KEY', $default)`                | Omgevingsvariabelen ophalen                          |
  </Accordion>

  <Accordion title="Arr-klasse vs collect()">
    **Wanneer gebruik je de `Arr::`-klasse**:

    * Eenvoudige arraybewerkingen (toegang tot geneste sleutels, sleutels filteren enz.)
    * Wanneer de overhead van een collection-object onnodig is
    * Wanneer je het resultaat als array wilt blijven gebruiken

    **Wanneer gebruik je `collect()`**:

    * Wanneer je meerdere bewerkingen als methodchain wilt uitdrukken
    * Wanneer je Eloquent-resultaten verder bewerkt (al een collection)
    * Wanneer je collection-specifieke methoden zoals `map`, `filter` en `groupBy` wilt gebruiken
  </Accordion>
</AccordionGroup>


## Related topics

- [Facades](/nl/facades.md)
- [Processen](/nl/processes.md)
- [Contracts](/nl/contracts.md)