Arr::randWeighted() - Code Metrics - Inspection of "Refactor to include Arr class" - spatie/array-functions - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#17)

unknown

created 2019-10-19 17:59 UTC

Arr::randWeighted() A

↳ Parent: Arr

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
nc	3
nop	1
dl	0
loc	12
rs	9.8666
c	0
b	0
f	0

<?php

namespace Spatie\Support;

class Arr
{
    /**
     * Get a random value from an array.
     *
     * @param array $array
     * @param int   $numReq The amount of values to return
     *
     * @return mixed
     */
    public static function randValue(array $array, $numReq = 1)
    {
        if (!count($array)) {
            return;
        }

        $keys = array_rand($array, $numReq);

        if ($numReq === 1) {
            return $array[$keys];
        }

        return array_intersect_key($array, array_flip($keys));
    }

    /**
     * Get a random value from an array, with the ability to skew the results.
     * Example: Arr::randWeighted(['foo' => 1, 'bar' => 2]) has a 66% chance of returning bar.
     *
     * @param array $array
     *
     * @return mixed
     */
    public static function randWeighted(array $array)
    {
        $options = [];

        foreach ($array as $option => $weight) {
            for ($i = 0; $i < $weight; ++$i) {
                $options[] = $option;
            }
        }

        return array_rand_value($options);
    }

    /**
     * Determine if all given needles are present in the haystack.
     *
     * @param array|string $needles
     * @param array        $haystack
     *
     * @return bool
     */
    public static function valuesInArray($needles, array $haystack)
    {
        if (!is_array($needles)) {
            $needles = [$needles];
        }

        return count(array_intersect($needles, $haystack)) === count($needles);
    }

    /**
     * Determine if all given needles are present in the haystack as array keys.
     *
     * @param array|string $needles
     * @param array        $haystack
     *
     * @return bool
     */
    public static function keysExist($needles, array $haystack)
    {
        if (!is_array($needles)) {
            return array_key_exists($needles, $haystack);
        }

        return values_in_array($needles, array_keys($haystack));
    }

    /**
     * Returns an array with two elements.
     *
     * Iterates over each value in the array passing them to the callback function.
     * If the callback function returns true, the current value from array is returned in the first
     * element of result array. If not, it is return in the second element of result array.
     *
     * Array keys are preserved.
     *
     * @param array    $array
     * @param callable $callback
     *
     * @return array
     */
    public static function splitFilter(array $array, callable $callback)
    {
        $passesFilter = array_filter($array, $callback);

        $negatedCallback = static function ($item) use ($callback) {return !$callback($item);};

        $doesNotPassFilter = array_filter($array, $negatedCallback);

        return [$passesFilter, $doesNotPassFilter];
    }

    /**
     * Split an array in the given amount of pieces.
     *
     * @param array $array
     * @param int   $numberOfPieces
     * @param bool  $preserveKeys
     * @throws \InvalidArgumentException if the provided argument $numberOfPieces is lower than 1
     *
     * @return array
     */
    public static function split(array $array, $numberOfPieces = 2, $preserveKeys = false)
    {
        if ($numberOfPieces <= 0) {
            throw new \InvalidArgumentException('Number of pieces parameter expected to be greater than 0');
        }

        if (count($array) === 0) {
            return [];
        }

        $splitSize = ceil(count($array) / $numberOfPieces);

        return array_chunk($array, $splitSize, $preserveKeys);
    }

    /**
     * Returns an array with the unique values from all the given arrays.
     *
     * @param \array[] $arrays
     *
     * @return array
     */
    public static function mergeValues(array...$arrays)
    {
        $allValues = array_reduce($arrays, static function ($carry, $array) {
            return array_merge($carry, $array);
        }, []);

        return array_values(array_unique($allValues));
    }

    /**
     * Flatten an array of arrays. The `$levels` parameter specifies how deep you want to
     * recurse in the array. If `$levels` is -1, the function will recurse infinitely.
     *
     * @param array $array
     * @param int   $levels
     *
     * @return array
     */
    public static function flatten(array $array, $levels = -1)
    {
        if ($levels === 0) {
            return $array;
        }

        $flattened = [];

        if ($levels !== -1) {
            --$levels;
        }

        foreach ($array as $element) {
            $flattened[] = is_array($element) ? array_flatten($element, $levels) : [$element];
        }

        return array_merge([], ...$flattened);
    }
}


