JavaScript Interview Questions (Flashcards)

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is variable declarations.
• The interviewer asks it because this is one of the most searched JavaScript interview questions.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, var is function-scoped and can be redeclared, let is block-scoped and can be reassigned, and const is block-scoped but cannot be reassigned.
• If you want to sound stronger, add a compact example such as: for (let i = 0; i < 3; i++) {}.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is saying const makes an object immutable.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is equality comparison.
• The interviewer asks it because it reveals whether you understand coercion.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, == compares after type coercion, while === compares both value and type without coercion.
• If you want to sound stronger, add a compact example such as: 0 == false is true, but 0 === false is false.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is using only a definition and no example.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is declaration behavior.
• The interviewer asks it because interviewers use it to test core language mechanics.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, JavaScript processes declarations before execution, so function declarations are fully hoisted, var declarations are hoisted as undefined, and let/const exist in the temporal dead zone until initialized.
• If you want to sound stronger, add a compact example such as: console.log(a); var a = 5;.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is saying variables are physically moved in code.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is scope retention.
• The interviewer asks it because closures are fundamental for callbacks, privacy, and functional patterns.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, a closure happens when an inner function remembers variables from its outer scope even after the outer function has returned.
• If you want to sound stronger, add a compact example such as: function makeCounter(){ let c=0; return ()=>++c; }.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is describing closures as only an interview trick instead of a real runtime behavior.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is async runtime model.
• The interviewer asks it because this separates surface-level knowledge from deeper understanding.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, the event loop coordinates the call stack, Web APIs, and callback queues so asynchronous tasks can run without blocking the main thread.
• If you want to sound stronger, add a compact example such as: Promise callbacks run in the microtask queue before setTimeout callbacks in the macrotask queue.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is saying JavaScript itself is multithreaded in the browser context.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is async abstraction.
• The interviewer asks it because promises are central to modern JavaScript code.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, a Promise represents an asynchronous result that is pending, fulfilled, or rejected, and lets you chain work with then, catch, and finally.
• If you want to sound stronger, add a compact example such as: fetch('/api').then(r => r.json()).catch(handleError).
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is treating promises as the same thing as callbacks.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is async syntax.
• The interviewer asks it because most real interviews ask this after Promise questions.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, async/await is syntax built on top of Promises that makes asynchronous code read more like synchronous code.
• If you want to sound stronger, add a compact example such as: async function load(){ try { const r = await fetch('/api'); } catch(e) {} }.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is thinking await blocks the entire application.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is context binding.
• The interviewer asks it because this causes many bugs and is frequently asked.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, the value of this depends on how a function is called: as a method, constructor, plain function, or arrow function, which lexically captures this.
• If you want to sound stronger, add a compact example such as: obj.say(); const f = obj.say; f();.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is claiming this always refers to the function owner.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is object delegation.
• The interviewer asks it because it is foundational to the language design.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, objects in JavaScript can inherit properties from another object through the prototype chain, and classes are syntax over this mechanism.
• If you want to sound stronger, add a compact example such as: Object.create(parent).
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is explaining only ES6 class syntax and not the underlying prototype model.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.

Core idea

• This is one of the most common JavaScript interview questions because it tests whether you understand the concept, can explain it clearly, and know why it matters in real work.
• The core idea is absence of value.
• The interviewer asks it because this is a frequent beginner-to-mid level question.
• A strong answer should begin with a plain-language definition, then move quickly into practical impact.
• For example, undefined usually means a value was not assigned, while null is an intentional assignment that means 'no value'.
• If you want to sound stronger, add a compact example such as: let x; // undefined, let y = null;.
• You do not need to recite code perfectly, but you should be able to explain what it does and when you would choose that approach in production.
• The best answers also mention trade-offs.
• In SQL and SQL Server, that often means performance versus correctness, readability versus control, or concurrency versus consistency.
• In JavaScript and Selenium, it often means convenience versus runtime behavior, stability, or maintainability.
• This is where stronger candidates stand out: they do not stop at the definition.
• They explain consequences, common failure modes, and one good rule of thumb.
• For example, they may mention how the concept affects query speed, locking, browser flakiness, debugging, or unexpected runtime results.
• A common mistake is saying they are interchangeable in all contexts.
• Another weak answer is a textbook explanation with no scenario, because interviewers then cannot tell whether the knowledge is usable.
• A better pattern is: define it, compare it to the closest related concept, show a realistic example, mention one trade-off, and finish with a practical takeaway.
• That style works well both in interviews and for search visibility because readers usually want an answer that is accurate, memorable, and immediately applicable.