Devolve o argumento especificado.

@return mixed|null
556050
public function getArgument($name)
    {
        if (isset($this->arguments[$name])) {
            return $this->arguments[$name];
        }
        return null;
    }
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;
    }
863258
public static function coalesce($args)
    {
        $args = func_get_args();
        foreach ($args as &$arg) {
            if (isset($arg) && !empty($arg)) {
                return $arg;
            }
        }

        return null;
    }
790555
public function activeSorter()
    {
        if (empty($sorter = $this->getSorter())) {
            return null;
        }

        $sorter = $this->sorters[$sorter];

        if ($sorter instanceof DirectionalSorterInterface) {
            return $sorter->withDirection($this->activeState()->sortDirection());
        }

        return clone $sorter;
    }
1365275
public function evaluate()
    {
        $matcherKeys = $this->sortNestedFusionKeys();

        foreach ($matcherKeys as $matcherName) {
            $renderedMatcher = $this->renderMatcher($matcherName);
            if ($this->matcherMatched($renderedMatcher)) {
                return $renderedMatcher;
            }
        }

        return null;
    }
273592
public function evaluate()
    {
        $glue = $this->getGlue();
        $parentResult = parent::evaluate();
        if ($parentResult !== []) {
            return implode($glue, $parentResult);
        }
        return null;
    }
678941
public function args()
    {
        $existing = is_callable($this->args) ? call_user_func($this->args) : $this->args;

        if (!is_array($existing)) {
            $existing = [];
        }

        $args = array_merge($existing, [
            'limit' => [
                'type' => Type::int(),
            ],
            'offset' => [
                'type' => Type::int()
            ]
        ]);

        if ($fields = $this->getSortableFields()) {
            $args['sortBy'] = [
                'type' => Type::listOf(
                    Injector::inst()->create(SortInputTypeCreator::class, $this->connectionName)
                        ->setSortableFields($fields)
                        ->toType()
                )
            ];
        }

        return $args;
    }
1172057
protected function argument($key = null)
    {
        if (is_null($key)) {
            return $this->input->getArguments();
        }

        return $this->input->getArgument($key);
    }
1307089
public function getArguments()
    {
        if (count($this->arguments) < 1) {
            return [];
        }

        asort($this->arguments);
        $lastArgument = end($this->arguments);
        $argumentsCount = $lastArgument->getIndex();
        $sortedArguments = [];
        for ($index = 1; $index <= $argumentsCount; $index++) {
            $sortedArguments[$index] = isset($this->arguments[$index]) ? $this->arguments[$index] : null;
        }
        return $sortedArguments;
    }
857082
public function getSortingParameters()
    {
        $sorting = $this->getSorting($this->getSortIdent());
        if (!is_array($sorting)) {
            return null;
        }

        return implode('|', $sorting);
    }
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);
    }
417644
protected function getArguments()
    {
        return array(
            array('name', InputArgument::REQUIRED, false),
            array('type', InputArgument::OPTIONAL, false),
            array('folder', InputArgument::OPTIONAL, false),
        );
    }
901728
public function arg( $index ) {
		return isset($this->arguments[$index]) ? $this->arguments[$index] : null;
	}
1273372
protected function getCommandLineArgumentContainer(): CommandLineArgumentContainer
    {
        $store = $this->input->getArgument(self::ARGUMENT_STORE);

        if ($store !== null && !is_string($store)) {
            throw new InstallException(
                sprintf(
                    'Value of `%s` argument should return `string|null` type. Return type is `%s`.',
                    self::ARGUMENT_STORE,
                    gettype($store)
                )
            );
        }

        return new CommandLineArgumentContainer($store);
    }
286606
protected function normalizePath()
    {
        if (func_num_args() <= 0) {
            return null;
        }

        if (func_num_args() > 1) {
            return call_user_func_array(array($this, __FUNCTION__), array(implode(DIRECTORY_SEPARATOR, func_get_args())));
        }
        if ((func_num_args() == 1) && (is_array(func_get_arg(0)))) {
            return call_user_func_array(array($this, __FUNCTION__), array(implode(DIRECTORY_SEPARATOR, func_get_arg(0))));
        }
        $_in = func_get_arg(0);
        $_out = str_replace(array('\\', '/'), DIRECTORY_SEPARATOR, $_in);
        $_out = str_replace(DIRECTORY_SEPARATOR . DIRECTORY_SEPARATOR, DIRECTORY_SEPARATOR, $_out);
        $_out = str_replace(DIRECTORY_SEPARATOR, '/', $_out); //??
        return $_out;
    }
293404
public function getArg($key='')
    {

        if(isset($this->args[$key])){
            return $this->args[$key];
        } else {
            return null;
        }
    }
230420
protected function getTemplateArguments()
    {
        $templateArguments = $this->arguments['arguments'] ?: [];
        ArrayUtility::mergeRecursiveWithOverrule($templateArguments, $this->fieldService->getFieldOptions());

        return $templateArguments;
    }