arrayOnly() - Code Metrics - Inspection of "Merge pull request #43 from sfneal/dev" - sfneal/array-helpers - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 276887...aed439 )

by Stephen

created 2021-08-05 16:21 UTC

arrayOnly() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
c	0
b	0
f	0
nc	1
nop	2
dl	0
loc	3
rs	10

<?php

use Sfneal\Helpers\Arrays\ArrayHelpers;
use Sfneal\Helpers\Arrays\Utils\ChunkSizer;

/**
 * Returns a chunked array with calculated chunk size.
 *
 * @param array $array
 * @param int $min
 * @param int|null $max
 * @param bool $no_remainders
 * @param bool $preserve_keys
 * @return array
 */
function arrayChunks(array $array,
                     int $min = 0,
                     int $max = null,
                     bool $no_remainders = false,
                     bool $preserve_keys = true): array
{
    return ArrayHelpers::from($array)->chunks($min, $max, $no_remainders, $preserve_keys)->get();
}

/**
 * Flatten a multidimensional array into a 2D array without nested keys.
 *
 * @param array $array
 * @param bool $nest_keys
 * @param string $separator
 * @return array
 */
function arrayFlattenKeys(array $array, bool $nest_keys = true, string $separator = '_'): array
{
    return ArrayHelpers::from($array)->flattenKeys($nest_keys, $separator)->get();
}

/**
 * Remove particular keys from a multidimensional array.
 *
 * @param array $array
 * @param array|string $keys
 * @return array
 */
function arrayRemoveKeys(array $array, $keys): array
{
    return ArrayHelpers::from($array)->removeKeys($keys)->get();
}

/**
 * Sum the values of two arrays.
 *
 * @param array $arrays
 * @return array
 */
function sumArrays(...$arrays): array
{
    return ArrayHelpers::sum(...$arrays);
}

/**
 * Determine if all values in an array of key => value pairs are unique.
 *
 * @param array $array
 * @return bool
 */
function arrayValuesUnique(array $array): bool
{
    return ArrayHelpers::from($array)->valuesUnique();
}

/**
 * Determine if all array_values are equal to a certain value.
 *
 * @param array $array
 * @param mixed $value
 * @return bool
 */
function arrayValuesEqual(array $array, $value): bool
{
    return ArrayHelpers::from($array)->valuesEqual($value);
}

/**
 * Determine if all array_values are NOT equal to a certain value.
 *
 * @param array $array
 * @param mixed $value
 * @return bool
 */
function arrayValuesNotEqual(array $array, $value): bool
{
    return ArrayHelpers::from($array)->valuesNotEqual($value);
}

/**
 * Determine if an array is multidimensional and has keys.
 *
 * @param array $array
 * @return bool
 */
function arrayHasKeys(array $array): bool
{
    return ArrayHelpers::from($array)->hasKeys();
}

if (! function_exists('array_except')) {
    // todo: refactor to `arrayExcept()`
    /**
     * Remove specific arrays of keys.
     *
     * @param array $original
     * @param array $except
     * @return array
     */
    function array_except(array $original, array $except): array
    {
        return ArrayHelpers::from($original)->except($except)->get();
    }
}

if (! function_exists('arrayOnly')) {
    /**
     * Retrieve an array with only the keys provided in the $only param.
     *
     * @param array $original
     * @param array $only
     * @return array
     */
    function arrayOnly(array $original, array $only): array
    {
        return ArrayHelpers::from($original)->only($only)->get();
    }
}

/**
 * Return a best fit chunk size to be passed to array_chunks functions.
 *
 * Calculates the remainder of array sizes divided by the divisor
 * using modulus division.  Continues to calculate remainders until
 * the remainder is zero, signifying evenly sized chunks, or the
 * divisor is equal to the array size.  If a remainder of zero is not
 * found the lowest remainder is returned.
 *
 * @param int $array_size size of the array
 * @param int $min minimum chunk size
 * @param int|null $max maximum chunk size
 * @param int $divisor
 * @return int $remainder lowest calculated remainder
 */
