ArrayUtility.php

Go to the documentation of this file.

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

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */
use TYPO3\CMS\Core\Utility\GeneralUtility;

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

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

    public static function arrayMergeRecursiveOverrule(array $firstArray, array $secondArray, $dontAddNewKeys = false, $emptyValuesOverride = true)
    {
        GeneralUtility::logDeprecatedFunction();
        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;
    }

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

    public static function containsMultipleTypes(array $array)
    {
        GeneralUtility::logDeprecatedFunction();
        if (!empty($array)) {
            foreach ($array as $value) {
                if (!isset($previousType)) {
                    $previousType = gettype($value);
                } elseif ($previousType !== gettype($value)) {
                    return true;
                }
            }
        }
        return false;
    }

    public static function array_reduce(array $array, $function, $initial = null)
    {
        GeneralUtility::logDeprecatedFunction();
        $accumlator = $initial;
        foreach ($array as $value) {
            $accumlator = $function($accumlator, $value);
        }
        return $accumlator;
    }

    public static function getValueByPath(array &$array, $path)
    {
        GeneralUtility::logDeprecatedFunction();
        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 (!empty($path)) {
                return is_array($array[$key]) ? self::getValueByPath($array[$key], $path) : null;
            }
            return $array[$key];
        }
        return null;
    }

    public static function setValueByPath($subject, $path, $value)
    {
        GeneralUtility::logDeprecatedFunction();
        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 (empty($path)) {
            $subject[$key] = $value;
        } else {
            if (!isset($subject[$key]) || !is_array($subject[$key])) {
                $subject[$key] = [];
            }
            $subject[$key] = self::setValueByPath($subject[$key], $path, $value);
        }
        return $subject;
    }

    public static function unsetValueByPath(array $array, $path)
    {
        GeneralUtility::logDeprecatedFunction();
        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 (empty($path)) {
            unset($array[$key]);
        } else {
            if (!isset($array[$key]) || !is_array($array[$key])) {
                return $array;
            }
            $array[$key] = self::unsetValueByPath($array[$key], $path);
        }
        return $array;
    }

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

    public static function convertObjectToArray($subject)
    {
        GeneralUtility::logDeprecatedFunction();
        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;
    }

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

    public static function sortArrayWithIntegerKeys($array)
    {
        GeneralUtility::logDeprecatedFunction();
        $containsNumericalKeysOnly = true;
        array_walk($array, function ($value, $key) use (&$containsNumericalKeysOnly) {
            if (!is_int($key)) {
                $containsNumericalKeysOnly = false;
                return;
            }
        });
        if ($containsNumericalKeysOnly === true) {
            ksort($array);
        }
        return $array;
    }
}