JavaScript rarely stops you. It turns a string into a number without being asked, lets you read a variable before the line that assigns it, and runs a callback long after the code around it has finished. That forgiveness is why a JavaScript program can work for the wrong reason and break on the next small change. The JavaScript (Basic) test checks that you know the reasons: most questions put a few lines of JavaScript in front of you and ask exactly what they print.
It suits anyone who has used the language for a few months — a course, scripts for a small website, practice problems — and wants a credential that shows they understand what their code does, not only that it runs. The multiple-choice section comes first; a few of its questions ask you to select every correct option, and only the exact set scores. A coding section follows, with a problem to solve in JavaScript against hidden test cases. Nothing on the test touches the browser: there is no DOM, no fetch and no framework, only the language and its built-in objects.
The topics, in plain terms
Each area below is a topic on your result, so a weak one shows up by name. The JavaScript study plan teaches all of them, with exercises that run on a judge.
- Types and coercion. Which operators convert their operands and to what, how loose and strict equality differ, which values count as false in a condition, and what
typeofreports. You should be able to explain, for example, whytrue + trueis2. - Scope and hoisting. How
var,letandconstdiffer in scope, what is hoisted and in what state, and what a name refers to when an inner scope declares the same name. - Functions and closures. Default and rest parameters, functions passed around as values, how arrow functions differ from
function, and closures: a function that keeps using variables from the scope it was created in after that scope has finished. thisand binding. How the way a function is called decides whatthisis, and why an arrow function behaves differently. Basic stays with methods on plain objects; binding in depth is Intermediate material.- Objects and prototypes. Object literals, dot and bracket access, adding and deleting properties, listing keys, the difference between two references to one object and two objects that merely look alike, and how a property is found on an object's prototype.
- Arrays. The everyday methods, from
pushandslicetomap,filter,reduceandsort: what each one returns, and whether it changes the array it was called on. - Strings and numbers. String methods and indexes, converting text to numbers, why decimal arithmetic is not exact in binary floating point, and rounding and formatting a number for display.
- Modern syntax. Template literals, destructuring with defaults, spread and rest, and shorthand and computed property names.
- Errors. How control moves through
try,catchandfinally, what an error object carries, and which built-in error type a given mistake raises. - Promises and async. Scheduling with
setTimeout, promise chains withthenandcatch, and what anasyncfunction gives back. You need the order in which synchronous code, promise callbacks and timers run, not the event loop in full.
Practising the way the test reads code
Predict, then run. Take a short snippet — from the study plan, from your own code, from a problem you have solved — write down exactly what it will print, and only then run it in Node.js or a browser console. When you were wrong, find the rule that explains the difference before moving on; a rule you looked up after a wrong guess is easier to remember than one you only read about. Do this little and often. It is the same habit the test rewards: reading each line for what it does.
In the JavaScript study plan, the modules that line up with this test are Values, types and coercion; Functions, scope and closures; Objects, arrays and destructuring; Errors and error handling; and the first lessons of Asynchronous JavaScript. Every lesson has a quiz and exercises checked on a judge, so you can see where you stand topic by topic before you sit the test.
For the coding section, solve easy problems in JavaScript from Arrays, Strings and Hash table; the roadmap lessons on arrays and hashing explain the techniques those problems lean on. In the sitting, the editor gives you a function to complete. Return the answer rather than printing it — the judge calls the function for each test case and compares what comes back. Run checks the visible cases, Submit runs every hidden case, and each case passed earns its share of the marks, so a solution that misses one edge case still scores most of them. Pasting into the editor is switched off during a sitting, so practise writing solutions from an empty function rather than adapting code you have copied.
Habits that cost marks
Most lost marks come from a few reading habits rather than from gaps in knowledge.
- Answering from intent. One option is often what the author of the code probably wanted, and another is what the code actually does. Trace the code, line by line, and trust the trace.
- Losing track of what changed. When two names refer to the same object, or a method changes its array in place, every later line sees the change. As you read, keep a note of which values are shared.
- Assuming code runs where it is written. A callback handed to
setTimeout,thenor an array method runs when it is called, not when the line that mentions it is read. - Skimming the multi-answer questions. "Select all that apply" questions score only when the whole set is right. Decide each option on its own, true or false, before you look at the set you have chosen.
- Leaving blanks. There is no negative marking, so an answer you are unsure of costs nothing. Mark your best option and move on rather than spending minutes on one question.
What the Intermediate test adds
The JavaScript (Intermediate) test assumes everything here and goes further: call, apply and bind, and this inside classes; prototype chains and class syntax in full; the event loop as a topic of its own, with microtasks and Node.js's process.nextTick; Promise.all and the other combinators; iterators, generators and Map; and coding problems that reach medium difficulty. If the questions here felt comfortable, that is the next step.