function chunkSizer(int $array_size, int $min = 0, int $max = null, int $divisor = 2): int
{
    return (new ChunkSizer($array_size, $min, $max, $divisor))->execute();
}

/**
 * Remove a key from an array & return the key's value.
 *
 * @param array $array
 * @param string $key
 * @return mixed
 */
function arrayPop(array $array, string $key)
{
    return ArrayHelpers::from($array)->pop($key);
}

/**
 * Remove a key from an array & the new array without the key.
 *
 * @param array $array
 * @param array|string $keys
 * @return array
 */
function arrayUnset(array $array, $keys): array
{
    return ArrayHelpers::from($array)->unset($keys)->get();
}

/**
 * Determine if all values in an array are null.
 *
 * @param array $array
 * @return bool
 */
function arrayValuesNull(array $array): bool
{
    return ArrayHelpers::from($array)->valuesNull();
}

if (! function_exists('arrayRandom')) {
    /**
     * Retrieve a random array of elements.
     *
     * @param array $array
     * @param int $items
     * @return array
     */
    function arrayRandom(array $array, int $items): array
    {
        return ArrayHelpers::from($array)->random($items)->get();
    }
}

/**
 * Only declare function if Illuminate/Collection is installed.
 */
if (function_exists('collect')) {
    /**
     * Return a flat array of values that were found in the $first array that are not found in the $second.
     *
     * @param array $first
     * @param array $second
     * @param bool $toArray
     * @return Illuminate\Support\Collection|array
     */
    function array_diff_flat(array $first, array $second, bool $toArray = true)
    {
        $diff = ArrayHelpers::from($first)->diffFlat($second);

        return $toArray ? $diff->get() : $diff->collect();
    }
}


