Helpers

• Introduzione
• Metodi Disponibili
• Array e Oggetti
• Numeri
• Percorsi
• URL
• Varie
• Altri Strumenti

Introduzione

Laravel include una varietà di funzioni PHP globali "helper". Molte di queste funzioni sono utilizzate dal framework stesso; tuttavia, sei libero di usarle nelle tue applicazioni se le trovi comode.

Metodi Disponibili

Array e Oggetti

• Arr::accessible
• Arr::add
• Arr::collapse
• Arr::crossJoin
• Arr::divide
• Arr::dot
• Arr::except
• Arr::exists
• Arr::first
• Arr::flatten
• Arr::forget
• Arr::get
• Arr::has
• Arr::hasAny
• Arr::isAssoc
• Arr::isList
• Arr::join
• Arr::keyBy
• Arr::last
• Arr::map
• Arr::mapSpread
• Arr::mapWithKeys
• Arr::only
• Arr::pluck
• Arr::prepend
• Arr::prependKeysWith
• Arr::pull
• Arr::query
• Arr::random
• Arr::set
• Arr::shuffle
• Arr::sort
• Arr::sortDesc
• Arr::sortRecursive
• Arr::take
• Arr::toCssClasses
• Arr::toCssStyles
• Arr::undot
• Arr::where
• Arr::whereNotNull
• Arr::wrap
• data_fill
• data_get
• data_set
• data_forget
• head
• last

Numeri

• Number::abbreviate
• Number::clamp
• Number::currency
• Number::defaultCurrency
• Number::defaultLocale
• Number::fileSize
• Number::forHumans
• Number::format
• Number::ordinal
• Number::pairs
• Number::percentage
• Number::spell
• Number::trim
• Number::useLocale
• Number::withLocale
• Number::useCurrency
• Number::withCurrency

Percorsi

• app_path
• base_path
• config_path
• database_path
• lang_path
• mix
• public_path
• resource_path
• storage_path

URL

• action
• asset
• route
• secure_asset
• secure_url
• to_route
• url

Varie

• abort
• abort_if
• abort_unless
• app
• auth
• back
• bcrypt
• blank
• broadcast
• cache
• class_uses_recursive
• collect
• config
• context
• cookie
• csrf_field
• csrf_token
• decrypt
• dd
• dispatch
• dispatch_sync
• dump
• encrypt
• env
• event
• fake
• filled
• info
• literal
• logger
• method_field
• now
• old
• once
• optional
• policy
• redirect
• report
• report_if
• report_unless
• request
• rescue
• resolve
• response
• retry
• session
• tap
• throw_if
• throw_unless
• today
• trait_uses_recursive
• transform
• validator
• value
• view
• with
• when

Array e Oggetti

Arr::accessible()

Il metodo Arr::accessible determina se il valore fornito è accessibile come array:

use Illuminate\Support\Arr;
use Illuminate\Support\Collection;

$isAccessible = Arr::accessible(['a' => 1, 'b' => 2]);

// true

$isAccessible = Arr::accessible(new Collection);

// true

$isAccessible = Arr::accessible('abc');

// false

$isAccessible = Arr::accessible(new stdClass);

// false

Arr::add()

Il metodo Arr::add aggiunge una coppia chiave/valore a un array se la chiave specificata non esiste già nell’array o è impostata su null:

use Illuminate\Support\Arr;

$array = Arr::add(['name' => 'Desk'], 'price', 100);

// ['name' => 'Desk', 'price' => 100]

$array = Arr::add(['name' => 'Desk', 'price' => null], 'price', 100);

// ['name' => 'Desk', 'price' => 100]

Arr::collapse()

Il metodo Arr::collapse unisce un array di array in un unico array:

use Illuminate\Support\Arr;

$array = Arr::collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

// [1, 2, 3, 4, 5, 6, 7, 8, 9]

Arr::crossJoin()

Il metodo Arr::crossJoin combina gli array forniti, restituendo un prodotto cartesiano con tutte le permutazioni possibili:

use Illuminate\Support\Arr;

$matrix = Arr::crossJoin([1, 2], ['a', 'b']);

/*
    [
        [1, 'a'],
        [1, 'b'],
        [2, 'a'],
        [2, 'b'],
    ]
*/

$matrix = Arr::crossJoin([1, 2], ['a', 'b'], ['I', 'II']);

/*
    [
        [1, 'a', 'I'],
        [1, 'a', 'II'],
        [1, 'b', 'I'],
        [1, 'b', 'II'],
        [2, 'a', 'I'],
        [2, 'a', 'II'],
        [2, 'b', 'I'],
        [2, 'b', 'II'],
    ]
*/

Arr::divide()

Il metodo Arr::divide restituisce due array: uno contenente le chiavi e l’altro contenente i valori dell’array fornito:

    use Illuminate\Support\Arr;

    [$keys, $values] = Arr::divide(['name' => 'Desk']);

    // $keys: ['name']

    // $values: ['Desk']

Arr::dot()

Il metodo Arr::dot appiattisce un array multidimensionale in un array a un unico livello, utilizzando la notazione a "punti" per indicare la profondità:

use Illuminate\Support\Arr;

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

$flattened = Arr::dot($array);

// ['products.desk.price' => 100]

Arr::except()

Il metodo Arr::except rimuove le coppie chiave/valore specificate da un array:

use Illuminate\Support\Arr;

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

$filtered = Arr::except($array, ['price']);

// ['name' => 'Desk']

Arr::exists()

Il metodo Arr::exists controlla se la chiave specificata esiste nell’array fornito:

use Illuminate\Support\Arr;

$array = ['name' => 'John Doe', 'age' => 17];

$exists = Arr::exists($array, 'name');

// true

$exists = Arr::exists($array, 'salary');

// false

Arr::first()

Il metodo Arr::first restituisce il primo elemento di un array che passa un determinato test:

use Illuminate\Support\Arr;

$array = [100, 200, 300];

$first = Arr::first($array, function (int $value, int $key) {
    return $value >= 150;
});

// 200

È possibile passare un valore di default come terzo parametro al metodo. Questo valore verrà restituito se nessun elemento supera il test:

use Illuminate\Support\Arr;

$first = Arr::first($array, $callback, $default);

Arr::flatten()

Il metodo Arr::flatten appiattisce un array multidimensionale in un array a un solo livello:

use Illuminate\Support\Arr;

$array = ['name' => 'Joe', 'languages' => ['PHP', 'Ruby']];

$flattened = Arr::flatten($array);

// ['Joe', 'PHP', 'Ruby']

Arr::forget()

Il metodo Arr::forget rimuove una specifica coppia chiave/valore da un array profondamente annidato usando la notazione "dot":

use Illuminate\Support\Arr;

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

Arr::forget($array, 'products.desk');

// ['products' => []]

Arr::get()

Il metodo Arr::get recupera un valore da un array profondamente annidato usando la notazione a punto:

use Illuminate\Support\Arr;

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

$price = Arr::get($array, 'products.desk.price');

// 100

Il metodo Arr::get accetta anche un valore di default, che verrà restituito se la chiave specificata non è presente nell’array:

use Illuminate\Support\Arr;

$discount = Arr::get($array, 'products.desk.discount', 0);

// 0

Arr::has()

Il metodo Arr::has controlla se un elemento o più elementi esistono in un array utilizzando la notazione a "punti":

use Illuminate\Support\Arr;

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

$contains = Arr::has($array, 'product.name');

// true

$contains = Arr::has($array, ['product.price', 'product.discount']);

// false

Arr::hasAny()

Il metodo Arr::hasAny controlla se almeno uno degli elementi in un insieme specificato esiste in un array usando la notazione "dot":

use Illuminate\Support\Arr;

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

$contains = Arr::hasAny($array, 'product.name');

// true

$contains = Arr::hasAny($array, ['product.name', 'product.discount']);

// true

$contains = Arr::hasAny($array, ['category', 'product.discount']);

// false

Arr::isAssoc()

Il metodo Arr::isAssoc ritorna true se l’array passato è un array associativo. Un array è considerato "associativo" se non ha chiavi numeriche sequenziali che iniziano da zero:

use Illuminate\Support\Arr;

$isAssoc = Arr::isAssoc(['product' => ['name' => 'Desk', 'price' => 100]]);

// true

$isAssoc = Arr::isAssoc([1, 2, 3]);

// false

Arr::isList()

