Strings inside the engine

Strings are values with engine shapes

JavaScript gives you one simple value type: string. The language says a string is an immutable sequence of UTF-16 code units. It does not say how an engine must store those code units. V8 can choose several internal representations while keeping the same JavaScript result for length, indexing, comparison, and concatenation.

Keep the boundary clear. The public lessons on strings, string methods, Unicode and strings, and text encoding teach language behavior and encodings. This lesson stays inside the engine. For heap-snapshot leak hunting, link to Finding memory leaks instead of repeating it.

Tagged values, Smis & heap numbers explained how values fit into machine words, and the oddball lessons that followed (booleans, undefined, and null) showed values that are single read-only objects. Strings usually live on the heap, so now we zoom into the object behind a string value. The next lessons do the same for BigInts, symbols, and then ordinary objects.

One-byte and two-byte strings

V8 can store a string in one byte per code unit when every UTF-16 code unit is between 0x00 and 0xFF. The moment a code unit is above that range, V8 needs two bytes per code unit for the whole string. That is an internal storage width, not UTF-8, not a network encoding, and not the number of user-perceived characters.

1function describeString(text) {2  const oneBytePossible = /^[\u0000-\u00FF]*$/.test(text);3  return {4    length: text.length,5    storage: oneBytePossible ? "one-byte possible" : "two-byte needed",6    bytesIfOneByte: text.length,7    bytesIfTwoByte: text.length * 2,8  };9}10 11for (const text of ["Asha", "café", "₹100", "अ"]) {12  const report = describeString(text);13  console.log(text, report.length, report.storage, report.bytesIfTwoByte);14}

Line 2 of the playground uses a real regular expression over code units. "café" still fits one-byte storage because é is 0x00E9. "₹100" does not, because the rupee sign is 0x20B9. The modeled two-byte count is simply text.length * 2; it is a useful storage model, not a promise about object headers or compression.

1// Node-only: run with --allow-natives-syntax.2function printKind(label, value) {3  process.stdout.write("@@" + label + "\n");4  %DebugPrint(value);5}6 7printKind("ascii", "Asha");8printKind("rupee", "₹");9printKind("devanagari", "अ");

1Node 22 / V8 12.4 stable excerpts2@@ascii      type: INTERNALIZED_ONE_BYTE_STRING_TYPE3@@rupee      type: INTERNALIZED_TWO_BYTE_STRING_TYPE4@@devanagari type: INTERNALIZED_TWO_BYTE_STRING_TYPE

Cons strings, ropes, and flattening

A cons string is V8's rope node: it points to a left string and a right string instead of copying all characters immediately. A rope is a tree of string pieces. This is why a + b can be cheap in a loop: the engine may build a small tree first and copy characters later.

1function makeConsString(left, right) {2  const length = left.length + right.length;3  if (length < 13) return left + right;4  return { kind: "cons", left, right, length };5}6 7function flattenRope(node) {8  return typeof node === "string"9    ? node10    : flattenRope(node.left) + flattenRope(node.right);11}12 13const left = "Asha-ticket-";Run14const right = "Pune-to-Kochi";15const receipt = makeConsString(left, right);16console.log(receipt.kind, receipt.length);17const flat = flattenRope(receipt);18console.log(flat);

This execution is a teaching model; it does not inspect your browser engine. The real V8 probe below checks the threshold. In this Node 22 / V8 12.4 build, a concatenation of total length 12 is sequential, while length 13 can become CONS_ONE_BYTE_STRING_TYPE. The same threshold appears for sliced strings.

1// Node-only: run with --allow-natives-syntax.2for (let n = 12; n <= 13; n += 1) {3  const value = "a".repeat(n - 1) + "b";4  process.stdout.write("@@cons " + n + "\n");5  %DebugPrint(value);6}7const big = "x".repeat(1000);8for (let n = 12; n <= 13; n += 1) {9  process.stdout.write("@@slice " + n + "\n");10  %DebugPrint(big.slice(0, n));11}

1Node 22 / V8 12.4 stable excerpts2cons length 12  type: SEQ_ONE_BYTE_STRING_TYPE3cons length 13  type: CONS_ONE_BYTE_STRING_TYPE4slice length 12 type: SEQ_ONE_BYTE_STRING_TYPE5slice length 13 type: SLICED_ONE_BYTE_STRING_TYPE

Sliced strings and retained memory

A sliced string is a view into another string. It stores a parent pointer, an offset, and a length. That can make big.slice(start, end) cheap, but it creates a memory trap: if the tiny slice escapes, the huge parent may stay alive too.

1const responseBytes = 10 * 1024 * 1024;Run2const response = "x".repeat(responseBytes);3const tiny = response.slice(100, 113);4console.log(tiny.length);5console.log("slice keeps parent", true);6const copied = Array.from(tiny).join("");7console.log("copy length", copied.length);

The runtime probe below uses --expose-gc and %FlattenString so the parent really occupies about 10 MB. Keeping a 13-character slice retains roughly that parent size. Returning Array.from(tiny).join("") from the same helper creates a flat 13-character string, and the measured delta stays small.

