String.prototype.toLowerCase() returns a new string with every character lowercased using Unicode default rules (same API as MDN String.prototype.toLowerCase()). Learn the no-argument API, case-insensitive compares, when to prefer toLocaleLowerCase(), five examples, and try-it labs.
01
Kind
Instance method
02
Returns
New string
03
Parameters
None
04
Rules
Unicode default
05
Mutates?
No
06
Baseline
Widely available
Fundamentals
Introduction
Need every letter in lowercase — for display, search, or a fair comparison? toLowerCase() is the everyday tool.
It uses Unicode default case mappings (not a locale argument). For most English and ASCII text that is exactly what you want. When the UI language has special rules (Turkish dotted/dotless i), reach for toLocaleLowerCase() instead.
💡
Beginner tip
For case-insensitive equality, lowercase both sides: a.toLowerCase() === b.toLowerCase().
str.toLowerCase() builds a new string where each character is converted to its lowercase form under Unicode default mappings.
Returns a new string — the original is unchanged.
Takes no parameters.
Great for ASCII / English normalization and case-insensitive checks.
For language-specific casing, use toLocaleLowerCase(locales).
Foundation
📝 Syntax
General form of String.prototype.toLowerCase:
JavaScript
str.toLowerCase()
Parameters
None.
Return value
A new string representing the calling string converted to lower case.
Exceptions
None for normal string values. (Calling on null/undefined without boxing throws in the usual way.)
Common patterns
JavaScript
"ALPHABET".toLowerCase(); // "alphabet"
"The Quick Brown Fox".toLowerCase(); // "the quick brown fox"
"Hello".toLowerCase() === "HELLO".toLowerCase(); // true
"MiXeD".toLowerCase(); // "mixed"
Cheat Sheet
⚡ Quick Reference
Goal
Code
Lowercase a string
str.toLowerCase()
Case-insensitive equal
a.toLowerCase() === b.toLowerCase()
Locale-aware lowercase
str.toLocaleLowerCase(locales)
Uppercase
str.toUpperCase()
Locale-aware uppercase
str.toLocaleUpperCase(locales)
Snapshot
🔍 At a Glance
Four facts to remember about String.toLowerCase().
Returns
string
New lowercased text
Args
none
No locales parameter
Mapping
Unicode
Default case rules
Mutates
no
Immutable string
Compare
📋 toLowerCase() vs toLocaleLowerCase()
toLowerCase()
toLocaleLowerCase()
Case rules
Unicode default mappings
Locale-specific mappings
Optional arg
None
locales (BCP 47)
English / ASCII
Ideal default
Same result usually
Turkish İ
May differ from Turkish UI
Correct with "tr"
Best for
Simple / locale-agnostic code
User-facing text in a language
Hands-On
Examples Gallery
Examples follow MDN String.toLowerCase() patterns plus practical beginner tips. Use View Output or Try It Yourself for each case.
📚 Getting Started
MDN demos for everyday lowercasing.
Example 1 — Basic toLowerCase()
MDN Try it demo: lowercase a full sentence.
JavaScript
const sentence = "The quick brown fox jumps over the lazy dog.";
console.log(sentence.toLowerCase());
// Expected output: "the quick brown fox jumps over the lazy dog."
Every uppercase Latin letter becomes its lowercase form. Spaces and punctuation are left unchanged. The original sentence variable is still mixed-case.
Search / filter prep — lowercase query and candidates first.
Not for Turkish UI — use toLocaleLowerCase("tr") when language rules matter.
Not for sorting — use localeCompare / Intl.Collator.
🧠 How toLowerCase() Works
1
Read the string
No parameters — only the calling string matters.
Input
2
Apply Unicode mappings
Map each character to its default lowercase form.
Transform
3
Build a new string
Non-letters stay as they are; length can change for some scripts.
Result
4
✅
Return the new string
The original string is never modified.
Important
📝 Notes
The method does not change str itself — assign the result if you need it.
There is no locales argument; use toLocaleLowerCase for that.
For fair compares, lowercase both values the same way.
Some characters may expand when case-converted (rare in English, common in other scripts).
Pair with toUpperCase() when you need the uppercase mirror.
Compatibility
Browser & Runtime Support
String.prototype.toLowerCase() is Baseline Widely available — supported across modern browsers since July 2015 (and long before in practice).
✓ Baseline · Widely available
String.toLowerCase()
Safe for production in browsers and runtimes (Node.js, Deno, Bun). Everyday choice for Unicode-default lowercasing.
UniversalWidely available
Google ChromeSupported · Desktop & Mobile
Full support
Mozilla FirefoxSupported · Desktop & Mobile
Full support
Apple SafariSupported · macOS & iOS
Full support
Microsoft EdgeSupported · Chromium
Full support
Internet ExplorerNo native support · Use a polyfill
Polyfill
OperaSupported · Modern versions
Full support
Samsung InternetSupported · Android
Full support
BunSupported · JavaScript runtime
Supported
DenoSupported · JavaScript runtime
Supported
Node.jsSupported · Server runtime
Supported
Android WebViewSupported · Modern WebView
Full support
toLowerCase()Excellent
Bottom line: Use String.toLowerCase() for default lowercase conversion and case-insensitive compares. Switch to toLocaleLowerCase() when language-specific rules matter.
Wrap Up
Conclusion
String.prototype.toLowerCase() is the simple, reliable way to lowercase text with Unicode defaults — perfect for beginners and for locale-agnostic code. Reach for toLocaleLowerCase() when the UI language changes casing rules.
Lowercase both sides for case-insensitive equality
Keep original casing for display when you only need to compare
Prefer toLocaleLowerCase for Turkish and similar
Assign the return value — the original does not change
❌ Don’t
Pass a locales argument (it is ignored / not part of the API)
Expect Turkish İ to match plain i
Use case methods to sort lists
Assume mutating the variable without assignment
Skip normalizing both sides in a compare
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about String.toLowerCase()
No-arg Unicode lowercase — original unchanged.
5
Core concepts
📝01
Returns
new string
API
🔢02
Parameters
none
Args
🌐03
Mapping
Unicode default
Rule
🔍04
Compare
lowercase both
Pattern
⚡05
Mutates
no
Immutable
❓ Frequently Asked Questions
String.prototype.toLowerCase() returns a new string with all characters converted to lowercase using Unicode default case mappings. It takes no arguments.
No. Strings are immutable. toLowerCase() returns a new lowercased string; the original stays unchanged.
toLowerCase always uses Unicode default mappings. toLocaleLowerCase can follow language-specific rules (for example Turkish İ). Prefer toLocaleLowerCase for user-facing text in a known language.
Normalize both sides: a.toLowerCase() === b.toLowerCase(). For Turkish and similar locales, use toLocaleLowerCase with the same locale on both sides.
No. If you need locale-aware lowercasing, use toLocaleLowerCase(locales).
Use toUpperCase when you need uppercase text. The APIs are mirrors of each other for default Unicode mappings.
Did you know?
toLowerCase and toUpperCase predate the locale-aware twins. When you only need English/ASCII behavior, the shorter methods keep code clear — switch to toLocale* only when language rules matter.