ArrayUtility.php

Go to the documentation of this file.

<?php
namespace TYPO3\CMS\Core\Utility;

class ArrayUtility {

    static public function filterByValueRecursive($needle = '', array $haystack = array()) {
        $resultArray = array();
        // Define a lambda function to be applied to all members of this array dimension
        // Call recursive if current value is of type array
        // Write to $resultArray (by reference!) if types and value match
        $callback = function (&$value, $key) use($needle, &$resultArray) {
            if ($value === $needle) {
                ($resultArray[$key] = $value);
            } elseif (is_array($value)) {
                ($subArrayMatches = \TYPO3\CMS\Core\Utility\ArrayUtility::filterByValueRecursive($needle, $value));
                if (count($subArrayMatches) > 0) {
                    ($resultArray[$key] = $subArrayMatches);
                }
            }
        };
        // array_walk() is not affected by the internal pointers, no need to reset
        array_walk($haystack, $callback);
        // Pointers to result array are reset internally
        return $resultArray;
    }

    static public function isValidPath(array $array, $path, $delimiter = '/') {
        $isValid = TRUE;
        try {
            // Use late static binding to enable mocking of this call in unit tests
            static::getValueByPath($array, $path, $delimiter);
        } catch (\RuntimeException $e) {
            $isValid = FALSE;
        }
        return $isValid;
    }

    static public function getValueByPath(array $array, $path, $delimiter = '/') {
        if (empty($path)) {
            throw new \RuntimeException('Path must not be empty', 1341397767);
        }
        // Extract parts of the path
        $path = str_getcsv($path, $delimiter);
        // Loop through each part and extract its value
        $value = $array;
        foreach ($path as $segment) {
            if (array_key_exists($segment, $value)) {
                // Replace current value with child
                $value = $value[$segment];
            } else {
                // Fail if key does not exist
                throw new \RuntimeException('Path does not exist in array', 1341397869);
            }
        }
        return $value;
    }

    static public function setValueByPath(array $array, $path, $value, $delimiter = '/') {
        if (empty($path)) {
            throw new \RuntimeException('Path must not be empty', 1341406194);
        }
        if (!is_string($path)) {
            throw new \RuntimeException('Path must be a string', 1341406402);
        }
        // Extract parts of the path
        $path = str_getcsv($path, $delimiter);
        // Point to the root of the array
        $pointer = &$array;
        // Find path in given array
        foreach ($path as $segment) {
            // Fail if the part is empty
            if (empty($segment)) {
                throw new \RuntimeException('Invalid path segment specified', 1341406846);
            }
            // Create cell if it doesn't exist
            if (!array_key_exists($segment, $pointer)) {
                $pointer[$segment] = array();
            }
            // Set pointer to new cell
            $pointer = &$pointer[$segment];
        }
        // Set value of target cell
        $pointer = $value;
        return $array;
    }

    static public function removeByPath(array $array, $path, $delimiter = '/') {
        if (empty($path)) {
            throw new \RuntimeException('Path must not be empty', 1371757718);
        }
        if (!is_string($path)) {
            throw new \RuntimeException('Path must be a string', 1371757719);
        }
        // Extract parts of the path
        $path = str_getcsv($path, $delimiter);
        $pathDepth = count($path);
        $currentDepth = 0;
        $pointer = &$array;
        // Find path in given array
        foreach ($path as $segment) {
            $currentDepth++;
            // Fail if the part is empty
            if (empty($segment)) {
                throw new \RuntimeException('Invalid path segment specified', 1371757720);
            }
            if (!array_key_exists($segment, $pointer)) {
                throw new \RuntimeException('Path segment ' . $segment . ' does not exist in array', 1371758436);
            }
            if ($currentDepth === $pathDepth) {
                unset($pointer[$segment]);
            } else {
                $pointer = &$pointer[$segment];
            }
        }
        return $array;
    }

    static public function sortByKeyRecursive(array $array) {
        ksort($array);
        foreach ($array as $key => $value) {
            if (is_array($value) && !empty($value)) {
                $array[$key] = self::sortByKeyRecursive($value);
            }
        }
        return $array;
    }

    static public function sortArraysByKey(array $arrays, $key, $ascending = TRUE) {
        if (empty($arrays)) {
            return $arrays;
        }
        // @ operator used: Some PHP versions like 5.4.4-14+deb7u8 (debian wheezy) are
        // affected by PHP bug https://bugs.php.net/bug.php?id=50688 and trigger a warning.
        // The code itself is ok and covered by unit tests, so the @ operator is used to
        // suppress output of the PHP bug. This can be removed if the core does not
        // support PHP version affected by this issue anymore.
        $sortResult = @uasort($arrays, function (array $a, array $b) use ($key, $ascending) {
            if (!isset($a[$key]) || !isset($b[$key])) {
                throw new \RuntimeException('The specified sorting key "' . $key . '" is not available in the given array.', 1373727309);
            }
            return ($ascending) ? strcasecmp($a[$key], $b[$key]) : strcasecmp($b[$key], $a[$key]);
        });
        if (!$sortResult) {
            throw new \RuntimeException('The function uasort() failed for unknown reasons.', 1373727329);
        }
        return $arrays;
    }

