UPPERCASE

Converts a string value to upper case.

@param    string        $mixedCaseString
@return    string
490305
public static function UPPERCASE($mixedCaseString)
    {
        $mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);

        if (is_bool($mixedCaseString)) {
            $mixedCaseString = ($mixedCaseString) ? PHPExcel_Calculation::getTRUE() : PHPExcel_Calculation::getFALSE();
        }

        return PHPExcel_Shared_String::StrToUpper($mixedCaseString);
    }
884852
public function toUpperCase() {
		$rawString = mb_strtoupper($this->rawString, $this->charset);

		return new static($rawString, $this->charset);
	}
596343
public static function toCamelcase($string, $capitalizeFirstCharacter = false) {

		if(false === is_string($string)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type string, "%s" given', __METHOD__, gettype($string)), E_USER_ERROR);
		}

		if(false === is_bool($capitalizeFirstCharacter)) {
			return trigger_error(sprintf('Argument 1 passed to %s() must be of the type boolean, "%s" given', __METHOD__, gettype($capitalizeFirstCharacter)), E_USER_ERROR);
		}

	    $str = str_replace(' ', '', ucwords(str_replace('_', ' ', $string)));

	    if(false === $capitalizeFirstCharacter) {
	        $str[0] = strtolower($str[0]);
	    }

	    return $str;
	}
423700
public static function nameCase($string = '', array $options = [])
    {
        if ($string == '') return $string;

        self::$options = array_merge(self::$options, $options);

        // Do not do anything if string is mixed and lazy option is true.
        if (self::$options['lazy'] && self::skipMixed($string)) return $string;

        // Capitalize
        $string = self::capitalize($string);
        $string = self::updateIrish($string);

        // Fixes for "son (daughter) of" etc
        foreach (self::$replacements as $pattern => $replacement) {
            $string = mb_ereg_replace($pattern, $replacement, $string);
        }

        $string = self::updateRoman($string);
        $string = self::fixConjunction($string);

        return $string;
    }
277161
protected function changeCase($string)
    {
        if ($this->isLowercase()) {
            return strtolower($string);
        }

        if ($this->isUppercase()) {
            return strtoupper($string);
        }

        return $string;
    }
871028
public static function toCamelCase($input)
    {
        // Convert words to uppercase and then remove spaces.
        $input = self::toSpaceSeparated($input);
        $input = ucwords($input);
        $input = str_ireplace(' ', '', $input);

        return $input;
    }
955925
public static Pattern stringCaseInsensitive(final String string) {
    return new Pattern() {
      @Override public int match(CharSequence src, int begin, int end) {
        return matchStringCaseInsensitive(string, src, begin, end);
      }
      @Override public String toString() {
        return string.toUpperCase();
      }
    };
  }
582728
public function caseFirstUpper()
    {
        $string = clone $this;
        $string->subString(0, 1)->caseUpper()->val();
        $this->subString(1, $this->length() - 1)->caseLower();

        $this->val($string . $this->val());

        return $this;
    }
1247192
public static function underscoredToLowerCamelCase($string) {
		$upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
		$lowerCamelCase = self::lcfirst($upperCamelCase);
		return $lowerCamelCase;
	}
540010
def uppercase_chars(string: any) -> str:
        """"""
        return ''.join([c if c.isupper() else '' for c in str(string)])
1126692
static function CamelCase($string) {
		$string = preg_replace_callback('#([_])(\w)#', function ($m) {
			return strtoupper($m[2]);
		}, strtolower($string));

		return ucfirst($string);
	}
404266
public function lowerCaseFirst()
    {
        return $this->cloneInstance(
            function (StringObject $new) {
                $new->string = Mbstring::lcfirst($new->string, $this->encoding);
            }
        );
    }
868466
public static function to($str, $upperCaseFirst = true)
    {
        $str = strtr(ucwords(strtr($str, ['_' => ' ', '.' => '_ ', '\\' => '_ '])), [' ' => '']);

        if ($upperCaseFirst === false) {
            $str = lcfirst($str);
        }

        return $str;
    }
792696
function uppercaseFirstLetter(options) {
  const string = options.fn(this);
  return string.charAt(0).toUpperCase() + string.slice(1);
}
663325
public static function toggleCase($string, $encoding = null)
    {
        $encoding = $encoding === null ? mb_internal_encoding() : $encoding;

        return preg_replace_callback(
            '/[\S]/u',
            function ($match) use ($encoding) {
                if ($match[0] === Mbstring::strtoupper($match[0], $encoding)) {
                    return Mbstring::strtolower($match[0], $encoding);
                }

                return Mbstring::strtoupper($match[0], $encoding);
            },
            $string
        );
    }
1089830
public static function lowerCase($strText, $strEncoding = '')
    {

        if (is_null(self::$blnMbstring)) {
            self::$blnMbstring = extension_loaded('mbstring');
        }

        if (!self::$blnMbstring) {
            $strLowerCaseText = strtolower($strText);
        } else {
            if ($strEncoding == '') {
                $strLowerCaseText = mb_strtolower($strText);
            } else {
                $strLowerCaseText = mb_strtolower($strText, $strEncoding);
            }
        }

        return $strLowerCaseText;
    }
802328
public static function toPascalCase(string $string): string
    {
        $words = self::_prepStringForCasing($string);
        $string = implode('', array_map([
            static::class,
            'upperCaseFirst'
        ], $words));

        return $string;
    }