array_unset() - Code Metrics - Inspection of "Fix phpunit config" - AgelxNash/functions - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dfe707...c47543 )

by Agel_Nash

created 2018-06-03 19:45 UTC

array_unset() B

↳ Parent: Project

Complexity

Conditions	6
Paths	4

Size

Total Lines	14
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	6
eloc	7
c	1
b	0
f	0
nc	4
nop	2
dl	0
loc	14
ccs	0
cts	7
cp	0
crap	42
rs	8.8571

<?php
if (! function_exists('for_all')) {
    /**
     * Применение callback функции к каждому элементу массива, который является строкой или просто строке
     * Всем переменным не являющимися массивом или строкой, будет присвоено значение null
     *
     * @param  mixed $data Строка или массив с данными
     * @param  Closure $callback callback функция
     * @return mixed
     */
    function for_all($data, Closure $callback)
    {
        switch (true) {
            case is_array($data):
                foreach ($data as &$val) {
                    $val = for_all($val, $callback);
                }
                break;
            case is_scalar($data):
                $data = $callback($data);
                break;
            default:
                $data = null;
        }

        return $data;
    }
}

if (! function_exists('get_key')) {
    /**
     * Получение значения по ключу из массива, либо возврат значения по умолчанию
     *
     * @param mixed $data массив
     * @param string $key ключ массива
     * @param mixed $default null значение по умолчанию
     * @param Closure $validate null функция дополнительной валидации значения (должна возвращать true или false)
     * @return mixed
     */
    function get_key($data, $key, $default = null, $validate = null)
    {
        $out = $default;
        if (is_array($data) && (is_int($key) || is_string($key)) && $key !== '' && array_key_exists($key, $data)) {
            $out = $data[$key];
        }
        if (! empty($validate) && is_callable($validate)) {
            $out = (($validate($out) === true) ? $out : $default);
        }

        return $out;
    }
}

if (! function_exists('rename_key_array')) {
    /**
     * Переменовывание элементов массива
     *
     * @param array $data массив с данными
     * @param string $prefix префикс ключей
     * @param string $suffix суффикс ключей
     * @param string $addPS разделитель суффиксов, префиксов и ключей массива
     * @param string $sep разделитель ключей при склейке многомерных массивов
     * @return array массив с переименованными ключами
     */
    function rename_key_array($data, $prefix = '', $suffix = '', $addPS = '.', $sep = '.')
    {
        $out = [];
        if (is_array($data)) {

            if (! is_scalar($addPS)) {

                $addPS = '';
            }
            $InsertPrefix = (is_scalar($prefix) && $prefix !== '') ? ($prefix . $addPS) : '';
            $InsertSuffix = (is_scalar($suffix) && $suffix !== '') ? ($addPS . $suffix) : '';
            foreach ($data as $key => $item) {
                $key = $InsertPrefix . $key;
                $val = null;
                switch (true) {
                    case is_scalar($item):
                        $val = $item;
                        break;
                    case is_array($item):
                        $val = (is_scalar($sep) && $sep !== '') ?
                            rename_key_array($item, $key . $sep, $InsertSuffix, '', $sep) : [];
                        $out = array_merge($out, $val);
                        $val = '';
                        break;
                }
                $out[$key . $InsertSuffix] = $val;
            }
        }

        return $out;
    }
}

if (! function_exists('make_array')) {
    /**
     * Создание многомерного массива из двухмерного, в имени которого содержится разделитель
     *
     * @param array $data массив с данными
     * @param string $sep разделитель ключей при склейке многомерных массивов
     * @return array массив с переименованными ключами
     */
    function make_array($data, $sep = '.')
    {
        $out = [];
        if (is_array($data)) {

            if (is_scalar($sep) && $sep !== '') {
                foreach ($data as $key => $val) {
                    $keys = explode($sep, $key);
                    $workArray = &$out;
                    foreach ($keys as $i => $subKey) {
                        if (! array_key_exists($subKey, $workArray)) {
                            $workArray[$subKey] = ($i + 1 == count($keys)) ? $val : [];
                        }
                        $workArray = &$workArray[$subKey];
                    }
                }
            } else {
                $out = $data;
            }
        }

        return $out;
    }
}

