类 yii\helpers\BaseArrayHelper

                public static function filter($array, $filters)
{
    $result = [];
    $excludeFilters = [];
    foreach ($filters as $filter) {
        if (!is_string($filter) && !is_int($filter)) {
            continue;
        }
        if (is_string($filter) && strncmp($filter, '!', 1) === 0) {
            $excludeFilters[] = substr($filter, 1);
            continue;
        }
        $nodeValue = $array; //set $array as root node
        $keys = explode('.', (string) $filter);
        foreach ($keys as $key) {
            if (!array_key_exists($key, $nodeValue)) {
                continue 2; //Jump to next filter
            }
            $nodeValue = $nodeValue[$key];
        }
        //We've found a value now let's insert it
        $resultNode = &$result;
        foreach ($keys as $key) {
            if (!array_key_exists($key, $resultNode)) {
                $resultNode[$key] = [];
            }
            $resultNode = &$resultNode[$key];
        }
        $resultNode = $nodeValue;
    }
    foreach ($excludeFilters as $filter) {
        $excludeNode = &$result;
        $keys = explode('.', (string) $filter);
        $numNestedKeys = count($keys) - 1;
        foreach ($keys as $i => $key) {
            if (!array_key_exists($key, $excludeNode)) {
                continue 2; //Jump to next filter
            }
            if ($i < $numNestedKeys) {
                $excludeNode = &$excludeNode[$key];
            } else {
                unset($excludeNode[$key]);
                break;
            }
        }
    }
    return $result;
}

            

                public static function getColumn($array, $name, $keepKeys = true)
{
    $result = [];
    if ($keepKeys) {
        foreach ($array as $k => $element) {
            $result[$k] = static::getValue($element, $name);
        }
    } else {
        foreach ($array as $element) {
            $result[] = static::getValue($element, $name);
        }
    }
    return $result;
}

            

                public static function getValue($array, $key, $default = null)
{
    if ($key instanceof \Closure) {
        return $key($array, $default);
    }
    if (is_array($key)) {
        $lastKey = array_pop($key);
        foreach ($key as $keyPart) {
            $array = static::getValue($array, $keyPart);
        }
        $key = $lastKey;
    }
    if (is_object($array) && property_exists($array, $key)) {
        return $array->$key;
    }
    if (static::keyExists($key, $array)) {
        return $array[$key];
    }
    if ($key && ($pos = strrpos($key, '.')) !== false) {
        $array = static::getValue($array, substr($key, 0, $pos), $default);
        $key = substr($key, $pos + 1);
    }
    if (static::keyExists($key, $array)) {
        return $array[$key];
    }
    if (is_object($array)) {
        // this is expected to fail if the property does not exist, or __get() is not implemented
        // it is not reliably possible to check whether a property is accessible beforehand
        try {
            return $array->$key;
        } catch (\Exception $e) {
            if ($array instanceof ArrayAccess) {
                return $default;
            }
            throw $e;
        }
    }
    return $default;
}

            

                public static function htmlDecode($data, $valuesOnly = true)
{
    $d = [];
    foreach ($data as $key => $value) {
        if (!$valuesOnly && is_string($key)) {
            $key = htmlspecialchars_decode($key, ENT_QUOTES | ENT_SUBSTITUTE);
        }
        if (is_string($value)) {
            $d[$key] = htmlspecialchars_decode($value, ENT_QUOTES | ENT_SUBSTITUTE);
        } elseif (is_array($value)) {
            $d[$key] = static::htmlDecode($value, $valuesOnly);
        } else {
            $d[$key] = $value;
        }
    }
    return $d;
}

            

                public static function htmlEncode($data, $valuesOnly = true, $charset = null)
{
    if ($charset === null) {
        $charset = Yii::$app ? Yii::$app->charset : 'UTF-8';
    }
    $d = [];
    foreach ($data as $key => $value) {
        if (!$valuesOnly && is_string($key)) {
            $key = htmlspecialchars($key, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
        }
        if (is_string($value)) {
            $d[$key] = htmlspecialchars($value, ENT_QUOTES | ENT_SUBSTITUTE, $charset);
        } elseif (is_array($value)) {
            $d[$key] = static::htmlEncode($value, $valuesOnly, $charset);
        } else {
            $d[$key] = $value;
        }
    }
    return $d;
}

            

                public static function index($array, $key, $groups = [])
{
    $result = [];
    $groups = (array) $groups;
    foreach ($array as $element) {
        $lastArray = &$result;
        foreach ($groups as $group) {
            $value = static::getValue($element, $group);
            if (!array_key_exists($value, $lastArray)) {
                $lastArray[$value] = [];
            }
            $lastArray = &$lastArray[$value];
        }
        if ($key === null) {
            if (!empty($groups)) {
                $lastArray[] = $element;
            }
        } else {
            $value = static::getValue($element, $key);
            if ($value !== null) {
                if (is_float($value)) {
                    $value = StringHelper::floatToString($value);
                }
                $lastArray[$value] = $element;
            }
        }
        unset($lastArray);
    }
    return $result;
}

            

                public static function isAssociative($array, $allStrings = true)
{
    if (empty($array) || !is_array($array)) {
        return false;
    }
    if ($allStrings) {
        foreach ($array as $key => $value) {
            if (!is_string($key)) {
                return false;
            }
        }
        return true;
    }
    foreach ($array as $key => $value) {
        if (is_string($key)) {
            return true;
        }
    }
    return false;
}

            

                public static function isIn($needle, $haystack, $strict = false)
{
    if (!static::isTraversable($haystack)) {
        throw new InvalidArgumentException('Argument $haystack must be an array or implement Traversable');
    }
    if (is_array($haystack)) {
        return in_array($needle, $haystack, $strict);
    }
    foreach ($haystack as $value) {
        if ($strict ? $needle === $value : $needle == $value) {
            return true;
        }
    }
    return false;
}

            

                public static function isIndexed($array, $consecutive = false)
{
    if (!is_array($array)) {
        return false;
    }
    if (empty($array)) {
        return true;
    }
    $keys = array_keys($array);
    if ($consecutive) {
        return $keys === array_keys($keys);
    }
    foreach ($keys as $key) {
        if (!is_int($key)) {
            return false;
        }
    }
    return true;
}

            

                public static function isSubset($needles, $haystack, $strict = false)
{
    if (!static::isTraversable($needles)) {
        throw new InvalidArgumentException('Argument $needles must be an array or implement Traversable');
    }
    foreach ($needles as $needle) {
        if (!static::isIn($needle, $haystack, $strict)) {
            return false;
        }
    }
    return true;
}

            

                public static function isTraversable($var)
{
    return is_array($var) || $var instanceof Traversable;
}

            

                public static function keyExists($key, $array, $caseSensitive = true)
{
    // ToDo: This check can be removed when the minimum PHP version is >= 8.1 (Yii2.2)
    if (is_float($key)) {
        $key = (int)$key;
    }
    if ($caseSensitive) {
        if (is_array($array) && array_key_exists($key, $array)) {
            return true;
        }
        // Cannot use `array_has_key` on Objects for PHP 7.4+, therefore we need to check using [[ArrayAccess::offsetExists()]]
        return $array instanceof ArrayAccess && $array->offsetExists($key);
    }
    if ($array instanceof ArrayAccess) {
        throw new InvalidArgumentException('Second parameter($array) cannot be ArrayAccess in case insensitive mode');
    }
    foreach (array_keys($array) as $k) {
        if (strcasecmp($key, $k) === 0) {
            return true;
        }
    }
    return false;
}

            

                public static function map($array, $from, $to, $group = null)
{
    $result = [];
    foreach ($array as $element) {
        $key = static::getValue($element, $from);
        $value = static::getValue($element, $to);
        if ($group !== null) {
            $result[static::getValue($element, $group)][$key] = $value;
        } else {
            $result[$key] = $value;
        }
    }
    return $result;
}

            

                public static function merge($a, $b)
{
    $args = func_get_args();
    $res = array_shift($args);
    while (!empty($args)) {
        foreach (array_shift($args) as $k => $v) {
            if ($v instanceof UnsetArrayValue) {
                unset($res[$k]);
            } elseif ($v instanceof ReplaceArrayValue) {
                $res[$k] = $v->value;
            } elseif (is_int($k)) {
                if (array_key_exists($k, $res)) {
                    $res[] = $v;
                } else {
                    $res[$k] = $v;
                }
            } elseif (is_array($v) && isset($res[$k]) && is_array($res[$k])) {
                $res[$k] = static::merge($res[$k], $v);
            } else {
                $res[$k] = $v;
            }
        }
    }
    return $res;
}

            

                public static function multisort(&$array, $key, $direction = SORT_ASC, $sortFlag = SORT_REGULAR)
{
    $keys = is_array($key) ? $key : [$key];
    if (empty($keys) || empty($array)) {
        return;
    }
    $n = count($keys);
    if (is_scalar($direction)) {
        $direction = array_fill(0, $n, $direction);
    } elseif (count($direction) !== $n) {
        throw new InvalidArgumentException('The length of $direction parameter must be the same as that of $keys.');
    }
    if (is_scalar($sortFlag)) {
        $sortFlag = array_fill(0, $n, $sortFlag);
    } elseif (count($sortFlag) !== $n) {
        throw new InvalidArgumentException('The length of $sortFlag parameter must be the same as that of $keys.');
    }
    $args = [];
    foreach ($keys as $i => $k) {
        $flag = $sortFlag[$i];
        $args[] = static::getColumn($array, $k);
        $args[] = $direction[$i];
        $args[] = $flag;
    }
    // This fix is used for cases when main sorting specified by columns has equal values
    // Without it it will lead to Fatal Error: Nesting level too deep - recursive dependency?
    $args[] = range(1, count($array));
    $args[] = SORT_ASC;
    $args[] = SORT_NUMERIC;
    $args[] = &$array;
    call_user_func_array('array_multisort', $args);
}

            

                public static function recursiveSort(array &$array, $sorter = null)
{
    foreach ($array as &$value) {
        if (is_array($value)) {
            static::recursiveSort($value, $sorter);
        }
    }
    unset($value);
    if ($sorter === null) {
        $sorter = static::isIndexed($array) ? 'sort' : 'ksort';
    }
    call_user_func_array($sorter, [&$array]);
    return $array;
}

            

                public static function remove(&$array, $key, $default = null)
{
    // ToDo: This check can be removed when the minimum PHP version is >= 8.1 (Yii2.2)
    if (is_float($key)) {
        $key = (int)$key;
    }
    if (is_array($array) && array_key_exists($key, $array)) {
        $value = $array[$key];
        unset($array[$key]);
        return $value;
    }
    return $default;
}

            

                public static function removeValue(&$array, $value)
{
    $result = [];
    if (is_array($array)) {
        foreach ($array as $key => $val) {
            if ($val === $value) {
                $result[$key] = $val;
                unset($array[$key]);
            }
        }
    }
    return $result;
}

            

                public static function setValue(&$array, $path, $value)
{
    if ($path === null) {
        $array = $value;
        return;
    }
    $keys = is_array($path) ? $path : explode('.', $path);
    while (count($keys) > 1) {
        $key = array_shift($keys);
        if (!isset($array[$key])) {
            $array[$key] = [];
        }
        if (!is_array($array[$key])) {
            $array[$key] = [$array[$key]];
        }
        $array = &$array[$key];
    }
    $array[array_shift($keys)] = $value;
}

            

                public static function toArray($object, $properties = [], $recursive = true)
{
    if (is_array($object)) {
        if ($recursive) {
            foreach ($object as $key => $value) {
                if (is_array($value) || is_object($value)) {
                    $object[$key] = static::toArray($value, $properties, true);
                }
            }
        }
        return $object;
    } elseif ($object instanceof \DateTimeInterface) {
        return (array)$object;
    } elseif (is_object($object)) {
        if (!empty($properties)) {
            $className = get_class($object);
            if (!empty($properties[$className])) {
                $result = [];
                foreach ($properties[$className] as $key => $name) {
                    if (is_int($key)) {
                        $result[$name] = $object->$name;
                    } else {
                        $result[$key] = static::getValue($object, $name);
                    }
                }
                return $recursive ? static::toArray($result, $properties) : $result;
            }
        }
        if ($object instanceof Arrayable) {
            $result = $object->toArray([], [], $recursive);
        } else {
            $result = [];
            foreach ($object as $key => $value) {
                $result[$key] = $value;
            }
        }
        return $recursive ? static::toArray($result, $properties) : $result;
    }
    return [$object];
}