1			<?php
2
3			use Sfneal\Helpers\Arrays\ArrayHelpers;
4			use Sfneal\Helpers\Arrays\Utils\ChunkSizer;
5
6			/**
7			* Returns a chunked array with calculated chunk size.
8			*
9			* @param array $array
10			* @param int $min
11			* @param int\|null $max
12			* @param bool $no_remainders
13			* @param bool $preserve_keys
14			* @return array
15			*/
16			function arrayChunks(array $array,
17			int $min = 0,
18			int $max = null,
19			bool $no_remainders = false,
20			bool $preserve_keys = true): array
21			{
22			return ArrayHelpers::from($array)->chunks($min, $max, $no_remainders, $preserve_keys)->get();
23			}
24
25			/**
26			* Flatten a multidimensional array into a 2D array without nested keys.
27			*
28			* @param array $array
29			* @param bool $nest_keys
30			* @param string $separator
31			* @return array
32			*/
33			function arrayFlattenKeys(array $array, bool $nest_keys = true, string $separator = '_'): array
34			{
35			return ArrayHelpers::from($array)->flattenKeys($nest_keys, $separator)->get();
36			}
37
38			/**
39			* Remove particular keys from a multidimensional array.
40			*
41			* @param array $array
42			* @param array\|string $keys
43			* @return array
44			*/
45			function arrayRemoveKeys(array $array, $keys): array
46			{
47			return ArrayHelpers::from($array)->removeKeys($keys)->get();
48			}
49
50			/**
51			* Sum the values of two arrays.
52			*
53			* @param array $arrays
54			* @return array
55			*/
56			function sumArrays(...$arrays): array
57			{
58			return ArrayHelpers::sum(...$arrays);
59			}
60
61			/**
62			* Determine if all values in an array of key => value pairs are unique.
63			*
64			* @param array $array
65			* @return bool
66			*/
67			function arrayValuesUnique(array $array): bool
68			{
69			return ArrayHelpers::from($array)->valuesUnique();
70			}
71
72			/**
73			* Determine if all array_values are equal to a certain value.
74			*
75			* @param array $array
76			* @param mixed $value
77			* @return bool
78			*/
79			function arrayValuesEqual(array $array, $value): bool
80			{
81			return ArrayHelpers::from($array)->valuesEqual($value);
82			}
83
84			/**
85			* Determine if all array_values are NOT equal to a certain value.
86			*
87			* @param array $array
88			* @param mixed $value
89			* @return bool
90			*/
91			function arrayValuesNotEqual(array $array, $value): bool
92			{
93			return ArrayHelpers::from($array)->valuesNotEqual($value);
94			}
95
96			/**
97			* Determine if an array is multidimensional and has keys.
98			*
99			* @param array $array
100			* @return bool
101			*/
102			function arrayHasKeys(array $array): bool
103			{
104			return ArrayHelpers::from($array)->hasKeys();
105			}
106
107			if (! function_exists('array_except')) {
108			// todo: refactor to `arrayExcept()`
109			/**
110			* Remove specific arrays of keys.
111			*
112			* @param array $original
113			* @param array $except
114			* @return array
115			*/
116			function array_except(array $original, array $except): array
117			{
118			return ArrayHelpers::from($original)->except($except)->get();
119			}
120			}
121
122			if (! function_exists('arrayOnly')) {
123			/**
124			* Retrieve an array with only the keys provided in the $only param.
125			*
126			* @param array $original
127			* @param array $only
128			* @return array
129			*/
130			function arrayOnly(array $original, array $only): array
131			{
132			return ArrayHelpers::from($original)->only($only)->get();
133			}
134			}
135
136			/**
137			* Return a best fit chunk size to be passed to array_chunks functions.
138			*
139			* Calculates the remainder of array sizes divided by the divisor
140			* using modulus division. Continues to calculate remainders until
141			* the remainder is zero, signifying evenly sized chunks, or the
142			* divisor is equal to the array size. If a remainder of zero is not
143			* found the lowest remainder is returned.
144			*
145			* @param int $array_size size of the array
146			* @param int $min minimum chunk size
147			* @param int\|null $max maximum chunk size
148			* @param int $divisor
149			* @return int $remainder lowest calculated remainder
150			*/
151			function chunkSizer(int $array_size, int $min = 0, int $max = null, int $divisor = 2): int
152			{
153			return (new ChunkSizer($array_size, $min, $max, $divisor))->execute();
154			}
155
156			/**
157			* Remove a key from an array & return the key's value.
158			*
159			* @param array $array
160			* @param string $key
161			* @return mixed
162			*/
163			function arrayPop(array $array, string $key)
164			{
165			return ArrayHelpers::from($array)->pop($key);
166			}
167
168			/**
169			* Remove a key from an array & the new array without the key.
170			*
171			* @param array $array
172			* @param array\|string $keys
173			* @return array
174			*/
175			function arrayUnset(array $array, $keys): array
176			{
177			return ArrayHelpers::from($array)->unset($keys)->get();
178			}
179
180			/**
181			* Determine if all values in an array are null.
182			*
183			* @param array $array
184			* @return bool
185			*/
186			function arrayValuesNull(array $array): bool
187			{
188			return ArrayHelpers::from($array)->valuesNull();
189			}
190
191			if (! function_exists('arrayRandom')) {
192			/**
193			* Retrieve a random array of elements.
194			*
195			* @param array $array
196			* @param int $items
197			* @return array
198			*/
199			function arrayRandom(array $array, int $items): array
200			{
201			return ArrayHelpers::from($array)->random($items)->get();
202			}
203			}
204
205			/**
206			* Only declare function if Illuminate/Collection is installed.
207			*/
208			if (function_exists('collect')) {
209			/**
210			* Return a flat array of values that were found in the $first array that are not found in the $second.
211			*
212			* @param array $first
213			* @param array $second
214			* @param bool $toArray
215			* @return Illuminate\Support\Collection\|array
216			*/
217			function array_diff_flat(array $first, array $second, bool $toArray = true)
218			{
219			$diff = ArrayHelpers::from($first)->diffFlat($second);
220
221			return $toArray ? $diff->get() : $diff->collect();
222			}
223			}
224

sfneal / array-helpers

Push — master ( 276887...aed439 )

arrayOnly() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like