---

Q: What's the difference between var, let, and const?
A: var is function-scoped, while let and const are block-scoped ({}), which helps avoid issues in loops or conditionals. let allows reassignment, const does not. Also, var is hoisted – it's moved to the top of the scope but not initialized.

if (true) {
  var a = 1;
  let b = 2;
}
console.log(a); // 1
console.log(b); // ReferenceError

---

Q: What's the difference between == and ===?
A: == is loose equality and allows type coercion. === is strict equality and requires both value and type to be the same. Using === helps avoid unexpected bugs caused by type coercion.

0 == false // true  
0 === false // false

---

Q: What's the difference between null and undefined?
A: undefined is the default value of uninitialized variables. null is intentionally assigned to indicate "nothing." Both are falsy but have different meanings.

---

Q: What data types are there in JavaScript?
A: JavaScript has two main types: primitive and object. Primitive types include: string, number, boolean, null, undefined, symbol, bigint. Everything else (arrays, functions, dates, etc.) is of type object.

---

Q: What's typeof null? Why?
A: typeof null returns "object" due to a historical bug in JavaScript's design. Although null is a primitive, it returns "object".

---

Q: How do you check if a variable is an array?
A: Use Array.isArray(value) for accurate checking. Avoid using typeof because typeof [] returns "object".

Array.isArray([1, 2, 3]) // true  
Array.isArray("abc")     // false

---

Q: How do you convert a string to a number?
A: Several ways: Number(str), parseInt(str), parseFloat(str), or simply +str. However, always validate input to avoid returning NaN.

+"42"           // 42  
parseInt("42px") // 42  
Number("42px")   // NaN

---

Q: What is NaN and how do you check it?
A: NaN stands for "Not a Number", returned from invalid math operations. Use Number.isNaN(value) for accurate checking. Don't use == because NaN !== NaN.

---

Q: What is a function in JavaScript?
A: A reusable block of code. You can define functions via function, function expression, or arrow function. Arrow functions don’t have their own this, which is useful in simple contexts.

---

Q: What's the difference between null, {}, and []?
A: null means intentional emptiness. {} is an empty object. [] is an empty array. They serve different purposes depending on the data type.

---

Q: Why does [] + [] result in an empty string?
A: Because the + operator coerces arrays into strings. So [] + [] becomes "" + "" = "".

---

Q: What are template strings?
A: A cleaner way to write strings with embedded variables using ${}. Use backticks ` instead of quotes.

const name = "Vũ";
console.log(`Hello ${name}`); // Hello Vũ

---

Q: What are falsy values?
A: Values that convert to false in a boolean context. These include: false, 0, "", null, undefined, NaN.

---

Q: How many ways to declare a variable?
A: Three: var (old, rarely used), let (modern), const (immutable reference, preferred for constants).

---

Q: Why use const more than let?
A: const makes code safer by preventing accidental reassignment. However, it only ensures the reference is constant; the contents (like arrays/objects) can still change.

---

Q: How to loop through an array?
A: Many ways: for, for...of, forEach, map, filter, reduce. Use each depending on need – forEach for actions, map for transforming, filter for filtering, etc.

---

Q: Can typeof check all data types?
A: Not entirely. For example, typeof null is "object" and typeof [] is also "object". For accurate checks, use Object.prototype.toString.call(value).

---

Q: How to copy arrays or objects?
A: For arrays: use [...] or array.slice(). For objects: use {...obj} or Object.assign(). Avoid direct assignment as it creates references.

const original = [1, 2];
const copy = [...original];

---

Q: Is JavaScript synchronous or asynchronous?
A: JavaScript is single-threaded but supports asynchronous behavior via the event loop, callbacks, Promises, and async/await. This prevents the UI from freezing during long operations.

Here are a few additional Fresher-level questions and answers – still simple, easy to understand, and with examples where needed.

---

Q: What's the difference between function declaration and function expression?
A: function declaration is hoisted – you can call the function before it’s declared. function expression (assigned to a variable) is not hoisted, so it must be defined before use.

sayHello(); // OK

function sayHello() {
  console.log("Hi!");
}

// -

greet(); // Error: greet is not a function

const greet = function () {
  console.log("Hello!");
};

---

Q: What does console.log(typeof NaN) output?
A: "number". Even though NaN means “Not a Number”, its type is still number. This is one of JavaScript’s quirks.

---

Q: What does parseInt("08") return?
A: 8. However, in older environments, if you don’t pass a radix, "08" may be interpreted as octal and return 0. So always pass the radix: parseInt("08", 10).

---

Q: What does typeof return for functions?
A: "function". It's the only case where typeof returns something more specific than "object", helping distinguish functions from regular objects.

---

Q: What's the difference between for...in and for...of?
A: for...in iterates over object keys (property names). for...of iterates over iterable values (arrays, strings, etc.).

const arr = ["a", "b"];
for (const i in arr) console.log(i); // 0, 1  
for (const v of arr) console.log(v); // "a", "b"

---

Q: When to use break and continue?
A: break exits the loop completely. continue skips the current loop iteration and proceeds to the next. Useful for controlling loop flow.

---

Q: What does isNaN("123") return?
A: false – because "123" can be coerced into a number. Prefer Number.isNaN() for reliable checks, as isNaN() can mislead due to coercion.

---

Q: Difference between setTimeout(fn, 0) and calling fn() directly?
A: fn() runs immediately. setTimeout(fn, 0) delays execution until the call stack is clear – it pushes the function to the end of the event loop queue.

---

Q: Do arrow functions have their own this?
A: No. Arrow functions inherit this from the outer scope. This is useful in callbacks to avoid losing context.

---

Q: Can you declare two var variables with the same name in the same scope?
A: Yes. JavaScript allows it due to var hoisting, but it can lead to logic errors. let and const do not allow duplicate declarations in the same scope.