array_diff_flat() - Code Metrics - sfneal/array-helpers - Measure and Improve Code Quality continuously with Scrutinizer

array_diff_flat() A
last analyzed 2021-08-16 16:16 UTC

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	3	Features	0

Metric	Value
cc	2
eloc	2
c	3
b	3
f	0
nc	2
nop	3
dl	0
loc	5
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('arrayExcept')) {
    /**
     * Remove specific arrays of keys.
     *
     * @param array $original
     * @param array $except
     * @return array
     */
    function arrayExcept(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('arrayExcept')) {
108			/**
109			* Remove specific arrays of keys.
110			*
111			* @param array $original
112			* @param array $except
113			* @return array
114			*/
115			function arrayExcept(array $original, array $except): array
116			{
117			return ArrayHelpers::from($original)->except($except)->get();
118			}
119			}
120
121			if (! function_exists('arrayOnly')) {
122			/**
123			* Retrieve an array with only the keys provided in the $only param.
124			*
125			* @param array $original
126			* @param array $only
127			* @return array
128			*/
129			function arrayOnly(array $original, array $only): array
130			{
131			return ArrayHelpers::from($original)->only($only)->get();
132			}
133			}
134
135			/**
136			* Return a best fit chunk size to be passed to array_chunks functions.
137			*
138			* Calculates the remainder of array sizes divided by the divisor
139			* using modulus division. Continues to calculate remainders until
140			* the remainder is zero, signifying evenly sized chunks, or the
141			* divisor is equal to the array size. If a remainder of zero is not
142			* found the lowest remainder is returned.
143			*
144			* @param int $array_size size of the array
145			* @param int $min minimum chunk size
146			* @param int\|null $max maximum chunk size
147			* @param int $divisor
148			* @return int $remainder lowest calculated remainder
149			*/
150			function chunkSizer(int $array_size, int $min = 0, int $max = null, int $divisor = 2): int
151			{
152			return (new ChunkSizer($array_size, $min, $max, $divisor))->execute();
153			}
154
155			/**
156			* Remove a key from an array & return the key's value.
157			*
158			* @param array $array
159			* @param string $key
160			* @return mixed
161			*/
162			function arrayPop(array $array, string $key)
163			{
164			return ArrayHelpers::from($array)->pop($key);
165			}
166
167			/**
168			* Remove a key from an array & the new array without the key.
169			*
170			* @param array $array
171			* @param array\|string $keys
172			* @return array
173			*/
174			function arrayUnset(array $array, $keys): array
175			{
176			return ArrayHelpers::from($array)->unset($keys)->get();
177			}
178
179			/**
180			* Determine if all values in an array are null.
181			*
182			* @param array $array
183			* @return bool
184			*/
185			function arrayValuesNull(array $array): bool
186			{
187			return ArrayHelpers::from($array)->valuesNull();
188			}
189
190			if (! function_exists('arrayRandom')) {
191			/**
192			* Retrieve a random array of elements.
193			*
194			* @param array $array
195			* @param int $items
196			* @return array
197			*/
198			function arrayRandom(array $array, int $items): array
199			{
200			return ArrayHelpers::from($array)->random($items)->get();
201			}
202			}
203
204			/**
205			* Only declare function if Illuminate/Collection is installed.
206			*/
207			if (function_exists('collect')) {
208			/**
209			* Return a flat array of values that were found in the $first array that are not found in the $second.
210			*
211			* @param array $first
212			* @param array $second
213			* @param bool $toArray
214			* @return Illuminate\Support\Collection\|array
215			*/
216			function array_diff_flat(array $first, array $second, bool $toArray = true)
217			{
218			$diff = ArrayHelpers::from($first)->diffFlat($second);
219
220			return $toArray ? $diff->get() : $diff->collect();
221			}
222			}
223

sfneal / array-helpers

array_diff_flat() A last analyzed 2021-08-16 16:16 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

array_diff_flat() A
last analyzed 2021-08-16 16:16 UTC