Il metodo Arr::isList restituisce true se le chiavi dell’array sono interi sequenziali a partire da zero:

    use Illuminate\Support\Arr;

    $isList = Arr::isList(['foo', 'bar', 'baz']);

    // true

    $isList = Arr::isList(['product' => ['name' => 'Desk', 'price' => 100]]);

    // false

Arr::join()

Il metodo Arr::join unisce gli elementi di un array con una stringa. Utilizzando il secondo argomento di questo metodo, puoi anche specificare la stringa di unione per l’ultimo elemento dell’array:

use Illuminate\Support\Arr;

$array = ['Tailwind', 'Alpine', 'Laravel', 'Livewire'];

$joined = Arr::join($array, ', ');

// Tailwind, Alpine, Laravel, Livewire

$joined = Arr::join($array, ', ', ' and ');

// Tailwind, Alpine, Laravel and Livewire

Arr::keyBy()

Il metodo Arr::keyBy assegna chiavi all’array basandosi sulla chiave fornita. Se più elementi hanno la stessa chiave, solo l’ultimo apparirà nel nuovo array:

use Illuminate\Support\Arr;

$array = [
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
];

$keyed = Arr::keyBy($array, 'product_id');

/*
    [
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

Arr::last()

Il metodo Arr::last restituisce l’ultimo elemento di un array che supera un determinato test:

use Illuminate\Support\Arr;

$array = [100, 200, 300, 110];

$last = Arr::last($array, function (int $value, int $key) {
    return $value >= 150;
});

// 300

È possibile passare un valore di default come terzo argomento al metodo. Questo valore verrà restituito se nessun elemento supera il test:

use Illuminate\Support\Arr;

$last = Arr::last($array, $callback, $default);

Arr::map()

Il metodo Arr::map itera l’array e passa ogni valore e chiave alla callback fornita. Il valore dell’array viene sostituito dal valore restituito dalla callback:

    use Illuminate\Support\Arr;
    
    $array = ['first' => 'james', 'last' => 'kirk'];
    
    $mapped = Arr::map($array, function (string $value, string $key) {
        return ucfirst($value);
    });
    
    // ['first' => 'James', 'last' => 'Kirk']

Arr::mapSpread()

Il metodo Arr::mapSpread itera sull’array, passando ogni valore degli elementi nidificati alla closure fornita. La closure può modificare l’elemento e restituirlo, creando così un nuovo array di elementi modificati:

    use Illuminate\Support\Arr;

    $array = [
        [0, 1],
        [2, 3],
        [4, 5],
        [6, 7],
        [8, 9],
    ];

    $mapped = Arr::mapSpread($array, function (int $even, int $odd) {
        return $even + $odd;
    });

    /*
        [1, 5, 9, 13, 17]
    */

Arr::mapWithKeys()

Il metodo Arr::mapWithKeys scorre l’array e passa ogni elemento al callback fornito. Il callback deve restituire un array associativo con una singola coppia chiave/valore:

use Illuminate\Support\Arr;

$array = [
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => 'john@example.com',
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => 'jane@example.com',
    ]
];

$mapped = Arr::mapWithKeys($array, function (array $item, int $key) {
    return [$item['email'] => $item['name']];
});

/*
    [
        'john@example.com' => 'John',
        'jane@example.com' => 'Jane',
    ]
*/

Arr::only()

Il metodo Arr::only restituisce solo le coppie chiave/valore specificate dall’array fornito:

use Illuminate\Support\Arr;

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

$slice = Arr::only($array, ['name', 'price']);

// ['name' => 'Desk', 'price' => 100]

Arr::pluck()

Il metodo Arr::pluck recupera tutti i valori di una chiave specifica da un array:

    use Illuminate\Support\Arr;

    $array = [
        ['developer' => ['id' => 1, 'name' => 'Taylor']],
        ['developer' => ['id' => 2, 'name' => 'Abigail']],
    ];

    $names = Arr::pluck($array, 'developer.name');

    // ['Taylor', 'Abigail']

Puoi anche specificare come desideri indicizzare la lista risultante:

    use Illuminate\Support\Arr;

    $names = Arr::pluck($array, 'developer.name', 'developer.id');

    // [1 => 'Taylor', 2 => 'Abigail']

Arr::prepend()

Il metodo Arr::prepend aggiunge un elemento all’inizio di un array:

use Illuminate\Support\Arr;

$array = ['one', 'two', 'three', 'four'];

$array = Arr::prepend($array, 'zero');

// ['zero', 'one', 'two', 'three', 'four']

Se necessario, puoi specificare la chiave da utilizzare per il valore:

use Illuminate\Support\Arr;

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

$array = Arr::prepend($array, 'Desk', 'name');

// ['name' => 'Desk', 'price' => 100]

Arr::prependKeysWith()

Il metodo Arr::prependKeysWith antepone un prefisso a tutti i nomi delle chiavi di un array associativo:

use Illuminate\Support\Arr;

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

$keyed = Arr::prependKeysWith($array, 'product.');

/*
    [
        'product.name' => 'Desk',
        'product.price' => 100,
    ]
*/

Arr::pull()

Il metodo Arr::pull restituisce e rimuove una coppia chiave/valore da un array:

    use Illuminate\Support\Arr;

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

    $name = Arr::pull($array, 'name');

    // $name: Desk

    // $array: ['price' => 100]

Un valore di default può essere passato come terzo argomento al metodo. Questo valore verrà restituito se la chiave non esiste:

    use Illuminate\Support\Arr;

    $value = Arr::pull($array, $key, $default);

Arr::query()

Il metodo Arr::query converte l’array in una stringa di query:

use Illuminate\Support\Arr;

$array = [
    'name' => 'Taylor',
    'order' => [
        'column' => 'created_at',
        'direction' => 'desc'
    ]
];

Arr::query($array);

// name=Taylor&order[column]=created_at&order[direction]=desc

Arr::random()

Il metodo Arr::random restituisce un valore casuale da un array:

use Illuminate\Support\Arr;

$array = [1, 2, 3, 4, 5];

$random = Arr::random($array);

// 4 - (recuperato casualmente)

Puoi anche specificare il numero di elementi da restituire come secondo argomento opzionale. Nota che fornendo questo argomento verrà restituito un array anche se desideri solo un elemento:

use Illuminate\Support\Arr;

$items = Arr::random($array, 2);

// [2, 5] - (recuperati casualmente)

Arr::set()

Il metodo Arr::set imposta un valore all’interno di un array profondamente annidato utilizzando la notazione con "punti":

use Illuminate\Support\Arr;

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

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

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

Arr::shuffle()

Il metodo Arr::shuffle mescola casualmente gli elementi nell’array:

use Illuminate\Support\Arr;

$array = Arr::shuffle([1, 2, 3, 4, 5]);

// [3, 2, 5, 1, 4] - (generato casualmente)

Arr::sort()

Il metodo Arr::sort ordina un array in base ai suoi valori:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

$sorted = Arr::sort($array);

// ['Chair', 'Desk', 'Table']

Puoi anche ordinare l’array in base ai risultati di una closure data:

use Illuminate\Support\Arr;

$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];

$sorted = array_values(Arr::sort($array, function (array $value) {
    return $value['name'];
}));

/*
    [
        ['name' => 'Chair'],
        ['name' => 'Desk'],
        ['name' => 'Table'],
    ]
*/

Arr::sortDesc()

Il metodo Arr::sortDesc ordina un array in ordine decrescente in base ai suoi valori:

use Illuminate\Support\Arr;

$array = ['Desk', 'Table', 'Chair'];

$sorted = Arr::sortDesc($array);

// ['Table', 'Desk', 'Chair']

Puoi anche ordinare l’array in base ai risultati di una closure:

use Illuminate\Support\Arr;

$array = [
    ['name' => 'Desk'],
    ['name' => 'Table'],
    ['name' => 'Chair'],
];

$sorted = array_values(Arr::sortDesc($array, function (array $value) {
    return $value['name'];
}));

/*
    [
        ['name' => 'Table'],
        ['name' => 'Desk'],
        ['name' => 'Chair'],
    ]
*/

Arr::sortRecursive()

