ucwords - PHP code example

PHP Function Ucwords

The php function ucwords can be used to convert the first letter of every word in a string to uppercase. This can be helpful in presenting text that is formatted with capital letters in a consistent and visually appealing manner, such as in displaying user names or titles in content. It is especially useful in applications that utilize user-generated input such as form inputs.

The ucwords() function has the following syntax:

$string = str(input())

The string is passed through a list of delimiters, such as "|" (which is default), vertical tab ("v") and form feed ("f"). The first letter of each word in this list will be converted to uppercase. The rest of the string remains unchanged.

Using the ucwords() function in PHP is straightforward. It can be compared to strtolower() and strtoupper(), which both change all characters in the string to lower or uppercase respectively, and lcfirst(), which only changes the first character of each word in the string to uppercase.

While these functions are helpful, they can also be problematic when working with specific strings that require certain characters to remain in uppercase. For example, many abbreviations and acronyms, such as HTML, UN, UNESCO and WHO, are required to be in uppercase and changing them using these methods may cause them to lose their original meaning. For this reason, it is always best to check the case of a string before using these functions. It is also best to use these functions only when you know the whole string will be in uppercase.

ucwords example

'in' => 'path',
            'schema' => ['type' => 'string', 'pattern' => '^[0-9a-f]{32}$'],
            'description' => 'Identifier for the ' . $definition->getEntityName(),
            'required' => true,
        ]);

        return $idParameter;
    }

    private function snakeCaseToCamelCase(string $input): string
    {
        return str_replace('_', '', ucwords($input, '_'));
    }

    private function isExperimental(EntityDefinition $definition): bool
    {
        $reflection = new \ReflectionClass($definition);

        return str_contains($reflection->getDocComment() ?: '', '@' . self::EXPERIMENTAL_ANNOTATION_NAME);
    }
}

    public function getRemovedIds(): array
    {
        return [];
    }

    /** * Camelizes a string. */
    public static function camelize(string $id): string
    {
        return strtr(ucwords(strtr($id, ['_' => ' ', '.' => '_ ', '\\' => '_ '])), [' ' => '']);
    }

    /** * A string to underscore. */
    public static function underscore(string $id): string
    {
        return strtolower(preg_replace(['/([A-Z]+)([A-Z][a-z])/', '/([a-z\d])([A-Z])/'], ['\\1_\\2', '\\1_\\2'], str_replace('_', '.', $id)));
    }

    /** * Creates a service by requiring its factory file. * * @return mixed */

        // Still here, just return the value.         return $value;
    }

    /** * Returns a "title case" version of the string. */
    public static function title(string $value): string
    {
        return ucwords(strtolower($value));
    }
}

    public function __toString(): string
    {
        if (!$headers = $this->all()) {
            return '';
        }

        ksort($headers);
        $max = max(array_map('strlen', array_keys($headers))) + 1;
        $content = '';
        foreach ($headers as $name => $values) {
            $name = ucwords($name, '-');
            foreach ($values as $value) {
                $content .= sprintf("%-{$max}s %s\r\n", $name.':', $value);
            }
        }

        return $content;
    }

    /** * Returns the headers. * * @param string|null $key The name of the headers to return or null to get them all * * @return ($key is null ? array<string, list<string|null>> : list<string|null>) */

protected $locations = array(
        'module'  => 'site/modules/{$name}/',
    );

    /** * Format package name to CamelCase */
    public function inflectPackageVars(array $vars): array
    {
        $vars['name'] = strtolower($this->pregReplace('/(?<=\\w)([A-Z])/', '_\\1', $vars['name']));
        $vars['name'] = str_replace(array('-', '_'), ' ', $vars['name']);
        $vars['name'] = str_replace(' ', '', ucwords($vars['name']));

        return $vars;
    }
}

            if ($name) {
                if (false !== $i = strpos($name, '::get')) {
                    $name = lcfirst(substr($name, 5 + $i));
                } elseif (str_contains($name, '::')) {
                    $name = null;
                }
            }

            if (null !== $name && !$this->container->has($name) && !$this->container->has($type.' $'.$name)) {
                $camelCaseName = lcfirst(str_replace(' ', '', ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $name))));
                $name = $this->container->has($type.' $'.$camelCaseName) ? $camelCaseName : $name;
            }

            $subscriberMap[$key] = new TypedReference((string) $serviceMap[$key], $type, $optionalBehavior ?: ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE, $name, $attributes);
            unset($serviceMap[$key]);
        }

        if ($serviceMap = array_keys($serviceMap)) {
            $message = sprintf(1 < \count($serviceMap) ? 'keys "%s" do' : 'key "%s" does', str_replace('%', '%%', implode('", "', $serviceMap)));
            throw new InvalidArgumentException(sprintf('Service %s not exist in the map returned by "%s::getSubscribedServices()" for service "%s".', $message, $class, $this->currentId));
        }

return $this->parseVars($vars);
    }

    /** * @param array<string, string> $vars * @return array<string, string> */
    protected function parseVars(array $vars): array
    {
        $vars['vendor'] = strtolower($vars['vendor']) == 'sitedirect' ? 'SiteDirect' : $vars['vendor'];
        $vars['name'] = str_replace(array('-', '_'), ' ', $vars['name']);
        $vars['name'] = str_replace(' ', '', ucwords($vars['name']));

        return $vars;
    }
}

