Interview Questions and Answers

            typeof undefined;        // "undefined"
            typeof true;             // "boolean"
            typeof 42;               // "number"
            typeof "Hello, world!";  // "string"
            typeof Symbol();         // "symbol"
            typeof {};               // "object"
            typeof [];               // "object" (arrays are objects)
            typeof function() {};    // "function"

const person = { name: "John", age: 30 };         

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

function greet(name) {
    console.log( Hello, ${name}! );
}

const currentDate = new Date();         

function Car(make, model) {
    this.make = make;
    this.model = model;
}
const myCar = new Car("Toyota", "Camry");

class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
    }
}
const person = new Person("Alice", 25);     

// Using array literal notation
const fruits = ["apple", "banana", "cherry"];

// Using the Array constructor
const numbers = new Array(1, 2, 3, 4, 5);        

const firstFruit = fruits[0]; // "apple"
const secondNumber = numbers[1]; // 2         

fruits[1] = "grape"; // Modifies the second element       

const fruitCount = fruits.length; // 3        

fruits.push("orange"); // Adds "orange" to the end
fruits.pop(); // Removes the last element
fruits.unshift("kiwi"); // Adds "kiwi" to the beginning
fruits.shift(); // Removes the first element

// Using a for loop
for (let i = 0; i < fruits.length; i++) {
    console.log(fruits[i]);
}

// Using forEach
fruits.forEach(function (fruit) {
    console.log(fruit);
});

const matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
    ];

const sortedNumbers = numbers.sort();
const filteredFruits = fruits.filter(fruit => fruit.startsWith("a"));
const index = fruits.indexOf("banana");         

const moreFruits = ["pear", "grapefruit", ...fruits];
const [first, second, ...rest] = fruits;         

var globalVar = "I'm a global variable";
function globalFunction() {
    console.log("I'm a global function");
}

function myFunction() {
    var localVar = "I'm a local variable"; // Function-scoped
    console.log(localVar); // Accessible within the function
}

// Accessing localVar outside the function will result in an error
// console.log(localVar); // Error: localVar is not defined
 

Example of block scope using  let :

 
if (true) {
    let blockVar = "I'm a block-scoped variable"; // Block-scoped
    console.log(blockVar); // Accessible within the block
}

// Accessing blockVar outside the block will result in an error
// console.log(blockVar); // Error: blockVar is not defined

var globalVar = "I'm a global variable";
function outerFunction() {
    var outerVar = "I'm an outer variable";
    function innerFunction() {
        console.log(globalVar); // Accessible due to lexical scope
        console.log(outerVar); // Accessible due to lexical scope
    }
    innerFunction();
}
outerFunction();

5 === 5;          // true (both value and type are the same)
"hello" === "hi"; // false (both are strings, but values are different)
5 === "5";        // false (value is the same, but types are different)

5 == 5;          // true (both value and type are the same)
"5" == 5;        // true (type coercion converts the string to a number)
0 == false;      // true (type coercion converts false to 0)
null == undefined; // true (both are considered "empty" values)

5 != 10;          // true
"hello" !== "hi"; // true
5 !== "5";        // true

function binarySearch(arr, target) {
    let left = 0;
    let right = arr.length - 1;
  
    while (left <= right) {
      const mid = Math.floor((left + right) / 2);
  
      if (arr[mid] === target) {
        return mid; // Element found, return its index
      } else if (arr[mid] < target) {
        left = mid + 1; // Adjust the left boundary
      } else {
        right = mid - 1; // Adjust the right boundary
      }
    }
  
    return -1; // Element not found
  }
  
  const array = [1, 2, 3, 4, 5, 6, 7, 8, 9];
  const target = 6;
  const result = binarySearch(array, target);
  
  if (result !== -1) {
    console.log( Element ${target} found at index ${result} );
  } else {
    console.log( Element ${target} not found in the array );
}

public static int binarySearch(int[] arr, int target) {
   int left = 0;
   int right = arr.length - 1;
 
   while (left <= right) {
     int mid = left + (right - left) / 2;
 
     if (arr[mid] == target) {
       return mid; // Element found, return its index
     } else if (arr[mid] < target) {
       left = mid + 1; // Adjust the left boundary
     } else {
       right = mid - 1; // Adjust the right boundary
     }
   }
 
   return -1; // Element not found
 }
 
 public static void main(String[] args) {
   int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   int target = 6;
   int result = binarySearch(array, target);
 
   if (result != -1) {
     System.out.println("Element " + target + " found at index " + result);
   } else {
     System.out.println("Element " + target + " not found in the array");
   }
}

    def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == target:
            return mid  # Element found, return its index
        elif arr[mid] < target:
            left = mid + 1  # Adjust the left boundary
        else:
            right = mid - 1  # Adjust the right boundary

    return -1  # Element not found

