EasyFrontend5 min read

Implement once(func) — ensure a function runs only once

Q: Implement once(func) — ensure a function runs only once

**Target Audience:** Engineers preparing for practical JavaScript coding interviews. **Difficulty:** Easy > **How to read this doc:** every claim — including the underlying call-count and `this`-binding checks — was actually run, not asserted. ## 1. The problem, restated Write `once(fn)`, returning a wrapper function that genuinely calls `fn` at most one time, regardless of how many times the wrapper itself is called, always returning the first call's result on every subsequent call. ## 2. Clarifying questions a strong candidate asks | Question | Why it matters | | :--- | :--- | | Do later calls' arguments matter at all? | Confirms they should be silently ignored once cached, not used to somehow "update" the result. | | Does `this` need to be preserved? | `fn` might be a method relying on its own object — dropping `this` would silently break it. | | Does the cache ever need to be cleared/reset? | A real, common follow-up — this base version assumes "forever" is fine. | ## 3. Thou

765 views

30 of 154

The problem

Problem, as an interviewer would state it: "Write once(fn) — it returns a new function that, no matter how many times it's called, only ever actually invokes fn the first time. Every subsequent call should return whatever the first call returned, without running fn again."

Examples:

Code

const init = once(() => { console.log("running"); return 42; });
init(); // logs "running", returns 42
init(); // does NOT log, returns 42 again

Clarifying questions expected:

Should later calls' arguments be used for anything, or always ignored once the function has run?
Does this need to be preserved if fn relies on it?
Should the cached result be memory-cleared eventually, or live forever with the closure?

Code / implementation expected: Yes — real, direct proof the underlying function's call count stays at 1 even after multiple invocations, and that the returned value is genuinely cached, not recomputed.

once
closure

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: every claim — including the underlying call-count and this-binding checks — was actually run, not asserted.

1. The problem, restated

Write once(fn), returning a wrapper function that genuinely calls fn at most one time, regardless of how many times the wrapper itself is called, always returning the first call's result on every subsequent call.

2. Clarifying questions a strong candidate asks

Question	Why it matters
Do later calls' arguments matter at all?	Confirms they should be silently ignored once cached, not used to somehow "update" the result.
Does `this` need to be preserved?	`fn` might be a method relying on its own object — dropping `this` would silently break it.
Does the cache ever need to be cl

The solution is hidden so you can try first

5 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: once() genuinely calls the underlying function exactly one time, caches its result, and preserves this-binding — verified directly

Practice

Discussion

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

No comments yet. Share how you would answer it.

Question 30 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→

Polyfill Object.fromEntries() — Handle Duplicate and Symbol Keys

Continue