get_key() - Code Metrics - AgelxNash/functions - Measure and Improve Code Quality continuously with Scrutinizer

get_key() C
last analyzed 2018-10-10 16:34 UTC

↳ Parent: Project

Complexity

Conditions	16
Paths	24

Size

Total Lines	36
Code Lines	26

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	21
CRAP Score	16.1685

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
cc	16
eloc	26
c	2
b	0
f	0
nc	24
nop	4
dl	0
loc	36
ccs	21
cts	23
cp	0.913
crap	16.1685
rs	5.5666

How to fix Complexity

<?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 int|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;
        $found = false;
        if (is_array($data) && (is_int($key) || is_string($key)) && $key !== '') {
            if (array_key_exists($key, $data)) {
                $out = $data[$key];
                $found = true;
            } else {
                $offset = 0;
                do {
                    if (($pos = \mb_strpos($key, '.', $offset)) > 0) {
                        $subData = get_key($data, mb_substr($key, 0, $pos));
                        $offset = $pos + 1;
                        $subKey = mb_substr($key, $offset);
                        if (\is_array($subData) && array_key_exists($subKey, $subData)) {
                            $out = $subData[$subKey];
                            $found = true;
                            break;
                        }
                    } else {
                        break;
                    }
                } while (true);

                if ($found === false && ($pos = \mb_strpos($key, '.', $offset)) > 0) {
                    $subData = get_key($data, mb_substr($key, 0, $pos));
                    $out = get_key($subData, mb_substr($key, $pos + 1), $default, $validate);
                }
            }
        }
        if ($found === true && ! empty($validate) && is_callable($validate)) {
            $out = (($validate($out) === true) ? $out : $default);
        }

        return $out;
    }
}

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

AgelxNash / functions

get_key() C last analyzed 2018-10-10 16:34 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

get_key() C
last analyzed 2018-10-10 16:34 UTC