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 Array.prototype.findLast(predicate, thisArg) searches an array-like object from the highest index down to zero and returns the value from the first position whose predicate result is truthy. If no position passes, it returns undefined. The method does not mutate the receiver by itself, but the callback can, and the length is captured before iteration begins. It visits integer positions in descending order, including empty slots as undefined, so mastery means predicting call order, separating a found undefined value from no match, understanding mutation timing, and choosing findLast only when the last qualifying value—not its index or every match—is the actual result needed. 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.

findLast tests positions from length minus one toward zero and stops at the first truthy predicate result. 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 describing it as find followed by an automatic array reversal. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Search runs from the highest index downward, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Search runs from the highest index downward chapter on JavaScript Array.prototype.findLast(), 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 describing it as find followed by an automatic array reversal. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[2,7,4,9,6];
console.log(a.findLast(x=>x%2===0));

Four purposeful transfer cases

Case 1: homework attempts. Predict the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Contrast the rule using the most recent session above a page threshold is found. 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: science readings. Stress-test the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Explain the rule using the latest confirmed entry is selected without sorting the list. 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 describing it as find followed by an automatic array reversal.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Search runs from the highest index downward, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Search runs from the highest index downward?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing describing it as find followed by an automatic array reversal be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library loans with the most recent overdue record is searched by predicate. Include one ordinary case, one boundary and one deliberate failure caused by describing it as find followed by an automatic array reversal. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Search runs from the highest index downward, separate the documented JavaScript Array.prototype.findLast() 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

findLast returns the qualifying element value, not its position. 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 the result as though it were an array index. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The returned result is a value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The returned result is a value chapter on JavaScript Array.prototype.findLast(), 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 the result as though it were an array index. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[3,8,5,8];
console.log(a.findLast(x=>x===8));

Four purposeful transfer cases

Case 1: science readings. Contrast the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Stress-test the rule using the latest confirmed entry is selected without sorting the list. 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: family errands. Explain the rule using the last open stop in an ordered plan is located. 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 loans. Transfer the rule using the most recent overdue record is searched by predicate. 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 the result as though it were an array index.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The returned result is a value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from The returned result is a value?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using the result as though it were an array index be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with holes, undefined, mutation, thisArg and array-like length expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by using the result as though it were an array index. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The returned result is a value, separate the documented JavaScript Array.prototype.findLast() 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

When every predicate result is falsy, the method completes with undefined. 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 expecting null, -1 or an empty array. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for No match returns undefined, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the No match returns undefined chapter on JavaScript Array.prototype.findLast(), 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 expecting null, -1 or an empty array. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log([1,3,5].findLast(x=>x%2===0));

Four purposeful transfer cases

Case 1: family errands. Stress-test the rule using the last open stop in an ordered plan is located. 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 loans. Explain the rule using the most recent overdue record is searched by predicate. 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: test laboratory. Transfer the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Predict the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 expecting null, -1 or an empty array.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for No match returns undefined, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from No match returns undefined?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting null, -1 or an empty array be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with findLast is compared with find, findLastIndex, filter, at, reverse and loops. Include one ordinary case, one boundary and one deliberate failure caused by expecting null, -1 or an empty array. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For No match returns undefined, separate the documented JavaScript Array.prototype.findLast() 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 element whose value is undefined can satisfy the predicate, producing the same returned value as the no-match case. 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 checking result === undefined and concluding the predicate never matched. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for A found undefined value is ambiguous by result alone, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the A found undefined value is ambiguous by result alone chapter on JavaScript Array.prototype.findLast(), 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 checking result === undefined and concluding the predicate never matched. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,undefined];
const v=a.findLast(x=>x===undefined);
const i=a.findLastIndex(x=>x===undefined);
console.log(v,i);

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Transfer the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 attempts. Predict the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Contrast the rule using the most recent session above a page threshold is found. 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 checking result === undefined and concluding the predicate never matched.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for A found undefined value is ambiguous by result alone, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from A found undefined value is ambiguous by result alone?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking result === undefined and concluding the predicate never matched be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework attempts with the latest submitted attempt meeting a completion rule is selected. Include one ordinary case, one boundary and one deliberate failure caused by checking result === undefined and concluding the predicate never matched. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A found undefined value is ambiguous by result alone, separate the documented JavaScript Array.prototype.findLast() 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 call gets the current value, numeric index and the original array-like object. 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 reversing parameter order and treating the index as the value. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The predicate receives value, index and receiver, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The predicate receives value, index and receiver chapter on JavaScript Array.prototype.findLast(), 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 reversing parameter order and treating the index as the value. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=['A','B'];
a.findLast((value,index,array)=>{console.log(value,index,array===a); return false;});