1// Node-only: run with --expose-gc --allow-natives-syntax.2function used() {3  global.gc();4  global.gc();5  return process.memoryUsage().heapUsed;6}7function makeSlice() {8  const big = %FlattenString("x".repeat(10 * 1024 * 1024));9  return big.slice(100, 113);10}11function makeCopy() {12  const big = %FlattenString("x".repeat(10 * 1024 * 1024));13  const tiny = big.slice(100, 113);14  return Array.from(tiny).join("");15}16const base = used();17let keep = makeSlice();18console.log("slice delta", used() - base);19keep = null;20console.log("after drop", used() - base);21const copied = makeCopy();22console.log("copy delta", used() - base, copied.length);

Thin, external, and internalized strings

An internalized string is a canonical entry in V8's string table. Engines use string tables so repeated property names and identifiers can share one canonical string. A thin string is a forwarding wrapper that points at another string, often after V8 discovers an internalized version already exists.

An external string stores characters outside the normal V8 heap. Node exposes this honestly for built-in module source strings. That does not mean every file you read becomes external; the lesson test probes Node's built-in fs source because it reliably shows EXTERNAL_ONE_BYTE_STRING_TYPE in this build.

1// Node-only: run with --allow-natives-syntax.2const source = process.binding("natives").fs;3process.stdout.write("@@external\n");4%DebugPrint(source);5 6const made = ("ticket" + Math.random()).slice(0, 6);7const object = {};8object[made] = 1;9process.stdout.write("@@original\n");10%DebugPrint(made);11process.stdout.write("@@key\n");12%DebugPrint(Object.getOwnPropertyNames(object)[0]);

1Node 22 / V8 12.4 stable excerpts2@@external type: EXTERNAL_ONE_BYTE_STRING_TYPE3@@original type: THIN_ONE_BYTE_STRING_TYPE4@@key      type: INTERNALIZED_ONE_BYTE_STRING_TYPE

Line 2 reads Node's built-in fs module source, which V8 reports as external one-byte. Lines 6 through 12 create a fresh non-internalized string, use it as a property key, then print the original and the stored property name. The original becomes thin; the key in Object.getOwnPropertyNames is internalized.

String building strategies

Because V8 has cons strings, += in a loop is not automatically a disaster. Because flattening and GC still cost memory and time, += is not automatically free either. Array.prototype.join is excellent when you already have an array of pieces or need a separator. Template literals are the clearest way to mix expressions and text.

1function makeLine(name, amount) {2  return name + " paid ₹" + amount;3}4 5let receipt = "";6for (const item of ["tea", "snacks", "fruit"]) {7  receipt += item + ";";8}9 10const joined = ["Asha", "Pune", "Kochi"].join(" -> ");11const templated = `${makeLine("Asha", 500)} for ${joined}`;12console.log(receipt);13console.log(joined);14console.log(templated);

Line 7 appends inside a loop. V8 may represent intermediate values as cons strings, then flatten when code needs contiguous characters. Line 9 uses join because the pieces already live in an array. Line 10 uses a template literal because the sentence is easier to read than a long chain of + operators.

Practical use and measurement

Most application code should stay boring: use clear string expressions, normalize or encode text at boundaries, and measure user-visible work before changing style. This internals knowledge matters when a profile or heap snapshot points at string-heavy code.

• Use measuring performance before rewriting concatenation.
• Use heap snapshots when you suspect slices are retaining large responses.
• Copy only the small substring that escapes a large temporary string.
• Keep Unicode correctness in the language lessons: Unicode and strings and Text encoding.
• Do not rely on V8 % natives outside controlled experiments and tests.

Common misconceptions

• “One-byte means UTF-8.” No. It means V8 stores each UTF-16 code unit in one byte when all code units fit Latin-1.
• “JavaScript exposes ropes.” No. Ropes are private engine representations; normal code still sees strings.
• “Every slice leaks memory.” No. Retention matters when a small slice escapes a large temporary parent.
• “`+=` is always slow.” No. Cons strings make repeated concatenation cheap in many modern V8 cases; measure hot paths.
• “DebugPrint types are portable facts.” No. They are V8 implementation details for this version, not language guarantees.

Practice exercises

function fitsOneByte(text) { return /^[\u0000-\u00FF]*$/.test(text); }
console.log(fitsOneByte("café"));
console.log(fitsOneByte("₹"));

const previews = new Map();
function rememberPreview(id, responseText) {
  previews.set(id, responseText.slice(0, 80));
}

const token = bigResponse.slice(100, 113);
// token escapes into a long-lived cache. Copy it here if measurement says retention matters.

const copied = Array.from(token).join("");

Check your understanding

Answer by separating JavaScript semantics from V8's private representation choices.

Key takeaways

• JavaScript strings are immutable UTF-16 code-unit sequences; V8 chooses private storage representations underneath.
• One-byte storage is possible when every code unit fits 0x00 through 0xFF; otherwise V8 uses two-byte storage.
• Cons strings make concatenation cheap by storing a rope node, and flattening creates contiguous characters later when needed.
• Sliced strings make substrings cheap, but a tiny long-lived slice can retain a huge parent in V8 12.4.
• Thin, external, and internalized strings are about forwarding, host-backed storage, and the string table.
• Use the clearest string-building style, then measure representative hot paths and memory retention.

Up next: BigInt inside the engine, another heap-allocated primitive, stored as a sign and an array of 64-bit digits. After symbols, Hidden classes & object shapes gives ordinary objects the same treatment.