    static public function arrayExport(array $array = array(), $level = 0) {
        $lines = 'array(' . LF;
        $level++;
        $writeKeyIndex = FALSE;
        $expectedKeyIndex = 0;
        foreach ($array as $key => $value) {
            if ($key === $expectedKeyIndex) {
                $expectedKeyIndex++;
            } else {
                // Found a non integer or non consecutive key, so we can break here
                $writeKeyIndex = TRUE;
                break;
            }
        }
        foreach ($array as $key => $value) {
            // Indention
            $lines .= str_repeat(TAB, $level);
            if ($writeKeyIndex) {
                // Numeric / string keys
                $lines .= is_int($key) ? $key . ' => ' : '\'' . $key . '\' => ';
            }
            if (is_array($value)) {
                if (count($value) > 0) {
                    $lines .= self::arrayExport($value, $level);
                } else {
                    $lines .= 'array(),' . LF;
                }
            } elseif (is_int($value) || is_float($value)) {
                $lines .= $value . ',' . LF;
            } elseif (is_null($value)) {
                $lines .= 'NULL' . ',' . LF;
            } elseif (is_bool($value)) {
                $lines .= $value ? 'TRUE' : 'FALSE';
                $lines .= ',' . LF;
            } elseif (is_string($value)) {
                // Quote \ to \\
                $stringContent = str_replace('\\', '\\\\', $value);
                // Quote ' to \'
                $stringContent = str_replace('\'', '\\\'', $stringContent);
                $lines .= '\'' . $stringContent . '\'' . ',' . LF;
            } else {
                throw new \RuntimeException('Objects are not supported', 1342294987);
            }
        }
        $lines .= str_repeat(TAB, ($level - 1)) . ')' . ($level - 1 == 0 ? '' : ',' . LF);
        return $lines;
    }

    static public function flatten(array $array, $prefix = '') {
        $flatArray = array();
        foreach ($array as $key => $value) {
            // Ensure there is no trailling dot:
            $key = rtrim($key, '.');
            if (!is_array($value)) {
                $flatArray[$prefix . $key] = $value;
            } else {
                $flatArray = array_merge($flatArray, self::flatten($value, $prefix . $key . '.'));
            }
        }
        return $flatArray;
    }

    public static function intersectRecursive(array $source, array $mask = array()) {
        $intersection = array();
        foreach ($source as $key => $_) {
            if (!array_key_exists($key, $mask)) {
                continue;
            }
            if (is_array($source[$key]) && is_array($mask[$key])) {
                $value = self::intersectRecursive($source[$key], $mask[$key]);
                if (!empty($value)) {
                    $intersection[$key] = $value;
                }
            } else {
                $intersection[$key] = $source[$key];
            }
        }
        return $intersection;
    }

    static public function renumberKeysToAvoidLeapsIfKeysAreAllNumeric(array $array = array(), $level = 0) {
        $level++;
        $allKeysAreNumeric = TRUE;
        foreach ($array as $key => $_) {
            if (is_numeric($key) === FALSE) {
                $allKeysAreNumeric = FALSE;
                break;
            }
        }
        $renumberedArray = $array;
        if ($allKeysAreNumeric === TRUE) {
            $renumberedArray = array_values($array);
        }
        foreach ($renumberedArray as $key => $value) {
            if (is_array($value)) {
                $renumberedArray[$key] = self::renumberKeysToAvoidLeapsIfKeysAreAllNumeric($value, $level);
            }
        }
        return $renumberedArray;
    }


    static public function mergeRecursiveWithOverrule(array &$original, array $overrule, $addKeys = TRUE, $includeEmptyValues = TRUE, $enableUnsetFeature = TRUE) {
        foreach ($overrule as $key => $_) {
            if ($enableUnsetFeature && $overrule[$key] === '__UNSET') {
                unset($original[$key]);
                continue;
            }
            if (isset($original[$key]) && is_array($original[$key])) {
                if (is_array($overrule[$key])) {
                    self::mergeRecursiveWithOverrule($original[$key], $overrule[$key], $addKeys, $includeEmptyValues, $enableUnsetFeature);
                }
            } elseif (
                ($addKeys || isset($original[$key])) &&
                ($includeEmptyValues || $overrule[$key])
            ) {
                $original[$key] = $overrule[$key];
            }
        }
        // This line is kept for backward compatibility reasons.
        reset($original);
    }
}