Four purposeful transfer cases

Case 1: homework attempts. Transfer the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Predict the rule using the most recent session above a page threshold is found. 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: science readings. Contrast the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Stress-test the rule using the latest confirmed entry is selected without sorting the list. 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 reversing parameter order and treating the index as the value.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The predicate receives value, index and receiver, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from The predicate receives value, index and receiver?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reversing parameter order and treating the index as the value be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading log with the most recent session above a page threshold is found. Include one ordinary case, one boundary and one deliberate failure caused by reversing parameter order and treating the index as the value. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The predicate receives value, index and receiver, separate the documented JavaScript Array.prototype.findLast() 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 predicate result is converted to Boolean; it need not literally be true. 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 returning an object accidentally and expecting search to continue. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Truthiness decides a match, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Truthiness decides a match chapter on JavaScript Array.prototype.findLast(), 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 returning an object accidentally and expecting search to continue. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

console.log([1,2,3].findLast(x=>x===2 ? {ok:true} : 0));

Four purposeful transfer cases

Case 1: science readings. Predict the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Contrast the rule using the latest confirmed entry is selected without sorting the list. 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: family errands. Stress-test the rule using the last open stop in an ordered plan is located. 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 loans. Explain the rule using the most recent overdue record is searched by predicate. 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 returning an object accidentally and expecting search to continue.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Truthiness decides a match, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Truthiness decides a match?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing returning an object accidentally and expecting search to continue be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science readings with the last in-range measurement is distinguished from the last array element. Include one ordinary case, one boundary and one deliberate failure caused by returning an object accidentally and expecting search to continue. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Truthiness decides a match, separate the documented JavaScript Array.prototype.findLast() 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 optional second argument becomes this for a non-arrow predicate under normal call semantics. 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 thisArg to an arrow function and expecting its lexical this to change. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for thisArg controls ordinary-function this, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the thisArg controls ordinary-function this chapter on JavaScript Array.prototype.findLast(), 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 thisArg to an arrow function and expecting its lexical this to change. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const rule={min:5};
console.log([3,6,4].findLast(function(x){return x>=this.min},rule));

Four purposeful transfer cases

Case 1: family errands. Contrast the rule using the last open stop in an ordered plan is located. 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 loans. Stress-test the rule using the most recent overdue record is searched by predicate. 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: test laboratory. Explain the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Transfer the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 thisArg to an arrow function and expecting its lexical this to change.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for thisArg controls ordinary-function this, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from thisArg controls ordinary-function this?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing thisArg to an arrow function and expecting its lexical this to change be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA attendance with the latest confirmed entry is selected without sorting the list. Include one ordinary case, one boundary and one deliberate failure caused by passing thisArg to an arrow function and expecting its lexical this to change. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For thisArg controls ordinary-function this, separate the documented JavaScript Array.prototype.findLast() 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 arrow predicate does not receive a dynamic this binding from thisArg. 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 mixing arrow syntax with a design that depends on thisArg. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Arrow functions keep lexical this, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Arrow functions keep lexical this chapter on JavaScript Array.prototype.findLast(), 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 mixing arrow syntax with a design that depends on thisArg. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const rule={min:5};
const outer=this;
[3,6].findLast((x)=>{console.log(this===outer); return x>=5},rule);

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Explain the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 attempts. Transfer the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Predict the rule using the most recent session above a page threshold is found. 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 mixing arrow syntax with a design that depends on thisArg.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Arrow functions keep lexical this, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Arrow functions keep lexical this?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing mixing arrow syntax with a design that depends on thisArg be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family errands with the last open stop in an ordered plan is located. Include one ordinary case, one boundary and one deliberate failure caused by mixing arrow syntax with a design that depends on thisArg. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Arrow functions keep lexical this, separate the documented JavaScript Array.prototype.findLast() 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

