@return array of argument values only

If your command was `php filename -f flagvalue argument1 argument2`
`getArguments` would return array("argument1", "argument2");
175750
public function getArgumentValues()
    {
        $this->parseIfNotParsed();
        return array_map(function(Option $argument) {
            return $argument->getValue();
        }, $this->arguments);
    }
1140038
public function getArguments()
    {
        if (empty($this->_arguments)) {
            $base = [];
            if (isset($this->_params['trailing'])) {
                $base = explode('/', $this->_params['trailing']);
            }
            $names = ['controller', 'action', 'namespace', 'trailing'];
            foreach ($this->_params as $key => $value) {
                if (in_array($key, $names)) {
                    continue;
                }
                $this->_arguments[$key] = $value;
            }

            $this->_arguments = array_merge($this->_arguments, $base);
        }
        return $this->_arguments;
    }
291242
public static function getAllArguments() {
		if(self::$arguments === array())
			self::$arguments = array_merge($_GET, $_POST, $_FILES);

		return self::$arguments;
	}
37415
private static function getArguments(array $arguments = [])
    {
        $args = [];

        foreach ($arguments as $argument) {
            $args[] = $argument instanceof self ? $argument->getMoney() : $argument;
        }

        return $args;
    }
118877
def get_flag_args(**options):
    """"""
    flags = []
    for key, value in options.items():
        # Build short flags.
        if len(key) == 1:
            flag = f'-{key}'
        # Built long flags.
        else:
            flag = f'--{key}'
        flags = flags + [flag, value]
    return flags
737888
public function getFlagValues()
    {
        $this->parseIfNotParsed();
        return array_map(function(Option $flag) {
            return $flag->getValue();
        }, $this->dedupeFlags());
    }
841251
public function getArguments()
    {
        $args = [];

        foreach ($this->arguments as $name => $callable) {
            $args[$name] = $this->getArgument($name);
        }

        return $args;
    }
585107
protected function getCoreArguments()
    {
        if ($this->coreArguments !== null) {
            return $this->coreArguments;
        }

        $argvWithoutConfig = [];
        if (isset($_SERVER['argv'])) {
            $argv = $_SERVER['argv'];

            for ($i = 0; $i < count($argv); $i++) {
                if (preg_match('/^(?:-([^c-]*)?c|--config(?:=|$))(.*)$/', $argv[$i], $match)) {
                    if (!empty($match[2])) { //same index
                        $this->preloadConfiguration($match[2]);
                    } elseif (isset($argv[$i + 1])) { //next index
                        $this->preloadConfiguration($argv[++$i]);
                    }
                    if (!empty($match[1])) {
                        $argvWithoutConfig[] = "-" . $match[1]; //rest commands
                    }
                    continue;
                }
                $argvWithoutConfig[] = $argv[$i];
            }
        }

        return $this->coreArguments = new ArgvInput($argvWithoutConfig);
    }
428038
public function getArguments(): array
    {
        // We will need to process the arguments and merge them.
        $arguments = array_map([$this, 'processArgument'], $this->arguments);

        return array_merge($arguments, $this->rawArguments);
    }
1334449
public function getArguments(): array
    {
        $result = [];
        foreach ($this->arguments as $arg) {
            $parts = $arg->getParts();
            if ($parts !== null) {
                foreach ($parts as $part) {
                    $result[] = $part;
                }
            }
        }

        return $result;
    }
682152
function getFunctionArgs(args) {
        if (args.length > 2) {
            var fnArgs = new Array(args.length - 2),
                i;
            for (i = 2; i < args.length; ++i) {
                fnArgs[i - 2] = args[i];
            }
            return fnArgs;
        }
        return [];
    }
731661
public static function argsToArray()
    {
        $_array = array();

        foreach ( func_get_args() as $_key => $_argument )
        {
            $_array[$_key] = $_argument;
        }

        //	Return the fresh array...
        return $_array;
    }
161083
private function extractArguments(): array
    {
        $parameters = [];

        //Use the Reflection API to create Parameter Value object
        foreach ($this->getReflectionInstance()->getParameters() as $param) {
            $name = $param->getName();
            $hasDefault = $param->isDefaultValueAvailable();

            //Default value. To null if the parameter has no default value
            $defaultValue = null;
            if (true === $hasDefault) {
                $defaultValue = $param->getDefaultValue();
            }
            $class = $param->getClass();

            $parameters[$name] = new Parameter($name, $hasDefault, $defaultValue, $class);
        }

        return $parameters;
    }
498128
public static function getArgumentSpecifications()
    {
        $specs = new OptionCollection;
        $specs->add('d|dir:', 'Tests directory path')
            ->isa('String');

        $specs->add('s|subdir+', 'Optional, subdirectory pattern, can be used multiple times as OR expression')
            ->isa('String')
            ->defaultValue(null);

        $specs->add('b|bootstrap?', 'Bootstrap file path')
            ->isa('File')
            ->defaultValue(null);

        $specs->add('v|verbose', 'Verbose output')
            ->defaultValue(false);

        $specs->add('show-globals', 'Show values of global variables')->defaultValue(false);
        $specs->add('debug', 'Show debug messages')->defaultValue(false);
        $specs->add('h|help', 'Show help')->defaultValue(false);
        $specs->add('no-colors', 'No colors')->defaultValue(false);
        $specs->add('i|immediate', 'Show error output immediately as it appears')->defaultValue(false);

        $specs->add('server-host?', 'Server host')->defaultValue(null);
        $specs->add('server-root',  'Server root path, default is ./public')->defaultValue('./public');

        return $specs;
    }
1308475
private function getServerArguments() {
        $args = $_SERVER['argv'];
        array_shift($args);

        $args = $this->parseArgs($args);

        return $args;
    }
1370781
protected function getCliParams() {
		if (empty($_SERVER['argv'])) {
			return [];
		}
		
		$params = preg_grep('/^\-\-zdebug:/', $_SERVER['argv']);
		
		if (empty($params)) {
			return [];
		}
		
		return array_map(function($in) {
			return str_replace('--zdebug:', '', $in);
		}, $params);
	}
1218150
public function getArgumentDefinitions(): array
    {
        if (!$this->hasArguments()) {
            return [];
        }
        $commandArgumentDefinitions = [];
        $commandMethodReflection = $this->getCommandMethodReflection();
        $annotations = $commandMethodReflection->getTagsValues();
        $commandParameters = $this->reflectionService->getMethodParameters($this->controllerClassName, $this->controllerCommandName . 'Command');
        $i = 0;
        foreach ($commandParameters as $commandParameterName => $commandParameterDefinition) {
            $explodedAnnotation = explode(' ', $annotations['param'][$i]);
            array_shift($explodedAnnotation);
            array_shift($explodedAnnotation);
            $description = implode(' ', $explodedAnnotation);
            $required = $commandParameterDefinition['optional'] !== true;
            $commandArgumentDefinitions[] = new CommandArgumentDefinition($commandParameterName, $required, $description);
            $i ++;
        }
        return $commandArgumentDefinitions;
    }