When a learner can reproduce a familiar example but a small variation causes confusion, the problem is usually an incomplete model rather than a lack of effort. The fastest useful response is to expose the hidden state and test one boundary at a time.

JavaScript RegExp.escape(string) returns text that represents the supplied string literally when embedded in a regular-expression pattern. Its algorithm does more than place backslashes before familiar metacharacters: it also protects a leading ASCII letter or digit, escapes punctuators safely, and handles whitespace and lone surrogates. Mastery means separating untrusted literal text from intentional pattern syntax. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.

The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.

Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.

Use disposable data and repositories, preserve backups, and check version-sensitive details against the official source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.

RegExp.escape turns a string into pattern text that matches those characters rather than interpreting them as regex operators. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is escaping an entire intentional pattern and thereby disabling its syntax. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Mark each fragment as literal data or deliberate pattern syntax before composing.

For the Literal text is the central job chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on escaping an entire intentional pattern and thereby disabling its syntax. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const literal = RegExp.escape('a+b');
const re = new RegExp(`^${literal}$`);
console.log(re.test('a+b'), re.test('aaab'));

Four purposeful transfer cases

Case 1: homework search. Predict the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library lookup. Contrast the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: CCA roster. Stress-test the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: science notes. Explain the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers escaping an entire intentional pattern and thereby disabling its syntax.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Mark each fragment as literal data or deliberate pattern syntax before composing.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Literal text is the central job?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing escaping an entire intentional pattern and thereby disabling its syntax be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny file finder with a user-entered filename suffix. Include one ordinary case, one boundary and one deliberate failure caused by escaping an entire intentional pattern and thereby disabling its syntax. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Literal text is the central job, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The specification requires a String value and throws TypeError for other types instead of coercing them silently. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is passing a number from a form model and assuming automatic conversion. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Convert deliberately at the application boundary only when numeric text is the intended value.

For the The input must be a string chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on passing a number from a form model and assuming automatic conversion. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

try { RegExp.escape(42); } catch (e) { console.log(e.name); }

Four purposeful transfer cases

Case 1: CCA roster. Contrast the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: science notes. Stress-test the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: revision filter. Explain the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: file finder. Transfer the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers passing a number from a form model and assuming automatic conversion.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Convert deliberately at the application boundary only when numeric text is the intended value.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from The input must be a string?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing a number from a form model and assuming automatic conversion be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny feedback tool with a phrase containing brackets or question marks. Include one ordinary case, one boundary and one deliberate failure caused by passing a number from a form model and assuming automatic conversion. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The input must be a string, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A leading ASCII alphanumeric is encoded with a hexadecimal escape so concatenation cannot merge it with a preceding numeric, hexadecimal or Unicode escape. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is reimplementing the function with a metacharacter-only replacement. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test a leading letter and digit adjacent to deliberate escape syntax.

For the The first ASCII letter or digit is hex-escaped chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on reimplementing the function with a metacharacter-only replacement. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log(RegExp.escape('foo'), RegExp.escape('1st'));

Four purposeful transfer cases

Case 1: revision filter. Stress-test the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: file finder. Explain the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: feedback tool. Transfer the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: test builder. Predict the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers reimplementing the function with a metacharacter-only replacement.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test a leading letter and digit adjacent to deliberate escape syntax.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from The first ASCII letter or digit is hex-escaped?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reimplementing the function with a metacharacter-only replacement be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test builder with table-driven literals compared with exact matches. Include one ordinary case, one boundary and one deliberate failure caused by reimplementing the function with a metacharacter-only replacement. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The first ASCII letter or digit is hex-escaped, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Characters such as caret, dollar, backslash, dot, star, plus, question mark, parentheses, brackets, braces and vertical bar are escaped. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is leaving one operator active and broadening the match. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a table containing every syntax character and verify exact whole-string matches.

For the Regex syntax characters receive escapes chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on leaving one operator active and broadening the match. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const text='[draft].txt';
const re=new RegExp(`^${RegExp.escape(text)}$`);
console.log(re.test(text));

Four purposeful transfer cases

Case 1: feedback tool. Explain the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: test builder. Transfer the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework search. Predict the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library lookup. Contrast the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers leaving one operator active and broadening the match.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use a table containing every syntax character and verify exact whole-string matches.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Regex syntax characters receive escapes?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing leaving one operator active and broadening the match be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework search with a learner-entered topic used in a highlight pattern. Include one ordinary case, one boundary and one deliberate failure caused by leaving one operator active and broadening the match. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Regex syntax characters receive escapes, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A slash is escaped so the result can be used safely in contexts that display or construct regular-expression source with slash delimiters. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming slash never matters because the RegExp constructor itself uses a string. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test constructor use and source representation without hand-editing the escaped result.

