Master JavaScript Interviews with Top 25+ Q&A | Try Personalized AI Help

== (Abstract Equality): Compares two values for equality, performing type conversion if necessary.

=== (Strict Equality): Compares two values for equality without performing type conversion. Both the value and the type must be the same.

console.log(5 == '5'); // true (type conversion happens)
console.log(5 === '5'); // false (no type conversion)

Prototypal Inheritance is a feature in JavaScript where objects can inherit properties and methods from other objects. Each object has a private property (prototype) that holds a link to another object called its prototype. This chain of prototypes is known as the prototype chain.

const animal = {
    eat: function() {
        console.log('Eating...');
    }
};

const dog = Object.create(animal);
dog.bark = function() {
    console.log('Barking...');
};

dog.eat(); // Eating... (inherited from animal)
dog.bark(); // Barking...

A Higher-Order Function is a function that can take other functions as arguments and/or return functions as its result. These are used extensively in functional programming.

function higherOrderFunction(callback) {
    return function(x) {
        return callback(x);
    };
}

const double = higherOrderFunction(function(x) {
    return x * 2;
});

console.log(double(5)); // 10

The this keyword refers to the object it belongs to. Its value is determined by how a function is called:

• Global Scope: In the global scope, this refers to the global object (window in browsers).
• Method: In a method, this refers to the object that owns the method.
• Constructor: In a constructor, this refers to the newly created instance.

function showThis() {
    console.log(this);
}

const obj = {
    method: showThis
};

showThis(); // Window (or global object in Node.js)
obj.method(); // obj

Synchronous Code: Executes sequentially, blocking further execution until the current operation completes.

Asynchronous Code: Executes independently of the main program flow, allowing other operations to run while waiting for an asynchronous operation to complete.

// Synchronous
console.log('Start');
console.log('End');

// Asynchronous
console.log('Start');
setTimeout(() => {
    console.log('Middle');
}, 1000);
console.log('End');

Arrow functions are a shorthand syntax for writing function expressions in JavaScript. They differ from regular functions in several key ways:

• Syntax: Arrow functions are more concise.
• this Binding: Arrow functions do not have their own this context; they inherit this from the enclosing scope.
• arguments Object: Arrow functions do not have their own arguments object.

// Regular function
function regularFunction(a, b) {
    return a + b;
}

// Arrow function
const arrowFunction = (a, b) => a + b;

null : Represents the intentional absence of any object value. It is an assignment value that indicates a variable points to no object.

undefined : Indicates that a variable has been declared but has not yet been assigned a value.

Currying is a technique of transforming a function that takes multiple arguments into a sequence of functions, each taking a single argument. This allows partial application of a function's arguments.

function curryFunction(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}

const curried = curryFunction(1)(2)(3); // 6

Event delegation is a technique where a single event listener is added to a parent element to manage events for its child elements. This is useful for handling events efficiently when dealing with many child elements.

Promises are objects representing the eventual completion or failure of an asynchronous operation. They are useful for managing asynchronous code in a more readable and maintainable way compared to callbacks, avoiding callback hell.

let promise = new Promise((resolve, reject) => {
    // asynchronous operation
    let success = true;
    if (success) {
        resolve('Operation was successful');
    } else {
        reject('Operation failed');
    }
});

promise
    .then((message) => console.log(message))
    .catch((error) => console.error(error));

• forEach : Iterates over array elements, executing a provided function once for each element. It does not return a new array.
• map : Iterates over array elements, executing a provided function for each element and returning a new array with the results.
• filter : Iterates over array elements, executing a provided function for each element, and returns a new array containing only the elements that pass the test implemented by the function.

async and await are syntactic sugar for working with Promises, making asynchronous code look and behave more like synchronous code.

• async : Declares an asynchronous function, which implicitly returns a Promise.
• await : Pauses the execution of an async function until the Promise is resolved, returning the resolved value.

async function fetchData() {
    try {
        const response = await fetch('https://api.example.com/data');
        const data = await response.json();
        console.log(data);
    } catch (error) {
        console.error('Error fetching data:', error);
    }
}

fetchData();

The bind method creates a new function that, when called, has its this keyword set to the provided value, with a given sequence of arguments preceding any provided when the new function is called.

const person = {
    name: 'John',
    greet: function(greeting) {
        console.log(greeting + ', ' + this.name);
    }
};

const greetJohn = person.greet.bind(person, 'Hello');
greetJohn(); // Hello, John

Debouncing: Ensures that a function is not called again until a certain amount of time has passed since it was last called. Useful for limiting the rate at which a function is executed.

function debounce(func, wait) {
    let timeout;
    return function() {
        clearTimeout(timeout);
        timeout = setTimeout(() => func.apply(this, arguments), wait);
    };
}

Throttling: Ensures that a function is called at most once in a specified time period. Useful for controlling the execution rate of an event handler.

function throttle(func, limit) {
    let lastFunc;
    let lastRan;
    return function() {
        const context = this;
        const args = arguments;
        if (!lastRan) {
            func.apply(context, args);
            lastRan = Date.now();
        } else {
            clearTimeout(lastFunc);
            lastFunc = setTimeout(() => {
                if ((Date.now() - lastRan) >= limit) {
                    func.apply(context, args);
                    lastRan = Date.now();
                }
            }, limit - (Date.now() - lastRan));
        }
    };
}

The event loop is a fundamental part of JavaScript's concurrency model. It allows JavaScript to perform non-blocking operations by offloading operations to the browser (or Node.js) and running a loop that checks for tasks, executes them, and then waits for more tasks.

• Call Stack: Executes code, one frame at a time.
• Web APIs: Browser features like DOM, setTimeout, etc.
• Callback Queue: Queues asynchronous callbacks to be executed.
• Event Loop: Continuously checks if the call stack is empty and moves the first task from the callback queue to the call stack for execution.