JavaScript coding test practice

What the real test usually looks like

There is no single JavaScript coding test. Each employer chooses a testing platform and then sets its own questions, number of tasks, time limit and allowed languages. Your test invitation is the best guide to yours. Public examples show the range:

• HackerRank. HackerRank lists its JavaScript (Basic) skills test as 2 questions in 1 hour 30 minutes, covering topics like functions (HackerRank). Its help center lists the question types an employer can put in a test, including coding, multiple choice, HTML/CSS/JavaScript, front-end developer, code review and subjective questions, and says employers can add questions from HackerRank's library or write their own (HackerRank Help).
• TestGorilla. TestGorilla's JavaScript coding tests page says individual tests range from 15 to 45 minutes, lists an entry-level algorithms test at 15 minutes, says candidates work in an online editor, and says employers choose which languages are available (TestGorilla).

Parts commonly reported in employer JavaScript tests:

• Coding tasks: write a function in an online editor, run it against sample inputs, then submit it to be checked against more test cases you may not see.
• Multiple choice: JavaScript concepts, what a snippet logs, and which code is correct.
• Debugging or code review: find and fix the problem in code someone else wrote.
• Sometimes more: building or fixing a web page, a larger front-end or back-end project, a take-home assignment, or webcam and screen monitoring during the test.

What our mocks cover. Our full mocks have 20 questions in 60 minutes in four sections: JavaScript concepts (6), what the code logs (6), finding the bug (5) and building a solution (3). All code is modern JavaScript as it runs on Node.js, with no browser or framework code. You can go back, change an answer and flag questions until you submit. Our mocks practice reading, tracing, debugging and choosing code. They do not run code you write. Many real assessments do ask you to write code that runs against hidden test cases; this practice builds the reading, tracing and debugging skills behind that, so add some timed practice in a real editor as well. Our mocks also leave out front-end, back-end and full-stack project tasks, proctoring, plagiarism checks, video interviews, take-home tasks and any employer pass mark.

Question types with worked examples

One worked example for each section, with the trap most people fall into.

1. JavaScript concepts. What is the difference between let and var? let is scoped to the nearest block, such as a loop body, and cannot be used before its line runs. var is scoped to the whole function and is hoisted, so it exists as undefined before its line. Trap: assuming const makes an object or array unchangeable. It only stops the name from being reassigned.

2. What the code logs. console.log(typeof null, typeof []) logs object object. Both are objects as far as typeof is concerned; use Array.isArray to check for an array. For async code, remember the order: ordinary code first, then promise callbacks, then timers. Trap: reading setTimeout(fn, 0) as "run now". It always waits until the current code and pending promise callbacks are done.

3. Finding the bug. A function returns undefined instead of a total. Look for an arrow function with braces but no return: (a, b) => { a + b } returns undefined, while (a, b) => a + b returns the sum. Trap: fixing the first line that looks unusual. Trace a tiny input through the code and find the first line where the value goes wrong.

4. Building a solution. You need the total price of a cart. items.reduce((sum, item) => sum + item.price, 0) does it. Without the 0 at the end, an empty cart throws a TypeError. Trap: picking the option that works for the example but not the edges. Check every choice against an empty array, one item, repeats and missing values.

How to prepare

1. Read your invitation first. Find out which platform you will use, how many tasks there are, the time limit, whether you can choose JavaScript, whether front-end tasks are included, and whether the test is monitored. Formats vary too much to assume.
2. Try the platform's practice area if it has one. Get used to the editor, the Run button and how sample test cases are shown, so the screen is not new on the day. HackerRank, for example, describes candidates clicking Run to run the test cases while they work (HackerRank Support).
3. Trace code by hand. For short snippets, write each variable's value after every line. For async code, keep three lists: what runs now, promise callbacks and timers.
4. Know the everyday tools. Arrays and their methods (map, filter, reduce, some, find, sort), objects, Map and Set, strings, destructuring, spread, template literals, async and await.
5. Think about edge cases before you submit. Empty arrays and strings, one item, repeated values, null and undefined, numbers given as strings. Hidden test cases often check exactly these.
6. Write some code against the clock. Our mocks train reading and debugging. Also solve a few small problems in a real editor with a timer, so writing and running code under pressure feels normal.
7. Practice at the real pace. If your test is like HackerRank's JavaScript (Basic) example, 2 questions in 1 hour 30 minutes gives about 45 minutes a problem (HackerRank). Take full timed mocks so pacing yourself feels normal.

How scoring usually works

Scoring depends on the platform and the employer. There is no universal scale and no universal pass mark. Coding questions are usually scored automatically against test cases. Two public descriptions:

• HackerRank says coding questions are evaluated with predefined test cases that measure correctness and efficiency. Each test case has its own score: code that passes a test case receives that test case's full score, and code that fails it receives zero. The question's total is the sum of the test cases passed, so a solution that passes some test cases earns part of the points (HackerRank Support). Coding and multiple choice questions are evaluated automatically, while HTML/CSS/JavaScript questions are evaluated by hand and front-end questions are evaluated automatically with a manual review recommended (HackerRank Help).
• TestGorilla describes percentile-based scoring based on overall correctness and a report showing each test case's result (TestGorilla).

What counts as a good result is up to each employer, and many look at your code as well as the score.

Our practice score is the number of our own questions you answered correctly, with a breakdown by section, so you can see where to focus. It is a practice score: it is not a score on any platform's test and does not predict whether you will pass.

Common mistakes

• Sorting numbers without a compare function. [10, 9, 1].sort() sorts as text. Use sort((a, b) => a - b).
• Using == and getting surprised by type conversion. Prefer === unless you have a reason not to.
• Forgetting that forEach does not wait. await inside a forEach callback does not pause the outer function. Use for...of or Promise.all.
• Comparing objects or arrays with ===. Two objects are equal only if they are the same object. Compare the fields you care about.
• Changing an array you meant to keep. sort, reverse and splice change the array in place. Copy it first with [...arr] when you need the original.
• Only testing the example. The visible example usually passes. Hidden test cases check empty input, single items, duplicates and large inputs.
• Running out of time on one task. If you are stuck, submit a simple version that passes some test cases, move on, and come back if time allows.