Il metodo Arr::sortRecursive ordina ricorsivamente un array utilizzando la funzione sort per gli array indicizzati numericamente e la funzione ksort per gli array associativi:

    use Illuminate\Support\Arr;

    $array = [
        ['Roman', 'Taylor', 'Li'],
        ['PHP', 'Ruby', 'JavaScript'],
        ['one' => 1, 'two' => 2, 'three' => 3],
    ];

    $sorted = Arr::sortRecursive($array);

    /*
        [
            ['JavaScript', 'PHP', 'Ruby'],
            ['one' => 1, 'three' => 3, 'two' => 2],
            ['Li', 'Roman', 'Taylor'],
        ]
    */

Se desideri che i risultati siano ordinati in ordine decrescente, puoi utilizzare il metodo Arr::sortRecursiveDesc.

    $sorted = Arr::sortRecursiveDesc($array);

Arr::take()

Il metodo Arr::take restituisce un nuovo array con il numero di elementi specificato:

use Illuminate\Support\Arr;

$array = [0, 1, 2, 3, 4, 5];

$chunk = Arr::take($array, 3);

// [0, 1, 2]

Puoi anche passare un intero negativo per ottenere il numero di elementi specificato dalla fine dell’array:

$array = [0, 1, 2, 3, 4, 5];

$chunk = Arr::take($array, -2);

// [4, 5]

Arr::toCssClasses()

Il metodo Arr::toCssClasses compila condizionalmente una stringa di classi CSS. Il metodo accetta un array di classi dove la chiave contiene la classe o le classi che si desidera aggiungere, mentre il valore è un’espressione booleana. Se l’elemento dell’array ha una chiave numerica, sarà sempre incluso nell’elenco delle classi renderizzate:

use Illuminate\Support\Arr;

$isActive = false;
$hasError = true;

$array = ['p-4', 'font-bold' => $isActive, 'bg-red' => $hasError];

$classes = Arr::toCssClasses($array);

/*
    'p-4 bg-red'
*/

Arr::toCssStyles()

Il metodo Arr::toCssStyles compila condizionalmente una stringa di stili CSS. Il metodo accetta un array di classi dove la chiave dell’array contiene la classe o le classi che desideri aggiungere, mentre il valore è un’espressione booleana. Se l’elemento dell’array ha una chiave numerica, verrà sempre incluso nella lista delle classi renderizzate:

use Illuminate\Support\Arr;

$hasColor = true;

$array = ['background-color: blue', 'color: blue' => $hasColor];

$classes = Arr::toCssStyles($array);

/*
    'background-color: blue; color: blue;'
*/

Questo metodo supporta le funzionalità di Laravel, consentendo l’unione delle classi con il sacchetto degli attributi di un componente Blade e la direttiva @class Blade.

Arr::undot()

Il metodo Arr::undot espande un array monodimensionale che utilizza la notazione a punti in un array multidimensionale:

use Illuminate\Support\Arr;

$array = [
    'user.name' => 'Kevin Malone',
    'user.occupation' => 'Accountant',
];

$array = Arr::undot($array);

// ['user' => ['name' => 'Kevin Malone', 'occupation' => 'Accountant']]

Arr::where()

Il metodo Arr::where filtra un array utilizzando la closure fornita:

use Illuminate\Support\Arr;

$array = [100, '200', 300, '400', 500];

$filtered = Arr::where($array, function (string|int $value, int $key) {
    return is_string($value);
});

// [1 => '200', 3 => '400']

Arr::whereNotNull()

Il metodo Arr::whereNotNull rimuove tutti i valori null dall’array fornito:

use Illuminate\Support\Arr;

$array = [0, null];

$filtered = Arr::whereNotNull($array);

// [0 => 0]

Arr::wrap()

Il metodo Arr::wrap incapsula il valore fornito in un array. Se il valore è già un array, verrà restituito senza modifiche:

use Illuminate\Support\Arr;

$string = 'Laravel';

$array = Arr::wrap($string);

// ['Laravel']

Se il valore fornito è null, verrà restituito un array vuoto:

use Illuminate\Support\Arr;

$array = Arr::wrap(null);

// []

data_fill()

La funzione data_fill imposta un valore mancante all’interno di un array annidato o di un oggetto utilizzando la notazione a "punto":

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

data_fill($data, 'products.desk.price', 200);

// ['products' => ['desk' => ['price' => 100]]]

data_fill($data, 'products.desk.discount', 10);

// ['products' => ['desk' => ['price' => 100, 'discount' => 10]]]

Questa funzione accetta anche gli asterischi come jolly e riempirà l’obiettivo di conseguenza:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2'],
    ],
];

data_fill($data, 'products.*.price', 200);

/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 100],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

data_get()

La funzione data_get recupera un valore da un array o oggetto annidato usando la notazione "dot":

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

$price = data_get($data, 'products.desk.price');

// 100

La funzione data_get accetta anche un valore di default, che verrà restituito se la chiave specificata non viene trovata:

$discount = data_get($data, 'products.desk.discount', 0);

// 0

La funzione accetta anche jolly usando asterischi, che possono indirizzare qualsiasi chiave dell’array o oggetto:

$data = [
    'product-one' => ['name' => 'Desk 1', 'price' => 100],
    'product-two' => ['name' => 'Desk 2', 'price' => 150],
];

data_get($data, '*.name');

// ['Desk 1', 'Desk 2'];

I placeholder {first} e {last} possono essere usati per recuperare il primo o l’ultimo elemento in un array:

$flight = [
    'segments' => [
        ['from' => 'LHR', 'departure' => '9:00', 'to' => 'IST', 'arrival' => '15:00'],
        ['from' => 'IST', 'departure' => '16:00', 'to' => 'PKX', 'arrival' => '20:00'],
    ],
];

data_get($flight, 'segments.{first}.arrival');

// 15:00

data_set()

La funzione data_set imposta un valore all’interno di un array o oggetto annidato usando la notazione a "punti":

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

data_set($data, 'products.desk.price', 200);

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

Questa funzione accetta anche caratteri jolly usando asterischi e imposterà i valori di conseguenza:

$data = [
    'products' => [
        ['name' => 'Desk 1', 'price' => 100],
        ['name' => 'Desk 2', 'price' => 150],
    ],
];

data_set($data, 'products.*.price', 200);

/*
    [
        'products' => [
            ['name' => 'Desk 1', 'price' => 200],
            ['name' => 'Desk 2', 'price' => 200],
        ],
    ]
*/

Di default, tutti i valori esistenti vengono sovrascritti. Se desideri impostare un valore solo se non esiste, puoi passare false come quarto argomento alla funzione:

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

data_set($data, 'products.desk.price', 200, overwrite: false);

// ['products' => ['desk' => ['price' => 100]]]

data_forget()

La funzione data_forget rimuove un valore all’interno di un array o oggetto annidato usando la notazione a punti:

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

    data_forget($data, 'products.desk.price');

    // ['products' => ['desk' => []]]

Questa funzione accetta anche caratteri jolly usando gli asterischi e rimuoverà i valori target di conseguenza:

    $data = [
        'products' => [
            ['name' => 'Desk 1', 'price' => 100],
            ['name' => 'Desk 2', 'price' => 150],
        ],
    ];

    data_forget($data, 'products.*.price');

    /*
        [
            'products' => [
                ['name' => 'Desk 1'],
                ['name' => 'Desk 2'],
            ],
        ]
    */

head()

La funzione head restituisce il primo elemento dell’array fornito:

$array = [100, 200, 300];

$first = head($array);

// 100

last()

La funzione last restituisce l’ultimo elemento nell’array fornito:

    $array = [100, 200, 300];
    
    $last = last($array);
    
    // 300

Numeri

Number::abbreviate()

Il metodo Number::abbreviate converte un valore numerico in un formato leggibile, abbreviando le unità:

use Illuminate\Support\Number;

$number = Number::abbreviate(1000);

// 1K

$number = Number::abbreviate(489939);

// 490K

$number = Number::abbreviate(1230000, precision: 2);

// 1.23M

Number::clamp()

Il metodo Number::clamp garantisce che un numero rimanga all’interno di un intervallo specificato. Se il numero è inferiore al minimo, viene restituito il valore minimo. Se il numero è superiore al massimo, viene restituito il valore massimo:

use Illuminate\Support\Number;

$number = Number::clamp(105, min: 10, max: 100);

// 100

$number = Number::clamp(5, min: 10, max: 100);

// 10

$number = Number::clamp(10, min: 10, max: 100);

// 10

$number = Number::clamp(20, min: 10, max: 100);

// 20

Number::currency()

Il metodo Number::currency restituisce la rappresentazione in valuta del valore fornito come stringa:

use Illuminate\Support\Number;

$currency = Number::currency(1000);

// $1,000.00

$currency = Number::currency(1000, in: 'EUR');

// €1,000.00

$currency = Number::currency(1000, in: 'EUR', locale: 'de');

// 1.000,00 €

Number::defaultCurrency()

Il metodo Number::defaultCurrency restituisce la valuta predefinita utilizzata dalla classe Number:

use Illuminate\Support\Number;

$currency = Number::defaultCurrency();

// USD

Number::defaultLocale()

Il metodo Number::defaultLocale restituisce la locale predefinita usata dalla classe Number:

use Illuminate\Support\Number;

$locale = Number::defaultLocale();

// en

Number::fileSize()

Il metodo Number::fileSize restituisce la rappresentazione della dimensione del file del valore byte fornito come stringa:

use Illuminate\Support\Number;

$size = Number::fileSize(1024);

// 1 KB

$size = Number::fileSize(1024 * 1024);

// 1 MB

$size = Number::fileSize(1024, precision: 2);

// 1.00 KB

Number::forHumans()

Il metodo Number::forHumans restituisce il formato leggibile del valore numerico fornito:

use Illuminate\Support\Number;

$number = Number::forHumans(1000);

// 1 mila

$number = Number::forHumans(489939);

// 490 mila

$number = Number::forHumans(1230000, precision: 2);

// 1.23 milioni

Number::format()

Il metodo Number::format formatta un numero dato in una stringa specifica per locale:

use Illuminate\Support\Number;

$number = Number::format(100000);

// 100,000

$number = Number::format(100000, precision: 2);

// 100,000.00

$number = Number::format(100000.123, maxPrecision: 2);

// 100,000.12

$number = Number::format(100000, locale: 'de');

// 100.000

Number::ordinal()

Il metodo Number::ordinal restituisce la rappresentazione ordinale di un numero:

use Illuminate\Support\Number;

$number = Number::ordinal(1);

// 1st

$number = Number::ordinal(2);

// 2nd

$number = Number::ordinal(21);

// 21st

Number::pairs()

Il metodo Number::pairs genera un array di coppie di numeri (sotto-intervalli) basato su un intervallo specificato e un valore di step. Questo metodo può essere utile per dividere un intervallo più ampio di numeri in sotto-intervalli più piccoli e gestibili per cose come la paginazione o l’elaborazione di task in batch. Il metodo pairs restituisce un array di array, dove ogni array interno rappresenta una coppia (sotto-intervallo) di numeri:

use Illuminate\Support\Number;

$result = Number::pairs(25, 10);

// [[1, 10], [11, 20], [21, 25]]

$result = Number::pairs(25, 10, offset: 0);

// [[0, 10], [10, 20], [20, 25]]

Number::percentage()

Il metodo Number::percentage restituisce la rappresentazione percentuale del valore dato come stringa:

use Illuminate\Support\Number;

$percentage = Number::percentage(10);

// 10%

$percentage = Number::percentage(10, precision: 2);

// 10.00%

$percentage = Number::percentage(10.123, maxPrecision: 2);

// 10.12%

$percentage = Number::percentage(10, precision: 2, locale: 'de');

// 10,00%

Number::spell()

Il metodo Number::spell trasforma il numero dato in una stringa di parole:

use Illuminate\Support\Number;

$number = Number::spell(102);

// cento e due

$number = Number::spell(88, locale: 'fr');

// quatre-vingt-huit

L’argomento after permette di specificare un valore oltre il quale tutti i numeri devono essere scritti in lettere:

$number = Number::spell(10, after: 10);

// 10

$number = Number::spell(11, after: 10);

// undici

L’argomento until permette di specificare un valore fino al quale tutti i numeri devono essere scritti in lettere:

$number = Number::spell(5, until: 10);

// cinque

$number = Number::spell(10, until: 10);

// 10

Number::trim()

Il metodo Number::trim elimina gli zeri finali dopo il punto decimale del numero dato:

use Illuminate\Support\Number;

$number = Number::trim(12.0);

// 12

$number = Number::trim(12.30);

// 12.3

Number::useLocale()

Il metodo Number::useLocale imposta il locale predefinito per i numeri a livello globale, influenzando il formato di numeri e valute nelle chiamate successive ai metodi della classe Number:

    use Illuminate\Support\Number;

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        Number::useLocale('de');
    }

Number::withLocale()

Il metodo Number::withLocale esegue la closure fornita con la locale specificata e poi ripristina la locale originale dopo che il callback è stato eseguito:

use Illuminate\Support\Number;

$number = Number::withLocale('de', function () {
    return Number::format(1500);
});

Number::useCurrency()

Il metodo Number::useCurrency imposta la valuta predefinita globalmente, influenzando come la valuta viene formattata dalle chiamate successive ai metodi della classe Number:

use Illuminate\Support\Number;

/**
 * Bootstrap any application services.
 */
public function boot(): void
{
    Number::useCurrency('GBP');
}

Number::withCurrency()

Il metodo Number::withCurrency esegue la closure fornita usando la valuta specificata e poi ripristina la valuta originale dopo che il callback è stato eseguito:

use Illuminate\Support\Number;

$number = Number::withCurrency('GBP', function () {
    // ...
});

Percorsi

app_path()

La funzione app_path restituisce il percorso completo della directory app della tua applicazione. Puoi anche usare la funzione app_path per generare un percorso completo a un file relativo alla directory dell’applicazione:

$path = app_path();

$path = app_path('Http/Controllers/Controller.php');

base_path()

La funzione base_path restituisce il percorso completo alla directory radice della tua applicazione. Puoi anche usare la funzione base_path per generare un percorso completo a un file specifico relativo alla directory radice del progetto:

$path = base_path();

$path = base_path('vendor/bin');

config_path()

La funzione config_path restituisce il percorso completo alla directory config della tua applicazione. Puoi anche usare la funzione config_path per generare un percorso completo a un file specifico all’interno della directory di configurazione dell’applicazione:

    $path = config_path();

    $path = config_path('app.php');

database_path()

La funzione database_path restituisce il percorso completo alla directory database della tua applicazione. Puoi anche usare la funzione database_path per generare un percorso completo a un determinato file all’interno della directory database:

$path = database_path();

$path = database_path('factories/UserFactory.php');

lang_path()

La funzione lang_path restituisce il percorso completamente qualificato alla directory lang della tua applicazione. Puoi anche usare la funzione lang_path per generare un percorso completamente qualificato a un file specifico all’interno della directory:

    $path = lang_path();

    $path = lang_path('en/messages.php');

Per impostazione predefinita, lo scheletro dell’applicazione Laravel non include la directory lang. Se desideri personalizzare i file delle lingue di Laravel, puoi pubblicarli tramite il comando Artisan lang:publish.

mix()

La funzione mix restituisce il percorso a un file Mix versionato:

$path = mix('css/app.css');

public_path()

La funzione public_path restituisce il percorso completo alla directory public della tua applicazione. Puoi anche usare la funzione public_path per generare un percorso completo a un file specifico all’interno della directory public:

$path = public_path();

$path = public_path('css/app.css');

resource_path()

La funzione resource_path restituisce il percorso completo alla directory resources della tua applicazione. Puoi anche usare la funzione resource_path per generare un percorso completo a un file specifico all’interno della directory resources:

$path = resource_path();

$path = resource_path('sass/app.scss');

storage_path()

La funzione storage_path restituisce il percorso completo alla directory storage della tua applicazione. Puoi anche usare la funzione storage_path per generare un percorso completo a un file specifico all’interno della directory di storage:

    $path = storage_path();

    $path = storage_path('app/file.txt');

URL

action()

La funzione action genera un URL per l’azione del controller specificato:

    use App\Http\Controllers\HomeController;

    $url = action([HomeController::class, 'index']);

Se il metodo accetta parametri di rotta, puoi passarli come secondo argomento del metodo:

    $url = action([UserController::class, 'profile'], ['id' => 1]);

asset()

La funzione asset genera un URL per un asset utilizzando lo schema corrente della richiesta (HTTP o HTTPS):

$url = asset('img/photo.jpg');

Puoi configurare l’host dell’URL degli asset impostando la variabile ASSET_URL nel tuo file .env. Questo può essere utile se ospiti i tuoi asset su un servizio esterno come Amazon S3 o un altro CDN:

// ASSET_URL=http://example.com/assets