array = [1, 2, 3, 4, 5, 6, 7, 8, 9]
target = 6
result = binary_search(array, target)

if result != -1:
    print(f"Element {target} found at index {result}")
else:
    print(f"Element {target} not found in the array")

let x = 42;         // Number
let y = "Hello";    // String

let result = x + y; // JavaScript coerces x to a string and concatenates them
console.log(result); // Outputs "42Hello"

let num = 42;
let str = "Hello";
let bool = true;
let obj = {};
let func = function () {};

console.log(typeof num);  // "number"
console.log(typeof str);  // "string"
console.log(typeof bool); // "boolean"
console.log(typeof obj);  // "object"
console.log(typeof func); // "function"

if (true) {
    let x = 10;
    console.log(x); // This works
  }
  console.log(x); // This would result in an error because x is not defined here

console.log(y); // This would result in a ReferenceError
let y = 5;

let count = 0;
count = 1; // This is allowed

console.log(z); // This would result in a ReferenceError
let z = 100;

let emptyValue = null;

let someVariable = null;
if (someVariable === null) {
  console.log("The variable is null.");
} else {
  console.log("The variable is not null.");
}

let notDefined;
console.log(notDefined); // Outputs undefined

function doSomething() {
    // No return statement
  }
  
let result = doSomething();
console.log(result); // Outputs undefined

let someVariable;
if (someVariable === undefined) {
  console.log("The variable is undefined.");
} else {
  console.log("The variable is defined.");
}

function myFunction() {
    "use strict";
    // Function code in strict mode
}

if (!Array.prototype.includes) {
    Array.prototype.includes = function (searchElement, fromIndex) {
      if (this == null) {
        throw new TypeError('"this" is null or not defined');
      }
  
      var O = Object(this);
      var len = O.length >>> 0;
  
      for (var i = fromIndex | 0; i < len; i++) {
        if (O[i] === searchElement) {
          return true;
        }
      }
  
      return false;
    };
}

    const person = {
        name: "Alice",
        age: 30,
        city: "New York",
      };
      
      for (const key in person) {
        console.log(key + ": " + person[key]);
      }    

    const person = {
        name: "Alice",
        age: 30,
        city: "New York",
      };
      
      const keys = Object.keys(person);
      
      for (const key of keys) {
        console.log(key + ": " + person[key]);
      }
       
     

    const person = {
        name: "Alice",
        age: 30,
        city: "New York",
      };
      
      for (const [key, value] of Object.entries(person)) {
        console.log(key + ": " + value);
      }

    const colors = ["red", "green", "blue"];
    
    for (let i = 0; i < colors.length; i++) {
      console.log(colors[i]);
    }

    const colors = ["red", "green", "blue"];
    
    colors.forEach(function (color) {
      console.log(color);
    });

    const colors = ["red", "green", "blue"];
    
    for (const color of colors) {
      console.log(color);
    }

try {
    throw Error('This is an error message');
  } catch (error) {
    console.error(error instanceof Error); // false
    console.error(error.message); // 'This is an error message'
  }

try {
    throw new Error('This is an error message');
  } catch (error) {
    console.error(error instanceof Error); // true
    console.error(error.message); // 'This is an error message'
  }

5 == "5" // true, because "5" is converted to a number
true == 1 // true, because true is converted to 1
null == undefined // true, because they are considered equal in loose equality

5 === "5" // false, because the types are different
true === 1 // false, because the types are different
null === undefined // false, because the types are different

npm install eslint --save-dev

module.exports = {
    // ... other ESLint configuration ...
    rules: {
      // Enable strict mode
      strict: ['error', 'global'],
      // ... other rules ...
    },
};

npx eslint your-file.js

node --use_strict your-script.js

asyncFunction1()
.then(result1 => asyncFunction2(result1))
.then(result2 => asyncFunction3(result2))
.then(result3 => asyncFunction4(result3))
.then(result4 => {
  // Handle the final result
})
.catch(error => {
  // Handle errors
});