if (! function_exists('array_sort')) {
    /**
     * Сортировка массива
     *
     * @param array $arr массив с данными
     * @param string $sort_field по какому ключу сортировать массив
     * @param bool $desc направление сортировки
     * @return array
     */
    function array_sort(array $arr, $sort_field, $desc = false)
    {
        $first = reset($arr);
        if (! isset($first[$sort_field])) {
            return $arr;
        }
        $sort = [];
        foreach ($arr as $key => $item) {
            $sort[$key] = $item[$sort_field];
        }
        array_multisort($sort, $desc ? SORT_DESC : SORT_ASC, $arr);

        return $arr;
    }
}

if (! function_exists('array_unset')) {
    /**
     * Удаление списка ключей из массива
     *
     * @param array $arr массив с данными
     * @param string|array $keys ключ или массив ключей, которые необходимо удалить
     * @return array
     */
    function array_unset($arr, $keys)
    {
        if (is_scalar($keys)) {
            $keys = [$keys];
        }
        if (is_array($keys) && is_array($arr)) {

            foreach ($keys as $key) {
                if (is_scalar($key)) {
                    unset($arr[$key]);
                }
            }
        }

        return $arr;
    }
}

if (! function_exists('array_filter')) {
    /**
     * Фильтрация массива
     *
     * @param array $data массив с данными
     * @param string|Closure $filter функция для фильтрации массива
     * @return array
     */
    function array_filter($data, $filter)
    {
        $out = [];
        foreach ($data as $k => $v) {
            if (is_callable($filter) && $filter($v, $k)) {
                $out[$k] = $v;
            }
        }

        return $out;
    }
}

if (! function_exists('array_path')) {
    /**
     * Получение значения многомерного массива
     *
     * @param array $array многомерный массив
     * @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
     * @param mixed $default значение по умолчанию, если ключа в массиве нет
     * @param string $separator разделитель уровней массива
     * @return mixed
     */
    function array_path($array, $path, $default = null, $separator = '.')
    {
        $path = explode($separator, $path);
        while ($key = array_shift($path)) {
            if (! isset($array[$key])) {
                return $default;
            }
            $array = $array[$key];
        }

        return $array;
    }
}

if (! function_exists('array_path_unset')) {
    /**
     * Удаление ключа многомерного массива
     *
     * @param array $array многомерный массив
     * @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
     * @param string $separator разделитель уровней массива
     * @return void
     */
    function array_path_unset(&$array, $path, $separator = '.')
    {
        $tmp = &$array;
        $path = explode($separator, $path);
        while (count($path) > 1) {
            $key = array_shift($path);
            if (! isset($tmp[$key])) {
                return;
            }
            $tmp = &$tmp[$key];
        }
        unset($tmp[array_shift($path)]);
    }
}

if (! function_exists('array_path_replace')) {
    /**
     * Заменить значение многомерного массива
     *
     * @param array $array многомерный массив
     * @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
     * @param mixed $value новое значение
     * @param string $separator разделитель уровней массива
     * @return void
     */
    function array_path_replace(&$array, $path, $value, $separator = '.')
    {
        $tmp = &$array;
        $path = explode($separator, $path);
        while (count($path) > 1) {
            $key = array_shift($path);
            if (! isset($tmp[$key])) {
                $tmp[$key] = [];
            }
            $tmp = &$tmp[$key];
        }
        $tmp[array_shift($path)] = $value;
    }
}

if (! function_exists('array_clean')) {
    /**
     * Удалить пустые элементы из массива
     *
     * @param array $array
     * @param array $symbols удаляемые значения
     * @return array
     */
    function array_clean($array, array $symbols = ['', null])
    {
        return is_array($array) ? array_diff($array, $symbols) : [];

    }
}