findLast depends on a length and integer-indexed properties rather than on the receiver being a genuine Array. 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 converting every array-like object to an array before a simple read-only search. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for The method is generic over array-like objects, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the The method is generic over array-like objects chapter on JavaScript Array.prototype.findLast(), 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 converting every array-like object to an array before a simple read-only search. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const r=Array.prototype.findLast.call({0:'a',1:'bb',length:2},x=>x.length===1);
console.log(r);

Four purposeful transfer cases

Case 1: homework attempts. Explain the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Transfer the rule using the most recent session above a page threshold is found. 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: science readings. Predict the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Contrast the rule using the latest confirmed entry is selected without sorting the list. 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 converting every array-like object to an array before a simple read-only search.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for The method is generic over array-like objects, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from The method is generic over array-like objects?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing converting every array-like object to an array before a simple read-only search be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library loans with the most recent overdue record is searched by predicate. Include one ordinary case, one boundary and one deliberate failure caused by converting every array-like object to an array before a simple read-only search. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The method is generic over array-like objects, separate the documented JavaScript Array.prototype.findLast() 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 receiver length is converted once near the start, so later appends beyond that initial boundary are not added to the search. 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 pushing a new qualifying value inside the callback and expecting it to be visited. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Length is captured before iteration, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Length is captured before iteration chapter on JavaScript Array.prototype.findLast(), 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 pushing a new qualifying value inside the callback and expecting it to be visited. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,2];
const r=a.findLast((x,i)=>{if(i===1)a.push(99); return x===99});
console.log(r,a);

Four purposeful transfer cases

Case 1: science readings. Transfer the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Predict the rule using the latest confirmed entry is selected without sorting the list. 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: family errands. Contrast the rule using the last open stop in an ordered plan is located. 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 loans. Stress-test the rule using the most recent overdue record is searched by predicate. 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 pushing a new qualifying value inside the callback and expecting it to be visited.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Length is captured before iteration, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Length is captured before iteration?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing pushing a new qualifying value inside the callback and expecting it to be visited be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with holes, undefined, mutation, thisArg and array-like length expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by pushing a new qualifying value inside the callback and expecting it to be visited. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Length is captured before iteration, separate the documented JavaScript Array.prototype.findLast() 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 gets every integer position in range, so an empty slot reaches the predicate with value undefined. 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 findLast skips holes in the same way as some iterative array methods. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Sparse-array holes are visited as undefined, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Sparse-array holes are visited as undefined chapter on JavaScript Array.prototype.findLast(), 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 findLast skips holes in the same way as some iterative array methods. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=Array(3); a[0]='start';
const seen=[]; a.findLast((v,i)=>{seen.push([i,v]); return false});
console.log(seen);

Four purposeful transfer cases

Case 1: family errands. Predict the rule using the last open stop in an ordered plan is located. 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 loans. Contrast the rule using the most recent overdue record is searched by predicate. 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: test laboratory. Stress-test the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Explain the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 findLast skips holes in the same way as some iterative array methods.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Sparse-array holes are visited as undefined, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Sparse-array holes are visited as undefined?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming findLast skips holes in the same way as some iterative array methods be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with findLast is compared with find, findLastIndex, filter, at, reverse and loops. Include one ordinary case, one boundary and one deliberate failure caused by assuming findLast skips holes in the same way as some iterative array methods. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Sparse-array holes are visited as undefined, separate the documented JavaScript Array.prototype.findLast() 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

