Que.1 Create 2 objects - parent and child. Attach methods to parent and use those methods in child object using parents prototype

  // Parent object constructor
  function Parent() {
    this.name = 'Parent';
  }
  
  // Method attached to Parent object
  Parent.prototype.sayHello = function() {
    console.log(`Hello, I am ${this.name}`);
  };
  
  // Child object constructor
  function Child() {
    this.name = 'Child';
  }
  
  // Inheriting from Parent's prototype
  Child.prototype = Object.create(Parent.prototype);
  Child.prototype.constructor = Child;
  
  // Creating a new instance of Child
  const childObj = new Child();
  
  // Using Parent's method in Child object
  childObj.sayHello(); // Output: "Hello, I am Child"
        

Output:   Hello, I am Child

Que.2 Write code to explain prototype chaining

  // Parent object constructor
  function Parent(name) {
    this.name = name;
  }
  
  // Method attached to Parent object
  Parent.prototype.sayHello = function() {
    console.log(`Hello, I am ${this.name}`);
  };
  
  // Child object constructor
  function Child(name, age) {
    Parent.call(this, name); // Call Parent's constructor with Child's instance
    this.age = age;
  }
  
  // Inheriting from Parent's prototype
  Child.prototype = Object.create(Parent.prototype);
  Child.prototype.constructor = Child;
  
  // Method attached to Child object
  Child.prototype.sayAge = function() {
    console.log(`I am ${this.age} years old`);
  };
  
  // Creating instances of Child
  const child1 = new Child('Child 1', 5);
  const child2 = new Child('Child 2', 8);
  
  // Using inherited methods
  child1.sayHello(); // Output: "Hello, I am Child 1"
  child1.sayAge(); // Output: "I am 5 years old"
  
  child2.sayHello(); // Output: "Hello, I am Child 2"
  child2.sayAge(); // Output: "I am 8 years old"
          
        

Output:   Hello, I am Child 1
I am 5 years old
Hello, I am Child 2
I am 8 years old

Que.3 Add a method to calculate sum of all elements in Array in array's protype, use that method to calculate sum for multiple arrays

  // Define the method to calculate sum in the prototype of arrays
  Array.prototype.sum = function() {
    let sum = 0;
    for (let i = 0; i < this.length; i++) {
      if (typeof this[i] === 'number') {
        sum += this[i];
      }
    }
    return sum;
  };
  
  // Create some example arrays
  const arr1 = [1, 2, 3, 4, 5];
  const arr2 = [10, 20, 30, 40, 50];
  const arr3 = [2.5, 3.7, 8.9, 1.2];
  
  // Use the sum method to calculate sum for each array
  const sum1 = arr1.sum();
  const sum2 = arr2.sum();
  const sum3 = arr3.sum();
  
  // Output the results
  console.log('Sum of arr1:', sum1); // Output: Sum of arr1: 15
  console.log('Sum of arr2:', sum2); // Output: Sum of arr2: 150
  console.log('Sum of arr3:', sum3); // Output: Sum of arr3: 16.3  
        

Output:  Sum of arr1: 15
Sum of arr2: 150
Sum of arr3: 16.3

Que.4 Write a JavaScript function to retrieve all the names of object's own and inherited properties.

  function getAllPropertyNames(obj) {
    let propertyNames = [];
    
    const getAllProperties = (obj) => {
      const proto = Object.getPrototypeOf(obj);
      if (proto !== null) {
        getAllProperties(proto);
      }
      
      const names = Object.getOwnPropertyNames(obj);
      for (const name of names) {
        if (!propertyNames.includes(name)) {
          propertyNames.push(name);
        }
      }
    }
    
    getAllProperties(obj);
    
    return propertyNames;
  }
  
  // Example usage:
  
  // Define parent object
  const parent = {
    parentProp1: 'Parent Prop 1',
    parentProp2: 'Parent Prop 2'
  };
  
  // Define child object with inheritance
  const child = Object.create(parent);
  child.childProp1 = 'Child Prop 1';
  child.childProp2 = 'Child Prop 2';
  
  // Retrieve all property names of child object
  const allPropertyNames = getAllPropertyNames(child);
  
  console.log(allPropertyNames);
  // Output: ["childProp1", "childProp2", "parentProp1", "parentProp2"]