Strings inside the engine

One string value, many ways to store it

In JavaScript, a string is one simple kind of value. The language rules say what a string is: a list of code units that can never change. A code unit is a 16-bit number for one piece of text. Most characters, like a or ₹, are one code unit each. Code units are often written in hexadecimal (base 16), like 0x61 for a.

The rules do not say how to keep those code units in memory. That is up to the engine, the program that runs your JavaScript. This lesson uses V8, the engine inside Chrome and Node. V8 can store the same string in several ways. Your code still gets the same length, the same characters, and the same results from === and +.

This lesson is only about what happens inside the engine. How strings behave in your code is in other lessons: strings, string methods, Unicode and strings, and text encoding. To hunt for memory leaks, see Finding memory leaks.

Tagged values, Smis & heap numbers showed how small values fit inside one machine word. The lessons on booleans, undefined, and null showed values that are single read-only objects. A string is usually bigger, so V8 keeps it in the heap: the memory area where the engine keeps objects. Now we look at that object. Next come BigInts, symbols, and then ordinary objects.

Each row below is one string kind. Read across to see what it means and where you meet it.

One-byte and two-byte strings

A byte holds a number from 0 to 255. In hexadecimal, that is 0x00 to 0xFF. If every code unit in a string is 255 or less, V8 can store each code unit in one byte. This is a one-byte string.

If even one code unit is bigger than 255, V8 gives every code unit in that string two bytes. This is a two-byte string.

This is only how V8 stores the string in its own memory. It is not UTF-8, the encoding used to send text over the network. It is also not the number of characters a person sees.

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 code uses a regular expression (a text pattern) to check every code unit. It asks: is each one 255 or less? "café" passes, because é is 0x00E9 (233). "₹100" fails, because ₹ is 0x20B9 (8377). The two-byte count is simply text.length * 2. It is a simple model: it leaves out the extra bytes V8 adds to every string for its own notes.

To see the real kind, you need Node and a special flag. Running node --allow-natives-syntax turns on V8's private helper functions. Their names start with %. %DebugPrint(value) prints what V8 knows about a value, including a type: line with its kind. These helpers only work in Node with that flag, so this code can't run in the browser.

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", "अ");

Lines 2 to 5 make a helper. It prints a label, then the V8 details for the value. Lines 7 to 9 call it for three strings: "Asha", "₹", and "अ".

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

In each type: line, ONE_BYTE or TWO_BYTE is the storage width. INTERNALIZED means the string is V8's one shared copy of that text. You'll meet that near the end of the lesson.

Cons strings: joining without copying

Joining two strings with + could copy every character into a new string. For long strings, that copying takes time. So V8 often makes a cons string instead. A cons string is a small node with two pointers: one to the left piece and one to the right piece. No characters are copied yet.

A cons string can point at other cons strings. Many joins then make a tree of pieces. This tree is called a rope.

Later, some code may need all the characters in one row in memory. Then V8 can flatten the rope: it copies every piece, in order, into one plain string. A plain string with all its characters in one row is called a flat string. V8's own name for it is a sequential string, or SEQ for short.

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 step-through is a teaching model written in JavaScript. It does not look inside your browser's engine. It copies one real V8 rule: a join shorter than 13 characters is copied right away. The Node code below checks that rule in real V8.

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}

Lines 2 to 6 join strings to make lengths 12 and 13, and print each one. Line 7 makes a 1000-character string. Lines 8 to 11 cut pieces of length 12 and 13 from it and print them. You'll meet these pieces, called slices, in the next section.

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

At length 12, V8 just copies the characters, so both strings are SEQ (flat). At length 13, the join becomes a CONS string, and the cut piece becomes a SLICED string. The number 13 is a detail of this V8 version. Other versions may use a different number.

Sliced strings can keep big strings in memory

A sliced string is a view into part of another string. The other string is called its parent. A sliced string stores three things:

• a pointer to the parent,
• where the piece starts in the parent,
• how long the piece is.

This makes big.slice(start, end) fast, because no characters are copied. But it has a cost. While the small slice is in use, V8 can't remove the parent from memory. If you keep a tiny slice for a long time, the huge parent stays 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);

This step-through is a model too. The real proof is the Node code below. It runs Node with two flags:

• --expose-gc lets the code call global.gc(). That runs the garbage collector, the part of V8 that frees memory nothing uses any more.
• --allow-natives-syntax turns on %FlattenString. It makes the 10 MB parent a real flat string in memory.

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);

In plain words, line by line:

1. Lines 2 to 6: used() runs the garbage collector twice, then returns how much memory is in use.
2. Lines 7 to 10: makeSlice() makes a 10 MB string and returns a 13-character slice of it.
3. Lines 11 to 15: makeCopy() does the same, but returns a copy of the slice. Array.from(tiny) splits the slice into an array of single characters, and .join("") glues them into a new flat string.
4. Lines 16 to 18: note the memory in use, keep the slice, and print how much memory grew. It grows by about 10 MB.
5. Lines 19 and 20: drop the slice. The memory goes back down.
6. Lines 21 and 22: keep the copy instead. The memory grows only a little.

Internalized, thin, and external strings

V8 keeps a string table: a list where each piece of text is stored once. A string in this table is called internalized. Property names and many string literals are internalized. So when two objects both have a name key, they share one "name" string.

Sometimes V8 has a second string with the same text as one in the table. V8 can turn that second string into a thin string: a small stand-in that just points at the copy in the table.

An external string keeps its characters outside V8's own memory area. Another program, like Node, owns those characters. Node does this for the source code of its built-in modules. That does not mean every file you read becomes external. The lesson uses the source of Node's built-in fs module only because it always shows EXTERNAL_ONE_BYTE_STRING_TYPE in this version.

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

In plain words, line by line:

1. Lines 2 to 4: read the source code of Node's built-in fs module and print it. V8 reports it as external.
2. Line 6: make the text "ticket" by cutting it from a longer random string. So made is a new string, not the copy in the table.
3. Lines 7 and 8: make an empty object and use made as a key. For the key, V8 uses the "ticket" in the string table.
4. Lines 9 and 10: print made. It is now a thin string.
5. Lines 11 and 12: print the key stored in the object. It is the internalized copy.

Ways to build a string

Because V8 has cons strings, += in a loop is often fine. It is not free either: flattening and freeing memory still take time. Here are three common ways to build a string:

• + and += join strings. They are fine for small or simple joins.
• join glues all the items of an array into one string. It fits when your pieces are already in an array, or when you want something between them, like " -> ".
• A template literal, written with backticks, mixes text and values, like `${name} paid`. It is often the easiest to read.

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);

Lines 1 to 3 make a helper that joins text with +. Line 7 adds to receipt inside a loop with +=. V8 may keep the in-between results as cons strings and flatten them when needed. Line 10 uses join because the pieces are already in an array. Line 11 uses a template literal because the sentence is easier to read than a long chain of +.

Each row below is a situation. Read across for a good first choice and the reason.

When this matters in real code

Most code should stay simple. Write clear string code. Measure the slow part before you change your style. This lesson's details help when a profile or a heap snapshot points at code that handles many strings. A profile shows where the time goes. A heap snapshot shows what is in memory.

• Measure before you rewrite string joins. See Measuring performance.
• Take heap snapshots if you think small slices keep big responses in memory.
• Copy only the small piece that you keep from a big string you no longer need.
• For how characters and encodings work, see Unicode and strings and Text encoding.
• Use V8's % helpers only in tests and experiments, never in app code.

Common misconceptions

• “One-byte means UTF-8.” No. It means V8 stores each code unit in one byte, because every code unit is 255 or less.
• “JavaScript code can see ropes.” No. Ropes exist only inside the engine. Your code still sees a normal string.
• “Every slice wastes memory.” No. It only matters when you keep a tiny slice of a huge string for a long time.
• “+= is always slow.” No. In V8, cons strings make many repeated joins cheap. Measure the code that runs most.
• “The %DebugPrint type is the same everywhere.” No. It shows how this V8 version stores the value. Other versions and other engines can differ.

Each row below is one idea. Read across for what it means and the mistake to avoid.

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 is kept in a cache for a long time.
// Copy it here if a memory tool shows the big string is kept.

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

Check your understanding

For each question, first think about what JavaScript does. Then think about how V8 stores the string.

Key takeaways

• A JavaScript string is a list of 16-bit code units that never changes. V8 picks how to store it, and your code can't see that choice.
• If every code unit is 255 (0xFF) or less, V8 can use one byte per code unit. If not, it uses two bytes per code unit.
• A cons string joins two pieces without copying them. V8 can flatten it into one plain string later.
• A sliced string is a view into a parent string. In V8 12.4, a tiny slice you keep can keep a huge parent in memory.
• Internalized strings are the shared copies in the string table. Thin strings point at them. External strings keep their characters outside V8.
• Write the clearest string code first. Then measure the busy parts for time and memory.

Up next: BigInt inside the engine. A BigInt is another value that V8 keeps in the heap, stored as a sign and a list of 64-bit digits. After symbols, Hidden classes & object shapes looks at ordinary objects the same way.