Converts this string to lowercase

@return static a new instance of this class
346960
public function toLowerCase() {
		$rawString = mb_strtolower($this->rawString, $this->charset);

		return new static($rawString, $this->charset);
	}
1247192
public static function underscoredToLowerCamelCase($string) {
		$upperCamelCase = str_replace(' ', '', ucwords(str_replace('_', ' ', self::strtolower($string))));
		$lowerCamelCase = self::lcfirst($upperCamelCase);
		return $lowerCamelCase;
	}
741316
public Version toUpperCase() {
        return new Version(this.major, this.minor, this.patch,
                copyCase(this.preReleaseParts, true),
                copyCase(this.buildMetaDataParts, true));
    }
254039
public function toCamelCase() {
        $parts = $this->toLower()->split(' ');
        $index = 0;
        $result = '';

        //Yeah, Its ugly. But fast...
        foreach($parts as $part) {
            if($index === 0) {
                $index++;
                $result .= $part;

                continue;
            }

            $result .= (string) $this->createClone($part)->ucfirst();
            $index++;
        }

        return $this->createClone($result);
    }
778336
public function string()
    {
        if (!is_string($this->value)) {
            throw new InvalidStringException($this->name, $this->value);
        }

        return $this;
    }
988555
def to_lower_case(string)
      assert_type string, :String, :string
      Sass::Script::Value::String.new(Sass::Util.downcase(string.value), string.type)
    end
68102
public function upperCaseFirst()
	{
		trigger_error('Function ' . __METHOD__ . ' not implemented yet');

		$first = \mb_substr($this->str, 0, 1, $this->encoding);
		$rest = \mb_substr($this->str, 1, $this->length() - 1, $this->encoding);

		$str = \mb_strtoupper($first, $this->encoding) . $rest;

		return static::create($str, $this->encoding);
	}
288744
protected static function convertToLowercase($str)
    {
        $explodedStr = explode('_', $str);

        if (count($explodedStr) > 1) {
            $lowerCasedStr = [];
            foreach ($explodedStr as $value) {
                $lowerCasedStr[] = strtolower($value);
            }
            $str = implode('_', $lowerCasedStr);
        }

        return $str;
    }
248886
public function substr()
    {
        $result = call_user_func_array('substr', array_merge([$this->subject], func_get_args()));
        $result = $result === false ? '' : $result;

        return new static($result);
    }
404266
public function lowerCaseFirst()
    {
        return $this->cloneInstance(
            function (StringObject $new) {
                $new->string = Mbstring::lcfirst($new->string, $this->encoding);
            }
        );
    }
23864
public static String toLowerCamelCase(String text, char separator) {
        char[] chars = text.toCharArray();
        int base = 0, top = 0;

        do {
            while (top < chars.length && chars[top] != separator) {
                chars[base++] = Character.toLowerCase(chars[top++]);
            }
            while (top < chars.length && chars[top] == separator) {
                ++top;
            }
            if (top < chars.length) {
                chars[base++] = Character.toUpperCase(chars[top++]);
            }
        } while (top < chars.length);

        return new String(chars, 0, base);
    }
849490
public function toLowerCase() {
    $token = $this->getConstantName()->lastToken();
    $token->setText(strtolower($token->getText()));
    return $this;
  }
1231397
protected function _upperCaseFirst()
    {
        if (!$this->_isVoid()) {
            $first_char = $this->_first()->_upper();
            $other_chars = $this->sub(1, $this->int_count);

            return self::concat($first_char, $other_chars);
        }

        return $this;
    }
893148
function lowercase(arr) {
  var ret = new Array(arr.length);

  for (var i = 0; i < arr.length; ++i) {
    ret[i] = String(arr[i]).toLowerCase();
  }

  return ret;
}
682114
public static function LOWERCASE($mixedCaseString)
    {
        $mixedCaseString = PHPExcel_Calculation_Functions::flattenSingleValue($mixedCaseString);

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

        return PHPExcel_Shared_String::StrToLower($mixedCaseString);
    }
1024887
public function reverse() {
		if (preg_match_all('/./us', $this->rawString, $matches)) {
			$rawString = join('', array_reverse($matches[0]));

			return new static($rawString, $this->charset);
		}
		else {
			return $this;
		}
	}
513306
public static function lowercase($val): string
    {
        if (!$val || !\is_string($val)) {
            return \is_int($val) ? $val : '';
        }

        if (\function_exists('mb_strtolower')) {
            return \mb_strtolower($val, 'utf-8');
        }

        return \strtolower($val);
    }