Module F-3 — Strings: Immutability and Manipulation Patterns

slice() and indexOf() are both O(n) in the worst case — they may have to scan or copy across the full length of the string. That's not a problem in isolation, but it becomes one the same way array scans do: calling .indexOf() inside a loop over every character turns an O(n) scan into O(n²) overall, exactly like .includes() did for arrays in Module F-1.

split() is worth calling out specifically because it converts an immutable string into a regular, freely mutable array — which is why "turn the string into an array, mutate the array, join it back into a string" is such a common pattern for anything that needs in-place-feeling edits.

---

Two Classic String Patterns

Palindrome check, using the same two-pointer shape introduced for array reversal in Module F-2 (and covered in full in Module F-8):

function isPalindrome(s: string): boolean {
  const clean = s.toLowerCase().replace(/[^a-z0-9]/g, ''); // strip punctuation/case
  let left = 0;
  let right = clean.length - 1;
  while (left < right) {
    if (clean[left] !== clean[right]) return false;
    left++;
    right--;
  }
  return true;
}

This is O(n) time and O(n) space here (the clean copy), or O(1) extra space if you skip non-alphanumeric characters in place with index math instead of pre-building a cleaned copy — a common follow-up optimization once the basic two-pointer shape is understood.

Rotation check — is s2 some rotation of s1 (e.g. is "lohel" a rotation of "hello")? The brute-force approach tries every possible rotation point, which is O(n²). There's a much shorter path:

function isRotation(s1: string, s2: string): boolean {
  if (s1.length !== s2.length) return false;
  return (s1 + s1).includes(s2); // any rotation of s1 is a substring of s1 doubled
}

Concatenating s1 with itself produces a string containing every possible rotation of s1 as a contiguous substring. Checking whether s2 appears anywhere in s1 + s1 answers the rotation question in one substring search — O(n) with an efficient search algorithm (Module A-11 covers exactly how .includes()-style substring search can be made linear instead of quadratic, via KMP).

---

Where This Shows Up in Your Stack

• Logging and request tracing: building a log line by concatenating dozens of += fragments per request, at high request volume, adds up to real CPU time spent on string allocation that has nothing to do with the actual work being logged. Template literals (`${a} ${b} ${c}`) compile to a single concatenation rather than several sequential ones, and are almost always preferable to a chain of +=.
• Building SQL or query strings: manually concatenating user input into a query string is both a performance anti-pattern (same O(n²) risk if done in a loop) and, far more importantly, the classic vector for SQL injection — Module F-7 of the Node.js course and every ORM's parameterized-query API exist specifically so you never do this by hand.
• Node.js Buffer vs string: when you're processing raw bytes (file contents, network payloads) rather than text meant to be read, converting to a JavaScript string and back is extra allocation and encoding/decoding work you don't need — this is why Node's fs and net APIs default to Buffer and only convert to string when you explicitly ask for one encoding or another.
• Safe cache keys: because strings are immutable and compared by value, they're the default choice for cache keys (Redis keys, Map keys, memoization keys) — a key that could quietly change after being stored would silently break every lookup depending on it. This immutability guarantee is the same property that makes strings (and not arrays, which are mutable) safe default keys in a Map.

---

Summary

• Strings are immutable. Every operation that looks like a mutation returns a new string; the original is untouched.
• Naive concatenation in a loop is O(n²). Each += allocates and copies everything built so far — the fix is accumulating pieces in an array and calling .join() once.
• Slicing and searching are O(n) each, and calling them inside a loop compounds into O(n²), the same trap as .includes() on arrays.
• split() converts an immutable string into a mutable array — the standard escape hatch for anything that needs repeated in-place-feeling edits.
• Two-pointer and concatenation-trick patterns recur: palindrome checking previews Module F-8's two-pointer technique; the rotation check ((s1+s1).includes(s2)) turns an O(n²) brute force into a single O(n) substring search.

The next module, Hash Maps: Hashing, Collisions, and O(1) Lookups, is where the "loop inside a loop" problem that's shown up twice now (Module F-1's duplicate check, this module's naive rotation check) gets its general-purpose fix.

---