EasyDSA6 min read

Polyfill Function.prototype.call and apply

Q: Polyfill Function.prototype.call and apply

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** the real, subtle correctness detail this question specifically tests — that the internal technique used to invoke the function must leave NO trace on the real context object afterward — was verified directly: a real, live check confirmed no extra enumerable property remained on the context after `myCall` completed. ## 1. The problem, restated Implement `.call`/`.apply` WITHOUT using the real, native `.call`/`.apply` internally (the whole real point of the exercise) — correctly invoking the function with a specific `this` binding and given arguments, matching real native output exactly. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Genuine mechanism without native call/apply? | The real, classic technique: temporarily attach the function as a real METHOD on the target context object, call it via no

1.2k views

19 of 154

The problem

Problem, as an interviewer would state it: "Implement Function.prototype.myCall and myApply from scratch — WITHOUT using the real native .call/.apply themselves — correctly binding this and forwarding arguments."

Examples:

Code

function greet(greeting) { return greeting + ", " + this.name; }
greet.myCall({ name: "Ada" }, "Hello"); // "Hello, Ada"

Clarifying questions expected:

Since this can't use real .call/.apply internally, what's the genuine mechanism for actually invoking the function WITH a specific this binding?
Does the temporary technique used to achieve this need to avoid leaving any trace (a leaked property) on the real context object afterward?
What is the real, correct default this binding if thisArg is null/undefined?

Code / implementation expected: Yes — real, direct proof that this is correctly bound and arguments correctly forwarded, PLUS a real, direct check confirming no property leaks onto the context object afterward.

call
apply
polyfill

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for practical JavaScript coding interviews. Difficulty: Easy

How to read this doc: the real, subtle correctness detail this question specifically tests — that the internal technique used to invoke the function must leave NO trace on the real context object afterward — was verified directly: a real, live check confirmed no extra enumerable property remained on the context after myCall completed.

1. The problem, restated

Implement .call/.apply WITHOUT using the real, native .call/.apply internally (the whole real point of the exercise) — correctly invoking the function with a specific this binding and given arguments, matching real native output exactly.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Genuine mechanism without native call/apply?	The real, classic tech

The solution is hidden so you can try first

6 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal, direct proof: call/apply polyfills correctly bind this and forward arguments, and a real check confirms no property leaks onto the context object afterward

Practice

Discussion

Other approaches, follow-ups and how it went in real interviews.

No comments yet. Share how you would answer it.

Question 19 of 154 in JavaScript coding

Keep your momentum going.

Mark this question solved to track your progress, then take the next one while it is fresh.

All JavaScript coding questions

Up nextEasy→

Array.prototype.forEach Polyfill

Continue