Because values are retrieved as their turn arrives, deleting a lower index before it is visited can make that call observe undefined. 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 every element value is snapshotted with the initial length. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Deleting an unvisited property changes its later value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Deleting an unvisited property changes its later value chapter on JavaScript Array.prototype.findLast(), 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 every element value is snapshotted with the initial length. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=['A','B','C'];
a.findLast((v,i)=>{if(i===2)delete a[0]; console.log(i,v); return false});

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Stress-test the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 attempts. Explain the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Transfer the rule using the most recent session above a page threshold is found. 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 every element value is snapshotted with the initial length.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Deleting an unvisited property changes its later value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Deleting an unvisited property changes its later value?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every element value is snapshotted with the initial length be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework attempts with the latest submitted attempt meeting a completion rule is selected. Include one ordinary case, one boundary and one deliberate failure caused by assuming every element value is snapshotted with the initial length. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Deleting an unvisited property changes its later value, separate the documented JavaScript Array.prototype.findLast() 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 callback mutation to a lower index may be observed when descending search reaches that index. 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 callback-side mutation as harmless because iteration order was predetermined. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Changing an unvisited value can affect the match, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Changing an unvisited value can affect the match chapter on JavaScript Array.prototype.findLast(), 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 callback-side mutation as harmless because iteration order was predetermined. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,2,3];
const r=a.findLast((v,i)=>{if(i===2)a[1]=20; return v===20});
console.log(r);

Four purposeful transfer cases

Case 1: homework attempts. Stress-test the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Explain the rule using the most recent session above a page threshold is found. 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: science readings. Transfer the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Predict the rule using the latest confirmed entry is selected without sorting the list. 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 callback-side mutation as harmless because iteration order was predetermined.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Changing an unvisited value can affect the match, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Changing an unvisited value can affect the match?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating callback-side mutation as harmless because iteration order was predetermined be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading log with the most recent session above a page threshold is found. Include one ordinary case, one boundary and one deliberate failure caused by treating callback-side mutation as harmless because iteration order was predetermined. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Changing an unvisited value can affect the match, separate the documented JavaScript Array.prototype.findLast() 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

Changing array length can delete elements below the original upper boundary, while the search still steps through the captured index range. 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 expecting a shorter length to end the algorithm immediately. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Shrinking length can remove later properties, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Shrinking length can remove later properties chapter on JavaScript Array.prototype.findLast(), 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 expecting a shorter length to end the algorithm immediately. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,2,3];
a.findLast((v,i)=>{if(i===2)a.length=1; console.log(i,v); return false});

Four purposeful transfer cases

Case 1: science readings. Explain the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Transfer the rule using the latest confirmed entry is selected without sorting the list. 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: family errands. Predict the rule using the last open stop in an ordered plan is located. 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 loans. Contrast the rule using the most recent overdue record is searched by predicate. 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 expecting a shorter length to end the algorithm immediately.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Shrinking length can remove later properties, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Shrinking length can remove later properties?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting a shorter length to end the algorithm immediately be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science readings with the last in-range measurement is distinguished from the last array element. Include one ordinary case, one boundary and one deliberate failure caused by expecting a shorter length to end the algorithm immediately. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Shrinking length can remove later properties, separate the documented JavaScript Array.prototype.findLast() 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

If the predicate throws, findLast propagates the exception and does not continue to earlier 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 expecting a failing candidate to be treated as a falsy predicate result. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for An exception stops the search, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the An exception stops the search chapter on JavaScript Array.prototype.findLast(), 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 expecting a failing candidate to be treated as a falsy predicate result. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

try{[1,2,3].findLast((x)=>{if(x===2)throw new Error('bad'); return false})}catch(e){console.log(e.message)}

Four purposeful transfer cases