$url = asset('img/photo.jpg'); // http://example.com/assets/img/photo.jpg

route()

La funzione route genera un URL per una route nominata:

    $url = route('route.name');

Se la route accetta parametri, puoi passarli come secondo argomento alla funzione:

    $url = route('route.name', ['id' => 1]);

Per impostazione predefinita, la funzione route genera un URL assoluto. Se desideri generare un URL relativo, puoi passare false come terzo argomento alla funzione:

    $url = route('route.name', ['id' => 1], false);

secure_asset()

La funzione secure_asset genera un URL per una risorsa utilizzando HTTPS:

$url = secure_asset('img/photo.jpg');

secure_url()

La funzione secure_url genera un URL HTTPS completamente qualificato per il percorso specificato. È possibile passare segmenti aggiuntivi dell’URL come secondo argomento della funzione:

    $url = secure_url('user/profile');

    $url = secure_url('user/profile', [1]);

to_route()

La funzione to_route genera una risposta HTTP di reindirizzamento per una route nominata:

return to_route('users.show', ['user' => 1]);

Se necessario, puoi passare il codice di stato HTTP da assegnare al reindirizzamento e eventuali intestazioni di risposta aggiuntive come terzo e quarto argomento al metodo to_route:

return to_route('users.show', ['user' => 1], 302, ['X-Framework' => 'Laravel']);

url()

La funzione url crea un URL completo per il percorso specificato:

$url = url('user/profile');

$url = url('user/profile', [1]);

Se non viene specificato un percorso, viene restituita un’istanza di Illuminate\Routing\UrlGenerator:

$current = url()->current();

$full = url()->full();

$previous = url()->previous();

Varie

abort()

La funzione abort lancia un’eccezione HTTP che sarà gestita dal gestore delle eccezioni:

    abort(403);

Puoi anche fornire il messaggio dell’eccezione e intestazioni HTTP personalizzate che devono essere inviate al browser:

    abort(403, 'Unauthorized.', $headers);

abort_if()

La funzione abort_if lancia un’eccezione HTTP se una determinata espressione booleana è true:

    abort_if(! Auth::user()->isAdmin(), 403);

Simile al metodo abort, puoi anche fornire il testo della risposta dell’eccezione come terzo argomento e un array di intestazioni personalizzate come quarto argomento della funzione.

abort_unless()

La funzione abort_unless lancia un’eccezione HTTP se un’espressione booleana data valuta a false:

    abort_unless(Auth::user()->isAdmin(), 403);

Come il metodo abort, puoi anche fornire il testo della risposta dell’eccezione come terzo argomento e un array di intestazioni personalizzate della risposta come quarto argomento alla funzione.

app()

La funzione app restituisce l’istanza del service container:

$container = app();

Puoi passare il nome di una classe o di un’interfaccia per ottenerla dal container:

$api = app('HelpSpot\API');

auth()

La funzione auth restituisce un’istanza di authenticator. Puoi usarla come alternativa alla facade Auth:

$user = auth()->user();

Se necessario, puoi specificare quale istanza di guard vuoi accedere:

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

back()

La funzione back genera una redirect HTTP response alla posizione precedente dell’utente:

return back($status = 302, $headers = [], $fallback = '/');

return back();

bcrypt()

La funzione bcrypt hashes il valore fornito usando Bcrypt. Puoi usare questa funzione come alternativa alla facade Hash:

    $password = bcrypt('my-secret-password');

blank()

La funzione blank determina se il valore fornito è "blank":

blank('');
blank('   ');
blank(null);
blank(collect());

// true

blank(0);
blank(true);
blank(false);

// false

Per l’inverso di blank, consulta il metodo filled.

broadcast()

La funzione broadcast broadcasts l’evento fornito ai suoi ascoltatori:

broadcast(new UserRegistered($user));

broadcast(new UserRegistered($user))->toOthers();

cache()

La funzione cache serve per ottenere valori dalla cache. Se la chiave specificata non esiste nella cache, viene restituito un valore predefinito opzionale:

$value = cache('key');

$value = cache('key', 'default');

Per aggiungere elementi alla cache, passa un array di coppie chiave/valore alla funzione. Devi anche specificare il numero di secondi o la durata per cui il valore in cache sarà considerato valido:

cache(['key' => 'value'], 300);

cache(['key' => 'value'], now()->addSeconds(10));

class_uses_recursive()

La funzione class_uses_recursive restituisce tutti i traits utilizzati da una classe, inclusi quelli usati da tutte le sue classi genitrici:

$traits = class_uses_recursive(App\Models\User::class);

collect()

La funzione collect crea un’istanza di collection dal valore fornito:

$collection = collect(['taylor', 'abigail']);

config()

La funzione config ottiene il valore di una variabile di configurazione. I valori di configurazione possono essere accessi usando la sintassi a "punti", che include il nome del file e l’opzione che si desidera ottenere. È possibile specificare un valore predefinito che verrà restituito se l’opzione di configurazione non esiste:

$value = config('app.timezone');

$value = config('app.timezone', $default);

Puoi impostare le variabili di configurazione al momento dell’esecuzione passando un array di coppie chiave/valore. Tuttavia, nota che questa funzione influisce solo sul valore di configurazione per la richiesta corrente e non aggiorna i valori di configurazione reali:

config(['app.debug' => true]);

context()

La funzione context ottiene il valore dal contesto corrente. È possibile specificare un valore di default che viene restituito se la chiave del contesto non esiste:

    $value = context('trace_id');

    $value = context('trace_id', $default);

Puoi impostare i valori del contesto passando un array di coppie chiave / valore:

    use Illuminate\Support\Str;

    context(['trace_id' => Str::uuid()->toString()]);

cookie()

La funzione cookie crea un nuovo cookie:

$cookie = cookie('name', 'value', $minutes);

csrf_field()

La funzione csrf_field crea un campo di input hidden HTML con il valore del token CSRF. Per esempio, usando la sintassi Blade:

    {{ csrf_field() }}

csrf_token()

La funzione csrf_token ottiene il valore dell’attuale token CSRF:

$token = csrf_token();

decrypt()

La funzione decrypt decifra il valore fornito. Puoi usare questa funzione come alternativa alla facade Crypt:

$password = decrypt($value);

dd()

La funzione dd fa il dump delle variabili fornite e termina l’esecuzione dello script:

dd($value);

dd($value1, $value2, $value3, ...);

Se non vuoi interrompere l’esecuzione del tuo script, usa invece la funzione dump.

dispatch()

La funzione dispatch inserisce il job nella coda di job di Laravel:

dispatch(new App\Jobs\SendEmails);

dispatch_sync()

La funzione dispatch_sync invia il job specificato alla coda sync in modo che venga elaborato immediatamente:

    dispatch_sync(new App\Jobs\SendEmails);

dump()

La funzione dump mostra le variabili fornite:

dump($value);

dump($value1, $value2, $value3, ...);

Se vuoi interrompere l’esecuzione dello script dopo aver mostrato le variabili, usa invece la funzione dd.

encrypt()

La funzione encrypt crittografa il valore fornito. Puoi usare questa funzione come alternativa al facade Crypt:

$secret = encrypt('my-secret-value');

env()

La funzione env recupera il valore di una environment variable oppure restituisce un valore predefinito:

$env = env('APP_ENV');

$env = env('APP_ENV', 'production');

Se esegui il comando config:cache durante il processo di deploy, devi assicurarti di chiamare la funzione env solo all’interno dei tuoi file di configurazione. Una volta che la configurazione è stata cacheata, il file .env non verrà caricato e tutte le chiamate alla funzione env restituiranno null.

event()

La funzione event invia l’event ai suoi listeners:

event(new UserRegistered($user));

fake()

La funzione fake recupera un singleton di Faker dal container, utile per creare dati fittizi in model factories, seeding del database, test e prototipi di viste:

@for($i = 0; $i < 10; $i++)
    <dl>
        <dt>Name</dt>
        <dd>{{ fake()->name() }}</dd>

        <dt>Email</dt>
        <dd>{{ fake()->unique()->safeEmail() }}</dd>
    </dl>
@endfor

Per impostazione predefinita, la funzione fake utilizza l’opzione di configurazione app.faker_locale nel file config/app.php. Di solito, questa opzione viene impostata tramite la variabile d’ambiente APP_FAKER_LOCALE. Puoi inoltre specificare il locale passando come parametro alla funzione fake. Ogni locale risolverà un singleton separato:

fake('nl_NL')->name()

filled()

La funzione filled determina se il valore dato non è "vuoto":

filled(0);
filled(true);
filled(false);

// true

filled('');
filled('   ');
filled(null);
filled(collect());

// false

Per l’inverso di filled, vedi il metodo blank.

info()

La funzione info scrive informazioni nel log della tua applicazione:

info('Some helpful information!');

È possibile passare anche un array di dati contestuali alla funzione:

info('User login attempt failed.', ['id' => $user->id]);

literal()

La funzione literal crea una nuova istanza di stdClass con gli argomenti nominati forniti come proprietà:

$obj = literal(
    name: 'Joe',
    languages: ['PHP', 'Ruby'],
);

$obj->name; // 'Joe'
$obj->languages; // ['PHP', 'Ruby']

logger()

La funzione logger può essere utilizzata per scrivere un messaggio di livello debug nel log:

logger('Debug message');

Puoi anche passare un array di dati contestuali alla funzione:

logger('User has logged in.', ['id' => $user->id]);

Se non viene passato alcun valore alla funzione, verrà restituita un’istanza di logger:

logger()->error('You are not allowed here.');

method_field()

La funzione method_field genera un campo input hidden HTML contenente il valore simulato del verbo HTTP del form. Ad esempio, usando la sintassi Blade:

    <form method="POST">
        {{ method_field('DELETE') }}
    </form>

now()

La funzione now crea una nuova istanza di Illuminate\Support\Carbon per l’ora attuale:

    $now = now();

old()

La funzione old recupera un valore di input precedente memorizzato nella sessione:

    $value = old('value');

    $value = old('value', 'default');

Poiché il "valore di default" fornito come secondo argomento alla funzione old è spesso un attributo di un modello Eloquent, Laravel permette di passare semplicemente l’intero modello Eloquent come secondo argomento alla funzione old. In questo modo, Laravel presumerà che il primo argomento fornito alla funzione old sia il nome dell’attributo Eloquent che deve essere considerato il "valore di default":

    {{ old('name', $user->name) }}

    // È equivalente a...

    {{ old('name', $user) }}

once()

La funzione once esegue il callback fornito e memorizza il risultato in cache nella memoria per la durata della richiesta. Eventuali chiamate successive alla funzione once con lo stesso callback restituiranno il risultato precedentemente memorizzato:

function random(): int
{
    return once(function () {
        return random_int(1, 1000);
    });
}

random(); // 123
random(); // 123 (risultato memorizzato)
random(); // 123 (risultato memorizzato)

Quando la funzione once viene eseguita all’interno di un’istanza di un oggetto, il risultato memorizzato in cache sarà unico per quell’istanza dell’oggetto:

<?php

class NumberService
{
    public function all(): array
    {
        return once(fn () => [1, 2, 3]);
    }
}

$service = new NumberService;

$service->all();
$service->all(); // (risultato memorizzato)

$secondService = new NumberService;

$secondService->all();
$secondService->all(); // (risultato memorizzato)

optional()

La funzione optional accetta qualsiasi argomento e ti permette di accedere alle proprietà o chiamare metodi su quell’oggetto. Se l’oggetto fornito è null, le proprietà e i metodi restituiranno null invece di causare un errore:

    return optional($user->address)->street;

    {!! old('name', optional($user)->name) !!}

La funzione optional accetta anche una closure come secondo argomento. La closure verrà invocata se il valore fornito come primo argomento non è null:

    return optional(User::find($id), function (User $user) {
        return $user->name;
    });

policy()

Il metodo policy ottiene un’istanza di policy per una classe specifica:

$policy = policy(App\Models\User::class);

redirect()

La funzione redirect restituisce una redirect HTTP response oppure l’istanza del redirector se viene chiamata senza argomenti:

    return redirect($to = null, $status = 302, $headers = [], $https = null);

    return redirect('/home');

    return redirect()->route('route.name');

report()

La funzione report segnala un’eccezione utilizzando il tuo gestore delle eccezioni:

    report($e);

La funzione report accetta anche una stringa come argomento. Quando viene fornita una stringa alla funzione, viene creata un’eccezione con la stringa fornita come messaggio:

    report('Something went wrong.');

report_if()

La funzione report_if segnalerà un’eccezione utilizzando il tuo exception handler se la condizione data è true:

    report_if($shouldReport, $e);

    report_if($shouldReport, 'Something went wrong.');

report_unless()

La funzione report_unless segnalerà un’eccezione utilizzando il tuo gestore delle eccezioni se la condizione data è false:

report_unless($reportingDisabled, $e);

report_unless($reportingDisabled, 'Qualcosa è andato storto.');

request()

La funzione request restituisce l’istanza attuale di request oppure ottiene il valore di un campo di input dalla richiesta corrente:

$request = request();

$value = request('key', $default);

rescue()

La funzione rescue esegue la closure fornita e cattura eventuali eccezioni che si verificano durante l’esecuzione. Tutte le eccezioni catturate saranno inviate al tuo gestore delle eccezioni; tuttavia, la richiesta continuerà a essere elaborata:

    return rescue(function () {
        return $this->method();
    });

Puoi anche passare un secondo argomento alla funzione rescue. Questo argomento sarà il valore "predefinito" che verrà restituito se si verifica un’eccezione durante l’esecuzione della closure:

    return rescue(function () {
        return $this->method();
    }, false);

    return rescue(function () {
        return $this->method();
    }, function () {
        return $this->failure();
    });

Un argomento report può essere fornito alla funzione rescue per determinare se l’eccezione deve essere segnalata tramite la funzione report:

    return rescue(function () {
        return $this->method();
    }, report: function (Throwable $throwable) {
        return $throwable instanceof InvalidArgumentException;
    });

resolve()

La funzione resolve converte un nome di classe o interfaccia fornito in un’istanza utilizzando il service container:

$api = resolve('HelpSpot\API');

response()

La funzione response crea un’istanza di response o ottiene un’istanza della response factory:

return response('Hello World', 200, $headers);

return response()->json(['foo' => 'bar'], 200, $headers);

retry()

La funzione retry tenta di eseguire la callback fornita fino a raggiungere il numero massimo di tentativi. Se la callback non lancia un’eccezione, verrà restituito il suo valore di ritorno. Se la callback lancia un’eccezione, verrà automaticamente ritentata. Se viene superato il numero massimo di tentativi, l’eccezione verrà lanciata:

    return retry(5, function () {
        // Attempt 5 times while resting 100ms between attempts...
    }, 100);

Se desideri calcolare manualmente il numero di millisecondi di attesa tra i tentativi, puoi passare una closure come terzo argomento alla funzione retry:

    use Exception;

    return retry(5, function () {
        // ...
    }, function (int $attempt, Exception $exception) {
        return $attempt * 100;
    });

Per comodità, puoi fornire un array come primo argomento alla funzione retry. Questo array verrà utilizzato per determinare quanti millisecondi attendere tra i tentativi successivi:

    return retry([100, 200], function () {
        // Sleep for 100ms on first retry, 200ms on second retry...
    });

Per ritentare solo sotto condizioni specifiche, puoi passare una closure come quarto argomento alla funzione retry:

    use Exception;

    return retry(5, function () {
        // ...
    }, 100, function (Exception $exception) {
        return $exception instanceof RetryException;
    });

session()

La funzione session può essere usata per ottenere o impostare i valori della session:

$value = session('key');

Puoi impostare valori passando un array di coppie chiave / valore alla funzione:

session(['chairs' => 7, 'instruments' => 3]);

Il session store verrà restituito se non viene passato nessun valore alla funzione:

$value = session()->get('key');

session()->put('key', $value);

tap()

La funzione tap accetta due argomenti: un $value arbitrario e una closure. Il $value verrà passato alla closure e poi restituito dalla funzione tap. Il valore restituito dalla closure non è importante:

$user = tap(User::first(), function (User $user) {
    $user->name = 'taylor';

    $user->save();
});

Se non viene passata una closure alla funzione tap, puoi chiamare qualsiasi metodo sul $value fornito. Il valore restituito dal metodo chiamato sarà sempre $value, indipendentemente da ciò che il metodo restituisce nella sua definizione. Ad esempio, il metodo update di Eloquent solitamente restituisce un intero. Tuttavia, possiamo forzare il metodo a restituire il modello stesso concatenando la chiamata al metodo update tramite la funzione tap:

