PHPackages                             nguyenanhung/30-seconds-of-php-code - 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. nguyenanhung/30-seconds-of-php-code

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

nguyenanhung/30-seconds-of-php-code
===================================

A curated collection of useful PHP snippets that you can understand in 30 seconds or less.

v1.0.2.14(1y ago)11731MITPHP

Since Oct 30Pushed 1y agoCompare

[ Source](https://github.com/nguyenanhung/30-seconds-of-php-code)[ Packagist](https://packagist.org/packages/nguyenanhung/30-seconds-of-php-code)[ RSS](/packages/nguyenanhung-30-seconds-of-php-code/feed)WikiDiscussions master Synced today

READMEChangelog (10)Dependencies (11)Versions (18)Used By (0)

[![Logo](/logo.png)](/logo.png)

30 seconds of php code
======================

[](#30-seconds-of-php-code)

> A curated collection of useful PHP snippets that you can understand in 30 seconds or less.

Note: This project is inspired by [30 Seconds of Code](https://github.com/Chalarangelo/30-seconds-of-code), but there is no affiliation with that project.

Table of Contents
-----------------

[](#table-of-contents)

### 📚 Array

[](#-array)

View contents- [`all`](#all)
- [`any`](#any)
- [`chunk`](#chunk)
- [`deepFlatten`](#deepflatten)
- [`drop`](#drop)
- [`findLast`](#findlast)
- [`findLastIndex`](#findlastindex)
- [`flatten`](#flatten)
- [`groupBy`](#groupby)
- [`hasDuplicates`](#hasduplicates)
- [`head`](#head)
- [`last`](#last)
- [`pluck`](#pluck)
- [`pull`](#pull)
- [`reject`](#reject)
- [`remove`](#remove)
- [`tail`](#tail)
- [`take`](#take)
- [`without`](#without)
- [`orderBy`](#orderby)

### ➗ Math

[](#-math)

View contents- [`average`](#average)
- [`factorial`](#factorial)
- [`fibonacci`](#fibonacci)
- [`gcd`](#gcd)
- [`isEven`](#iseven)
- [`isPrime`](#isprime)
- [`lcm`](#lcm)
- [`median`](#median)
- [`maxN`](#maxn)
- [`minN`](#minn)
- [`approximatelyEqual`](#approximatelyequal)
- [`clampNumber`](#clampnumber)

### 📜 String

[](#-string)

View contents- [`endsWith`](#endswith)
- [`firstStringBetween`](#firststringbetween)
- [`isAnagram`](#isanagram)
- [`isLowerCase`](#islowercase)
- [`isUpperCase`](#isuppercase)
- [`palindrome`](#palindrome)
- [`startsWith`](#startswith)
- [`countVowels`](#countvowels)
- [`decapitalize`](#decapitalize)
- [`isContains`](#iscontains)

### 🎛️ Function

[](#️-function)

View contents- [`compose`](#compose)
- [`memoize`](#memoize)
- [`curry`](#curry)
- [`once`](#once)
- [`variadicFunction`](#variadicfunction)

---

📚 Array
-------

[](#-array-1)

### all

[](#all)

Returns `true` if the provided function returns `true` for all elements of an array, `false` otherwise.

```
function all($items, $func)
{
    return count(array_filter($items, $func)) === count($items);
}
```

Examples```
all([2, 3, 4, 5], function ($item) {
    return $item > 1;
}); // true
```

[⬆ Back to top](#table-of-contents)

### any

[](#any)

Returns `true` if the provided function returns `true` for at least one element of an array, `false` otherwise.

```
function any($items, $func)
{
    return count(array_filter($items, $func)) > 0;
}
```

Examples```
any([1, 2, 3, 4], function ($item) {
    return $item < 2;
}); // true
```

[⬆ Back to top](#table-of-contents)

### chunk

[](#chunk)

Chunks an array into smaller arrays of a specified size.

```
function chunk($items, $size)
{
    return array_chunk($items, $size);
}
```

Examples```
chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
```

[⬆ Back to top](#table-of-contents)

### deepFlatten

[](#deepflatten)

Deep flattens an array.

```
function deepFlatten($items)
{
    $result = [];
    foreach ($items as $item) {
        if (!is_array($item)) {
            $result[] = $item;
        } else {
            $result = array_merge($result, deepFlatten($item));
        }
    }

    return $result;
}
```

Examples```
deepFlatten([1, [2], [[3], 4], 5]); // [1, 2, 3, 4, 5]
```

[⬆ Back to top](#table-of-contents)

### drop

[](#drop)

Returns a new array with `n` elements removed from the left.

```
function drop($items, $n = 1)
{
    return array_slice($items, $n);
}
```

Examples```
drop([1, 2, 3]); // [2,3]
drop([1, 2, 3], 2); // [3]
```

[⬆ Back to top](#table-of-contents)

### findLast

[](#findlast)

Returns the last element for which the provided function returns a truthy value.

```
function findLast($items, $func)
{
    $filteredItems = array_filter($items, $func);

    return array_pop($filteredItems);
}
```

Examples```
findLast([1, 2, 3, 4], function ($n) {
    return ($n % 2) === 1;
});
// 3
```

[⬆ Back to top](#table-of-contents)

### findLastIndex

[](#findlastindex)

Returns the index of the last element for which the provided function returns a truthy value.

```
function findLastIndex($items, $func)
{
    $keys = array_keys(array_filter($items, $func));

    return array_pop($keys);
}
```

Examples```
findLastIndex([1, 2, 3, 4], function ($n) {
    return ($n % 2) === 1;
});
// 2
```

[⬆ Back to top](#table-of-contents)

### flatten

[](#flatten)

Flattens an array up to the one level depth.

```
function flatten($items)
{
    $result = [];
    foreach ($items as $item) {
        if (!is_array($item)) {
            $result[] = $item;
        } else {
            $result = array_merge($result, array_values($item));
        }
    }

    return $result;
}
```

Examples```
flatten([1, [2], 3, 4]); // [1, 2, 3, 4]
```

[⬆ Back to top](#table-of-contents)

### groupBy

[](#groupby)

Groups the elements of an array based on the given function.

```
function groupBy($items, $func)
{
    $group = [];
    foreach ($items as $item) {
        if ((!is_string($func) && is_callable($func)) || function_exists($func)) {
            $key = call_user_func($func, $item);
            $group[$key][] = $item;
        } elseif (is_object($item)) {
            $group[$item->{$func}][] = $item;
        } elseif (isset($item[$func])) {
            $group[$item[$func]][] = $item;
        }
    }

    return $group;
}
```

Examples```
groupBy(['one', 'two', 'three'], 'strlen'); // [3 => ['one', 'two'], 5 => ['three']]
```

[⬆ Back to top](#table-of-contents)

### hasDuplicates

[](#hasduplicates)

Checks a flat list for duplicate values. Returns `true` if duplicate values exists and `false` if values are all unique.

```
function hasDuplicates($items)
{
    return count($items) > count(array_unique($items));
}
```

Examples```
hasDuplicates([1, 2, 3, 4, 5, 5]); // true
```

[⬆ Back to top](#table-of-contents)

### head

[](#head)

Returns the head of a list.

```
function head($items)
{
    return reset($items);
}
```

Examples```
head([1, 2, 3]); // 1
```

[⬆ Back to top](#table-of-contents)

### last

[](#last)

Returns the last element in an array.

```
function last($items)
{
    return end($items);
}
```

Examples```
last([1, 2, 3]); // 3
```

[⬆ Back to top](#table-of-contents)

### pluck

[](#pluck)

Retrieves all of the values for a given key:

```
function pluck($items, $key)
{
    return array_map( function($item) use ($key) {
        return is_object($item) ? $item->$key : $item[$key];
    }, $items);
}
```

Examples```
pluck([
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
], 'name');
// ['Desk', 'Chair']
```

[⬆ Back to top](#table-of-contents)

### pull

[](#pull)

Mutates the original array to filter out the values specified.

```
function pull(&$items, ...$params)
{
    $items = array_values(array_diff($items, $params));
    return $items;
}
```

Examples```
$items = ['a', 'b', 'c', 'a', 'b', 'c'];
pull($items, 'a', 'c'); // $items will be ['b', 'b']
```

[⬆ Back to top](#table-of-contents)

### reject

[](#reject)

Filters the collection using the given callback.

```
function reject($items, $func)
{
    return array_values(array_diff($items, array_filter($items, $func)));
}
```

Examples```
reject(['Apple', 'Pear', 'Kiwi', 'Banana'], function ($item) {
    return strlen($item) > 4;
}); // ['Pear', 'Kiwi']
```

[⬆ Back to top](#table-of-contents)

### remove

[](#remove)

Removes elements from an array for which the given function returns false.

```
function remove($items, $func)
{
    $filtered = array_filter($items, $func);

    return array_diff_key($items, $filtered);
}
```

Examples```
remove([1, 2, 3, 4], function ($n) {
    return ($n % 2) === 0;
});
// [0 => 1, 2 => 3]
```

[⬆ Back to top](#table-of-contents)

### tail

[](#tail)

Returns all elements in an array except for the first one.

```
function tail($items)
{
    return count($items) > 1 ? array_slice($items, 1) : $items;
}
```

Examples```
tail([1, 2, 3]); // [2, 3]
```

[⬆ Back to top](#table-of-contents)

### take

[](#take)

Returns an array with n elements removed from the beginning.

```
function take($items, $n = 1)
{
    return array_slice($items, 0, $n);
}
```

Examples```
take([1, 2, 3], 5); // [1, 2, 3]
take([1, 2, 3, 4, 5], 2); // [1, 2]
```

[⬆ Back to top](#table-of-contents)

### without

[](#without)

Filters out the elements of an array, that have one of the specified values.

```
function without($items, ...$params)
{
    return array_values(array_diff($items, $params));
}
```

Examples```
without([2, 1, 2, 3], 1, 2); // [3]
```

[⬆ Back to top](#table-of-contents)

### orderBy

[](#orderby)

Sorts a collection of arrays or objects by key.

```
function orderBy($items, $attr, $order)
{
    $sortedItems = [];
    foreach ($items as $item) {
        $key = is_object($item) ? $item->{$attr} : $item[$attr];
        $sortedItems[$key] = $item;
    }
    if ($order === 'desc') {
        krsort($sortedItems);
    } else {
        ksort($sortedItems);
    }

    return array_values($sortedItems);
}
```

Examples```
orderBy(
    [
        ['id' => 2, 'name' => 'Joy'],
        ['id' => 3, 'name' => 'Khaja'],
        ['id' => 1, 'name' => 'Raja']
    ],
    'id',
    'desc'
); // [['id' => 3, 'name' => 'Khaja'], ['id' => 2, 'name' => 'Joy'], ['id' => 1, 'name' => 'Raja']]
```

[⬆ Back to top](#table-of-contents)

---

➗ Math
------

[](#-math-1)

### average

[](#average)

Returns the average of two or more numbers.

```
function average(...$items)
{
    return count($items) === 0 ? 0 : array_sum($items) / count($items);
}
```

Examples```
average(1, 2, 3); // 2
```

[⬆ Back to top](#table-of-contents)

### factorial

[](#factorial)

Calculates the factorial of a number.

```
function factorial($n)
{
    if ($n  2) {
        return array_reduce($numbers, 'gcd');
    }

    $r = $numbers[0] % $numbers[1];
    return $r === 0 ? abs($numbers[1]) : gcd($numbers[1], $r);
}
```

Examples```
gcd(8, 36); // 4
gcd(12, 8, 32); // 4
```

[⬆ Back to top](#table-of-contents)

### isEven

[](#iseven)

Returns `true` if the given number is even, `false` otherwise.

```
function isEven($number)
{
    return ($number % 2) === 0;
}
```

Examples```
isEven(4); // true
```

[⬆ Back to top](#table-of-contents)

### isPrime

[](#isprime)

Checks if the provided integer is a prime number.

```
function isPrime($number)
{
    $boundary = floor(sqrt($number));
    for ($i = 2; $i = 2;
}
```

Examples```
isPrime(3); // true
```

[⬆ Back to top](#table-of-contents)

### lcm

[](#lcm)

Returns the least common multiple of two or more numbers.

```
function lcm(...$numbers)
{
    $ans = $numbers[0];
    for ($i = 1; $i < count($numbers); $i++) {
        $ans = ((($numbers[$i] * $ans)) / (gcd($numbers[$i], $ans)));
    }

    return $ans;
}
```

Examples```
lcm(12, 7); // 84
lcm(1, 3, 4, 5); // 60
```

[⬆ Back to top](#table-of-contents)

### median

[](#median)

Returns the median of an array of numbers.

```
function median($numbers)
{
    sort($numbers);
    $totalNumbers = count($numbers);
    $mid = floor($totalNumbers / 2);

    return ($totalNumbers % 2) === 0 ? ($numbers[$mid - 1] + $numbers[$mid]) / 2 : $numbers[$mid];
}
```

Examples```
median([1, 3, 3, 6, 7, 8, 9]); // 6
median([1, 2, 3, 6, 7, 9]); // 4.5
```

[⬆ Back to top](#table-of-contents)

### maxN

[](#maxn)

Returns the n maximum elements from the provided array.

```
function maxN($numbers)
{
    $maxValue = max($numbers);
    $maxValueArray = array_filter($numbers, function ($value) use ($maxValue) {
        return $maxValue === $value;
    });

    return count($maxValueArray);
}
```

Examples```
maxN([1, 2, 3, 4, 5, 5]); // 2
maxN([1, 2, 3, 4, 5]); // 1
```

[⬆ Back to top](#table-of-contents)

### minN

[](#minn)

Returns the n minimum elements from the provided array.

```
function minN($numbers)
{
    $minValue = min($numbers);
    $minValueArray = array_filter($numbers, function ($value) use ($minValue) {
        return $minValue === $value;
    });

    return count($minValueArray);
}
```

Examples```
minN([1, 1, 2, 3, 4, 5, 5]); // 2
minN([1, 2, 3, 4, 5]); // 1
```

[⬆ Back to top](#table-of-contents)

### approximatelyEqual

[](#approximatelyequal)

Checks if two numbers are approximately equal to each other.

Use abs() to compare the absolute difference of the two values to epsilon. Omit the third parameter, epsilon, to use a default value of 0.001.

```
function approximatelyEqual($number1, $number2, $epsilon = 0.001)
{
    return abs($number1 - $number2) < $epsilon;
}
```

Examples```
approximatelyEqual(10.0, 10.00001); // true

approximatelyEqual(10.0, 10.01); // false
```

[⬆ Back to top](#table-of-contents)

### clampNumber

[](#clampnumber)

Clamps num within the inclusive range specified by the boundary values a and b.

If num falls within the range, return num. Otherwise, return the nearest number in the range.

```
function clampNumber($num, $a, $b)
{
    return max(min($num, max($a, $b)), min($a, $b));
}
```

Examples```
clampNumber(2, 3, 5); // 3
clampNumber(1, -1, -5); // -1
```

[⬆ Back to top](#table-of-contents)

---

📜 String
--------

[](#-string-1)

### endsWith

[](#endswith)

Check if a string is ends with a given substring.

```
function endsWith($haystack, $needle)
{
    return strrpos($haystack, $needle) === (strlen($haystack) - strlen($needle));
}
```

Examples```
endsWith('Hi, this is me', 'me'); // true
```

[⬆ Back to top](#table-of-contents)

### firstStringBetween

[](#firststringbetween)

Returns the first string there is between the strings from the parameter start and end.

```
function firstStringBetween($haystack, $start, $end)
{
    return trim(strstr(strstr($haystack, $start), $end, true), $start . $end);
}
```

Examples```
firstStringBetween('This is a [custom] string', '[', ']'); // custom
```

[⬆ Back to top](#table-of-contents)

### isAnagram

[](#isanagram)

Compare two strings and returns `true` if both strings are anagram, `false` otherwise.

```
function isAnagram($string1, $string2)
{
    return count_chars($string1, 1) === count_chars($string2, 1);
}
```

Examples```
isAnagram('act', 'cat'); // true
```

[⬆ Back to top](#table-of-contents)

### isLowerCase

[](#islowercase)

Returns `true` if the given string is lower case, `false` otherwise.

```
function isLowerCase($string)
{
    return $string === strtolower($string);
}
```

Examples```
isLowerCase('Morning shows the day!'); // false
isLowerCase('hello'); // true
```

[⬆ Back to top](#table-of-contents)

### isUpperCase

[](#isuppercase)

Returns `true` if the given string is upper case, false otherwise.

```
function isUpperCase($string)
{
    return $string === strtoupper($string);
}
```

Examples```
isUpperCase('MORNING SHOWS THE DAY!'); // true
isUpperCase('qUick Fox'); // false
```

[⬆ Back to top](#table-of-contents)

### palindrome

[](#palindrome)

Returns `true` if the given string is a palindrome, `false` otherwise.

```
function palindrome($string)
{
    return strrev($string) === (string) $string;
}
```

Examples```
palindrome('racecar'); // true
palindrome(2221222); // true
```

[⬆ Back to top](#table-of-contents)

### startsWith

[](#startswith)

Check if a string starts with a given substring.

```
function startsWith($haystack, $needle)
{
    return strpos($haystack, $needle) === 0;
}
```

Examples```
startsWith('Hi, this is me', 'Hi'); // true
```

[⬆ Back to top](#table-of-contents)

### countVowels

[](#countvowels)

Returns number of vowels in provided string.

Use a regular expression to count the number of vowels (A, E, I, O, U) in a string.

```
function countVowels($string)
{
    preg_match_all('/[aeiou]/i', $string, $matches);

    return count($matches[0]);
}
```

Examples```
countVowels('sampleInput'); // 4
```

[⬆ Back to top](#table-of-contents)

### decapitalize

[](#decapitalize)

Decapitalizes the first letter of a string.

Decapitalizes the first letter of the string and then adds it with rest of the string. Omit the `upperRest` parameter to keep the rest of the string intact, or set it to `true` to convert to uppercase.

```
function decapitalize($string, $upperRest = false)
{
    return lcfirst($upperRest ? strtoupper($string) : $string);
}
```

Examples```
decapitalize('FooBar'); // 'fooBar'
```

[⬆ Back to top](#table-of-contents)

### isContains

[](#iscontains)

Check if a word / substring exist in a given string input. Using `strpos` to find the position of the first occurrence of a substring in a string. Returns either `true` or `false`

```
function isContains($string, $needle)
{
    return strpos($string, $needle);
}
```

Examples```
isContains('This is an example string', 'example'); // true
```

```
isContains('This is an example string', 'hello'); // false
```

[⬆ Back to top](#table-of-contents)

---

🎛️ Function
-----------

[](#️-function-1)

### compose

[](#compose)

Return a new function that composes multiple functions into a single callable.

```
function compose(...$functions)
{
    return array_reduce(
        $functions,
        function ($carry, $function) {
            return function ($x) use ($carry, $function) {
                return $function($carry($x));
            };
        },
        function ($x) {
            return $x;
        }
    );
}
```

Examples```
$compose = compose(
    // add 2
    function ($x) {
        return $x + 2;
    },
    // multiply 4
    function ($x) {
        return $x * 4;
    }
);
$compose(3); // 20
```

[⬆ Back to top](#table-of-contents)

### memoize

[](#memoize)

Memoization of a function results in memory.

```
function memoize($func)
{
    return function () use ($func) {
        static $cache = [];

        $args = func_get_args();
        $key = serialize($args);
        $cached = true;

        if (!isset($cache[$key])) {
            $cache[$key] = $func(...$args);
            $cached = false;
        }

        return ['result' => $cache[$key], 'cached' => $cached];
    };
}
```

Examples```
$memoizedAdd = memoize(
    function ($num) {
        return $num + 10;
    }
);

var_dump($memoizedAdd(5)); // ['result' => 15, 'cached' => false]
var_dump($memoizedAdd(6)); // ['result' => 16, 'cached' => false]
var_dump($memoizedAdd(5)); // ['result' => 15, 'cached' => true]
```

[⬆ Back to top](#table-of-contents)

### curry

[](#curry)

Curries a function to take arguments in multiple calls.

```
function curry($function)
{
    $accumulator = function ($arguments) use ($function, &$accumulator) {
        return function (...$args) use ($function, $arguments, $accumulator) {
            $arguments = array_merge($arguments, $args);
            $reflection = new ReflectionFunction($function);
            $totalArguments = $reflection->getNumberOfRequiredParameters();

            if ($totalArguments