/** * Normalize frontend and backend names to allow multiple words TitleCased * * @param string $name Name to normalize * @return string */
    protected static function _normalizeName($name)
    {
        $name = ucfirst(strtolower($name));
        $name = str_replace(array('-', '_', '.'), ' ', $name);
        $name = ucwords($name);
        $name = str_replace(' ', '', $name);
        if (stripos($name, 'ZendServer') === 0) {
            $name = 'ZendServer_' . substr($name, strlen('ZendServer'));
        }

        return $name;
    }

    /** * Returns TRUE if the $filename is readable, or FALSE otherwise. * This function uses the PHP include_path, where PHP's is_readable() * does not. * * Note : this method comes from Zend_Loader (see #ZF-2891 for details) * * @param string $filename * @return boolean */

        $contentType = $_SERVER['CONTENT_TYPE'] ?? getenv('CONTENT_TYPE');
        if (! empty($contentType)) {
            $this->setHeader('Content-Type', $contentType);
        }
        unset($contentType);

        foreach (array_keys($_SERVER) as $key) {
            if (sscanf($key, 'HTTP_%s', $header) === 1) {
                // take SOME_HEADER and turn it into Some-Header                 $header = str_replace('_', ' ', strtolower($header));
                $header = str_replace(' ', '-', ucwords($header));

                $this->setHeader($header, $_SERVER[$key]);

                // Add us to the header map so we can find them case-insensitively                 $this->headerMap[strtolower($header)] = $header;
            }
        }
    }

    /** * Returns an array containing all Headers. * * @return array<string, Header> An array of the Header objects */

        $adapterNamespace = 'Zend_Db_Adapter';
        if (isset($config['adapterNamespace'])) {
            if ($config['adapterNamespace'] != '') {
                $adapterNamespace = $config['adapterNamespace'];
            }
            unset($config['adapterNamespace']);
        }

        // Adapter no longer normalized- see http://framework.zend.com/issues/browse/ZF-5606         $adapterName = $adapterNamespace . '_';
        $adapterName .= str_replace(' ', '_', ucwords(str_replace('_', ' ', strtolower($adapter))));

        /* * Load the adapter class. This throws an exception * if the specified class cannot be loaded. */
        if (!class_exists($adapterName)) {
            Zend_Loader::loadClass($adapterName);
        }

        /* * Create an instance of the adapter class. * Pass the config to the adapter class constructor. */

        }

        return [false, $errors];
    }

    /** * Camelizes a given string. */
    private function camelize(string $string): string
    {
        return str_replace(' ', '', ucwords(str_replace('_', ' ', $string)));
    }

    /** * Return allowed reflection method flags. */
    private function getMethodsFlags(int $accessFlags): int
    {
        $methodFlags = 0;

        if ($accessFlags & self::ALLOW_PUBLIC) {
            $methodFlags |= \ReflectionMethod::IS_PUBLIC;
        }

    // cSpell:enable   }

  /** * Tests multibyte ucwords. * * @dataProvider providerUcwords * @covers ::ucwords */
  public function testUcwords($text, $expected) {
    $this->assertEquals($expected, Unicode::ucwords($text));
  }

  /** * Data provider for testUcwords(). * * @see testUcwords() * * @return array * An array containing a string and its capitalized version. */
  public function providerUcwords() {

if (! function_exists('camelize')) {
    /** * Camelize * * Takes multiple words separated by spaces or * underscores and converts them to camel case. * * @param string $string Input string */
    function camelize(string $string): string
    {
        return lcfirst(str_replace(' ', '', ucwords(preg_replace('/[\s_]+/', ' ', $string))));
    }
}

if (! function_exists('pascalize')) {
    /** * Pascalize * * Takes multiple words separated by spaces or * underscores and converts them to Pascal case, * which is camel case with an uppercase first letter. * * @param string $string Input string */

protected $locations = array(
        'plugin' => 'plugins/{$name}/',
    );

    /** * Format package name to CamelCase */
    public function inflectPackageVars(array $vars): array
    {
        $vars['name'] = strtolower($this->pregReplace('/(?<=\\w)([A-Z])/', '_\\1', $vars['name']));
        $vars['name'] = str_replace(array('-', '_'), ' ', $vars['name']);
        $vars['name'] = str_replace(' ', '', ucwords($vars['name']));

        return $vars;
    }
}

        $str = clone $this;
        $str->string .= 1 >= \count($suffix) ? ($suffix[0] ?? '') : implode('', $suffix);

        return $str;
    }

    public function camel(): static
    {
        $str = clone $this;

        $parts = explode(' ', trim(ucwords(preg_replace('/[^a-zA-Z0-9\x7f-\xff]++/', ' ', $this->string))));
        $parts[0] = 1 !== \strlen($parts[0]) && ctype_upper($parts[0]) ? $parts[0] : lcfirst($parts[0]);
        $str->string = implode('', $parts);

        return $str;
    }

    public function chunk(int $length = 1): array
    {
        if (1 > $length) {
            throw new InvalidArgumentException('The chunk length must be greater than zero.');
        }