PHPackages                             phannaly/laravel-helpers - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. phannaly/laravel-helpers

ActiveLibrary[Utility & Helpers](/categories/utility)

phannaly/laravel-helpers
========================

The PHP helpers function extract from Laravel

v1.0.3(7y ago)410.9k↓39.3%11MITPHPCI failing

Since Sep 13Pushed 6y ago1 watchersCompare

[ Source](https://github.com/phannaly/laravel-helpers)[ Packagist](https://packagist.org/packages/phannaly/laravel-helpers)[ RSS](/packages/phannaly-laravel-helpers/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (3)Dependencies (1)Versions (5)Used By (1)

The PHP helpers function extract from Laravel
=============================================

[](#the-php-helpers-function-extract-from-laravel)

[![Build Status](https://camo.githubusercontent.com/d832288dc29a9c6ea14944a46b9795418ae99199c81c4acd0d9d42770c780a10/68747470733a2f2f7472617669732d63692e6f72672f7068616e6e616c792f6c61726176656c2d68656c706572732e7376673f6272616e63683d6d6173746572)](https://travis-ci.org/phannaly/laravel-helpers) [![StyleCI](https://camo.githubusercontent.com/ce5c9d2a39f0cdd68fcca17c1edd3d07967b48faee29b34af5ddc8d0eae9ce41/68747470733a2f2f6769746875622e7374796c6563692e696f2f7265706f732f3134383636393639382f736869656c643f6272616e63683d6d6173746572)](https://github.styleci.io/repos/148669698)

This project is independently you don't need to install anything(composer) unless you want to contribute.

Most of the code extract from Laravel codebase.

Requirements
------------

[](#requirements)

- PHP 7.0 or higher

Setup
-----

[](#setup)

You don't need to install by composer if your project doesn't have it.

Just import it manually in `src` folder.

But If you want to install by composer, please follow command below

```
composer require phannaly/laravel-helpers

```

This library will load automatically after you install it. Done!, you are good to go.

Available Methods
-----------------

[](#available-methods)

### Arrays & Objects

[](#arrays--objects)

- [array\_add](#method-array-add)
- [array\_collapse](#method-array-collapse)
- [array\_divide](#method-array-divide)
- [array\_dot](#method-array-dot)
- [array\_except](#method-array-except)
- [array\_first](#method-array-first)
- [array\_flatten](#method-array-flatten)
- [array\_forget](#method-array-forget)
- [array\_get](#method-array-get)
- [array\_has](#method-array-has)
- [array\_last](#method-array-last)
- [array\_only](#method-array-only)
- [array\_pluck](#method-array-pluck)
- [array\_prepend](#method-array-prepend)
- [array\_pull](#method-array-pull)
- [array\_random](#method-array-random)
- [array\_set](#method-array-set)
- [array\_sort](#method-array-sort)
- [array\_sort\_recursive](#method-array-sort-recursive)
- [array\_where](#method-array-where)
- [array\_wrap](#method-array-wrap)
- [data\_fill](#method-data-fill)
- [data\_get](#method-data-get)
- [data\_set](#method-data-set)
- [head](#method-head)
- [last](#method-last)

### Strings

[](#strings)

- [camel\_case](#method-camel-case)
- [ends\_with](#method-ends-with)
- [kebab\_case](#method-kebab-case)
- [preg\_replace\_array](#method-preg-replace-array)
- [snake\_case](#method-snake-case)
- [starts\_with](#method-starts-with)
- [str\_after](#method-str-after)
- [str\_before](#method-str-before)
- [str\_contains](#method-str-contains)
- [str\_finish](#method-str-finish)
- [str\_is](#method-str-is)
- [str\_limit](#method-str-limit)
- [str\_random](#method-str-random)
- [str\_replace\_array](#method-str-replace-array)
- [str\_replace\_first](#method-str-replace-first)
- [str\_replace\_last](#method-str-replace-last)
- [str\_slug](#method-str-slug)
- [str\_start](#method-str-start)
- [studly\_case](#method-studly-case)
- [title\_case](#method-title-case)

Arrays & Objects
--------------------

[](#arrays--objects-1)

#### `array_add()`

[](#array_add)

The `array_add` function adds a given key / value pair to an array if the given key doesn't already exist in the array:

```
$array = array_add(['name' => 'Desk'], 'price', 100);

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

#### `array_collapse()`

[](#array_collapse)

The `array_collapse` function collapses an array of arrays into a single array:

```
$array = array_collapse([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

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

#### `array_divide()`

[](#array_divide)

The `array_divide` function returns two arrays, one containing the keys, and the other containing the values of the given array:

```
[$keys, $values] = array_divide(['name' => 'Desk']);

// $keys: ['name']

// $values: ['Desk']
```

#### `array_dot()`

[](#array_dot)

The `array_dot` function flattens a multi-dimensional array into a single level array that uses "dot" notation to indicate depth:

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

$flattened = array_dot($array);

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

#### `array_except()`

[](#array_except)

The `array_except` function removes the given key / value pairs from an array:

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

$filtered = array_except($array, ['price']);

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

#### `array_first()`

[](#array_first)

The `array_first` function returns the first element of an array passing a given truth test:

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

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

// 200
```

A default value may also be passed as the third parameter to the method. This value will be returned if no value passes the truth test:

```
$first = array_first($array, $callback, $default);
```

#### `array_flatten()`

[](#array_flatten)

The `array_flatten` function flattens a multi-dimensional array into a single level array:

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

$flattened = array_flatten($array);

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

#### `array_forget()`

[](#array_forget)

The `array_forget` function removes a given key / value pair from a deeply nested array using "dot" notation:

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

array_forget($array, 'products.desk');

// ['products' => []]
```

#### `array_get()`

[](#array_get)

The `array_get` function retrieves a value from a deeply nested array using "dot" notation:

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

$price = array_get($array, 'products.desk.price');

// 100
```

The `array_get` function also accepts a default value, which will be returned if the specific key is not found:

```
$discount = array_get($array, 'products.desk.discount', 0);

// 0
```

#### `array_has()`

[](#array_has)

The `array_has` function checks whether a given item or items exists in an array using "dot" notation:

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

$contains = array_has($array, 'product.name');

// true

$contains = array_has($array, ['product.price', 'product.discount']);

// false
```

#### `array_last()`

[](#array_last)

The `array_last` function returns the last element of an array passing a given truth test:

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

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

// 300
```

A default value may be passed as the third argument to the method. This value will be returned if no value passes the truth test:

```
$last = array_last($array, $callback, $default);
```

#### `array_only()`

[](#array_only)

The `array_only` function returns only the specified key / value pairs from the given array:

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

$slice = array_only($array, ['name', 'price']);

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

#### `array_pluck()`

[](#array_pluck)

The `array_pluck` function retrieves all of the values for a given key from an array:

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

$names = array_pluck($array, 'developer.name');

// ['Taylor', 'Abigail']
```

You may also specify how you wish the resulting list to be keyed:

```
$names = array_pluck($array, 'developer.name', 'developer.id');

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

#### `array_prepend()`

[](#array_prepend)

The `array_prepend` function will push an item onto the beginning of an array:

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

$array = array_prepend($array, 'zero');

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

If needed, you may specify the key that should be used for the value:

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

$array = array_prepend($array, 'Desk', 'name');

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

#### `array_pull()`

[](#array_pull)

The `array_pull` function returns and removes a key / value pair from an array:

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

$name = array_pull($array, 'name');

// $name: Desk

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

A default value may be passed as the third argument to the method. This value will be returned if the key doesn't exist:

```
$value = array_pull($array, $key, $default);
```

#### `array_random()`

[](#array_random)

The `array_random` function returns a random value from an array:

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

$random = array_random($array);

// 4 - (retrieved randomly)
```

You may also specify the number of items to return as an optional second argument. Note that providing this argument will return an array, even if only one item is desired:

```
$items = array_random($array, 2);

// [2, 5] - (retrieved randomly)
```

#### `array_set()`

[](#array_set)

The `array_set` function sets a value within a deeply nested array using "dot" notation:

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

array_set($array, 'products.desk.price', 200);

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

#### `array_sort()`

[](#array_sort)

The array\_sort function sorts an array by its values:

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

$sorted = array_sort($array);

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

You may also sort the array by the results of the given Closure:

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

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

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

#### `array_sort_recursive()`

[](#array_sort_recursive)

The `array_sort_recursive` function recursively sorts an array using the `sort` function for numeric sub=arrays and `ksort` for associative sub-arrays:

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

$sorted = array_sort_recursive($array);

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

```

#### `array_where()`

[](#array_where)

The `array_where` function filters an array using the given Closure:

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

$filtered = array_where($array, function ($value, $key) {
    return is_string($value);
});

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

#### `array_wrap()`

[](#array_wrap)

The `array_wrap` function wraps the given value in an array. If the given value is already an array it will not be changed:

```
$string = 'Laravel';

$array = array_wrap($string);

// ['Laravel']
```

If the given value is null, an empty array will be returned:

```
$nothing = null;

$array = array_wrap($nothing);

// []
```

#### `data_fill()`

[](#data_fill)

The `data_fill` function sets a missing value within a nested array or object using "dot" notation:

```
$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]]]
```

This function also accepts asterisks as wildcards and will fill the target accordingly:

```
$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()`

[](#data_get)

The `data_get` function retrieves a value from a nested array or object using "dot" notation:

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

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

// 100
```

The `data_get` function also accepts a default value, which will be returned if the specified key is not found:

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

// 0
```

#### `data_set()`

[](#data_set)

The `data_set` function sets a value within a nested array or object using "dot" notation:

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

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

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

This function also accepts wildcards and will set values on the target accordingly:

```
$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],
        ],
    ]
*/
```

By default, any existing values are overwritten. If you wish to only set a value if it doesn't exist, you may pass `false` as the third argument:

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

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

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

#### `head()`

[](#head)

The `head` function returns the first element in the given array:

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

$first = head($array);

// 100
```

#### `last()`

[](#last)

The `last` function returns the last element in the given array:

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

$last = last($array);

// 300
```

Strings
-------

[](#strings-1)

#### `camel_case()`

[](#camel_case)

The `camel_case` function converts the given string to `camelCase`:

```
$converted = camel_case('foo_bar');

// fooBar
```

#### `ends_with()`

[](#ends_with)

The `ends_with` function determines if the given string ends with the given value:

```
$result = ends_with('This is my name', 'name');

// true
```

#### `kebab_case()`

[](#kebab_case)

The `kebab_case` function converts the given string to `kebab-case`:

```
$converted = kebab_case('fooBar');

// foo-bar
```

#### `preg_replace_array()`

[](#preg_replace_array)

The `preg_replace_array` function replaces a given pattern in the string sequentially using an array:

```
$string = 'The event will take place between :start and :end';

$replaced = preg_replace_array('/:[a-z_]+/', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00
```

#### `snake_case()`

[](#snake_case)

The `snake_case` function converts the given string to `snake_case`:

```
$converted = snake_case('fooBar');

// foo_bar
```

#### `starts_with()`

[](#starts_with)

The `starts_with` function determines if the given string begins with the given value:

```
$result = starts_with('This is my name', 'This');

// true
```

#### `str_after()`

[](#str_after)

The `str_after` function returns everything after the given value in a string:

```
$slice = str_after('This is my name', 'This is');

// ' my name'
```

#### `str_before()`

[](#str_before)

The `str_before` function returns everything before the given value in a string:

```
$slice = str_before('This is my name', 'my name');

// 'This is '
```

#### `str_contains()`

[](#str_contains)

The `str_contains` function determines if the given string contains the given value (case sensitive):

```
$contains = str_contains('This is my name', 'my');

// true
```

You may also pass an array of values to determine if the given string contains any of the values:

```
$contains = str_contains('This is my name', ['my', 'foo']);

// true
```

#### `str_finish()`

[](#str_finish)

The `str_finish` function adds a single instance of the given value to a string if it does not already end with the value:

```
$adjusted = str_finish('this/string', '/');

// this/string/

$adjusted = str_finish('this/string/', '/');

// this/string/
```

#### `str_is()`

[](#str_is)

The `str_is` function determines if a given string matches a given pattern. Asterisks may be used to indicate wildcards:

```
$matches = str_is('foo*', 'foobar');

// true

$matches = str_is('baz*', 'foobar');

// false
```

#### `str_limit()`

[](#str_limit)

The `str_limit` function truncates the given string at the specified length:

```
$truncated = str_limit('The quick brown fox jumps over the lazy dog', 20);

// The quick brown fox...
```

You may also pass a third argument to change the string that will be appended to the end:

```
$truncated = str_limit('The quick brown fox jumps over the lazy dog', 20, ' (...)');

// The quick brown fox (...)
```

#### `str_random()`

[](#str_random)

The `str_random` function generates a random string of the specified length. This function uses PHP's `random_bytes` function:

```
$random = str_random(40);
```

#### `str_replace_array()`

[](#str_replace_array)

The `str_replace_array` function replaces a given value in the string sequentially using an array:

```
$string = 'The event will take place between ? and ?';

$replaced = str_replace_array('?', ['8:30', '9:00'], $string);

// The event will take place between 8:30 and 9:00
```

#### `str_replace_first()`

[](#str_replace_first)

The `str_replace_first` function replaces the first occurrence of a given value in a string:

```
$replaced = str_replace_first('the', 'a', 'the quick brown fox jumps over the lazy dog');

// a quick brown fox jumps over the lazy dog
```

#### `str_replace_last()`

[](#str_replace_last)

The `str_replace_last` function replaces the last occurrence of a given value in a string:

```
$replaced = str_replace_last('the', 'a', 'the quick brown fox jumps over the lazy dog');

// the quick brown fox jumps over a lazy dog
```

#### `str_slug()`

[](#str_slug)

The `str_slug` function generates a URL friendly "slug" from the given string:

```
$slug = str_slug('Laravel 5 Framework', '-');

// laravel-5-framework
```

#### `str_start()`

[](#str_start)

The `str_start` function adds a single instance of the given value to a string if it does not already start with the value:

```
$adjusted = str_start('this/string', '/');

// /this/string

$adjusted = str_start('/this/string', '/');

// /this/string
```

#### `studly_case()`

[](#studly_case)

The `studly_case` function converts the given string to `StudlyCase`:

```
$converted = studly_case('foo_bar');

// FooBar
```

#### `title_case()`

[](#title_case)

The `title_case` function converts the given string to `Title Case`:

```
$converted = title_case('a nice title uses the correct case');

// A Nice Title Uses The Correct Case
```

Contributing
------------

[](#contributing)

Feel free to contribute through PR.

See [CODE OF CONDUCT](https://github.com/phannaly/laravel-helpers/blob/master/CODE_OF_CONDUCT.md) for details.

License
-------

[](#license)

This package operates under the MIT License (MIT). See the [LICENSE](https://github.com/phannaly/laravel-helpers/blob/master/LICENSE.md) file for details.

###  Health Score

35

—

LowBetter than 80% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity29

Limited adoption so far

Community10

Small or concentrated contributor base

Maturity65

Established project with proven stability

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~0 days

Total

4

Last Release

2803d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/13119017?v=4)[phanna](/maintainers/phannaly)[@phannaly](https://github.com/phannaly)

---

Top Contributors

[![phannaly](https://avatars.githubusercontent.com/u/13119017?v=4)](https://github.com/phannaly "phannaly (40 commits)")

---

Tags

helper-functionshelpershelpers-librarylaravelphplaravelarraystringhelpers

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/phannaly-laravel-helpers/health.svg)

```
[![Health](https://phpackages.com/badges/phannaly-laravel-helpers/health.svg)](https://phpackages.com/packages/phannaly-laravel-helpers)
```

###  Alternatives

[pragmarx/ia-arr

Laravel Illuminate Agnostic Arr

553.6M12](/packages/pragmarx-ia-arr)[pragmarx/ia-str

Laravel Illuminate Agnostic Str

523.5M5](/packages/pragmarx-ia-str)[iteks/laravel-enum

A comprehensive Laravel package providing enhanced enum functionalities, including attribute handling, select array conversions, and fluent facade interactions for robust enum management in Laravel applications.

2516.7k](/packages/iteks-laravel-enum)[transprime-research/piper

PHP Pipe method execution with values from chained method executions

174.6k2](/packages/transprime-research-piper)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)