if (! function_exists('array_shuffle')) {
    /**
     * Перемешать массив в случайном порядке с сохранением ключей
     *
     * @param array $data массив с данными
     * @return bool результат сортировки массива
     */
    function array_shuffle(array &$data = [])
    {
        return uksort($data, function () {
            return rand() > rand();
        });
    }
}

if (! function_exists('array_random')) {
    /**
     * Получить несколько случайных записей из массива с сохранением ключей
     *
     * @param array $data массив с данными
     * @param int $count требуемое число записей из массива
     * @return array|mixed
     */
    function array_random(array $data = [], $count = 1)
    {
        $flag = array_shuffle($data);
        if ($flag) {
            if ((int)$count > 0) {
                $data = current(array_chunk($data, (int)$count, true));
            }
        } else {
            $data = [];
        }

        return $data;
    }
}

if (! function_exists('is_assoc')) {
    /**
     * Является ли массив ассоциативным
     *
     * @param array $array проверяемый массив
     * @return bool результат проверки
     */
    function is_assoc($array)
    {
        return is_array($array) ? (bool)count(array_filter(array_keys($array), 'is_string')) : false;

    }
}

if (! function_exists('array_copy_key')) {
    /**
     * Определить ключи массива равыне значениям
     *
     * @param array $data исходный массив со значениями
     * @return array
     */
    function array_copy_key(array $data = [])
    {
        $data = array_filter($data, function ($val) {
            return is_scalar($val);
        });

        return array_combine($data, $data);
    }
}

if (! function_exists('make_tree')) {
    /**
     * Helper function
     * @see http://gostash.it/ru/users/3191
     *
     * @param array $tree flat data, implementing a id/parent id (adjacency list) structure
     * @param mixed $pid root id, node to return
     * @param string $parent parent id index
     * @param string $key id index
     * @param string $children children index
     * @return array
     */
    function make_tree($tree = [], $pid = 0, $parent = 'pid', $key = 'id', $children = 'tree')
    {
        $result = [];

        if (! empty($tree)) {
            $m = [];

            foreach ($tree as $e) {
                isset($m[$e[$parent]]) ?: $m[$e[$parent]] = [];
                isset($m[$e[$key]]) ?: $m[$e[$key]] = [];

                $m[$e[$parent]][] = array_merge($e, [$children => &$m[$e[$key]]]);
            }

            $result = $m[$pid];
        }

        return $result;
    }
}

if (! function_exists('array_chunk_vcolumn')) {
    /**
     * Разбиение массива на несколько частей с сохранением ключей, чтобы в каждой из этих частей было равное кол-во элементов
     * Массив наполняется последовательно. Т.е. сначала наполняется данными первая часть, потом вторая и так, пока не закончатся данные.
     *
     * @see: http://gostash.it/ru/stashes/117
     * @param array $input исходный массив
     * @param int $size кол-во частей
     */
    function array_chunk_vcolumn(array $input, $size)
    {
        $data = array_fill(0, $size, []);
        $size = ceil(count($input) / $size);
        $i = 0;
        $j = 0;
        foreach ($input as $k => $v) {
            if (++$j > $size) {
                $i++;
                $j = 1;
            }
            $data[$i][$k] = $v;
        }

        return $data;
    }
}

if (! function_exists('array_chunk_hcolumn')) {
    /**
     * Разбиение массива на несколько частей с сохранением ключей, чтобы в каждой из этих частей было равное кол-во элементов
     * Массив наполняется равномерно. Т.е. в первую строку каждой части складывается по одному элементу из массива. Затем аналогичным образом во вторую и так, пока не закончатся данные.
     *
     * @param array $input исходный массив
     * @param int $size кол-во частей
     */
    function array_chunk_hcolumn(array $input, $size)
    {
        $data = array_fill(0, $size, []);
        $j = -1;
        foreach ($input as $k => $v) {
            if (++$j >= $size) {
                $j = 0;
            }
            $data[$j][$k] = $v;
        }

        return $data;
    }
}

