PHPackages                             dimsog/arrayhelper - 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. dimsog/arrayhelper

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

dimsog/arrayhelper
==================

ArrayHelper for PHP 5.4+

1.2.3(6y ago)32112MITPHPPHP >=5.4.0CI failing

Since Jan 30Pushed 6y ago2 watchersCompare

[ Source](https://github.com/dimsog/arrayhelper)[ Packagist](https://packagist.org/packages/dimsog/arrayhelper)[ RSS](/packages/dimsog-arrayhelper/feed)WikiDiscussions master Synced 3d ago

READMEChangelog (10)Dependencies (1)Versions (26)Used By (0)

ArrayHelper
===========

[](#arrayhelper)

ArrayHelper for PHP 5.4+

Supported PHP versions:

- PHP 5.4
- PHP 5.5
- PHP 5.6
- PHP 7.0
- PHP 7.1
- PHP 7.2
- PHP 7.3
- PHP 7.4

Install
=======

[](#install)

You can install ArrayHelper via composer:

```
composer require dimsog/arrayhelper
```

Packagist link [here](https://packagist.org/packages/dimsog/arrayhelper)

Upgrade information
===================

[](#upgrade-information)

### Upgrade from 1.2.1 to 1.2.2

[](#upgrade-from-121-to-122)

- Fluent::chunk($array, $column = 2) transformed to Fluent::chunk($column = 2)

Fluent interface
================

[](#fluent-interface)

```
ArrayHelper::fluent($sourceArray)
    ->toInt(['id', 'parent_id'])
    ->except(['some_field'])
    ->filter(['user_id' => 100])
    ->get();

// or

Arr::fluent([[1], [2], [3]])
    ->collapse()
    ->map(function($item) {
        return $item * 2;
    })
    ->get();
```

Short code
==========

[](#short-code)

You can use Arr instead ArrayHelper.

```
ArrayHelper::collapse([[1, 2, 3], [4, 5, 6]]);
// or
Arr::collapse([[1, 2, 3], [4, 5, 6]]);
```

Available methods
=================

[](#available-methods)

- [camelCaseKeys](#camel-case-keys)
- [collapse](#collapse)
- [column](#column)
- [chunk](#chunk)
- [except](#except)
- [exist](#exist)
- [filter](#filter)
- [findFirst](#find-first)
- [firstKey](#first-key)
- [getValue](#get-value)
- [has](#has)
- [ids](#ids)
- [insert](#insert)
- [isAssoc](#isassoc)
- [isMulti](#ismulti)
- [keyValue](#keyvalue)
- [lastKey](#last-key)
- [map](#map)
- [only](#only)
- [onlyWithKey](#only-with-key)
- [paginate](#paginate)
- [prepend](#prepend)
- [random](#random)
- [reindex](#reindex)
- [remove](#remove)
- [replaceKey](#replace-key)
- [set](#set)
- [shuffle](#shuffle-an-array)
- [sortBy](#sorting)
- [sortByAsc](#sorting)
- [sortByDesc](#sorting)
- [splitString](#split-string)
- [sum](#sum)
- [toArray](#to-array)
- [toInt](#toint)
- [unique](#unique)
- [values](#values)
- [wrap](#wrap)

Code examples
=============

[](#code-examples)

### Camel Case Keys

[](#camel-case-keys)

Convert snak\_case keys to camelCase

```
ArrayHelper::camelCaseKeys(array $source)
```

##### Demo:

[](#demo)

```
$data = ArrayHelper::camelCaseKeys([
    'demo_field' => 100
]);

// result ($data):
[
     'demoField' => 100
]
```

### Collapse

[](#collapse)

Collapse an array of arrays into a single array

```
ArrayHelper::collapse(array $array)
```

##### Demo:

[](#demo-1)

```
$result = ArrayHelper::collapse([[1, 2, 3], [4, 5, 6]]);
result: [1, 2, 3, 4, 5, 6]

$result = ArrayHelper::collapse([1, 2, 3, [4], [5, 6]]);
result: [1, 2, 3, 4, 5, 6]
```

### Column

[](#column)

Return the values from a single column in the input array

```
ArrayHelper::column(array $array, $key)
```

##### Demo:

[](#demo-2)

```
$array = [
    [
        'id' => 1,
        'name' => 'test1'
    ],
    [
        'id' => 2,
        'name' => 'test2'
    ]
];
ArrayHelper::column($array, 'id');
result: [1, 2]
```

### Chunk

[](#chunk)

Split an array into columns

```
ArrayHelper::chunk(array $array, $column = 2)
```

##### Demo:

[](#demo-3)

```
$array = [
    'foo' => 'bar',
    'bar' => 'baz',
    'vodka' => 'balalayka'
];
$result = ArrayHelper::chunk($array, 2)

result: [
    [
        'foo' => 'bar',
        'bar' => 'baz'
    ],
    [
        'vodka' => 'balalayka'
    ]
];
```

### Except

[](#except)

Get a subset of the items from the given array except $keys

```
ArrayHelper::except(array $array, array $keys)
```

##### Demo:

[](#demo-4)

```
ArrayHelper::except(['a', 'b', 'c'], ['a', 'b']);
result: ['c']
```

### Exist

[](#exist)

This method checks exist or not value by key, value or callable

```
ArrayHelper::exist(array $array, $condition)
```

##### Demo:

[](#demo-5)

```
ArrayHelper::exist(['a', 'b', 'c'], 'b'); // true
$array = [
    [
        'id'    => 100,
        'name'  => 'Product 1'
    ],
    [
        'id'    => 200,
        'name'  => 'Product 2'
    ],
    [
        'id'    => 300,
        'name'  => 'Product 3'
    ]
];
ArrayHelper::exist($array, ['id' => 200]); // true
ArrayHelper::exist($array, function($item) {
    return $item['id'] == 300;
});
```

### Filter

[](#filter)

Filter an array

```
ArrayHelper::filter(array $array, $condition, $preserveKeys = false)
```

##### Demo:

[](#demo-6)

```
$array = [
      [
          'id' => 1,
          'category_id' => 5,
          'name' => 'test1'
      ],
      [
          'id' => 3,
          'category_id' => 1,
          'name' => 'test3'
      ],
 ];

 ArrayHelper::filter($array, ['category_id' => 5]);
 // OR
 ArrayHelper::filter($array, function($item) {
     return $item['category_id'] == 5;
 });

 result:
 [
      [
          'id' => 1,
          'category_id' => 5,
          'name' => 'test1'
      ]
 ]
```

### Find first

[](#find-first)

Find a first array item from an array

```
ArrayHelper::findFirst(array $array, $condition)
```

##### Demo:

[](#demo-7)

```
$array = [
    [
        'id' => 1,
        'foo' => 'bar'
    ],
    [
        'id' => 2,
        'foo' => 'baz'
    ],
    [
        'id' => 3,
        'foo' => 'baz'
    ]
];

// find a first element using callback:
ArrayHelper::findFirst($array, function($element) {
    return $element['foo'] == 'baz';
});
result:
[
    'id'    => 2,
    'foo'   => 'baz'
]

// find a first element using array condition:
ArrayHelper::findFirst($array, ['foo' => 'baz']);
result:
[
    'id'    => 2,
    'foo'   => 'baz'
]
```

### First key

[](#first-key)

Get the first key of the given array

```
ArrayHelper::firstKey(array $array)
```

##### Demo:

[](#demo-8)

```
$array = [
    'a' => 1,
    'b' => 2,
    'c' => 3
];
ArrayHelper::firstKey($array);
// result: 'a'
```

### Insert

[](#insert)

Insert a new column to exist array

```
ArrayHelper::insert(&$array, $key, $value = null)
```

##### Demo:

[](#demo-9)

```
$array = [
    'id' => 1,
    'name' => 'Dmitry R'
];
ArrayHelper::insert($array, 'country', 'Russia');
result:
[
    'id' => 1,
    'name' => 'Dmitry R',
    'country' => 'Russia'
]
```

```
$array = [
    [
        'id' => 1,
        'name' => 'Dmitry R'
    ],
    [
        'id' => 1,
        'name' => 'Dmitry R'
    ]
];
ArrayHelper::insert($array, 'foo', 'bar');
result:
[
    [
        'id' => 1,
        'name' => 'Dmitry R',
        'foo' => 'bar'
    ],
    [
        'id' => 1,
        'name' => 'Dmitry R',
        'foo' => 'bar'
    ]
]
```

### Get value

[](#get-value)

Retrieves the value of an array. You may also use stdClass instead array.

```
ArrayHelper::getValue($array, $key, $defaultValue = null)
ArrayHelper::get($array, $key, $defaultValue = null)
```

##### Demo:

[](#demo-10)

```
ArrayHelper::getValue($user, 'id');

// with callback default value
ArrayHelper::getValue($user, 'name', function() {
     return "Dmitry R";
});

// Retrivies the value of a sub-array
$user = [
    'photo' => [
        'big'   => '/path/to/image.jpg'
    ]
]
ArrayHelper::getValue($user, 'photo.big');

// Retrivies the value of a stdClass
$user = json_decode($userJsonString);
ArrayHelper::getValue($user, 'photo.big');
```

### has

[](#has)

This method checks a given key exist in an array. You may use dot notation.

```
ArrayHelper::has(array $array, $key)
```

##### Demo:

[](#demo-11)

```
$array = [
    'foo' => [
        'bar' => 10
    ]
];
ArrayHelper::has($array, 'foo.bar')
// true
```

```
$array = [
    'foo' => [
        'bar' => [0, 1, 2, 'a']
    ]
];
ArrayHelper::has($array, 'foo.bar.1')
// true
```

### Ids

[](#ids)

This method will return all of id values from the input array. This is alias for ArrayHelper::column($array, 'id');

```
ArrayHelper::ids($array)
```

##### Demo:

[](#demo-12)

```
$array = [
    [
        'id' => 1,
        'name' => 'test1'
    ],
    [
        'id' => 2,
        'name' => 'test2'
    ]
];
ArrayHelper::ids($array);
result: [1, 2]
```

### isAssoc

[](#isassoc)

Determine whether array is assoc or not

```
ArrayHelper::isAssoc(array $array)
```

##### Demo:

[](#demo-13)

```
ArrayHelper::isAssoc([1, 2, 3]);
result: false

ArrayHelper::isAssoc(['foo' => 'bar']);
result: true
```

### isMulti

[](#ismulti)

Check if an array is multidimensional

```
ArrayHelper::isMulti(array $array, $strongCheck = false)
```

```
$array = [
    ['foo' => 'bar'],
    ['foo' => 'bar']
];
ArrayHelper::isMulti($array);
```

### KeyValue

[](#keyvalue)

Convert a multidimensional array to key-value array

```
ArrayHelper::keyValue(array $items, $keyField = 'key', $valueField = 'value')
```

##### Demo:

[](#demo-14)

```
$array = [
    [
        'key' => 'name',
        'value' => 'Dmitry'
    ],
    [
        'key' => 'country',
        'value' => 'Russia'
    ],
    [
        'key' => 'city',
        'value' => 'Oryol (eagle)'
    ]
];

$array = ArrayHelper::keyValue($array, 'key', 'value');

result:
[
    'name' => 'Dmitry',
    'country' => 'Russia',
    'city' => 'Oryol (eagle)'
];
```

### Last key

[](#last-key)

Get the last key of the given array

```
ArrayHelper::lastKey($array)
```

##### Demo:

[](#demo-15)

```
$array = [
    'a' => 1,
    'b' => 2,
    'c' => 3
];
ArrayHelper::lastKey($array);
// result: 'c'
```

### Map

[](#map)

Applies the callback to the elements of the given array

```
ArrayHelper::map($array, \Closure $callback)
```

##### Demo:

[](#demo-16)

```
ArrayHelper::map($array, function($item) {
    return $item;
});
```

### Only

[](#only)

Get a subset of the items from the given array

```
ArrayHelper::only(array $array, array $keys)
```

##### Demo:

[](#demo-17)

```
ArrayHelper::only(['a', 'b', 'c'], ['a', 'b']);
result: ['a', 'b'];
```

With assoc array:

```
$array = [
    'foo'   => 'bar',
    'foo2'  => 'bar2',
    'foo3'  => 'bar3'
];
ArrayHelper::only($array, ['foo2']);

result:
[
    'foo2' => 'bar2'
]
```

With multi array:

```
$array = [
    [
        'foo' => 'bar',
        'foo2' => 'bar2'
    ],
    [
        'foo' => 'bar',
        'foo2' => 'bar2'
    ]
];
ArrayHelper::only($array, ['foo']);
result:
[
    ['foo' => 'bar'],
    ['foo' => 'bar']
]
```

With assoc array:

```
$array = [
    'foo' => 'bar',
    'foo2' => 'bar2'
];
ArrayHelper::except($array, ['foo2']);
result: ['foo' => 'bar']
```

With multi array:

```
$array = [
     [
         'foo' => 'bar',
         'foo2' => 'bar2'
     ],
     [
         'foo' => 'bar',
         'foo2' => 'bar2'
     ]
];
ArrayHelper::except($array, ['foo2']);
result:
[
  ['foo' => 'bar'],
  ['foo' => 'bar']
]
```

### Only with key

[](#only-with-key)

Get a subset of the items from the given array with key $key

```
ArrayHelper::onlyWithKey(array $array, $key)
```

##### Demo:

[](#demo-18)

```
$array = [
    [
        'a' => 1,
        'b' => 2
    ],
    [
        'a' => 1,
        'b' => 2
    ],
    [
        'b' => 2
    ]
];

ArrayHelper::onlyWithKey($array, 'a');
// result:
[
    [
        'a' => 1,
        'b' => 2
    ],
    [
        'a' => 1,
        'b' => 2
    ]
]
```

### Paginate

[](#paginate)

Extract a slice of the array

```
ArrayHelper::paginate(array $array, $page, $limit)
```

##### Demo:

[](#demo-19)

```
$array = [1, 2, 3, 4, 5, 6];
ArrayHelper::paginate($array, 1, 3)
result: [1, 2, 3]
```

### Prepend

[](#prepend)

This method will push an item on the beginning of an array.

```
ArrayHelper::prepend(&$array, $keyOrValue, $value = null)
```

##### Demo:

[](#demo-20)

```
$array = [
    1, 2, 3, 4
];
ArrayHelper::prepend($array, -1);
result:
[-1, 1, 2, 3, 4]

$array = [
    'foo' => 'bar'
];
ArrayHelper::prepend($array, 'test', 123);
result:
[
    'test' => 123,
    'foo' => 'bar'
];
```

### Random

[](#random)

Pick one or more random elements out of an array

```
ArrayHelper::random(array $array, $count = 1)
```

##### Demo:

[](#demo-21)

```
ArrayHelper::random([1, 2, 3])
result: 1 or 2 or 3

ArrayHelper::random([1, 2, 3], 2);
result: [1, 3]
```

### Reindex

[](#reindex)

Reindex all the keys of an array

```
ArrayHelper::reindex($array)
```

##### Demo:

[](#demo-22)

```
$array = [
    1 => 10,
    2 => 20
];
ArrayHelper::reindex($array);
result: [10, 20]
```

### Remove

[](#remove)

Removes a given key (or keys) from an array using dot notation

```
ArrayHelper::remove(array &$array, $keys)
```

##### Demo:

[](#demo-23)

Simple example 1:

```
$array = [
    'foo' => [
        'bar' => 'baz'
    ],
    'foo1' => 123
];
ArrayHelper::remove($array, 'foo.bar');

// result:
[
    'foo' => [],
    'foo1' => 123
]
```

Simple example 2:

```
$array = [
    [
        'foo' => 'bar',
        'test' => 'test1'
    ],
    [
        'foo' => 'bar',
        'test' => 'test2'
    ]
];
ArrayHelper::remove($array, 'foo');

// result:
[
    ['test' => 'test1'],
    ['test' => 'test2']
]
```

Advanced example:

```
$array = [
    [
        'foo' => [
            'bar' => [
                'baz' => 1
            ]
        ],
        'test' => 'test',
        'test2' => '123',
        'only' => true
    ],
    [
        'foo' => [
            'bar' => [
                'baz' => 2
            ]
        ],
        'test' => 'test',
        'test2' => 123
    ]
];

ArrayHelper::remove($array, ['foo.bar.baz', 'test', 'only']);
// result:
[
    [
        'foo' => [
            'bar' => []
        ],
        'test2' => '123'
    ],
    [
        'foo' => [
            'bar' => []
        ],
        'test2' => 123
    ]
]
```

### Replace key

[](#replace-key)

Replace the key from an array.

```
ArrayHelper::replaceKey($oldKey, $newKey, &$array)
```

##### Demo:

[](#demo-24)

```
$array = [
     'foo' => 'bar'
];

ArrayHelper::replaceKey('foo', 'baz', $array);

// result ($array):
[
     'baz' => 'bar'
]
```

### Set

[](#set)

Set a value into an array using "dot" notation

```
ArrayHelper::set(array &$array, $key, $value)
```

##### Demo:

[](#demo-25)

```
$array = [
    'product' => [
        'name' => 'Some name',
        'price' => 500
    ]
];
ArrayHelper::set($array, 'product.price', 600);
```

### Shuffle an array

[](#shuffle-an-array)

```
ArrayHelper::shuffle(array $array)
```

##### Demo:

[](#demo-26)

```
ArrayHelper::shuffle([1, 2, 3]);
result: [3, 1, 2]
```

### Sorting

[](#sorting)

These methods sort arrays

```
ArrayHelper::sortBy(array $array, $key = null, $direction = 'ASC');
ArrayHelper::sortByAsc(array $array, $key = null);
ArrayHelper::sortByDesc(array $array, $key = null);
```

##### Demo

[](#demo-27)

```
$array = [
    ['id' => 1],
    ['id' => 10]
];

$result = ArrayHelper::sortByDesc($array, 'id');
result:
[
    ['id' => 10],
    ['id' => 1]
];
```

### Split string

[](#split-string)

Split a given string to array

```
ArrayHelper::splitString($str)
```

##### Demo:

[](#demo-28)

```
$string = 'Ab Cd';
ArrayHelper::splitString($string);
result: ['A', 'b', ' ', 'C', 'd']
```

### Sum

[](#sum)

Calculate the sum of values in an array with a specific key

```
ArrayHelper::sum(array $array, $key)
```

```
$array = [
    [
        'name' => 'entity1',
        'total' => 5
    ],
    [
        'name' => 'entity2',
        'total' => 6
    ]
];
$result = ArrayHelper::sum($array, 'total');
// result: 11
```

### To array

[](#to-array)

Convert a mixed data to array recursively

#### Demo:

[](#demo-29)

```
ArrayHelper::toArray([stdClassInstance, stdClassInstance, someMixedClass]);
```

```
ArrayHelper::toArray('{"foo":{"bar":123}}');
```

##### Crazy example:

[](#crazy-example)

```
class SimpleClass
{
    public $test = null;

    public function __construct()
    {
        $std = new \stdClass();
        $std->f = (new \stdClass());
        $std->f->b = [1, 2];
        $this->test = [$std, ['a', 'b']];
    }
}

class SimpleIteratorTestClass implements \Iterator
{
    // ...
    private $array = [];

    public function __construct()
    {
        $this->position = 0;
        $std = new \stdClass();
        $std->f = (new \stdClass());
        $std->f->b = [1, 2];
        $this->array = [1, 2, 3, 4, 'asd', $std, new SimpleClass(), ['yeah' => [1, 2]]];
    }

    // ...
}
ArrayHelper::toArray(new SimpleIteratorTestClass());

result:
[
    1, 2, 3, 4, 'asd',
    [
        'f' => [
            'b' => [1, 2]
        ]
    ],
    [
        'test' => [
            [
                'f' => [
                    'b' => [1, 2]
                ]
            ],
            [
                'a', 'b'
            ]
        ]
    ],
    [
        'yeah' => [1, 2]
    ]
]
```

### toInt

[](#toint)

Transform some properties to int

```
ArrayHelper::toInt(array $source, array $keys = [])
```

##### Demo:

[](#demo-30)

```
$source = [
    "id" => "100",
    "created_at" => "10000",
    "name" => "Foo Bar"
];

$source = ArrayHelper::toInt($source, ["id" "created_at"]);

// result:
[
    "id" => 100,
    "created_at" => 10000,
    "name" => "Foo Bar"
]

// Convert all values:
$source = ArrayHelper::toInt($source);

// Since 1.1.0
$source = [
    [
        'id' => '100',
        'created_at' => '1000',
        'name' => 'FooBar',
        'other' => '200'
    ],
    [
        'id' => '200',
        'created_at' => '2000',
        'name' => 'FooBar',
        'other' => '300'
    ]
];
ArrayHelper::toInt($source, ['id', 'created_at', 'other']);
```

### Unique

[](#unique)

Removes duplicate values from an array

```
ArrayHelper::unique(array $array, $key = null)
```

##### Demo:

[](#demo-31)

```
$array = [
    'a', 'a', 'b', 'b'
];
$array = ArrayHelper::unique($array);
// result:
['a', 'b']
```

```
$array = [
    ['a', 'a', 'b', 'b'],
    ['a', 'a', 'b', 'b']
];
$array = ArrayHelper::unique($array);

// result:
[
    ['a', 'b'],
    ['a', 'b']
]
```

```
$array = [
    [
        'id' => 100,
        'name' => 'Product 1'
    ],
    [
        'id' => 200,
        'name' => 'Product 2'
    ],
    [
        'id' => 100,
        'name' => 'Product 3'
    ],
    [
        'name' => 'Product 4'
    ]
];
$array = ArrayHelper::unique($array, 'id');
// result:
[
    [
        'id' => 100,
        'name' => 'Product 1'
    ],
    [
        'id' => 200,
        'name' => 'Product 2'
    ]
]
```

### Values

[](#values)

Flattens a multidimensional array into an single (flat) array

```
ArrayHelper::values(array $array)
```

##### Demo:

[](#demo-32)

```
$array = [
    'name' => 'Dmitry R',
    'country' => 'Russia',
    'skills' => ['PHP', 'JS'],
    [
        'identifier' => 'vodka medved balalayka'
    ]
];
ArrayHelper::values($array);
// result:
['Dmitry R', 'Russia', 'PHP', 'JS', 'vodka medved balalayka'];
```

### Wrap

[](#wrap)

Wrap a value to array

```
ArrayHelper::wrap($value)
```

##### Demo:

[](#demo-33)

```
ArrayHelper::wrap('123');
// result: ['123']
```

###  Health Score

31

—

LowBetter than 68% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity17

Limited adoption so far

Community9

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 ~13 days

Recently: every ~52 days

Total

24

Last Release

2344d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/749a4498fe922187690a19e92ef1f20e95a8f173217cee00dd18c2ec0e6e990d?d=identicon)[dimsog](/maintainers/dimsog)

---

Top Contributors

[![dimsog](https://avatars.githubusercontent.com/u/904958?v=4)](https://github.com/dimsog "dimsog (116 commits)")

---

Tags

arrayarrayhelper

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/dimsog-arrayhelper/health.svg)

```
[![Health](https://phpackages.com/badges/dimsog-arrayhelper/health.svg)](https://phpackages.com/packages/dimsog-arrayhelper)
```

###  Alternatives

[doctrine/collections

PHP Doctrine Collections library that adds additional functionality on top of PHP arrays.

6.0k411.1M1.2k](/packages/doctrine-collections)[symfony/property-access

Provides functions to read and write from/to an object or array using a simple string notation

2.8k295.3M2.5k](/packages/symfony-property-access)[nette/utils

🛠 Nette Utils: lightweight utilities for string & array manipulation, image handling, safe JSON encoding/decoding, validation, slug or strong password generating etc.

2.1k394.3M1.5k](/packages/nette-utils)[league/config

Define configuration arrays with strict schemas and access values with dot notation

564302.2M24](/packages/league-config)[cuyz/valinor

Dependency free PHP library that helps to map any input into a strongly-typed structure.

1.5k9.2M108](/packages/cuyz-valinor)[aimeos/map

Easy and elegant handling of PHP arrays as array-like collection objects similar to jQuery and Laravel Collections

4.2k412.9k11](/packages/aimeos-map)

PHPackages © 2026

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