$user = tap($user)->update([
    'name' => $name,
    'email' => $email,
]);

Per aggiungere un metodo tap a una classe, puoi aggiungere il trait Illuminate\Support\Traits\Tappable alla classe. Il metodo tap di questo trait accetta una Closure come unico argomento. L’istanza dell’oggetto verrà passata alla Closure e poi restituita dal metodo tap:

return $user->tap(function (User $user) {
    // ...
});

throw_if()

La funzione throw_if lancia l’eccezione fornita se una determinata espressione booleana è true:

throw_if(! Auth::user()->isAdmin(), AuthorizationException::class);

throw_if(
    ! Auth::user()->isAdmin(),
    AuthorizationException::class,
    'Non sei autorizzato ad accedere a questa pagina.'
);

throw_unless()

La funzione throw_unless lancia l’eccezione specificata se una determinata espressione booleana risulta false:

    throw_unless(Auth::user()->isAdmin(), AuthorizationException::class);
    
    throw_unless(
        Auth::user()->isAdmin(),
        AuthorizationException::class,
        'Non hai il permesso di accedere a questa pagina.'
    );

today()

La funzione today crea una nuova istanza Illuminate\Support\Carbon per la data odierna:

    $today = today();

trait_uses_recursive()

La funzione trait_uses_recursive restituisce tutti i trait utilizzati da un trait:

$traits = trait_uses_recursive(\Illuminate\Notifications\Notifiable::class);

transform()

La funzione transform esegue una closure su un valore dato se il valore non è blank e poi restituisce il valore di ritorno della closure:

$callback = function (int $value) {
    return $value * 2;
};

$result = transform(5, $callback);

// 10

Un valore predefinito o una closure può essere passato come terzo argomento alla funzione. Questo valore sarà restituito se il valore dato è blank:

$result = transform(null, $callback, 'The value is blank');

// The value is blank

validator()

La funzione validator crea una nuova istanza di validator con gli argomenti forniti. Puoi usarla come alternativa alla facade Validator:

$validator = validator($data, $rules, $messages);

value()

La funzione value restituisce il valore che le viene dato. Tuttavia, se passi un closure alla funzione, il closure verrà eseguito e il suo valore restituito sarà restituito:

    $result = value(true);

    // true

    $result = value(function () {
        return false;
    });

    // false

È possibile passare argomenti aggiuntivi alla funzione value. Se il primo argomento è un closure, i parametri aggiuntivi verranno passati al closure come argomenti, altrimenti saranno ignorati:

    $result = value(function (string $name) {
        return $name;
    }, 'Taylor');

    // 'Taylor'

view()

La funzione view recupera un’istanza di view:

    return view('auth.login');

with()

La funzione with restituisce il valore che le viene passato. Se viene fornita una closure come secondo argomento, la closure verrà eseguita e il suo valore di ritorno sarà restituito:

$callback = function (mixed $value) {
    return is_numeric($value) ? $value * 2 : 0;
};

$result = with(5, $callback);

// 10

$result = with(null, $callback);

// 0

$result = with(5, null);

// 5

when()

La funzione when restituisce il valore fornito se una condizione è vera. Altrimenti, restituisce null. Se viene passata una closure come secondo argomento alla funzione, la closure verrà eseguita e il suo risultato sarà restituito:

$value = when(true, 'Hello World');

$value = when(true, fn () => 'Hello World');

La funzione when è principalmente utile per renderizzare condizionatamente attributi HTML:

<div {!! when($condition, 'wire:poll="calculate"') !!}>
    ...
</div>

Altri Strumenti

Benchmarking

A volte potresti voler testare rapidamente le prestazioni di alcune parti della tua applicazione. In tali occasioni, puoi utilizzare la classe di supporto Benchmark per misurare il numero di millisecondi necessari al completamento delle callback fornite:

<?php

use App\Models\User;
use Illuminate\Support\Benchmark;

Benchmark::dd(fn () => User::find(1)); // 0.1 ms

Benchmark::dd([
    'Scenario 1' => fn () => User::count(), // 0.5 ms
    'Scenario 2' => fn () => User::all()->count(), // 20.0 ms
]);

Per impostazione predefinita, le callback fornite verranno eseguite una volta (una iterazione) e la loro durata verrà mostrata nel browser o nella console.

Per invocare una callback più di una volta, puoi specificare il numero di iterazioni come secondo argomento del metodo. Quando esegui una callback più volte, la classe Benchmark restituirà la media dei millisecondi necessari per eseguire la callback in tutte le iterazioni:

Benchmark::dd(fn () => User::count(), iterations: 10); // 0.5 ms

A volte, potresti voler misurare l’esecuzione di una callback ottenendo comunque il valore restituito dalla callback. Il metodo value restituirà una tupla contenente il valore restituito dalla callback e il numero di millisecondi necessari per eseguire la callback:

[$count, $duration] = Benchmark::value(fn () => User::count());

Date

Laravel include Carbon, una potente libreria per la manipolazione di date e orari. Per creare una nuova istanza di Carbon, puoi usare la funzione now. Questa funzione è disponibile globalmente nella tua applicazione Laravel:

$now = now();

Oppure, puoi creare una nuova istanza di Carbon usando la classe Illuminate\Support\Carbon:

use Illuminate\Support\Carbon;

$now = Carbon::now();

Per una discussione approfondita su Carbon e le sue funzionalità, consulta la documentazione ufficiale di Carbon.

Funzioni Deferred

Le funzioni deferred sono attualmente in beta mentre raccogliamo feedback dalla comunità.

Mentre i jobs in coda di Laravel ti permettono di mettere in coda delle attività per l’elaborazione in background, a volte potresti avere compiti semplici che vuoi differire senza configurare o mantenere un lavoratore di coda a lungo termine.

Le funzioni deferred ti permettono di posticipare l’esecuzione di una closure fino a dopo che la risposta HTTP è stata inviata all’utente, mantenendo la tua applicazione veloce e reattiva. Per differire l’esecuzione di una closure, passa semplicemente la closure alla funzione Illuminate\Support\defer:

use App\Services\Metrics;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use function Illuminate\Support\defer;

Route::post('/orders', function (Request $request) {
    // Crea ordine...

    defer(fn () => Metrics::reportOrder($order));

    return $order;
});

Per impostazione predefinita, le funzioni deferred verranno eseguite solo se la risposta HTTP, il comando Artisan o il job in coda dal quale viene invocata Illuminate\Support\defer termina con successo. Ciò significa che le funzioni deferred non saranno eseguite se una richiesta risulta in una risposta HTTP 4xx o 5xx. Se desideri che una funzione deferred venga sempre eseguita, puoi concatenare il metodo always alla tua funzione deferred:

defer(fn () => Metrics::reportOrder($order))->always();

Annullare le Funzioni Differite

Se hai bisogno di annullare una funzione differita prima che venga eseguita, puoi usare il metodo forget per cancellare la funzione per nome. Per assegnare un nome a una funzione differita, fornisci un secondo argomento alla funzione Illuminate\Support\defer:

defer(fn () => Metrics::report(), 'reportMetrics');

defer()->forget('reportMetrics');

Compatibilità delle Funzioni Deferred

Se hai aggiornato a Laravel 11.x da un’applicazione Laravel 10.x e lo scheletro della tua applicazione contiene ancora un file app/Http/Kernel.php, dovresti aggiungere il middleware InvokeDeferredCallbacks all’inizio della proprietà $middleware del kernel:

protected $middleware = [
    \Illuminate\Foundation\Http\Middleware\InvokeDeferredCallbacks::class, // [tl! add]
    \App\Http\Middleware\TrustProxies::class,
    // ...
]

Disabilitare le Funzioni Deferred nei Test

Quando scrivi i test, può essere utile disabilitare le funzioni deferred. Puoi chiamare withoutDefer nel tuo test per istruire Laravel a eseguire tutte le funzioni deferred immediatamente:

test('senza defer', function () {
    $this->withoutDefer();

    // ...
});

use Tests\TestCase;

class ExampleTest extends TestCase
{
    public function test_senza_defer(): void
    {
        $this->withoutDefer();

        // ...
    }
}

Se vuoi disabilitare le funzioni deferred per tutti i test all’interno di un test case, puoi chiamare il metodo withoutDefer dal metodo setUp nella tua classe base TestCase:

<?php

namespace Tests;

use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

