Strings & Regex

Strings are immutable primitives. No method or index assignment can change an existing string in place — methods like toUpperCase, slice, and replace return a brand-new string and leave the original untouched. Writing str[0] = 'x' silently does nothing (it throws only in strict mode). To 'change' a string you reassign the variable to the new returned value.

Template literals are strings written in backticks ` ` instead of quotes. They support interpolation: any expression inside ${...} is evaluated and its result inserted into the string. They are also natively multiline — a literal newline in the source becomes a \n` in the value, with no concatenation or escape needed.

A regular expression is a pattern describing a set of strings, used to search, test, or replace text. A literal like /abc/i is parsed once when the script loads, so it suits fixed patterns. new RegExp('abc', 'i') builds the same pattern from a string at runtime, which is needed when the pattern is dynamic — but backslashes must then be doubled.

slice(start, end) and substring(start, end) both return a substring between two indices. indexOf(sub) returns the first position of a substring or -1 if absent. toUpperCase() returns the string uppercased. trim() returns it with leading and trailing whitespace removed. All return new strings; none mutate the original.

includes(sub) returns true if the substring appears anywhere. startsWith(sub) and endsWith(sub) return true only when it appears at the start or end. indexOf(sub) returns the first index of the substring, or -1 if absent, so indexOf(sub) !== -1 is the older boolean test. All are case-sensitive and accept an optional position argument.

g (global) finds all matches instead of stopping at the first. i makes matching case-insensitive. m (multiline) makes ^ and $ match at line breaks, not just string ends. s (dotAll) lets . match newlines. u enables full Unicode and code-point mode. y (sticky) anchors each match exactly at lastIndex. Flags follow the closing slash, e.g. /abc/gi.

test and exec are called on the regex: test(str) returns a boolean, exec(str) returns one match array (or null) and advances lastIndex with g. match, matchAll, replace, and search are called on the string: match returns matches or groups, matchAll returns an iterator of all matches, replace substitutes, and search returns the first index or -1.

=== and </> compare strings lexicographically by UTF-16 code unit, so order follows code-unit numbers — uppercase sorts before lowercase and accented letters land oddly. localeCompare instead compares per locale rules, returning a negative, zero, or positive number. For case-insensitive comparison, lowercase both sides first, or pass { sensitivity: 'base' } to localeCompare.

slice(start, end) and substring(start, end) both take a start and end index, but slice treats negative indices as offsets from the end while substring clamps any negative argument to 0. substring also swaps its arguments if start > end; slice does not and returns ''. The deprecated substr(start, length) takes a length, not an end index — prefer slice.

A tagged template is a function call written as ` tag... . The tag function receives the array of literal string chunks as its first argument and the interpolated ${...} values as the remaining arguments, letting it process or escape input before assembling output. The strings array also has a .raw property holding each chunk with escape sequences left uninterpreted, as String.raw` uses.

Parentheses create capture groups returned after the full match. Quantifiers like + and * are greedy — they match as much as possible and backtrack; adding ? (+?, *?) makes them lazy, matching as little as possible. A g-flag regex is stateful: exec/test resume from its mutable lastIndex, so reusing one shared instance across calls skips matches. matchAll sidesteps that by iterating cleanly.

JS strings are sequences of UTF-16 code units, and .length counts code units, not characters. An astral character like an emoji is a surrogate pair of two code units, so '😀'.length is 2 and indexing splits it. Spread, for...of, and Array.from iterate by code point and keep it whole. normalize() reconciles equivalent forms (e.g. é composed vs decomposed) before comparing.