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

# Helfer-Funktionen

> Praxisnahe Erklärung der globalen Helfer-Funktionen von Laravel sowie der Klassen `Arr` und `Number`.

## Was sind Helfer-Funktionen

Laravel liefert viele globale PHP-Funktionen (Helfer) mit. Das Framework selbst nutzt sie intern; Sie können sie aber überall in Ihrer Anwendung einsetzen.

Grobe Kategorien:

* **Array/Objekt** – Klasse `Arr::` und Funktionen wie `data_get()`
* **Zahlen** – Klasse `Number::`
* **Pfade** – `app_path()`, `storage_path()` u. Ä.
* **URLs** – `route()`, `url()`, `asset()` u. Ä.
* **Sonstige** – häufig genutzte Utilities wie `config()`, `collect()`, `auth()`

<Info>
  Helfer-Funktionen sind ohne `use` überall verfügbar. Für die Klassen `Arr` und `Number` müssen Sie z. B. `use Illuminate\Support\Arr;` importieren.
</Info>

## Array-Helfer (`Arr`-Klasse)

### `Arr::get()` – verschachtelte Werte per Punkt-Notation

Sicherer Zugriff auf verschachtelte Arrays. Fehlt der Schlüssel, wird ein Default zurückgegeben.

```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'

// Default-Wert
$charset = Arr::get($config, 'database.connections.mysql.charset', 'utf8mb4');
// 'utf8mb4'
```

<Tip>
  Die globale Funktion `data_get()` bietet die gleiche Funktionalität – auch für `Arrayable`-Objekte wie Eloquent-Beziehungen.
</Tip>

### `Arr::set()` – Wert in verschachteltem Array setzen

```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()` – Schlüssel-Existenz prüfen

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

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

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

// Mehrere Schlüssel
$hasAll = Arr::has($array, ['product.name', 'product.price']);
// true
```

### `Arr::only()` / `Arr::except()` – filtern/ausschließen

Ideal, um aus Request- oder Konfigurationsdaten nur die benötigten (oder ausschließlich sichere) Felder zu behalten.

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

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

$safe = Arr::only($user, ['id', 'name', 'email']);

$public = Arr::except($user, ['password']);
```

### `Arr::pluck()` – Werte aus verschachteltem Array extrahieren

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

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

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

$nameById = Arr::pluck($records, 'user.name', 'user.id');
// [1 => 'Yamada Taro', 2 => 'Suzuki Hanako']
```

### `Arr::first()` / `Arr::last()` – erstes/letztes passendes Element

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

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

$first = Arr::first($prices, fn ($price) => $price >= 100);
// 150

$first = Arr::first($prices, fn ($price) => $price >= 500, 0);
// 0

$last = Arr::last($prices);
// 120
```

### `Arr::flatten()` – mehrdimensional platt machen

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

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

$allTags = Arr::flatten($tags);
```

### `Arr::wrap()` – Wert sicher als Array

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

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

### `Arr::sort()` – Werte sortieren

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

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

$products = [
    ['name' => 'Laptop', 'price' => 120000],
    ['name' => 'Maus', 'price' => 3500],
    ['name' => 'Tastatur', 'price' => 8000],
];

$byPrice = Arr::sort($products, fn ($p) => $p['price']);
```

### `Arr::dot()` / `Arr::undot()` – flach/verschachtelt

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

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

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

$restored = Arr::undot($dotted);
```

### `Arr::join()` – Array zu String

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

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

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

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

## `data_get()` – Zugriff auf verschachtelte Daten

Die generische Variante von `Arr::get()`. Funktioniert auch mit Objekten, Eloquent-Modellen und Collections.

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

$city = data_get($users, '0.address.city');
// 'Tokio'

$cities = data_get($users, '*.address.city');
// ['Tokio', 'Osaka']
```

## Zahl-Helfer (`Number`-Klasse)

### `Number::format()` – lesbar formatieren

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

Number::format(1234567.89);
Number::format(1234567.89, precision: 0, locale: 'de');
```

### `Number::currency()` – Währung

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

Number::currency(10000, 'EUR', locale: 'de');
Number::currency(29.99, 'USD');
```

### `Number::fileSize()` – Dateigröße

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

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

### `Number::abbreviate()` – große Zahlen abkürzen

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

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

### `Number::percentage()` – Prozent

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

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

## Pfad-Helfer

Liefern absolute Pfade – unabhängig von der Umgebung.

```php theme={null}
app_path();
app_path('Http/Controllers/UserController.php');
base_path('composer.json');
config_path('database.php');
database_path('migrations');
storage_path('app/uploads');
public_path('css/app.css');
resource_path('views/welcome.blade.php');
```

## URL-Helfer

### `route()` – URL für benannte Route

```php theme={null}
$url = route('users.show', ['user' => 1]);
// 'https://example.com/users/1'

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

### `url()` – absolute URL

```php theme={null}
$url = url('user/profile');

