Are JavaScript strings mutable?

No. Strings are immutable primitives, so no method changes the string in place. Methods like toUpperCase, replace, and trim all return a brand-new string and leave the original unchanged. You must assign the result to keep it.

Difference between slice, substring, and substr?

slice(start, end) accepts negative indices counting from the end. substring(start, end) clamps negatives to 0 and swaps the arguments if start is greater than end. substr(start, length) is legacy and takes a length instead of an end index. Prefer slice.

What does normalize do?

normalize returns the Unicode Normalization Form of a string. The same visible character can be encoded differently, for example e with an accent as one code point or as e plus a combining accent. normalize('NFC') unifies them so comparisons and searches match reliably.

How does replace differ from replaceAll?

replace only replaces the first match when given a string pattern, or all matches when given a global regular expression. replaceAll replaces every occurrence of a string pattern directly, and throws if given a non-global regex. Use replaceAll for clear all-occurrence replacement.

Why does length count emoji as two?

length counts UTF-16 code units, and characters outside the Basic Multilingual Plane such as many emoji are stored as a surrogate pair of two code units. To count visible characters, iterate with the spread operator or for...of, which yield whole code points.

What is the JavaScript String Methods?

Searchable JavaScript String method reference. Each entry lists the call signature, return type, and unicode behaviour, with a reminder that strings are immutable so every method returns a new value rather than changing the original. It runs free in your browser on Gera Tools, with nothing uploaded.

JavaScript String Methods

Name: JavaScript String Methods
Creator: Gera Tools
License: https://creativecommons.org/licenses/by/4.0/

JavaScript strings are immutable, so every method here returns a new string or a derived value rather than changing the original. This reference lists each String.prototype method with its signature, return type, and the unicode gotchas that trip people up.

The one rule that prevents most string bugs

Strings are immutable. No String.prototype method ever changes the original string. Every method returns a new value, and if you do not assign that return value, it is lost silently. This trips up developers coming from languages where string mutation is common:

let name = "  alice  ";
name.trim();         // does nothing visible — return value discarded
console.log(name);   // "  alice  " — unchanged

name = name.trim();  // correct — assign the return value
console.log(name);   // "alice"

Method groups

Search — indexOf, lastIndexOf, includes, startsWith, endsWith, match, matchAll, search — locate text or patterns.
Slice — slice, substring, substr, at — extract a portion of the string.
Transform — toUpperCase, toLowerCase, toLocaleLowerCase, trim, trimStart, trimEnd, padStart, padEnd, replace, replaceAll, repeat, normalize — produce a new transformed string.
Convert — split, charAt, charCodeAt, codePointAt, fromCharCode, localeCompare — move between strings, arrays, and numeric code points.

Because strings are immutable, none of these mutate this; you always keep the return value.

The `slice` vs `substring` vs `substr` trap

These three look similar but behave differently at the edges:

Method	Negative indices	Argument meaning
`slice(start, end)`	Counts from end of string	Start and end positions
`substring(start, end)`	Clamps negatives to 0; swaps args if start > end	Start and end positions
`substr(start, length)`	Negative start counts from end	Start position and length

substr is legacy and its removal from the standard has been discussed. Prefer slice for predictable behaviour with negative indices.

The `replace` vs `replaceAll` trap

replace with a string pattern only replaces the first match. replaceAll replaces every occurrence. Forgetting this is one of the most common JavaScript string bugs:

"foo foo foo".replace("foo", "bar")    // "bar foo foo"
"foo foo foo".replaceAll("foo", "bar") // "bar bar bar"

If you pass a regex to replaceAll, it must have the g (global) flag or a TypeError is thrown.

Unicode pitfalls

length counts UTF-16 code units, not characters. Characters outside the Basic Multilingual Plane (many emoji, some CJK extension characters) are encoded as two code units (a surrogate pair). A single emoji can have a .length of 2.

"A".length    // 1
"😀".length   // 2

To count visible characters: [..."😀"].length gives 1 because spread and for...of iterate over Unicode code points, not code units.

normalize for reliable comparison. The same visible character can have multiple Unicode representations — for example “é” as a single precomposed code point or as “e” followed by a combining accent. They look identical but are not === equal. Always normalise before comparison or search:

"café".normalize("NFC") === "café".normalize("NFC") // true even with different source encodings

Practical decision guide

Need the position of a match? → indexOf / lastIndexOf
Just need to know if a string is present? → includes (cleaner than indexOf !== -1)
Extracting a portion? → slice (prefer over substring)
Replacing all occurrences of a literal string? → replaceAll
Padding a number string to fixed width? → padStart
Splitting into words or tokens? → split
Comparing user-entered text that might have different Unicode encodings? → normalize('NFC') first