For the The slash is escaped too chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming slash never matters because the RegExp constructor itself uses a string. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const part=RegExp.escape('m/s');
console.log(new RegExp(part).test('m/s'));

Four purposeful transfer cases

Case 1: homework search. Transfer the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library lookup. Predict the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: CCA roster. Contrast the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: science notes. Stress-test the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming slash never matters because the RegExp constructor itself uses a string.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test constructor use and source representation without hand-editing the escaped result.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from The slash is escaped too?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming slash never matters because the RegExp constructor itself uses a string be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library lookup with a literal shelf label containing punctuation. Include one ordinary case, one boundary and one deliberate failure caused by assuming slash never matters because the RegExp constructor itself uses a string. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The slash is escaped too, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Characters such as hyphen, comma, equals, angle brackets, hash and several quotes are encoded in forms valid across relevant pattern grammar positions. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is prefixing every punctuation mark with a backslash and producing invalid Unicode-mode patterns. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Trust the standard algorithm and run cases under the flags the application uses.

For the Other punctuators use safe hexadecimal forms chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on prefixing every punctuation mark with a backslash and producing invalid Unicode-mode patterns. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const p=RegExp.escape('A-B');
console.log(p, new RegExp(p,'u').test('A-B'));

Four purposeful transfer cases

Case 1: CCA roster. Predict the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: science notes. Contrast the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: revision filter. Stress-test the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: file finder. Explain the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers prefixing every punctuation mark with a backslash and producing invalid Unicode-mode patterns.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Trust the standard algorithm and run cases under the flags the application uses.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Other punctuators use safe hexadecimal forms?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing prefixing every punctuation mark with a backslash and producing invalid Unicode-mode patterns be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with a student name searched without regex semantics. Include one ordinary case, one boundary and one deliberate failure caused by prefixing every punctuation mark with a backslash and producing invalid Unicode-mode patterns. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Other punctuators use safe hexadecimal forms, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

An ordinary space is represented explicitly, avoiding ambiguity in generated or free-spacing-adjacent tooling. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is trimming user input after escaping and changing the search term. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Decide trimming before the escape step and test leading, internal and trailing spaces.

For the Space becomes a hexadecimal escape chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on trimming user input after escaping and changing the search term. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const p=RegExp.escape('two words');
console.log(new RegExp(`^${p}$`).test('two words'));

Four purposeful transfer cases

Case 1: revision filter. Contrast the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: file finder. Stress-test the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: feedback tool. Explain the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: test builder. Transfer the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers trimming user input after escaping and changing the search term.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Decide trimming before the escape step and test leading, internal and trailing spaces.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Space becomes a hexadecimal escape?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing trimming user input after escaping and changing the search term be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science notes with a unit string such as m/s or °C. Include one ordinary case, one boundary and one deliberate failure caused by trimming user input after escaping and changing the search term. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Space becomes a hexadecimal escape, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Tab, newline, carriage return, form feed and vertical tab use their standard escape forms. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is printing the result and mistaking display formatting for the represented character. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare code points and exact matches instead of relying only on console appearance.

For the Control whitespace has named escapes chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on printing the result and mistaking display formatting for the represented character. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const p=RegExp.escape('a\nb');
console.log(new RegExp(`^${p}$`).test('a\nb'));

Four purposeful transfer cases

Case 1: feedback tool. Stress-test the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: test builder. Explain the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework search. Transfer the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library lookup. Predict the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers printing the result and mistaking display formatting for the represented character.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare code points and exact matches instead of relying only on console appearance.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Control whitespace has named escapes?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing printing the result and mistaking display formatting for the represented character be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision filter with a literal tag inserted beside deliberate anchors. Include one ordinary case, one boundary and one deliberate failure caused by printing the result and mistaking display formatting for the represented character. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Control whitespace has named escapes, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The algorithm uses Unicode escape sequences where needed for non-ASCII whitespace and lone surrogate code units. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming JSON escaping and regex escaping have identical rules. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use code-point-aware fixtures and keep string serialization separate from pattern construction.

For the Other whitespace and lone surrogates are represented safely chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming JSON escaping and regex escaping have identical rules. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const text='A\u2028B';
const p=RegExp.escape(text);
console.log(new RegExp(`^${p}$`,'u').test(text));

Four purposeful transfer cases