$current  = url()->current();
$full     = url()->full();
$previous = url()->previous();
```

### `asset()` – URL für statische Assets

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

### `to_route()` – Redirect zu benannter Route

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

return to_route('users.show', ['user' => 1], 302, ['X-Custom' => 'value']);
```

## Weitere häufig genutzte Helfer

### `config()`

```php theme={null}
$timezone = config('app.timezone');
$debug = config('app.debug', false);
config(['app.locale' => 'de']);
```

### `collect()`

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

<Tip>
  `collect()` ist der Einstiegspunkt zu Collections. Details unter [Collections](/de/collections).
</Tip>

### `auth()`

```php theme={null}
$user = auth()->user();

if (auth()->check()) {
    // Angemeldet
}

$admin = auth('admin')->user();
```

### `blank()` / `filled()`

`blank()` bewertet `null`, leere Strings, reine Leerzeichen sowie leere Collections/Arrays als `true`. `filled()` ist das Gegenteil.

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

blank(0);      // false
blank(false);  // false

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

### `abort()` / `abort_if()` / `abort_unless()`

```php theme={null}
abort(404);
abort(403, 'Kein Zugriff auf diese Seite.');

abort_if(! auth()->user()->isAdmin(), 403);
abort_unless(auth()->check(), 401);
```

### `dd()` / `dump()`

```php theme={null}
dd($user);
dd($user, $orders, $config);

dump($query);
```

### `dispatch()`

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

### `encrypt()` / `decrypt()`

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

### `env()`

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

<Warning>
  Best Practice: `env()` nur in `config/`-Dateien verwenden und über `config()` darauf zugreifen. Ist der Konfigurations-Cache (`php artisan config:cache`) aktiv, liefert `env()` sonst evtl. nicht die erwarteten Werte.
</Warning>

## Wann `Arr::` und wann `collect()`?

`Arr::` operiert auf normalen PHP-Arrays, `collect()` liefert ein Collection-Objekt.

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

// Arrays direkt manipulieren → Arr
$filtered = Arr::where($items, fn ($v) => $v > 0);

// Mehrere Operationen als Chain → collect()
$result = collect($items)
    ->filter(fn ($v) => $v > 0)
    ->map(fn ($v) => $v * 2)
    ->values()
    ->all();
```

<Info>
  Eloquent-Ergebnisse sind bereits Collections – Sie müssen sie nicht extra mit `collect()` einpacken. Für einfache Array-Manipulation ist `Arr::` oft kürzer.
</Info>

## Zusammenfassung

<AccordionGroup>
  <Accordion title="Häufig genutzte Helfer im Überblick">
    | Helfer                                | Zweck                                       |
    | ------------------------------------- | ------------------------------------------- |
    | `Arr::get($array, 'a.b.c', $default)` | Sicherer Zugriff auf verschachtelte Werte   |
    | `Arr::only($array, $keys)`            | Nur bestimmte Schlüssel behalten            |
    | `Arr::except($array, $keys)`          | Bestimmte Schlüssel entfernen               |
    | `Arr::pluck($array, 'key')`           | Werte aus verschachtelten Arrays einsammeln |
    | `Arr::flatten($array)`                | Mehrdimensional flach machen                |
    | `Arr::wrap($value)`                   | In Array einpacken                          |
    | `data_get($target, 'a.*.b')`          | Zugriff mit Wildcard                        |
    | `Number::format($n)`                  | Zahl lesbar formatieren                     |
    | `Number::currency($n, 'EUR')`         | Währung                                     |
    | `Number::fileSize($bytes)`            | Dateigröße                                  |
    | `route('name', $params)`              | URL zu benannter Route                      |
    | `url('path')`                         | Absolute URL                                |
    | `asset('path')`                       | Asset-URL                                   |
    | `config('key', $default)`             | Konfigurationswert                          |
    | `collect($array)`                     | Collection erzeugen                         |
    | `auth()->user()`                      | Aktueller Nutzer                            |
    | `blank($value)`                       | Leere-Prüfung                               |
    | `filled($value)`                      | Nicht-leer-Prüfung                          |
    | `abort(403)`                          | HTTP-Fehler                                 |
    | `dispatch($job)`                      | Job in die Queue                            |
    | `env('KEY', $default)`                | Umgebungsvariable                           |
  </Accordion>

  <Accordion title="Arr vs. collect()">
    **`Arr::`**:

    * Direkte Array-Operationen (verschachtelte Keys, Filter)
    * Keine Collection-Overhead nötig
    * Ergebnisse als Array

    **`collect()`**:

    * Mehrere Operationen in einer Chain
    * Eloquent-Ergebnisse weiterverarbeiten
    * Collection-spezifische Methoden wie `map`, `filter`, `groupBy`
  </Accordion>
</AccordionGroup>


## Related topics

- [Facades](/de/facades.md)
- [Collections](/de/collections.md)
- [String-Operationen (Str-Klasse)](/de/strings.md)
- [Lokalisierung](/de/localization.md)
- [Laravel-Tests mit Pest PHP starten](/de/blog/pest-introduction.md)