abstract class TestCase extends BaseTestCase
{
    protected function setUp(): void// [tl! add:start]
    {
        parent::setUp();

        $this->withoutDefer();
    }// [tl! add:end]
}

Lotteria

La classe lotteria di Laravel può essere utilizzata per eseguire callback in base a delle probabilità stabilite. Questo può essere particolarmente utile quando si desidera eseguire il codice solo per una percentuale delle richieste in entrata:

use Illuminate\Support\Lottery;

Lottery::odds(1, 20)
    ->winner(fn () => $user->won())
    ->loser(fn () => $user->lost())
    ->choose();

Puoi combinare la classe lotteria di Laravel con altre funzionalità di Laravel. Per esempio, potresti voler segnalare solo una piccola percentuale di query lente al tuo gestore delle eccezioni. Inoltre, poiché la classe lotteria è callable, possiamo passare un’istanza della classe a qualsiasi metodo che accetta callable:

use Carbon\CarbonInterval;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Lottery;

DB::whenQueryingForLongerThan(
    CarbonInterval::seconds(2),
    Lottery::odds(1, 100)->winner(fn () => report('Querying > 2 seconds.')),
);

Testare le Lotterie

Laravel offre alcuni metodi semplici per permetterti di testare facilmente le invocazioni delle lotterie della tua applicazione:

// La lotteria vincerà sempre...
Lottery::alwaysWin();

// La lotteria perderà sempre...
Lottery::alwaysLose();

// La lotteria vincerà poi perderà e infine tornerà al comportamento normale...
Lottery::fix([true, false]);

// La lotteria tornerà al comportamento normale...
Lottery::determineResultsNormally();

Pipeline

La facade Pipeline di Laravel fornisce un modo conveniente per "inoltrare" un dato input attraverso una serie di classi invocabili, closure o callables, dando a ciascuna classe la possibilità di ispezionare o modificare l’input e invocare il prossimo callable nella pipeline:

use Closure;
use App\Models\User;
use Illuminate\Support\Facades\Pipeline;

$user = Pipeline::send($user)
            ->through([
                function (User $user, Closure $next) {
                    // ...

                    return $next($user);
                },
                function (User $user, Closure $next) {
                    // ...

                    return $next($user);
                },
            ])
            ->then(fn (User $user) => $user);

Come puoi vedere, ogni classe invocabile o closure nella pipeline riceve l’input e una closure $next. Invocare la closure $next chiamerà il prossimo callable nella pipeline. Come avrai notato, questo è molto simile al middleware.

Quando l’ultimo callable nella pipeline invoca la closure $next, verrà invocato il callable fornito al metodo then. Di solito, questo callable semplicemente restituirà l’input fornito.

Naturalmente, come discusso in precedenza, non sei limitato a fornire closure alla tua pipeline. Puoi anche fornire classi invocabili. Se viene fornito un nome di classe, la classe sarà istanziata tramite il service container di Laravel, permettendo l’iniezione delle dipendenze nella classe invocabile:

$user = Pipeline::send($user)
            ->through([
                GenerateProfilePhoto::class,
                ActivateSubscription::class,
                SendWelcomeEmail::class,
            ])
            ->then(fn (User $user) => $user);

Sleep

La classe Sleep di Laravel è un wrapper leggero attorno alle funzioni native di PHP sleep e usleep, offrendo una maggiore testabilità e una API facile da usare per lavorare con il tempo:

use Illuminate\Support\Sleep;

$waiting = true;

while ($waiting) {
    Sleep::for(1)->second();

    $waiting = /* ... */;
}

La classe Sleep offre una varietà di metodi che ti permettono di lavorare con diverse unità di tempo:

// Restituisce un valore dopo aver dormito...
$result = Sleep::for(1)->second()->then(fn () => 1 + 1);

// Dorme mentre un determinato valore è vero...
Sleep::for(1)->second()->while(fn () => shouldKeepSleeping());

// Pausa l'esecuzione per 90 secondi...
Sleep::for(1.5)->minutes();

// Pausa l'esecuzione per 2 secondi...
Sleep::for(2)->seconds();

// Pausa l'esecuzione per 500 millisecondi...
Sleep::for(500)->milliseconds();

// Pausa l'esecuzione per 5.000 microsecondi...
Sleep::for(5000)->microseconds();

// Pausa l'esecuzione fino a un determinato tempo...
Sleep::until(now()->addMinute());

// Alias della funzione nativa "sleep" di PHP...
Sleep::sleep(2);

// Alias della funzione nativa "usleep" di PHP...
Sleep::usleep(5000);

Per combinare facilmente unità di tempo, puoi usare il metodo and:

Sleep::for(1)->second()->and(10)->milliseconds();

Testing Sleep

Quando si testa il codice che utilizza la classe Sleep o le funzioni sleep native di PHP, il test interrompe l’esecuzione. Come potresti aspettarti, questo rallenta significativamente la suite di test. Ad esempio, immagina di testare il seguente codice:

$waiting = /* ... */;

$seconds = 1;

while ($waiting) {
    Sleep::for($seconds++)->seconds();

    $waiting = /* ... */;
}

Tipicamente, testare questo codice richiederebbe almeno un secondo. Fortunatamente, la classe Sleep ci permette di "fingere" il sonno in modo che la suite di test rimanga veloce:

php tab=Pest
it('waits until ready', function () {
    Sleep::fake();

    // ...
});

php tab=PHPUnit
public function test_it_waits_until_ready()
{
    Sleep::fake();

    // ...
}

Quando si finge la classe Sleep, la pausa effettiva nell’esecuzione viene bypassata, rendendo il test sostanzialmente più veloce.

Una volta che la classe Sleep è stata finta, è possibile fare delle asserzioni contro i "sleep" previsti che avrebbero dovuto verificarsi. Per illustrare questo, immaginiamo di testare un codice che pausa l’esecuzione tre volte, aumentando ogni pausa di un secondo. Usando il metodo assertSequence, possiamo verificare che il nostro codice abbia "dormito" per il tempo corretto mantenendo il test veloce:

php tab=Pest
it('checks if ready three times', function () {
    Sleep::fake();

    // ...

    Sleep::assertSequence([
        Sleep::for(1)->second(),
        Sleep::for(2)->seconds(),
        Sleep::for(3)->seconds(),
    ]);
});

php tab=PHPUnit
public function test_it_checks_if_ready_three_times()
{
    Sleep::fake();

    // ...

    Sleep::assertSequence([
        Sleep::for(1)->second(),
        Sleep::for(2)->seconds(),
        Sleep::for(3)->seconds(),
    ]);
}

Naturalmente, la classe Sleep offre una varietà di altre asserzioni che puoi utilizzare durante i test:

use Carbon\CarbonInterval as Duration;
use Illuminate\Support\Sleep;

// Verifica che sleep sia stato chiamato 3 volte...
Sleep::assertSleptTimes(3);

// Verifica la durata del sleep...
Sleep::assertSlept(function (Duration $duration): bool {
    return /* ... */;
}, times: 1);

// Verifica che la classe Sleep non sia mai stata invocata...
Sleep::assertNeverSlept();

// Verifica che, anche se Sleep è stato chiamato, non si sia verificata alcuna pausa nell'esecuzione...
Sleep::assertInsomniac();

A volte può essere utile eseguire un’azione ogni volta che si verifica un sleep finto nel codice della tua applicazione. Per ottenere ciò, puoi fornire un callback al metodo whenFakingSleep. Nel seguente esempio, utilizziamo gli helper per la manipolazione del tempo di Laravel per avanzare istantaneamente il tempo della durata di ogni sleep:

use Carbon\CarbonInterval as Duration;

$this->freezeTime();

Sleep::fake();

Sleep::whenFakingSleep(function (Duration $duration) {
    // Avanza il tempo quando si finge sleep...
    $this->travel($duration->totalMilliseconds)->milliseconds();
});

Poiché avanzare il tempo è un requisito comune, il metodo fake accetta un argomento syncWithCarbon per mantenere Carbon sincronizzato durante lo sleep all’interno di un test:

Sleep::fake(syncWithCarbon: true);

$start = now();

Sleep::for(1)->second();

$start->diffForHumans(); // 1 secondo fa

Laravel utilizza internamente la classe Sleep ogni volta che interrompe l’esecuzione. Ad esempio, l’helper retry utilizza la classe Sleep durante lo sleep, consentendo una migliore testabilità quando si utilizza questo helper.