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, but there is no affiliation with that project.
Table of Contents
📚 Array
View contents
➗ Math
View contents
📜 String
View contents
🎛️ Function
📚 Array
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
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
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]]
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]
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]
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
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
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]
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']]
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
head
Returns the head of a list.
function head($items)
{
return reset($items);
}
Examples
head([1, 2, 3]); // 1
last
Returns the last element in an array.
function last($items)
{
return end($items);
}
Examples
last([1, 2, 3]); // 3
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']
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']
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']
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]
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]
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]
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]
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']]
➗ Math
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
factorial
Calculates the factorial of a number.
function factorial($n)
{
if ($n <= 1) {
return 1;
}
return $n * factorial($n - 1);
}
Examples
factorial(6); // 720
fibonacci
Generates an array, containing the Fibonacci sequence, up until the nth term.
function fibonacci($n)
{
$sequence = [0, 1];
for ($i = 2; $i < $n; $i++) {
$sequence[$i] = $sequence[$i-1] + $sequence[$i-2];
}
return $sequence;
}
Examples
fibonacci(6); // [0, 1, 1, 2, 3, 5]
gcd
Calculates the greatest common divisor between two or more numbers.
function gcd(...$numbers)
{
if (count($numbers) > 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
isEven
Returns true
if the given number is even, false
otherwise.
function isEven($number)
{
return ($number % 2) === 0;
}
Examples
isEven(4); // true
isPrime
Checks if the provided integer is a prime number.
function isPrime($number)
{
$boundary = floor(sqrt($number));
for ($i = 2; $i <= $boundary; $i++) {
if ($number % $i === 0) {
return false;
}
}
return $number >= 2;
}
Examples
isPrime(3); // true
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
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
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
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
maxN([1, 1, 2, 3, 4, 5, 5]); // 2
maxN([1, 2, 3, 4, 5]); // 1
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
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
📜 String
endsWith
Check if a string is ends with a given substring.
function endsWith($haystack, $needle)
{
return substr($haystack, -strlen($needle)) === $needle;
}
Examples
endsWith('Hi, this is me', 'me'); // true
firstStringBetween
Returns the first string there is between the strings from the parameter start and end.
function firstStringBetween($haystack, $start, $end)
{
$char = strpos($haystack, $start);
if ($char === false) {
return '';
}
$char += strlen($start);
$len = strpos($haystack, $end, $char) - $char;
return substr($haystack, $char, $len);
}
Examples
firstStringBetween('This is a [custom] string', '[', ']'); // custom
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
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
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
palindrome
Returns true
if the given string is a palindrome, false
otherwise.
function palindrome($string)
{
return strrev($string) === $string;
}
Examples
palindrome('racecar'); // true
startsWith
Check if a string is starts with a given substring.
function startsWith($haystack, $needle)
{
return substr($haystack, 0, strlen($needle)) === $needle;
}
Examples
startsWith('Hi, this is me', 'Hi'); // true
countVowels
Retuns 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
decapitalize
Decapitalizes the first letter of a string.
Decapitalizes the first letter of the sring 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 strtolower(substr($string, 0, 1)) . ($upperRest ? strtoupper(substr($string, 1)) : substr($string, 1));
}
Examples
decapitalize('FooBar'); // 'fooBar'
🎛️ Function
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
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] = call_user_func_array($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]
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 <= count($arguments)) {
return call_user_func_array($function, $arguments);
}
return $accumulator($arguments);
};
};
return $accumulator([]);
}
Examples
$curriedAdd = curry(
function ($a, $b) {
return $a + $b;
}
);
$add10 = $curriedAdd(10);
var_dump($add10(15)); // 25
Contribute
You're always welcome to contribute to this project. Please read the contribution guide.
License
This project is licensed under the MIT License - see the License File for details