Case 1: homework search. Explain the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library lookup. Transfer the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: CCA roster. Predict the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: science notes. Contrast the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming JSON escaping and regex escaping have identical rules.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use code-point-aware fixtures and keep string serialization separate from pattern construction.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Other whitespace and lone surrogates are represented safely?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming JSON escaping and regex escaping have identical rules be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny file finder with a user-entered filename suffix. Include one ordinary case, one boundary and one deliberate failure caused by assuming JSON escaping and regex escaping have identical rules. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Other whitespace and lone surrogates are represented safely, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

RegExp.escape prepares literal text for a pattern; it is different from the specification operation that displays an existing pattern as source. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is feeding regex.source into RegExp.escape and expecting an equivalent regular expression. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Identify whether the input is data or already-authored pattern syntax.

For the Escaping is not regex-literal serialization chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on feeding regex.source into RegExp.escape and expecting an equivalent regular expression. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const authored=/a+b/;
const literal=new RegExp(RegExp.escape(authored.source));
console.log(authored.test('aaab'), literal.test('a+b'));

Four purposeful transfer cases

Case 1: CCA roster. Transfer the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: science notes. Predict the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: revision filter. Contrast the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: file finder. Stress-test the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers feeding regex.source into RegExp.escape and expecting an equivalent regular expression.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Identify whether the input is data or already-authored pattern syntax.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Escaping is not regex-literal serialization?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing feeding regex.source into RegExp.escape and expecting an equivalent regular expression be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny feedback tool with a phrase containing brackets or question marks. Include one ordinary case, one boundary and one deliberate failure caused by feeding regex.source into RegExp.escape and expecting an equivalent regular expression. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Escaping is not regex-literal serialization, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Application code may place ^ and $ around an escaped literal to require a whole-string match. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is escaping the anchors together with the data and losing the boundary rule. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Construct syntax from fixed code and insert only the escaped data fragment.

For the Anchors remain deliberate outer syntax chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on escaping the anchors together with the data and losing the boundary rule. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const value='Punggol?';
const re=new RegExp(`^${RegExp.escape(value)}$`);

Four purposeful transfer cases

Case 1: revision filter. Predict the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: file finder. Contrast the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: feedback tool. Stress-test the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: test builder. Explain the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers escaping the anchors together with the data and losing the boundary rule.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Construct syntax from fixed code and insert only the escaped data fragment.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Anchors remain deliberate outer syntax?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing escaping the anchors together with the data and losing the boundary rule be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test builder with table-driven literals compared with exact matches. Include one ordinary case, one boundary and one deliberate failure caused by escaping the anchors together with the data and losing the boundary rule. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Anchors remain deliberate outer syntax, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Each user-controlled alternative should be escaped separately before fixed vertical-bar syntax joins the branches. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is joining raw alternatives first and letting parentheses or bars alter the grammar. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Map escape over values, then group the resulting fragments.

For the Alternation needs separate escaped branches chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on joining raw alternatives first and letting parentheses or bars alter the grammar. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const values=['A+B','C|D'];
const re=new RegExp(`^(?:${values.map(RegExp.escape).join('|')})$`);

Four purposeful transfer cases

Case 1: feedback tool. Contrast the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: test builder. Stress-test the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework search. Explain the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library lookup. Transfer the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers joining raw alternatives first and letting parentheses or bars alter the grammar.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Map escape over values, then group the resulting fragments.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Alternation needs separate escaped branches?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing joining raw alternatives first and letting parentheses or bars alter the grammar be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework search with a learner-entered topic used in a highlight pattern. Include one ordinary case, one boundary and one deliberate failure caused by joining raw alternatives first and letting parentheses or bars alter the grammar. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Alternation needs separate escaped branches, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Escaped literals can be embedded safely, but a character class matches one character rather than a whole phrase. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is placing a multi-character escaped term inside brackets and expecting an exact string. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Choose concatenation, grouping or alternation according to the intended language.

For the Character classes are often the wrong abstraction chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on placing a multi-character escaped term inside brackets and expecting an exact string. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const term=RegExp.escape('ab');
console.log(new RegExp(`^(?:${term})$`).test('ab'));

Four purposeful transfer cases

Case 1: homework search. Stress-test the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library lookup. Explain the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: CCA roster. Transfer the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: science notes. Predict the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers placing a multi-character escaped term inside brackets and expecting an exact string.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Choose concatenation, grouping or alternation according to the intended language.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Character classes are often the wrong abstraction?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing placing a multi-character escaped term inside brackets and expecting an exact string be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library lookup with a literal shelf label containing punctuation. Include one ordinary case, one boundary and one deliberate failure caused by placing a multi-character escaped term inside brackets and expecting an exact string. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Character classes are often the wrong abstraction, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Escaping controls pattern syntax, while flags such as i, m, s, u and v independently affect matching behaviour. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling an escaped search exact while enabling case-insensitive matching. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Document flags beside the user-facing search rule and test culturally relevant text.

