Are you confused by some of JavaScript’s tricky behaviors? The best way to understand them is to think like JavaScript runs your code.
When you read code snippets and try to run them in your mind step by step, you build two things at once: a deeper understanding of JavaScript and a stronger ability to spot patterns. This is what helps you grow from a normal developer into a confident one.
Below are 10 interactive quiz questions. Each one focuses on a concept that often confuses developers and are most asked interviews questions. Try to answer first before looking at the hint, and don’t skip the explanation. If you really want to understand the concept, you need to know why the answer is what it is.
We have covered topics like reference vs value, shallow copy, closures, IIFE, async promises, hoisting, prototype chain, and type coercion.
Ready? Let’s begin.
10 Conceptual JavaScript Quizzes for interview prep
How does JavaScript handle array references when multiple variables point to the same array?
1const colors = ['red', 'blue', 'green']
2
3const favColors = colors
4
5favColors[1] = 'purple'
6
7console.log(colors === favColors)
8console.log(colors)What happens when you use the spread operator on an object that contains nested objects?
1const user = {
2 name: 'Ahmed',
3 email: 'ahmed@email.com',
4 designation: 'Frontend Developer',
5 address: { city: 'Karachi' },
6}
7
8const newUser = { ...user, designation: 'Fullstack Engineer' }
9
10newUser.address.city = 'Lahore'
11
12console.log(user.address.city)
13console.log(newUser)How does the continue statement affect a loop's execution flow?
1let num = 0
2
3for (let i = 1; i <= 5; i++) {
4 if (i % 2 === 0) continue
5 num += i
6}
7
8console.log(num)How does JavaScript determine the length of sparse arrays?
1const arr = [1, , 3, , 5]
2
3arr[10] = 10
4
5console.log(arr.length)How can arrow functions access values from their surrounding scope?
1const welcome = {
2name: 'Ali',
3greet: function () {
4 const that = this
5 return () => {
6 console.log('Hello, ' + that.name)
7 }
8},
9}
10
11const greetFunction = welcome.greet()
12greetFunction()How does method overriding work in JavaScript class inheritance?
1class Animal {
2constructor(name) {
3 this.name = name
4}
5
6speak() {
7 return this.name + ' makes a noise.'
8}
9}
10
11class Pet extends Animal {
12constructor(name, ownerName) {
13 super(name)
14 this.ownerName = ownerName
15}
16
17getOwner() {
18 return this.name + ' belongs to ' + this.ownerName + '.'
19}
20}
21
22class Dog extends Pet {
23speak() {
24 return this.name + ' barks.'
25}
26}
27
28const dog = new Dog('Rex', 'Alice')
29
30console.log(dog.speak())
31console.log(dog.getOwner())How do closures preserve and share private state across function calls?
1const Counter = (function () {
2let count = 0
3
4return {
5 increment: function () {
6 count++
7 return count
8 },
9
10 decrement: function () {
11 count--
12 return count
13 },
14
15 getCount: function () {
16 return count
17 },
18}
19})()
20
21console.log(Counter.increment())
22console.log(Counter.increment())
23console.log(Counter.getCount())What happens when a Promise is resolved and then rejected immediately afterward?
1let promise = new Promise((resolve, reject) => {
2 resolve('Resolved')
3 reject('Rejected')
4})
5
6promise
7.then((result) => {
8 console.log(result)
9})
10.catch((error) => {
11 console.log(error)
12})How does the logical NOT (!) operator behave when applied to truthy values?
1console.log(!"Codevertiser")What is the difference between loose equality (==) and strict equality (===) when comparing primitives and objects?
1let a = "Flexy UI"
2let b = new String("Flexy UI")
3
4console.log(a == b)
5console.log(a === b)How Did You Score?
Work through your wrong answers — each one points to a specific gap worth closing. The concepts tested here show up constantly in real code and job interviews.
Concepts covered in this quiz:
- Q1 — Reference types vs value types
- Q2 — Shallow copy with spread operator
- Q3 —
continuestatement in loops - Q4 — Sparse arrays and length calculation
- Q5 —
thisbinding and arrow function lexical scope - Q6 — Prototype chain inheritance
- Q7 — IIFE and closure
- Q8 — Promise single-settlement
- Q9 — Truthy/falsy and logical NOT
- Q10 — Loose vs strict equality with type coercion
Next Steps
If closures (Q5, Q7) or the event loop (Q8) tripped you up, those are the highest-leverage topics to study next. Understanding them deeply separates junior developers from mid-level developers.
If type coercion (Q10) or reference semantics (Q1, Q2) caught you out, spend time with JavaScript's type system, it will save you hours of debugging.
Keep running code mentally before executing it. That habit alone will make you a significantly better JavaScript developer.
Written by
Abdul Basit
Frontend developer passionate about JavaScript, React, and building great web experiences. Writing about web development to help developers level up their skills.
Continue reading