estimatedPosition = low + ((target - arr[low]) * (high - low)) / (arr[high] - arr[low])
      

(function () {
    var x = 10; // Variable x is scoped to the IIFE
    console.log(x); // 10
  })();
  
  // Attempting to access x here will result in an error because it's not in scope.
       
  

var num = 5;
var str = "10";

var result = num + str; // The number is coerced to a string, and concatenation occurs.
console.log(result); // "510"  
      

var str = "42";
var num = Number(str); // Explicitly converts the string to a number.
console.log(num); // 42
        
    

var add = function (a, b) {
  return a + b;
};
// Using an anonymous function as an argument
setTimeout(function () {
  console.log("This is an anonymous function.");
}, 1000);
       
   
       

function add(a, b) {
  return a + b;
}
// Calling a named function
var result = add(5, 3);

 function outer() {
  var outerVar = 10;
  function inner() {
    console.log(outerVar); // inner function references outerVar
  }
  return inner; // Return the inner function
}
var closureFunction = outer(); // closureFunction now "closes over" outerVar

closureFunction(); // Outputs: 10
      

 function counter() {
  var count = 0;
  return function () {
    return ++count;
  };
}
var increment = counter();
console.log(increment()); // 1
console.log(increment()); // 2
       

function shallowEqual(objA, objB) {
    const keysA = Object.keys(objA);
    const keysB = Object.keys(objB);
    if (keysA.length !== keysB.length) {
      return false;
    }
    for (let key of keysA) {
      if (objA[key] !== objB[key]) {
        return false;
      }
    }
    return true;
}  

        

const _ = require('lodash');
const objA = { a: 1, b: { c: 2 } };
const objB = { a: 1, b: { c: 2 } };
const areEqual = _.isEqual(objA, objB);
console.log(areEqual); // true
       

const objA = { name: 'John' };
const objB = objA; // objB references the same object as objA
console.log(objA === objB); // true
      

var x; // Declared but undefined
console.log(x); // undefined
function doSomething() {} // Implicitly returns undefined
console.log(doSomething()); // undefined
        
       

console.log(y); // ReferenceError: y is not defined
        
    
     

function higherOrderFunction(callback) {
    // Perform some operation or logic
    const result = 42;
  
    // Call the callback function with the result
    callback(result);
  }
  
  // Usage of the higher-order function
  higherOrderFunction(function (result) {
    console.log( The result is ${result} );
});
       
 

foo(); // You can call foo before its declaration
function foo() {
  console.log("Hello, foo!");
}
foo(); // Calling foo after its declaration
         
     

foo(); // This will result in an error: TypeError: foo is not a function
var foo = function() {
  console.log("Hello, foo!");
};
foo(); // Calling foo after the assignment
         
   
      

function exampleScope() {
    if (true) {
      var varVariable = "I'm a var";
      let letVariable = "I'm a let";
    }

    console.log(varVariable); // Accessible
    console.log(letVariable); // ReferenceError: letVariable is not defined
}
           
     

console.log(x); // undefined
var x = 10;

console.log(y); // ReferenceError: y is not defined
let y = 20;
     
   

var x = 10;
var x = 20; // No error

let y = 10;
let y = 20; // SyntaxError: Identifier 'y' has already been declared
     
   

// In a browser environment
let globalLet = 10;
console.log(window.globalLet); // undefined

var globalVar = 20;
console.log(window.globalVar); // 20
     
   

const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5]; // Create a new array by spreading elements
         
      

