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

Passed

Push — master ( 7550a2...325e2d )

by Stephen

created 2021-08-03 17:54 UTC

arrayValuesNotEqual() 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
nc	1
nop	2
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

use Sfneal\Helpers\Arrays\ArrayHelpers;
use Sfneal\Helpers\Arrays\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 (new ArrayHelpers($array))->arrayChunks($min, $max, $no_remainders, $preserve_keys);
}

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

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

/**
 * Sum the values of two arrays.
 *
 * @param array $array1
 * @param array $array2
 * @return array
 */
function sumArrays(array $array1, array $array2): array
{
    return (new ArrayHelpers($array1))->sumArrays($array2);
}

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

/**
 * 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 (new ArrayHelpers($array))->arrayValuesEqual($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 (new ArrayHelpers($array))->arrayValuesNotEqual($value);
}

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

if (! function_exists('array_except')) {
    /**
     * Remove specific arrays of keys without modifying the original array.
     *
     * @param array $original
     * @param array $except
     * @return array
     */
    function array_except(array $original, array $except): array
    {
        return (new ArrayHelpers($original))->array_except($except);
    }
}

/**
 * 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 (new ArrayHelpers($array))->arrayPop($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 (new ArrayHelpers($array))->arrayUnset($keys);
}

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

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 (new ArrayHelpers($array))->random($items);
    }
}

/**
 * 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)
    {
        return (new ArrayHelpers($first))->diffFlat($second, $toArray);
    }
}


1			<?php
2
3			use Sfneal\Helpers\Arrays\ArrayHelpers;
4			use Sfneal\Helpers\Arrays\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 (new ArrayHelpers($array))->arrayChunks($min, $max, $no_remainders, $preserve_keys);
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			* @return array
31			*/
32			function arrayFlattenKeys(array $array, bool $nest_keys = true): array
33			{
34			return (new ArrayHelpers($array))->arrayFlattenKeys($nest_keys);
35			}
36
37			/**
38			* Remove particular keys from a multidimensional array.
39			*
40			* @param array $array
41			* @param array\|string $keys
42			* @return array
43			*/
44			function arrayRemoveKeys(array $array, $keys): array
45			{
46			return (new ArrayHelpers($array))->arrayRemoveKeys($keys);
47			}
48
49			/**
50			* Sum the values of two arrays.
51			*
52			* @param array $array1
53			* @param array $array2
54			* @return array
55			*/
56			function sumArrays(array $array1, array $array2): array
57			{
58			return (new ArrayHelpers($array1))->sumArrays($array2);
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 (new ArrayHelpers($array))->arrayValuesUnique();
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 (new ArrayHelpers($array))->arrayValuesEqual($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 (new ArrayHelpers($array))->arrayValuesNotEqual($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 (new ArrayHelpers($array))->arrayHasKeys();
105			}
106
107			if (! function_exists('array_except')) {
108			/**
109			* Remove specific arrays of keys without modifying the original array.
110			*
111			* @param array $original
112			* @param array $except
113			* @return array
114			*/
115			function array_except(array $original, array $except): array
116			{
117			return (new ArrayHelpers($original))->array_except($except);
118			}
119			}
120
121			/**
122			* Return a best fit chunk size to be passed to array_chunks functions.
123			*
124			* Calculates the remainder of array sizes divided by the divisor
125			* using modulus division. Continues to calculate remainders until
126			* the remainder is zero, signifying evenly sized chunks, or the
127			* divisor is equal to the array size. If a remainder of zero is not
128			* found the lowest remainder is returned.
129			*
130			* @param int $array_size size of the array
131			* @param int $min minimum chunk size
132			* @param int\|null $max maximum chunk size
133			* @param int $divisor
134			* @return int $remainder lowest calculated remainder
135			*/
136			function chunkSizer(int $array_size, int $min = 0, int $max = null, int $divisor = 2): int
137			{
138			return (new ChunkSizer($array_size, $min, $max, $divisor))->execute();
139			}
140
141			/**
142			* Remove a key from an array & return the key's value.
143			*
144			* @param array $array
145			* @param string $key
146			* @return mixed
147			*/
148			function arrayPop(array $array, string $key)
149			{
150			return (new ArrayHelpers($array))->arrayPop($key);
151			}
152
153			/**
154			* Remove a key from an array & the new array without the key.
155			*
156			* @param array $array
157			* @param array\|string $keys
158			* @return array
159			*/
160			function arrayUnset(array $array, $keys): array
161			{
162			return (new ArrayHelpers($array))->arrayUnset($keys);
163			}
164
165			/**
166			* Determine if all values in an array are null.
167			*
168			* @param array $array
169			* @return bool
170			*/
171			function arrayValuesNull(array $array): bool
172			{
173			return (new ArrayHelpers($array))->arrayValuesNull();
174			}
175
176			if (! function_exists('arrayRandom')) {
177			/**
178			* Retrieve a random array of elements.
179			*
180			* @param array $array
181			* @param int $items
182			* @return array
183			*/
184			function arrayRandom(array $array, int $items): array
185			{
186			return (new ArrayHelpers($array))->random($items);
187			}
188			}
189
190			/**
191			* Only declare function if Illuminate/Collection is installed.
192			*/
193			if (function_exists('collect')) {
194			/**
195			* Return a flat array of values that were found in the $first array that are not found in the $second.
196			*
197			* @param array $first
198			* @param array $second
199			* @param bool $toArray
200			* @return Illuminate\Support\Collection\|array
201			*/
202			function array_diff_flat(array $first, array $second, bool $toArray = true)
203			{
204			return (new ArrayHelpers($first))->diffFlat($second, $toArray);
205			}
206			}
207

sfneal / array-helpers

Push — master ( 7550a2...325e2d )

arrayValuesNotEqual() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like