Case 1: family errands. Transfer the rule using the last open stop in an ordered plan is located. 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 loans. Predict the rule using the most recent overdue record is searched by predicate. 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: test laboratory. Contrast the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Stress-test the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 expecting a failing candidate to be treated as a falsy predicate result.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for An exception stops the search, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from An exception stops the search?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting a failing candidate to be treated as a falsy predicate result be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA attendance with the latest confirmed entry is selected without sorting the list. Include one ordinary case, one boundary and one deliberate failure caused by expecting a failing candidate to be treated as a falsy predicate result. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For An exception stops the search, separate the documented JavaScript Array.prototype.findLast() 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

find searches low-to-high, while findLast searches high-to-low; either may stop before visiting the other side. 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 sorting or reversing data when only the intended direction differs. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for findLast differs from find, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the findLast differs from find chapter on JavaScript Array.prototype.findLast(), 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 sorting or reversing data when only the intended direction differs. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[4,7,9,12];
console.log(a.find(x=>x>5),a.findLast(x=>x>5));

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Contrast the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 attempts. Stress-test the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Explain the rule using the most recent session above a page threshold is found. 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 sorting or reversing data when only the intended direction differs.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for findLast differs from find, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from findLast differs from find?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing sorting or reversing data when only the intended direction differs be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family errands with the last open stop in an ordered plan is located. Include one ordinary case, one boundary and one deliberate failure caused by sorting or reversing data when only the intended direction differs. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For findLast differs from find, separate the documented JavaScript Array.prototype.findLast() 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 related method applies the same directional predicate search but returns the index or minus one. 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 indexOf on an object result when the predicate, not identity, defines the match. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for findLastIndex serves position-based work, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the findLastIndex serves position-based work chapter on JavaScript Array.prototype.findLast(), 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 indexOf on an object result when the predicate, not identity, defines the match. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[{ok:true},{ok:false},{ok:true}];
console.log(a.findLastIndex(x=>x.ok));

Four purposeful transfer cases

Case 1: homework attempts. Contrast the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Stress-test the rule using the most recent session above a page threshold is found. 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: science readings. Explain the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Transfer the rule using the latest confirmed entry is selected without sorting the list. 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 indexOf on an object result when the predicate, not identity, defines the match.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for findLastIndex serves position-based work, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from findLastIndex serves position-based work?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling indexOf on an object result when the predicate, not identity, defines the match be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library loans with the most recent overdue record is searched by predicate. Include one ordinary case, one boundary and one deliberate failure caused by calling indexOf on an object result when the predicate, not identity, defines the match. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For findLastIndex serves position-based work, separate the documented JavaScript Array.prototype.findLast() 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

filter evaluates the range to collect all passing values; findLast stops after the last qualifying value is known. 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 building a whole result array and taking its last item for a one-value job. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for filter answers a different cardinality question, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the filter answers a different cardinality question chapter on JavaScript Array.prototype.findLast(), 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 building a whole result array and taking its last item for a one-value job. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,6,3,8];
console.log(a.findLast(x=>x>5));

Four purposeful transfer cases

Case 1: science readings. Stress-test the rule using the last in-range measurement is distinguished from the last array element. 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: CCA attendance. Explain the rule using the latest confirmed entry is selected without sorting the list. 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: family errands. Transfer the rule using the last open stop in an ordered plan is located. 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 loans. Predict the rule using the most recent overdue record is searched by predicate. 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 building a whole result array and taking its last item for a one-value job.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for filter answers a different cardinality question, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from filter answers a different cardinality question?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing building a whole result array and taking its last item for a one-value job be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with holes, undefined, mutation, thisArg and array-like length expose boundaries. Include one ordinary case, one boundary and one deliberate failure caused by building a whole result array and taking its last item for a one-value job. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For filter answers a different cardinality question, separate the documented JavaScript Array.prototype.findLast() 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