1			<?php
2
3			namespace Spatie\Support;
4
5			class Arr
6			{
7			/**
8			* Get a random value from an array.
9			*
10			* @param array $array
11			* @param int $numReq The amount of values to return
12			*
13			* @return mixed
14			*/
15			public static function randValue(array $array, $numReq = 1)
16			{
17			if (!count($array)) {
18			return;
19			}
20
21			$keys = array_rand($array, $numReq);
22
23			if ($numReq === 1) {
24			return $array[$keys];
25			}
26
27			return array_intersect_key($array, array_flip($keys));
28			}
29
30			/**
31			* Get a random value from an array, with the ability to skew the results.
32			* Example: Arr::randWeighted(['foo' => 1, 'bar' => 2]) has a 66% chance of returning bar.
33			*
34			* @param array $array
35			*
36			* @return mixed
37			*/
38			public static function randWeighted(array $array)
39			{
40			$options = [];
41
42			foreach ($array as $option => $weight) {
43			for ($i = 0; $i < $weight; ++$i) {
44			$options[] = $option;
45			}
46			}
47
48			return array_rand_value($options);
49			}
50
51			/**
52			* Determine if all given needles are present in the haystack.
53			*
54			* @param array\|string $needles
55			* @param array $haystack
56			*
57			* @return bool
58			*/
59			public static function valuesInArray($needles, array $haystack)
60			{
61			if (!is_array($needles)) {
62			$needles = [$needles];
63			}
64
65			return count(array_intersect($needles, $haystack)) === count($needles);
66			}
67
68			/**
69			* Determine if all given needles are present in the haystack as array keys.
70			*
71			* @param array\|string $needles
72			* @param array $haystack
73			*
74			* @return bool
75			*/
76			public static function keysExist($needles, array $haystack)
77			{
78			if (!is_array($needles)) {
79			return array_key_exists($needles, $haystack);
80			}
81
82			return values_in_array($needles, array_keys($haystack));
83			}
84
85			/**
86			* Returns an array with two elements.
87			*
88			* Iterates over each value in the array passing them to the callback function.
89			* If the callback function returns true, the current value from array is returned in the first
90			* element of result array. If not, it is return in the second element of result array.
91			*
92			* Array keys are preserved.
93			*
94			* @param array $array
95			* @param callable $callback
96			*
97			* @return array
98			*/
99			public static function splitFilter(array $array, callable $callback)
100			{
101			$passesFilter = array_filter($array, $callback);
102
103			$negatedCallback = static function ($item) use ($callback) {return !$callback($item);};
104
105			$doesNotPassFilter = array_filter($array, $negatedCallback);
106
107			return [$passesFilter, $doesNotPassFilter];
108			}
109
110			/**
111			* Split an array in the given amount of pieces.
112			*
113			* @param array $array
114			* @param int $numberOfPieces
115			* @param bool $preserveKeys
116			* @throws \InvalidArgumentException if the provided argument $numberOfPieces is lower than 1
117			*
118			* @return array
119			*/
120			public static function split(array $array, $numberOfPieces = 2, $preserveKeys = false)
121			{
122			if ($numberOfPieces <= 0) {
123			throw new \InvalidArgumentException('Number of pieces parameter expected to be greater than 0');
124			}
125
126			if (count($array) === 0) {
127			return [];
128			}
129
130			$splitSize = ceil(count($array) / $numberOfPieces);
131
132			return array_chunk($array, $splitSize, $preserveKeys);
133			}
134
135			/**
136			* Returns an array with the unique values from all the given arrays.
137			*
138			* @param \array[] $arrays
139			*
140			* @return array
141			*/
142			public static function mergeValues(array...$arrays)
143			{
144			$allValues = array_reduce($arrays, static function ($carry, $array) {
145			return array_merge($carry, $array);
146			}, []);
147
148			return array_values(array_unique($allValues));
149			}
150
151			/**
152			* Flatten an array of arrays. The `$levels` parameter specifies how deep you want to
153			* recurse in the array. If `$levels` is -1, the function will recurse infinitely.
154			*
155			* @param array $array
156			* @param int $levels
157			*
158			* @return array
159			*/
160			public static function flatten(array $array, $levels = -1)
161			{
162			if ($levels === 0) {
163			return $array;
164			}
165
166			$flattened = [];
167
168			if ($levels !== -1) {
169			--$levels;
170			}
171
172			foreach ($array as $element) {
173			$flattened[] = is_array($element) ? array_flatten($element, $levels) : [$element];
174			}
175
176			return array_merge([], ...$flattened);
177			}
178			}
179

spatie / array-functions

GitHub Access Token became invalid

Pull Request — master (#17)

Arr::randWeighted() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like