const obj1 = { x: 1, y: 2 };
const obj2 = { ...obj1, z: 3 }; // Create a new object by spreading properties
    
   

    const numbers = [1, 2, 3];
        
    function sum(a, b, c) {
      return a + b + c;
    }
    
    const result = sum(...numbers); // Pass array elements as individual arguments
    
  

        function sum(...args) {
            return args.reduce((total, num) => total + num, 0);
          }
          const result = sum(1, 2, 3, 4, 5);
           
     
    

    const [first, second, ...rest] = [1, 2, 3, 4, 5];
    console.log(first); // 1
    console.log(second); // 2
    console.log(rest); // [3, 4, 5]
     
   

    class Person {
        constructor(name) {
          this.name = name;
        }
   
        sayHello() {
          console.log( Hello, my name is ${this.name} );
        }
      }
       
   

    class Student extends Person {
        constructor(name, studentId) {
          super(name); // Call the parent class constructor
          this.studentId = studentId;
        }
      }
       
   

    function Person(name) {
        this.name = name;
      }
   
      Person.prototype.sayHello = function() {
        console.log( Hello, my name is ${this.name} );
      };
   

    function Student(name, studentId) {
        Person.call(this, name); // Call the parent constructor
        this.studentId = studentId;
      }
   
      Student.prototype = Object.create(Person.prototype);
      Student.prototype.constructor = Student;
       
 

    // Traditional function
    const add = function (a, b) {
      return a + b;
    };

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

        const double = (num) => num * 2;
         
       

    function Counter() {
        this.count = 0;
        setInterval(() => {
          //  this  refers to the Counter instance
          this.count++;
        }, 1000);
      }
       
   

        const numbers = [1, 2, 3, 4, 5];
        const squared = numbers.map((num) => num * num);
        
      

        const greet = (name) =>  Hello, ${name}! ;
       

        const person = {
            name: "Alice",
            sayHello: () => {
              console.log( Hello, my name is ${this.name} );
            },
          };
           
     

    class MyClass {
        constructor() {
          this[privateSymbol] = 'This is a private property';
        }
   
        getPrivateProperty() {
          return this[privateSymbol];
        }
      }
       
   

    const myIterable = {
        [Symbol.iterator]: function* () {
          yield 1;
          yield 2;
          yield 3;
        },
      };
       
   

    function greet(name) {
        console.log( Hello, ${name}! I am ${this.name} );
      }
   
      const person = { name: 'Alice' };
      greet.call(person, 'Bob'); // Output: Hello, Bob! I am Alice
       
   

        function greet(name) {
            console.log( Hello, ${name}! I am ${this.name} );
          }
       
          const person = { name: 'Alice' };
          greet.apply(person, ['Bob']); // Output: Hello, Bob! I am Alice
           
     

       // ES5 constructor function
       function Person(name) {
         this.name = name;
       }
    
       Person.prototype.sayHello = function() {
         console.log( Hello, my name is ${this.name} );
       };
    
       // ES6 class
       class Person {
         constructor(name) {
           this.name = name;
         }
    
         sayHello() {
           console.log( Hello, my name is ${this.name} );
         }
       }
        
       

        class Student extends Person {
            constructor(name, studentId) {
              super(name); // Call the parent class constructor
              this.studentId = studentId;
            }
          }
           
     

        class MathUtils {
            static add(x, y) {
              return x + y;
            }
          }
       
          const result = MathUtils.add(2, 3); // Call a static method
           
    

        class Counter {
            #count = 0; // Private field
            increment() {
              this.#count++;
            }
            getCount() {
              return this.#count;
            }
          }
           
      

    // Exporting a module
    module.exports = { key: 'value' };
 
    // Importing a module
    const myModule = require('./myModule');
     
   

    // Defining a module
    define(['dependency1', 'dependency2'], function(dep1, dep2) {
      return { key: 'value' };
    });
 
    // Importing a module
    require(['myModule'], function(myModule) {
      // Use myModule
    });
     
  

    const DaysOfWeek = {
        SUNDAY: 0,
        MONDAY: 1,
        TUESDAY: 2,
        WEDNESDAY: 3,
        THURSDAY: 4,
        FRIDAY: 5,
        SATURDAY: 6,
      };
       

    const DaysOfWeek = {
        SUNDAY: Symbol('SUNDAY'),
        MONDAY: Symbol('MONDAY'),
        TUESDAY: Symbol('TUESDAY'),
        // ...
      };
       
      
      Usage:
      
       
      const today = DaysOfWeek.MONDAY;
      console.log(today === DaysOfWeek.MONDAY); // true
       
 

   const Enumify = require('enumify');
   
   class DaysOfWeek extends Enumify {}
   
   DaysOfWeek.initEnum({
     SUNDAY: {},
     MONDAY: {},
     TUESDAY: {},
     // ...
   });
    
   
   Usage:
   
    
   const today = DaysOfWeek.MONDAY;
   console.log(today); // Outputs: MONDAY
    
   

       function* generateNumbers() {
        let i = 0;
        while (true) {
          yield i++;
        }
      }
   
      const numbers = generateNumbers();
      console.log(numbers.next().value); // 0
      console.log(numbers.next().value); // 1
      // ...
       
        

       function* fetchUserAndPosts(userId) {
        const user = yield fetch( /users/${userId} );
        const posts = yield fetch( /posts/${user.id} );
        return { user, posts };
      }
   
      const generator = fetchUserAndPosts(1);
      const { value, done } = generator.next();
   
      if (!done) {
        value.then(result => {
          const { value, done } = generator.next(result);
          if (!done) {
            value.then(result => {
              console.log(result);
            });
          }
        });
      }
       
    

       const customIterable = {
        *[Symbol.iterator]() {
          yield 1;
          yield 2;
          yield 3;
        },
      };
   
      for (const value of customIterable) {
        console.log(value);
      }
       
        

       function* fibonacci() {
        let a = 0, b = 1;
        while (true) {
          yield a;
          [a, b] = [b, a + b];
        }
      }
   
      const fib = fibonacci();
      console.log(fib.next().value); // 0
      console.log(fib.next().value); // 1
      console.log(fib.next().value); // 1
      console.log(fib.next().value); // 2
      // ...
       
   
        

        button.addEventListener('click', function() {
            console.log('Button clicked!');
          });
           
    

    (function() {
        var privateVar = 10;
        // Other code...
      })();
   

    const numbers = [1, 2, 3, 4, 5];
    const squared = numbers.map(function(x) {
      return x * x;
    });
     
  

        const result = doSomething(function(x, y) {
            return x + y;
          });
           
     

    function createMultiplier(factor) {
        return function(number) {
          return number * factor;
        };
      }
      const double = createMultiplier(2);
       
 

        const sortedArray = someArray.sort(function(a, b) {
            return a - b;
          });
           
    

    fetch(url)
    .then(response => response.json())
    .then(data => console.log(data))
    .catch(error => console.error(error));
   
 

        document.getElementById('myButton').onclick = function() {
            alert('Button clicked!');
          };
           
    

    function createCounter() {
        let count = 0;
        return function() {
          return ++count;
        };
      }
   
      const counter = createCounter();
      console.log(counter()); // 1
      console.log(counter()); // 2
       
  

    function createIncrementer(initialValue) {
        let value = initialValue;
        return function() {
          return ++value;
        };
      }
   
      const incrementByOne = createIncrementer(1);
      console.log(incrementByOne()); // 2
      console.log(incrementByOne()); // 3
       
   
 

    function multiplier(factor) {
        return function(x) {
          return x * factor;
        };
      }
   
      const double = multiplier(2);
      console.log(double(5)); // 10
       
  

    function fetchData(url) {
        let data = null;
        fetch(url)
          .then(response => response.json())
          .then(result => {
            data = result;
          });
   
        return function() {
          return data;
        };
      }
   
      const getFetchedData = fetchData('https://example.com/data');
      setTimeout(() => {
        console.log(getFetchedData()); // Accesses the fetched data even after fetchData has completed.
      }, 1000);
       

        const pi = 3.14159;
        pi = 4; // Error: Assignment to constant variable.
        
      

        const person = { name: 'Alice' };
        person.name = 'Bob'; // Allowed
        
    

        const person = Object.freeze({ name: 'Alice' });
        person.name = 'Bob'; // Error: Cannot assign to read-only property 'name' of object
         
     

    const obj = Object.freeze({
        prop1: 'value1',
        nested: { prop2: 'value2' },
      });
 
      obj.nested.prop2 = 'new value'; // Allowed because the nested object isn't frozen.
 
      Object.freeze(obj.nested);
      obj.nested.prop2 = 'new value'; // Error: Cannot assign to read-only property 'prop2' of object
      
   

        document.addEventListener('DOMContentLoaded', function() {
            // DOM is ready for manipulation.
          });
           
     

        window.addEventListener('load', function() {
            // Entire page, including external resources, is loaded.
          });
     

    // Traditional function expression
    const add = function (a, b) {
      return a + b;
    };
 
    // Arrow function
    const add = (a, b) => a + b;
     
 
 

        function Person() {
            this.age = 0;
       
            setInterval(() => {
              this.age++; // 'this' refers to the Person instance
            }, 1000);
          }
             
    

       // Traditional function expression
       const square = function (x) {
         return x * x;
       };
    
       // Arrow function with a single parameter
       const square = x => x * x;