For the Flags still change matching semantics chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling an escaped search exact while enabling case-insensitive matching. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const p=RegExp.escape('Math');
console.log(new RegExp(`^${p}$`,'i').test('math'));

Four purposeful transfer cases

Case 1: CCA roster. Explain the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: science notes. Transfer the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: revision filter. Predict the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: file finder. Contrast the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers calling an escaped search exact while enabling case-insensitive matching.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Document flags beside the user-facing search rule and test culturally relevant text.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Flags still change matching semantics?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling an escaped search exact while enabling case-insensitive matching be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with a student name searched without regex semantics. Include one ordinary case, one boundary and one deliberate failure caused by calling an escaped search exact while enabling case-insensitive matching. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Flags still change matching semantics, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A safe literal fragment can still be inserted into a poorly designed surrounding regex with costly backtracking. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating injection safety as a performance guarantee. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep outer syntax simple, bound inputs and benchmark adversarial cases.

For the Escaping does not prevent expensive outer patterns chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating injection safety as a performance guarantee. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const safe=RegExp.escape('topic');
const re=new RegExp(`^${safe}$`);

Four purposeful transfer cases

Case 1: revision filter. Transfer the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: file finder. Predict the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: feedback tool. Contrast the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: test builder. Stress-test the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating injection safety as a performance guarantee.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Keep outer syntax simple, bound inputs and benchmark adversarial cases.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Escaping does not prevent expensive outer patterns?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating injection safety as a performance guarantee be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science notes with a unit string such as m/s or °C. Include one ordinary case, one boundary and one deliberate failure caused by treating injection safety as a performance guarantee. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Escaping does not prevent expensive outer patterns, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The function makes pattern syntax literal; it does not decide whether a term is allowed, meaningful, private or too long. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using successful escaping as permission to process any input. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Validate length and domain policy before or alongside pattern construction.

For the Escaping is not input validation chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using successful escaping as permission to process any input. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const term='x'.repeat(5000);
console.log(RegExp.escape(term).length >= term.length);

Four purposeful transfer cases

Case 1: feedback tool. Predict the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: test builder. Contrast the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework search. Stress-test the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library lookup. Explain the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using successful escaping as permission to process any input.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Validate length and domain policy before or alongside pattern construction.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Escaping is not input validation?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using successful escaping as permission to process any input be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision filter with a literal tag inserted beside deliberate anchors. Include one ordinary case, one boundary and one deliberate failure caused by using successful escaping as permission to process any input. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Escaping is not input validation, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

RegExp.escape is a modern standard feature, so deployed runtimes must be checked rather than assumed. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is shipping a call to older browsers or Node versions without a support plan. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test typeof RegExp.escape and load a reviewed standards-conforming fallback when required.

For the Compatibility needs feature detection chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on shipping a call to older browsers or Node versions without a support plan. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if (typeof RegExp.escape !== 'function') {
  console.log('compatibility path required');
}

Four purposeful transfer cases

Case 1: homework search. Contrast the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library lookup. Stress-test the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: CCA roster. Explain the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: science notes. Transfer the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers shipping a call to older browsers or Node versions without a support plan.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test typeof RegExp.escape and load a reviewed standards-conforming fallback when required.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Compatibility needs feature detection?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing shipping a call to older browsers or Node versions without a support plan be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny file finder with a user-entered filename suffix. Include one ordinary case, one boundary and one deliberate failure caused by shipping a call to older browsers or Node versions without a support plan. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Compatibility needs feature detection, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Common snippets cover visible metacharacters but miss leading-character ambiguity, punctuators, whitespace or lone surrogates. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is publishing a one-line replacement as a complete polyfill. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use the native operation or a maintained conformance-tested implementation.

For the A hand-written replace is easy to get wrong chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on publishing a one-line replacement as a complete polyfill. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const naive=s=>s.replace(/[.*+?^${}()|[\]\\]/g,'\\$&');
console.log(naive('1-a'));

Four purposeful transfer cases

