ArrayUtility.php

Go to the documentation of this file.

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

class ArrayUtility {

    static public function integerExplode($delimiter, $string) {
        $explodedValues = explode($delimiter, $string);
        foreach ($explodedValues as &$value) {
            $value = (int)$value;
        }
        unset($value);
        return $explodedValues;
    }

    static public function trimExplode($delimiter, $string, $onlyNonEmptyValues = FALSE) {
        $chunksArr = explode($delimiter, $string);
        $newChunksArr = array();
        foreach ($chunksArr as $value) {
            if ($onlyNonEmptyValues === FALSE || trim($value) !== '') {
                $newChunksArr[] = trim($value);
            }
        }
        reset($newChunksArr);
        return $newChunksArr;
    }

    static public function arrayMergeRecursiveOverrule(array $firstArray, array $secondArray, $dontAddNewKeys = FALSE, $emptyValuesOverride = TRUE) {
        foreach ($secondArray as $key => $value) {
            if (array_key_exists($key, $firstArray) && is_array($firstArray[$key])) {
                if (is_array($secondArray[$key])) {
                    $firstArray[$key] = self::arrayMergeRecursiveOverrule($firstArray[$key], $secondArray[$key], $dontAddNewKeys, $emptyValuesOverride);
                } else {
                    $firstArray[$key] = $secondArray[$key];
                }
            } else {
                if ($dontAddNewKeys) {
                    if (array_key_exists($key, $firstArray)) {
                        if ($emptyValuesOverride || !empty($value)) {
                            $firstArray[$key] = $value;
                        }
                    }
                } else {
                    if ($emptyValuesOverride || !empty($value)) {
                        $firstArray[$key] = $value;
                    }
                }
            }
        }
        reset($firstArray);
        return $firstArray;
    }

    static public function randomizeArrayOrder(array $array) {
        $reorderedArray = array();
        if (count($array) > 1) {
            $keysInRandomOrder = array_rand($array, count($array));
            foreach ($keysInRandomOrder as $key) {
                $reorderedArray[] = $array[$key];
            }
        } else {
            $reorderedArray = $array;
        }
        return $reorderedArray;
    }

    static public function containsMultipleTypes(array $array) {
        if (count($array) > 0) {
            foreach ($array as $value) {
                if (!isset($previousType)) {
                    $previousType = gettype($value);
                } elseif ($previousType !== gettype($value)) {
                    return TRUE;
                }
            }
        }
        return FALSE;
    }

    static public function array_reduce(array $array, $function, $initial = NULL) {
        $accumlator = $initial;
        foreach ($array as $value) {
            $accumlator = $function($accumlator, $value);
        }
        return $accumlator;
    }

    static public function getValueByPath(array &$array, $path) {
        if (is_string($path)) {
            $path = explode('.', $path);
        } elseif (!is_array($path)) {
            throw new \InvalidArgumentException('getValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1304950007);
        }
        $key = array_shift($path);
        if (isset($array[$key])) {
            if (count($path) > 0) {
                return is_array($array[$key]) ? self::getValueByPath($array[$key], $path) : NULL;
            } else {
                return $array[$key];
            }
        } else {
            return NULL;
        }
    }

    static public function setValueByPath($subject, $path, $value) {
        if (!is_array($subject) && !$subject instanceof \ArrayAccess) {
            throw new \InvalidArgumentException('setValueByPath() expects $subject to be array or an object implementing \\ArrayAccess, "' . (is_object($subject) ? get_class($subject) : gettype($subject)) . '" given.', 1306424308);
        }
        if (is_string($path)) {
            $path = explode('.', $path);
        } elseif (!is_array($path)) {
            throw new \InvalidArgumentException('setValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1305111499);
        }
        $key = array_shift($path);
        if (count($path) === 0) {
            $subject[$key] = $value;
        } else {
            if (!isset($subject[$key]) || !is_array($subject[$key])) {
                $subject[$key] = array();
            }
            $subject[$key] = self::setValueByPath($subject[$key], $path, $value);
        }
        return $subject;
    }

    static public function unsetValueByPath(array $array, $path) {
        if (is_string($path)) {
            $path = explode('.', $path);
        } elseif (!is_array($path)) {
            throw new \InvalidArgumentException('unsetValueByPath() expects $path to be string or array, "' . gettype($path) . '" given.', 1305111513);
        }
        $key = array_shift($path);
        if (count($path) === 0) {
            unset($array[$key]);
        } else {
            if (!isset($array[$key]) || !is_array($array[$key])) {
                return $array;
            }
            $array[$key] = self::unsetValueByPath($array[$key], $path);
        }
        return $array;
    }

    static public function sortKeysRecursively(array &$array, $sortFlags = NULL) {
        foreach ($array as &$value) {
            if (is_array($value)) {
                if (self::sortKeysRecursively($value, $sortFlags) === FALSE) {
                    return FALSE;
                }
            }
        }
        return ksort($array, $sortFlags);
    }

    static public function convertObjectToArray($subject) {
        if (!is_object($subject) && !is_array($subject)) {
            throw new \InvalidArgumentException('convertObjectToArray expects either array or object as input, ' . gettype($subject) . ' given.', 1287059709);
        }
        if (is_object($subject)) {
            $subject = (array) $subject;
        }
        foreach ($subject as $key => $value) {
            if (is_array($value) || is_object($value)) {
                $subject[$key] = self::convertObjectToArray($value);
            }
        }
        return $subject;
    }

    static public function removeEmptyElementsRecursively(array $array) {
        $result = $array;
        foreach ($result as $key => $value) {
            if (is_array($value)) {
                $result[$key] = self::removeEmptyElementsRecursively($value);
                if ($result[$key] === array()) {
                    unset($result[$key]);
                }
            } elseif ($value === NULL) {
                unset($result[$key]);
            }
        }
        return $result;
    }

    public static function sortArrayWithIntegerKeys($array) {
        $containsNumericalKeysOnly = TRUE;
        array_walk($array, function($value, $key) use (&$containsNumericalKeysOnly) {
            if (!is_integer($key)) {
                $containsNumericalKeysOnly = FALSE;
                return;
            }
        });
        if ($containsNumericalKeysOnly === TRUE) {
            ksort($array);
        }
        return $array;
    }
}