Array.prototype.reverse changes order in place, while findLast performs a directional read without rearranging the receiver. 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 reverse().find(…) on data whose order other code still relies on. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for reverse can mutate the source, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the reverse can mutate the source chapter on JavaScript Array.prototype.findLast(), 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 reverse().find(…) on data whose order other code still relies on. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const a=[1,2,3]; const r=a.findLast(x=>x<3); console.log(r,a);

Four purposeful transfer cases

Case 1: family errands. Explain the rule using the last open stop in an ordered plan is located. 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 loans. Transfer the rule using the most recent overdue record is searched by predicate. 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: test laboratory. Predict the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Contrast the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 reverse().find(…) on data whose order other code still relies on.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for reverse can mutate the source, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from reverse can mutate the source?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using reverse().find(…) on data whose order other code still relies on be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with findLast is compared with find, findLastIndex, filter, at, reverse and loops. Include one ordinary case, one boundary and one deliberate failure caused by using reverse().find(…) on data whose order other code still relies on. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For reverse can mutate the source, separate the documented JavaScript Array.prototype.findLast() 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

Use findLast when established order already has meaning and one final predicate match is required; choose at for a fixed last element, findLastIndex for position, filter for all matches, or a loop for richer control. 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 findLast merely because the desired answer happens to be near the end in one sample. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the contract for Choose findLast for the last qualifying value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.

For the Choose findLast for the last qualifying value chapter on JavaScript Array.prototype.findLast(), 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 findLast merely because the desired answer happens to be near the end in one sample. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const latestComplete=attempts.findLast(a=>a.submitted&&a.score!==null);

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using holes, undefined, mutation, thisArg and array-like length expose boundaries. 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: design decision. Predict the rule using findLast is compared with find, findLastIndex, filter, at, reverse and loops. 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 attempts. Contrast the rule using the latest submitted attempt meeting a completion rule is selected. 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: reading log. Stress-test the rule using the most recent session above a page threshold is found. 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 findLast merely because the desired answer happens to be near the end in one sample.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the contract for Choose findLast for the last qualifying value, predict one ordinary case and one boundary, run the smallest disposable test, then explain the earliest difference between prediction and evidence.” 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 Array.prototype.findLast() syntax. For this chapter, useful prompts are: “What did you expect from Choose findLast for the last qualifying value?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using findLast merely because the desired answer happens to be near the end in one sample be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework attempts with the latest submitted attempt meeting a completion rule is selected. Include one ordinary case, one boundary and one deliberate failure caused by using findLast merely because the desired answer happens to be near the end in one sample. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Choose findLast for the last qualifying value, separate the documented JavaScript Array.prototype.findLast() 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 attempts: model, boundary and recovery

Create a small homework attempts using the latest submitted attempt meeting a completion rule is selected. Combine “Search runs from the highest index downward” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. reading log: model, boundary and recovery

Create a small reading log using the most recent session above a page threshold is found. Combine “A found undefined value is ambiguous by result alone” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. science readings: model, boundary and recovery

Create a small science readings using the last in-range measurement is distinguished from the last array element. Combine “thisArg controls ordinary-function this” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. CCA attendance: model, boundary and recovery

Create a small CCA attendance using the latest confirmed entry is selected without sorting the list. Combine “Length is captured before iteration” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. family errands: model, boundary and recovery

Create a small family errands using the last open stop in an ordered plan is located. Combine “Changing an unvisited value can affect the match” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. library loans: model, boundary and recovery

Create a small library loans using the most recent overdue record is searched by predicate. Combine “findLast differs from find” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. test laboratory: model, boundary and recovery

Create a small test laboratory using holes, undefined, mutation, thisArg and array-like length expose boundaries. Combine “reverse can mutate the source” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. design decision: model, boundary and recovery

Create a small design decision using findLast is compared with find, findLastIndex, filter, at, reverse and loops. Combine “The returned result is a value” 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 Array.prototype.findLast()
• eduKatePunggol: How Studying Works

Return to contents