Case 1: CCA roster. Stress-test the rule using a student name searched without regex semantics. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: science notes. Explain the rule using a unit string such as m/s or °C. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: revision filter. Transfer the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: file finder. Predict the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers publishing a one-line replacement as a complete polyfill.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use the native operation or a maintained conformance-tested implementation.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from A hand-written replace is easy to get wrong?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing publishing a one-line replacement as a complete polyfill be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny feedback tool with a phrase containing brackets or question marks. Include one ordinary case, one boundary and one deliberate failure caused by publishing a one-line replacement as a complete polyfill. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A hand-written replace is easy to get wrong, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A robust test creates a pattern from each escaped fixture and checks the intended literal succeeds while near-misses fail. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is snapshotting only the escape string and tying tests to one display spelling. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test semantic matches plus a few required algorithm examples.

For the Round-trip tests should assert meaning chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on snapshotting only the escape string and tying tests to one display spelling. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for (const s of ['a+b','[x]','two words']) {
  const re=new RegExp(`^${RegExp.escape(s)}$`);
  console.assert(re.test(s));
}

Four purposeful transfer cases

Case 1: revision filter. Explain the rule using a literal tag inserted beside deliberate anchors. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: file finder. Transfer the rule using a user-entered filename suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: feedback tool. Predict the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: test builder. Contrast the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers snapshotting only the escape string and tying tests to one display spelling.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test semantic matches plus a few required algorithm examples.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Round-trip tests should assert meaning?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing snapshotting only the escape string and tying tests to one display spelling be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test builder with table-driven literals compared with exact matches. Include one ordinary case, one boundary and one deliberate failure caused by snapshotting only the escape string and tying tests to one display spelling. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Round-trip tests should assert meaning, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The safest design keeps authored regex structure in code and sends every data fragment through the standard escape operation exactly once. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is double-escaping stored fragments or mixing raw and escaped values in one array. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep raw values canonical and escape only at pattern-construction time.

For the Separate fixed grammar from variable data chapter on JavaScript RegExp.escape(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on double-escaping stored fragments or mixing raw and escaped values in one array. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

function exact(value){
  return new RegExp(`^${RegExp.escape(value)}$`,'u');
}

Four purposeful transfer cases

Case 1: feedback tool. Transfer the rule using a phrase containing brackets or question marks. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: test builder. Predict the rule using table-driven literals compared with exact matches. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework search. Contrast the rule using a learner-entered topic used in a highlight pattern. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library lookup. Stress-test the rule using a literal shelf label containing punctuation. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers double-escaping stored fragments or mixing raw and escaped values in one array.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Keep raw values canonical and escape only at pattern-construction time.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript RegExp.escape() syntax. For this chapter, useful prompts are: “What did you expect from Separate fixed grammar from variable data?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing double-escaping stored fragments or mixing raw and escaped values in one array be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework search with a learner-entered topic used in a highlight pattern. Include one ordinary case, one boundary and one deliberate failure caused by double-escaping stored fragments or mixing raw and escaped values in one array. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Separate fixed grammar from variable data, separate the documented JavaScript RegExp.escape() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Start with evidence, not a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.

Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.

Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.

1. homework search: model, boundary and recovery

Create a small homework search using a learner-entered topic used in a highlight pattern. Combine “Literal text is the central job” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. library lookup: model, boundary and recovery

Create a small library lookup using a literal shelf label containing punctuation. Combine “Regex syntax characters receive escapes” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. CCA roster: model, boundary and recovery

Create a small CCA roster using a student name searched without regex semantics. Combine “Space becomes a hexadecimal escape” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. science notes: model, boundary and recovery

Create a small science notes using a unit string such as m/s or °C. Combine “Escaping is not regex-literal serialization” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. revision filter: model, boundary and recovery

Create a small revision filter using a literal tag inserted beside deliberate anchors. Combine “Character classes are often the wrong abstraction” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. file finder: model, boundary and recovery

Create a small file finder using a user-entered filename suffix. Combine “Escaping is not input validation” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. feedback tool: model, boundary and recovery

Create a small feedback tool using a phrase containing brackets or question marks. Combine “Round-trip tests should assert meaning” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. test builder: model, boundary and recovery

Create a small test builder using table-driven literals compared with exact matches. Combine “The input must be a string” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

Use one complete prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.

Should every option or function be memorised?

No. Memorise the governing distinctions and practise retrieving the official reference. Understanding means predicting and explaining, not reciting a parameter list.

What if the result is correct but the explanation is weak?

Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.

Is the shortest solution the best?

Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.

When should official documentation be used?

Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation settles the current contract.

How can a parent help without technical expertise?

Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.

How do we test transfer?

Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.

What should be saved after practice?

Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.

Can these exercises replace backups?

No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.

What counts as mastery?

The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.

Official and supporting references

• Primary technical documentation for JavaScript RegExp.escape()
• eduKatePunggol: How Studying Works

Return to contents