if (! function_exists('array_filter_keys')) {
    /**
     * Фильтрация массива по ключу
     *
     * @param array $array исходный массив
     * @param string $needle регулярное выражение для фильтрации ключей
     */
    function array_filter_keys($array, $needle)
    {
        $matchedKeys = array_filter(array_keys($array), function ($key) use ($needle) {
            return preg_match($needle, $key);
        });

        return array_intersect_key($array, array_flip($matchedKeys));
    }
}
if (! function_exists('choose_chance')) {
    /***
     * Выбор ключа массива со определенной вероятность
     * choose_chance(array("a" => 10, "b" => 25, "c" => 25, "d" => 40));
     *
     * @see: http://gostash.it/ru/stashes/381
     * @param array $arr исходный массив
     */
    function choose_chance(array $arr)
    {
        $rnd = mt_rand(1, array_sum($arr));
        $i = 0;
        foreach ($arr as $value => $chance) {
            $i += $chance;
            //$i = 51;
            if ($rnd <= $i) {
                return $value;
            }
        }
    }
}


1		<?php
2		if (! function_exists('for_all')) {
3		/**
4		* Применение callback функции к каждому элементу массива, который является строкой или просто строке
5		* Всем переменным не являющимися массивом или строкой, будет присвоено значение null
6		*
7		* @param mixed $data Строка или массив с данными
8		* @param Closure $callback callback функция
9		* @return mixed
10		*/
11		function for_all($data, Closure $callback)
12		{
13		switch (true) {
14	18	case is_array($data):
15		foreach ($data as &$val) {
16		$val = for_all($val, $callback);
17		}
18		break;
19	18	case is_scalar($data):
20	18	$data = $callback($data);
21	18	break;
22		default:
23		$data = null;
24		}
25
26	18	return $data;
27		}
28		}
29
30		if (! function_exists('get_key')) {
31		/**
32		* Получение значения по ключу из массива, либо возврат значения по умолчанию
33		*
34		* @param mixed $data массив
35		* @param string $key ключ массива
36		* @param mixed $default null значение по умолчанию
37		* @param Closure $validate null функция дополнительной валидации значения (должна возвращать true или false)
38		* @return mixed
39		*/
40		function get_key($data, $key, $default = null, $validate = null)
41		{
42	5	$out = $default;
43	5	if (is_array($data) && (is_int($key) \|\| is_string($key)) && $key !== '' && array_key_exists($key, $data)) {
44	4	$out = $data[$key];
45		}
46	5	if (! empty($validate) && is_callable($validate)) {
47	2	$out = (($validate($out) === true) ? $out : $default);
48		}
49
50	5	return $out;
51		}
52		}
53
54		if (! function_exists('rename_key_array')) {
55		/**
56		* Переменовывание элементов массива
57		*
58		* @param array $data массив с данными
59		* @param string $prefix префикс ключей
60		* @param string $suffix суффикс ключей
61		* @param string $addPS разделитель суффиксов, префиксов и ключей массива
62		* @param string $sep разделитель ключей при склейке многомерных массивов
63		* @return array массив с переименованными ключами
64		*/
65		function rename_key_array($data, $prefix = '', $suffix = '', $addPS = '.', $sep = '.')
66		{
67	9	$out = [];
68	9	if (is_array($data)) {
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_array($data)` is always `true`. Loading history...
69	9	if (! is_scalar($addPS)) {
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_scalar($addPS)` is always `true`. Loading history...
70		$addPS = '';
71		}
72	9	$InsertPrefix = (is_scalar($prefix) && $prefix !== '') ? ($prefix . $addPS) : '';
73	9	$InsertSuffix = (is_scalar($suffix) && $suffix !== '') ? ($addPS . $suffix) : '';
74	9	foreach ($data as $key => $item) {
75	9	$key = $InsertPrefix . $key;
76	9	$val = null;
77		switch (true) {
78	9	case is_scalar($item):
79	9	$val = $item;
80	9	break;
81	9	case is_array($item):
82	9	$val = (is_scalar($sep) && $sep !== '') ?
83	9	rename_key_array($item, $key . $sep, $InsertSuffix, '', $sep) : [];
84	9	$out = array_merge($out, $val);
85	9	$val = '';
86	9	break;
87		}
88	9	$out[$key . $InsertSuffix] = $val;
89		}
90		}
91
92	9	return $out;
93		}
94		}
95
96		if (! function_exists('make_array')) {
97		/**
98		* Создание многомерного массива из двухмерного, в имени которого содержится разделитель
99		*
100		* @param array $data массив с данными
101		* @param string $sep разделитель ключей при склейке многомерных массивов
102		* @return array массив с переименованными ключами
103		*/
104		function make_array($data, $sep = '.')
105		{
106	2	$out = [];
107	2	if (is_array($data)) {
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_array($data)` is always `true`. Loading history...
108	2	if (is_scalar($sep) && $sep !== '') {
109	1	foreach ($data as $key => $val) {
110	1	$keys = explode($sep, $key);
111	1	$workArray = &$out;
112	1	foreach ($keys as $i => $subKey) {
113	1	if (! array_key_exists($subKey, $workArray)) {
114	1	$workArray[$subKey] = ($i + 1 == count($keys)) ? $val : [];
115		}
116	1	$workArray = &$workArray[$subKey];
117		}
118		}
119		} else {
120	1	$out = $data;
121		}
122		}
123
124	2	return $out;
125		}
126		}
127
128		if (! function_exists('array_sort')) {
129		/**
130		* Сортировка массива
131		*
132		* @param array $arr массив с данными
133		* @param string $sort_field по какому ключу сортировать массив
134		* @param bool $desc направление сортировки
135		* @return array
136		*/
137		function array_sort(array $arr, $sort_field, $desc = false)
138		{
139		$first = reset($arr);
140		if (! isset($first[$sort_field])) {
141		return $arr;
142		}
143		$sort = [];
144		foreach ($arr as $key => $item) {
145		$sort[$key] = $item[$sort_field];
146		}
147		array_multisort($sort, $desc ? SORT_DESC : SORT_ASC, $arr);
148
149		return $arr;
150		}
151		}
152
153		if (! function_exists('array_unset')) {
154		/**
155		* Удаление списка ключей из массива
156		*
157		* @param array $arr массив с данными
158		* @param string\|array $keys ключ или массив ключей, которые необходимо удалить
159		* @return array
160		*/
161		function array_unset($arr, $keys)
162		{
163		if (is_scalar($keys)) {
164		$keys = [$keys];
165		}
166		if (is_array($keys) && is_array($arr)) {
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_array($arr)` is always `true`. Loading history...
167		foreach ($keys as $key) {
168		if (is_scalar($key)) {
169		unset($arr[$key]);
170		}
171		}
172		}
173
174		return $arr;
175		}
176		}
177
178		if (! function_exists('array_filter')) {
179		/**
180		* Фильтрация массива
181		*
182		* @param array $data массив с данными
183		* @param string\|Closure $filter функция для фильтрации массива
184		* @return array
185		*/
186		function array_filter($data, $filter)
187		{
188		$out = [];
189		foreach ($data as $k => $v) {
190		if (is_callable($filter) && $filter($v, $k)) {
191		$out[$k] = $v;
192		}
193		}
194
195		return $out;
196		}
197		}
198
199		if (! function_exists('array_path')) {
200		/**
201		* Получение значения многомерного массива
202		*
203		* @param array $array многомерный массив
204		* @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
205		* @param mixed $default значение по умолчанию, если ключа в массиве нет
206		* @param string $separator разделитель уровней массива
207		* @return mixed
208		*/
209		function array_path($array, $path, $default = null, $separator = '.')
210		{
211		$path = explode($separator, $path);
212		while ($key = array_shift($path)) {
213		if (! isset($array[$key])) {
214		return $default;
215		}
216		$array = $array[$key];
217		}
218
219		return $array;
220		}
221		}
222
223		if (! function_exists('array_path_unset')) {
224		/**
225		* Удаление ключа многомерного массива
226		*
227		* @param array $array многомерный массив
228		* @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
229		* @param string $separator разделитель уровней массива
230		* @return void
231		*/
232		function array_path_unset(&$array, $path, $separator = '.')
233		{
234		$tmp = &$array;
235		$path = explode($separator, $path);
236		while (count($path) > 1) {
237		$key = array_shift($path);
238		if (! isset($tmp[$key])) {
239		return;
240		}
241		$tmp = &$tmp[$key];
242		}
243		unset($tmp[array_shift($path)]);
244		}
245		}
246
247		if (! function_exists('array_path_replace')) {
248		/**
249		* Заменить значение многомерного массива
250		*
251		* @param array $array многомерный массив
252		* @param string $path путь к ключу многомерного массива (каждый уровень разделяется символом $separator)
253		* @param mixed $value новое значение
254		* @param string $separator разделитель уровней массива
255		* @return void
256		*/
257		function array_path_replace(&$array, $path, $value, $separator = '.')
258		{
259		$tmp = &$array;
260		$path = explode($separator, $path);
261		while (count($path) > 1) {
262		$key = array_shift($path);
263		if (! isset($tmp[$key])) {
264		$tmp[$key] = [];
265		}
266		$tmp = &$tmp[$key];
267		}
268		$tmp[array_shift($path)] = $value;
269		}
270		}
271
272		if (! function_exists('array_clean')) {
273		/**
274		* Удалить пустые элементы из массива
275		*
276		* @param array $array
277		* @param array $symbols удаляемые значения
278		* @return array
279		*/
280		function array_clean($array, array $symbols = ['', null])
281		{
282		return is_array($array) ? array_diff($array, $symbols) : [];
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_array($array)` is always `true`. Loading history...
283		}
284		}
285
286		if (! function_exists('array_shuffle')) {
287		/**
288		* Перемешать массив в случайном порядке с сохранением ключей
289		*
290		* @param array $data массив с данными
291		* @return bool результат сортировки массива
292		*/
293		function array_shuffle(array &$data = [])
294		{
295		return uksort($data, function () {
296		return rand() > rand();
297		});
298		}
299		}
300
301		if (! function_exists('array_random')) {
302		/**
303		* Получить несколько случайных записей из массива с сохранением ключей
304		*
305		* @param array $data массив с данными
306		* @param int $count требуемое число записей из массива
307		* @return array\|mixed
308		*/
309		function array_random(array $data = [], $count = 1)
310		{
311		$flag = array_shuffle($data);
312		if ($flag) {
313		if ((int)$count > 0) {
314		$data = current(array_chunk($data, (int)$count, true));
315		}
316		} else {
317		$data = [];
318		}
319
320		return $data;
321		}
322		}
323
324		if (! function_exists('is_assoc')) {
325		/**
326		* Является ли массив ассоциативным
327		*
328		* @param array $array проверяемый массив
329		* @return bool результат проверки
330		*/
331		function is_assoc($array)
332		{
333		return is_array($array) ? (bool)count(array_filter(array_keys($array), 'is_string')) : false;
		0 ignored issues – show introduced 2018-06-03 19:50 UTC by Report Bug Copy Issue Report The condition `is_array($array)` is always `true`. Loading history...
334		}
335		}
336
337		if (! function_exists('array_copy_key')) {
338		/**
339		* Определить ключи массива равыне значениям
340		*
341		* @param array $data исходный массив со значениями
342		* @return array
343		*/
344		function array_copy_key(array $data = [])
345		{
346		$data = array_filter($data, function ($val) {
347		return is_scalar($val);
348		});
349
350		return array_combine($data, $data);
351		}
352		}
353
354		if (! function_exists('make_tree')) {
355		/**
356		* Helper function
357		* @see http://gostash.it/ru/users/3191
358		*
359		* @param array $tree flat data, implementing a id/parent id (adjacency list) structure
360		* @param mixed $pid root id, node to return
361		* @param string $parent parent id index
362		* @param string $key id index
363		* @param string $children children index
364		* @return array
365		*/
366		function make_tree($tree = [], $pid = 0, $parent = 'pid', $key = 'id', $children = 'tree')
367		{
368		$result = [];
369
370		if (! empty($tree)) {
371		$m = [];
372
373		foreach ($tree as $e) {
374		isset($m[$e[$parent]]) ?: $m[$e[$parent]] = [];
375		isset($m[$e[$key]]) ?: $m[$e[$key]] = [];
376
377		$m[$e[$parent]][] = array_merge($e, [$children => &$m[$e[$key]]]);
378		}
379
380		$result = $m[$pid];
381		}
382
383		return $result;
384		}
385		}
386
387		if (! function_exists('array_chunk_vcolumn')) {
388		/**
389		* Разбиение массива на несколько частей с сохранением ключей, чтобы в каждой из этих частей было равное кол-во элементов
390		* Массив наполняется последовательно. Т.е. сначала наполняется данными первая часть, потом вторая и так, пока не закончатся данные.
391		*
392		* @see: http://gostash.it/ru/stashes/117
393		* @param array $input исходный массив
394		* @param int $size кол-во частей
395		*/
396		function array_chunk_vcolumn(array $input, $size)
397		{
398		$data = array_fill(0, $size, []);
399		$size = ceil(count($input) / $size);
400		$i = 0;
401		$j = 0;
402		foreach ($input as $k => $v) {
403		if (++$j > $size) {
404		$i++;
405		$j = 1;
406		}
407		$data[$i][$k] = $v;
408		}
409
410		return $data;
411		}
412		}
413
414		if (! function_exists('array_chunk_hcolumn')) {
415		/**
416		* Разбиение массива на несколько частей с сохранением ключей, чтобы в каждой из этих частей было равное кол-во элементов
417		* Массив наполняется равномерно. Т.е. в первую строку каждой части складывается по одному элементу из массива. Затем аналогичным образом во вторую и так, пока не закончатся данные.
418		*
419		* @param array $input исходный массив
420		* @param int $size кол-во частей
421		*/
422		function array_chunk_hcolumn(array $input, $size)
423		{
424		$data = array_fill(0, $size, []);
425		$j = -1;
426		foreach ($input as $k => $v) {
427		if (++$j >= $size) {
428		$j = 0;
429		}
430		$data[$j][$k] = $v;
431		}
432
433		return $data;
434		}
435		}
436
437		if (! function_exists('array_filter_keys')) {
438		/**
439		* Фильтрация массива по ключу
440		*
441		* @param array $array исходный массив
442		* @param string $needle регулярное выражение для фильтрации ключей
443		*/
444		function array_filter_keys($array, $needle)
445		{
446		$matchedKeys = array_filter(array_keys($array), function ($key) use ($needle) {
447		return preg_match($needle, $key);
448		});
449
450		return array_intersect_key($array, array_flip($matchedKeys));
451		}
452		}
453		if (! function_exists('choose_chance')) {
454		/***
455		* Выбор ключа массива со определенной вероятность
456		* choose_chance(array("a" => 10, "b" => 25, "c" => 25, "d" => 40));
457		*
458		* @see: http://gostash.it/ru/stashes/381
459		* @param array $arr исходный массив
460		*/
461		function choose_chance(array $arr)
462		{
463		$rnd = mt_rand(1, array_sum($arr));
464		$i = 0;
465		foreach ($arr as $value => $chance) {
466		$i += $chance;
467		//$i = 51;
468		if ($rnd <= $i) {
469		return $value;
470		}
471		}
472		}
473		}
474

AgelxNash / functions

Push — master ( dfe707...c47543 )

array_unset() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like