10 Essential JavaScript Interview Questions for Beginners

Answer: JavaScript has several data types:

Hover or touch each icon to find out more. Click or touch again to see a longer description.

Answer:

• == checks if values are equal, even if they are different types (like 5 == '5' is true).
• === checks if values and types are the same (like 5 === '5' is false).

Answer:

• let and const are block-scoped. This means they only exist within the block (like inside curly braces {}) where they are defined. Variables created using "let" can be changed, but those that use "const" cannot.

  // Example of block-scoped variables with let and const
  {
    let x = 10;
    const y = 20;
    
    console.log(x); // 10: 'x' is accessible inside the block
    console.log(y); // 20: 'y' is accessible inside the block
  }
  
  // Outside the block
  console.log(x); // Error: x is not defined
  console.log(y); // Error: y is not defined
  
  // Redeclaring variables inside the same scope 
  let b = 1;
  let b = 2; // Error: Identifier 'b' has already been declared
  
  // Redeclaring const inside the same scope
  const c = 1;
  const c = 2; // Error: Identifier 'c' has already been declared                   
  

  
  
• var is function-scoped. This means it exists within the function where it is defined. It can be redeclared, which can cause issues in larger programs.

  // Example of function-scoped variables with var
  function exampleVar() {
    var z = 30;
    console.log(z); // 30: 'z' is accessible inside the function
  }
  exampleVar();
  
  // Outside the function
  console.log(z); // Error: z is not defined
  
  // Redeclaring variables with var
  var a = 1;
  var a = 2; // Allowed: 'var' allows redeclaration
  console.log(a); // 2: The second declaration overwrites the first one

Answer: An array is an ordered list of values accessed by numerical indexes (starting at 0). Use arrays when you need to store and process items in a specific sequence.

An object is a collection of key-value pairs, where keys are strings that describe the data they contain. Use objects when you need to represent entities with named properties.

// Array: ordered list with numeric indexes
let fruits = ['apple', 'banana'];

// Object: named properties
let person = { name: 'Corey', age: 32 };

Answer: In JavaScript, functions come in several types, each with its own syntax and use cases. The main types of functions are:

• Function Declarations: These are the most common functions, defined with the 'function' keyword.
• Function Expressions: Functions that are assigned to variables, can be anonymous or named.
• Arrow Functions: A shorter syntax for writing function expressions, using the '=>' arrow notation.
• Anonymous Functions: Functions without a name, typically used as arguments or in callbacks.
• Immediately Invoked Function Expressions (IIFE): A function that is defined and invoked immediately after creation, often used for creating local scopes.

Examples:

// Function Declaration
function greet(name) {
    return `Hello, ${name}!`;
}

// Function Expression
const square = function(x) {
    return x * x;
};

// Arrow Function
const add = (a, b) => a + b;

// Anonymous Function
setTimeout(function() {
    console.log("This runs after 1 second");
}, 1000);

// IIFE (Immediately Invoked Function Expression)
(function() {
    console.log("I am executed immediately!");
})();
                

Answer: JavaScript runs on a single thread, meaning it can only do one thing at a time. However, asynchronous programming allows JavaScript to perform tasks like loading data or waiting for timers without blocking other operations. It achieves this using techniques like callbacks, promises, and `async/await`.

1. Using Callbacks

Callbacks are functions passed into other functions to be executed later. They allow JavaScript to continue running other code while waiting for something to finish.

// Example using a callback
function fetchData(callback) {
  setTimeout(() => {
    callback("Data fetched");
  }, 1000);
}

fetchData((data) => {
  console.log(data); // "Data fetched" after 1 second
});
                

2. Using Promises

Promises are objects that represent the eventual completion (or failure) of an asynchronous operation. You can chain `.then()` to handle the result once it's ready.

// Example using a Promise
function fetchDataPromise() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve("Data fetched");
    }, 1000);
  });
}

fetchDataPromise().then((data) => {
  console.log(data); // "Data fetched" after 1 second
});
                

3. Using Async/Await

`async/await` is a more modern and cleaner way to handle async code. It allows you to write asynchronous code that looks like regular, synchronous code. `async` functions return a promise, and `await` pauses the execution until the promise is resolved.

// Example using async/await
async function fetchDataAsync() {
  const data = await fetchDataPromise();
  console.log(data); // "Data fetched" after 1 second
}

fetchDataAsync();
                

Answer: In JavaScript, both `null` and `undefined` represent the absence of a value, but they are used in different contexts:

• undefined: This means a variable has been declared, but it hasn’t been assigned a value yet. It’s the default value JavaScript gives to variables that are declared but not initialized.
• null: This is an intentional assignment of "no value" to a variable. It explicitly represents a lack of value and is often used to indicate that a variable should be empty or cleared.

Example:

// undefined example
let myVar;
console.log(myVar); //undefined: variable is declared but not assigned a value
// null example
let myObject = null;
console.log(myObject); // null: explicitly set to indicate no value
        

Answer: Hoisting is when JavaScript automatically moves your function and variable declarations to the top of their scope before running the code. Think of it like JavaScript "lifting" these declarations up. However, only the declarations move up, not the values you assign to variables.

Examples:

// Functions are fully hoisted - this works!
sayHello(); // Outputs: "Hi there!"

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

// Variables declared with 'var' are hoisted, but not their values
console.log(message); // undefined (not an error!)
var message = "Hello";

// Variables with 'let' and 'const' are hoisted but not initialized
console.log(name); // Error: Cannot access 'name' before initialization
let name = "Alex";

Answer: JavaScript arrays have several built-in methods that help you manipulate data. The most commonly used ones are:

• map(): Creates a new array by transforming each element
• filter(): Creates a new array with elements that pass a test
• reduce(): Reduces an array to a single value
• push()/pop(): Add/remove elements from the end
• forEach(): Executes a function on each element

Examples:

const numbers = [1, 2, 3, 4, 5];

// map(): double each number
const doubled = numbers.map(num => num * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

// filter(): get even numbers
const evens = numbers.filter(num => num % 2 === 0);
console.log(evens); // [2, 4]

// reduce(): sum all numbers
const sum = numbers.reduce((total, num) => total + num, 0);
console.log(sum); // 15

// forEach(): log each number
numbers.forEach(num => console.log(num));

Answer: A closure happens when a function "remembers" the variables from its outer scope even after the outer function has finished running. Think of it like creating a secure bubble around some data that can only be accessed by the functions you define.

Real-world Example:

// Create a counter that can't be modified from outside
function createCounter() {
  let count = 0;  // This variable is private and protected
  
  return {
    increment: function() {
      count++;
      return count;
    },
    decrement: function() {
      count--;
      return count;
    },
    getCount: function() {
      return count;
    }
  };
}

const counter = createCounter();
console.log(counter.getCount());  // 0
counter.increment();              // 1
counter.increment();              // 2
counter.decrement();             // 1

// The 'count' variable can't be accessed directly:
console.log(count);              // ReferenceError: count is not defined
console.log(counter.count);      // undefined