@param       $key
@param array $exclude

@return array
771457
protected function excludeNext($key, array $exclude)
  {
    if (array_key_exists($key, $exclude) && is_array($exclude[$key]))
    {
      return $exclude[$key];
    }

    return array();
  }
1270286
public static function getAll(array $only = [], array $exclude = [], $alias = false)
    {
        return $alias === true
            ? ArrayHelper::only(static::$classAliases, $only, $exclude)
            : ArrayHelper::only(static::$classNames, $only, $exclude);
    }
674380
public function getOptions(array $excludes = null): array
    {
        if (! is_null($excludes)) {
            return array_filter($this->options, function ($key) use ($excludes) {
                return ! in_array($key, $excludes, true);
            }, ARRAY_FILTER_USE_KEY);
        }

        return $this->options;
    }
464721
public function get($name, array $exclude = [])
    {
        $dependency = $this->getProvider($name)->getDependency();
        $value = $dependency->getValue();
        if (!($value instanceof Closure)) {
            return $value;
        }

        $exclude[] = $name;
        $function = new FunctionWrapper($value);
        $this->dependenciesParams[$name] = array_map(function (ReflectionParameter $param) {
            return $param->name;
        }, $function->getParameters());

        $cacheKey = spl_object_hash($value).'_'.$name;

        if (!isset($this->cache[$cacheKey])) {
            $callee = function () use ($cacheKey) {
                return call_user_func_array($this->cache[$cacheKey], func_get_args());
            };
            $arguments = array_map(function ($dependencyName) use ($exclude, $callee) {
                return in_array($dependencyName, $exclude)
                    ? $callee
                    : $this->get($dependencyName, $exclude);
            }, $dependency->getDependencies());

            $this->cache[$cacheKey] = call_user_func_array($value, $arguments);
        }

        return $this->cache[$cacheKey];
    }
299158
public function getParams(array $keys = null)
    {
        $params = $this->params;

        if ($keys) {
            $subset = [];
            foreach ($keys as $key) {
                if (array_key_exists($key, $params)) {
                    $subset[$key] = $params[$key];
                }
            }
            return $subset;
        }

        return $params;
    }
997657
public function fetch($key) : Collection
    {
        $extr = [];
        foreach ($this->list as $list) {
            if (is_array($list) && key_exists($key, $list)) {
                $extr[] = $list[$key];
            }
        }

        return self::from(...$extr);
    }
1100306
private function makeFinder(array $directories = [], array $exclude = []): Finder
    {
        $finder = new Finder();

        if (empty($directories)) {
            $directories = $this->config->getDirectories();
        }

        if (empty($exclude)) {
            $exclude = $this->config->getExcludes();
        }

        return $finder->files()->in($directories)->exclude($exclude)->name('*.php');
    }
1042700
public function parseExcludes($excludes)
    {
        $this->requestedExcludes = [];

        if (is_string($excludes)) {
            $excludes = explode(',', $excludes);
        }

        if (! is_array($excludes)) {
            throw new \InvalidArgumentException(
                'The parseExcludes() method expects a string or an array. '.gettype($excludes).' given'
            );
        }

        foreach ($excludes as $excludeName) {
            $excludeName = $this->trimToAcceptableRecursionLevel($excludeName);

            if (in_array($excludeName, $this->requestedExcludes)) {
                continue;
            }

            $this->requestedExcludes[] = $excludeName;
        }

        return $this;
    }
1218576
public function get($key)
    {
        $res = $this->_errors[$key];
        if (!is_array($res)) {
            return [$res];
        }

        return $res;
    }
320565
public function except($keys)
    {
        $keys = is_array($keys) ? $keys : func_get_args();
        $results = [];
        $inputs = $this->all();
        foreach ($inputs as $key => $input) {
            if(!in_array($key,$keys))
                $results[$key] = $input[$key];
        }
        return $results;
    }
305689
public function exclude($key)
    {
        $this->populateInput();

        if (array_key_exists($key, $this->input)) {
            unset($this->input[$key]);
        }

        return $this->input;
    }
597056
public function getTableColumns( $table, array $exclude = [ ] )
    {
        $query = "pragma table_info( $table )";

        $result = $this->query( $query );

        // grab all columns
        $columns = [ ];

        foreach ( $result as $res )
        {
            foreach ( $res as $key => $value )
            {
                if ( 'name' === $key && !in_array( $value, $exclude ) )
                {
                    $null = ' NULL';

                    if ( TRUE === ( bool ) $res[ 'notnull' ] )
                    {
                        $null = ' NOT NULL';
                    }

                    $columns[ $value ] = $res[ 'type' ] . $null;
                }
            }
        }

        return $columns;
    }
132611
public function values(?string $key = null) : array
    {
        $value = $this->get($key);

        if (!is_array($value)) {
            throw new InvalidArgumentException(
                'method values() should be called on array'
            );
        }

        return array_values($value);
    }
622636
function addExclude($exclude) {
        $exclude = func_get_args();
        foreach($exclude as $v) {
            $this->exclude = array_merge($this->exclude, (array) $v);
        }
        
        return $this;
    }
534859
public static function lists($array, $key)
    {
        $result = [];
        foreach ($array as $element) {
            $value = static::get($element, $key);
            $result[$value] = $element;
        }

        return $result;
    }
1122496
protected function getAsIntegerArray($key)
    {
        $stringValue = $this->getAsString($key);

        if ($stringValue === '') {
            return [];
        }

        return GeneralUtility::intExplode(',', $stringValue);
    }
330517
public function extractKey($key)
    {
        $self       = clone($this);
        $self->data = Accessor::get($this->data, $key) ?: [];
        return $self;
    }