同步操作将从 30秒学代码/30-seconds-of-php-code 强制同步,此操作会覆盖自 Fork 仓库以来所做的任何修改,且无法恢复!!!
确定后同步将在后台操作,完成时将刷新页面,请耐心等待。
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.
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);
}
all([2, 3, 4, 5], function ($item) {
return $item > 1;
}); // true
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;
}
any([1, 2, 3, 4], function ($item) {
return $item < 2;
}); // true
Chunks an array into smaller arrays of a specified size.
function chunk($items, $size)
{
return array_chunk($items, $size);
}
chunk([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
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;
}
deepFlatten([1, [2], [[3], 4], 5]); // [1, 2, 3, 4, 5]
Returns a new array with n
elements removed from the left.
function drop($items, $n = 1)
{
return array_slice($items, $n);
}
drop([1, 2, 3]); // [2,3]
drop([1, 2, 3], 2); // [3]
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);
}
findLast([1, 2, 3, 4], function ($n) {
return ($n % 2) === 1;
});
// 3
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);
}
findLastIndex([1, 2, 3, 4], function ($n) {
return ($n % 2) === 1;
});
// 2
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;
}
flatten([1, [2], 3, 4]); // [1, 2, 3, 4]
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;
}
groupBy(['one', 'two', 'three'], 'strlen') // [3 => ['one', 'two'], 5 => ['three']]
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));
}
hasDuplicates([1, 2, 3, 4, 5, 5]); // true
Returns the head of a list.
function head($items)
{
return reset($items);
}
head([1, 2, 3]); // 1
Returns the last element in an array.
function last($items)
{
return end($items);
}
last([1, 2, 3]); // 3
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);
}
pluck([
['product_id' => 'prod-100', 'name' => 'Desk'],
['product_id' => 'prod-200', 'name' => 'Chair'],
], 'name');
// ['Desk', 'Chair']
Mutates the original array to filter out the values specified.
function pull(&$items, ...$params)
{
$items = array_values(array_diff($items, $params));
return $items;
}
$items = ['a', 'b', 'c', 'a', 'b', 'c'];
pull($items, 'a', 'c'); // $items will be ['b', 'b']
Filters the collection using the given callback.
function reject($items, $func)
{
return array_values(array_diff($items, array_filter($items, $func)));
}
reject(['Apple', 'Pear', 'Kiwi', 'Banana'], function ($item) {
return strlen($item) > 4;
}); // ['Pear', 'Kiwi']
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);
}
remove([1, 2, 3, 4], function ($n) {
return ($n % 2) === 0;
});
// [0 => 1, 2 => 3]
Returns all elements in an array except for the first one.
function tail($items)
{
return count($items) > 1 ? array_slice($items, 1) : $items;
}
tail([1, 2, 3]); // [2, 3]
Returns an array with n elements removed from the beginning.
function take($items, $n = 1)
{
return array_slice($items, 0, $n);
}
take([1, 2, 3], 5); // [1, 2, 3]
take([1, 2, 3, 4, 5], 2); // [1, 2]
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));
}
without([2, 1, 2, 3], 1, 2); // [3]
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);
}
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']]
Returns the average of two or more numbers.
function average(...$items)
{
return count($items) === 0 ? 0 : array_sum($items) / count($items);
}
average(1, 2, 3); // 2
Calculates the factorial of a number.
function factorial($n)
{
if ($n <= 1) {
return 1;
}
return $n * factorial($n - 1);
}
factorial(6); // 720
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;
}
fibonacci(6); // [0, 1, 1, 2, 3, 5]
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);
}
gcd(8, 36); // 4
gcd(12, 8, 32); // 4
Returns true
if the given number is even, false
otherwise.
function isEven($number)
{
return ($number % 2) === 0;
}
isEven(4); // true
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;
}
isPrime(3); // true
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;
}
lcm(12, 7); // 84
lcm(1, 3, 4, 5); // 60
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];
}
median([1, 3, 3, 6, 7, 8, 9]); // 6
median([1, 2, 3, 6, 7, 9]); // 4.5
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);
}
maxN([1, 2, 3, 4, 5, 5]); // 2
maxN([1, 2, 3, 4, 5]); // 1
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);
}
maxN([1, 1, 2, 3, 4, 5, 5]); // 2
maxN([1, 2, 3, 4, 5]); // 1
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;
}
approximatelyEqual(10.0, 10.00001); // true
approximatelyEqual(10.0, 10.01); // false
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));
}
clampNumber(2, 3, 5); // 3
clampNumber(1, -1, -5); // -1
Check if a string is ends with a given substring.
function endsWith($haystack, $needle)
{
return strrpos($haystack, $needle) === (strlen($haystack) - strlen($needle));
}
endsWith('Hi, this is me', 'me'); // true
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);
}
firstStringBetween('This is a [custom] string', '[', ']'); // custom
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);
}
isAnagram('act', 'cat'); // true
Returns true
if the given string is lower case, false
otherwise.
function isLowerCase($string)
{
return $string === strtolower($string);
}
isLowerCase('Morning shows the day!'); // false
isLowerCase('hello'); // true
Returns true
if the given string is upper case, false otherwise.
function isUpperCase($string)
{
return $string === strtoupper($string);
}
isUpperCase('MORNING SHOWS THE DAY!'); // true
isUpperCase('qUick Fox'); // false
Returns true
if the given string is a palindrome, false
otherwise.
function palindrome($string)
{
return strrev($string) === (string) $string;
}
palindrome('racecar'); // true
palindrome(2221222); // true
Check if a string is starts with a given substring.
function startsWith($haystack, $needle)
{
return strpos($haystack, $needle) === 0;
}
startsWith('Hi, this is me', 'Hi'); // true
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]);
}
countVowels('sampleInput'); // 4
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 lcfirst($upperRest ? strtoupper($string) : $string);
}
decapitalize('FooBar'); // 'fooBar'
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;
}
);
}
$compose = compose(
// add 2
function ($x) {
return $x + 2;
},
// multiply 4
function ($x) {
return $x * 4;
}
);
$compose(3); // 20
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];
};
}
$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]
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 $function(...$arguments);
}
return $accumulator($arguments);
};
};
return $accumulator([]);
}
$curriedAdd = curry(
function ($a, $b) {
return $a + $b;
}
);
$add10 = $curriedAdd(10);
var_dump($add10(15)); // 25
Call a function only once.
function once($function)
{
return function (...$args) use ($function) {
static $called = false;
if ($called) {
return;
}
$called = true;
return $function(...$args);
};
}
$add = function ($a, $b) {
return $a + $b;
};
$once = once($add);
var_dump($once(10, 5)); // 15
var_dump($once(20, 10)); // null
You're always welcome to contribute to this project. Please read the contribution guide.
This project is licensed under the MIT License - see the License File for details
此处可能存在不合适展示的内容,页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容,可点击提交进行申诉,我们将尽快为您处理。