add new notes

Author: famsameerkhan1342

notes/English/52-OOPs In JavaScript.md renamed to notes/English/51-OOPs In JavaScript.md

@@ -1,52 +1,52 @@
-### OOPs in JavaScript
-
-In JavaScript, OOPs is based on the concept of prototypes, which is different from class-based OOPs in other languages like Java and C++.
-
-In JavaScript, every object has a prototype object, which acts as a template for the object. When a property or method is accessed on an object, JavaScript first looks for that property or method on the object itself. If it's not found, JavaScript looks for it on the object's prototype. If it's still not found, JavaScript continues up the prototype chain until it reaches the Object.prototype, which is the root of the prototype chain.
-
-To create an object in JavaScript, we can use either the object literal notation or the Object() constructor. For example, here's how we can create an object using the object literal notation:
-
-```javascript
-const person = {
-  name: 'Alice',
-  age: 30,
-  gender: 'female',
-  walk() {
-    console.log(`${this.name} is walking.`);
-  },
-  talk() {
-    console.log(`${this.name} is talking.`);
-  }
-};
-
-```
-
-In this example, we create an object called "person" that has properties for the person's name, age, and gender, as well as methods for walking and talking.
-
-We can also create objects using constructor functions, which act as blueprints for creating objects with shared properties and methods. For example:
-
-```javascript
-function Person(name, age, gender) {
-  this.name = name;
-  this.age = age;
-  this.gender = gender;
-}
-
-Person.prototype.walk = function() {
-  console.log(`${this.name} is walking.`);
-};
-
-Person.prototype.talk = function() {
-  console.log(`${this.name} is talking.`);
-};
-
-const person1 = new Person('Alice', 30, 'female');
-const person2 = new Person('Bob', 40, 'male');
-
-person1.walk(); // logs "Alice is walking."
-person2.talk(); // logs "Bob is talking."
-```
-
-In this example, we define a constructor function called "Person" that takes in arguments for the person's name, age, and gender, and sets those properties on the newly created object using this. We then add the walk() and talk() methods to the Person.prototype object, which will be shared by all instances of the "Person" object.
-
-Overall, JavaScript's approach to OOPs is based on prototypes rather than classes, which can take some getting used to if you are coming from a class-based OOPs language. However, once you understand the concept of prototypes and how they work, you can create powerful and flexible object-oriented code in JavaScript.
+### OOPs in JavaScript
+
+In JavaScript, OOPs is based on the concept of prototypes, which is different from class-based OOPs in other languages like Java and C++.
+
+In JavaScript, every object has a prototype object, which acts as a template for the object. When a property or method is accessed on an object, JavaScript first looks for that property or method on the object itself. If it's not found, JavaScript looks for it on the object's prototype. If it's still not found, JavaScript continues up the prototype chain until it reaches the Object.prototype, which is the root of the prototype chain.
+
+To create an object in JavaScript, we can use either the object literal notation or the Object() constructor. For example, here's how we can create an object using the object literal notation:
+
+```javascript
+const person = {
+  name: 'Alice',
+  age: 30,
+  gender: 'female',
+  walk() {
+    console.log(`${this.name} is walking.`);
+  },
+  talk() {
+    console.log(`${this.name} is talking.`);
+  }
+};
+
+```
+
+In this example, we create an object called "person" that has properties for the person's name, age, and gender, as well as methods for walking and talking.
+
+We can also create objects using constructor functions, which act as blueprints for creating objects with shared properties and methods. For example:
+
+```javascript
+function Person(name, age, gender) {
+  this.name = name;
+  this.age = age;
+  this.gender = gender;
+}
+
+Person.prototype.walk = function() {
+  console.log(`${this.name} is walking.`);
+};
+
+Person.prototype.talk = function() {
+  console.log(`${this.name} is talking.`);
+};
+
+const person1 = new Person('Alice', 30, 'female');
+const person2 = new Person('Bob', 40, 'male');
+
+person1.walk(); // logs "Alice is walking."
+person2.talk(); // logs "Bob is talking."
+```
+
+In this example, we define a constructor function called "Person" that takes in arguments for the person's name, age, and gender, and sets those properties on the newly created object using this. We then add the walk() and talk() methods to the Person.prototype object, which will be shared by all instances of the "Person" object.
+
+Overall, JavaScript's approach to OOPs is based on prototypes rather than classes, which can take some getting used to if you are coming from a class-based OOPs language. However, once you understand the concept of prototypes and how they work, you can create powerful and flexible object-oriented code in JavaScript.

notes/English/51-OOPs.md

@@ -1,55 +1,55 @@
-### Prototypal inheritance and prototype chain
-
-Prototypal inheritance is a mechanism in JavaScript that allows objects to inherit properties and methods from other objects, known as their prototypes. When a property or method is accessed on an object, JavaScript first looks for it directly on the object, and if it's not found, it looks for it on the object's prototype, and then on the prototype's prototype, and so on, following the prototype chain until the property or method is found or until the end of the chain is reached (which is the object `Object.prototype`, the final fallback).
-
-The prototype chain is the chain of prototypes that an object follows to access properties and methods. Each object has an internal property called `[[Prototype]]` (also accessible via the `__proto__` property) that points to its prototype object. When an object is created using object literals, the default prototype is `Object.prototype`. However, you can create custom prototypes by defining constructor functions and setting their `prototype` property to an object that will be used as the prototype for the objects created with that constructor function.
-
-
-### Prototypal inheritance on Built-in objects in JavaScript
-
-Prototypal inheritance is a fundamental concept in JavaScript that allows objects to inherit properties and methods from other objects. In the case of built-in objects, such as arrays or strings, they inherit their properties and methods from their prototype object. This means that any instance of an array, for example, will have access to all the properties and methods defined on the Array.prototype object. Similarly, instances of strings will have access to the properties and methods defined on the String.prototype object. This feature makes JavaScript highly flexible and extensible.
-
-### Difference between Inheritance and classes
-
-In JavaScript, classes are blueprints for creating objects with specific properties and methods. Inheritance, on the other hand, is a mechanism that allows an object to inherit properties and methods from another object. 
-
-Classes provide a way to define objects with similar behavior and characteristics in a reusable way. They can be used to create multiple instances of an object with their own unique characteristics.
-
-Inheritance allows objects to share properties and methods with other objects, which can simplify code and avoid repetition. It provides a way to create new objects based on existing ones, inheriting their properties and methods while also adding or modifying them as needed.
-
-In summary, classes are used to define objects while inheritance is a mechanism for sharing properties and methods between objects.
-
-
-### How to use constructor functions ?
-
-Constructor functions in JavaScript are used to create objects with shared properties and methods. Here's an example of how to use a constructor function:
-
-1. Define the constructor function: 
-```
-function Person(name, age) {
-  this.name = name;
-  this.age = age;
-}
-```
-
-2. Create new instances of the object using the `new` keyword:
-```
-let person1 = new Person('John', 30);
-let person2 = new Person('Jane', 25);
-```
-
-3. Access the object's properties using dot notation:
-```
-console.log(person1.name); // Output: John
-console.log(person2.age); // Output: 25
-```
-
-You can also add methods to the constructor function's prototype, which will be shared by all instances of the object:
-```
-Person.prototype.sayHello = function() {
-  console.log(`Hello, my name is ${this.name}.`);
-}
-
-person1.sayHello(); // Output: Hello, my name is John.
-person2.sayHello(); // Output: Hello, my name is Jane.
-```
+### Prototypal inheritance and prototype chain
+
+Prototypal inheritance is a mechanism in JavaScript that allows objects to inherit properties and methods from other objects, known as their prototypes. When a property or method is accessed on an object, JavaScript first looks for it directly on the object, and if it's not found, it looks for it on the object's prototype, and then on the prototype's prototype, and so on, following the prototype chain until the property or method is found or until the end of the chain is reached (which is the object `Object.prototype`, the final fallback).
+
+The prototype chain is the chain of prototypes that an object follows to access properties and methods. Each object has an internal property called `[[Prototype]]` (also accessible via the `__proto__` property) that points to its prototype object. When an object is created using object literals, the default prototype is `Object.prototype`. However, you can create custom prototypes by defining constructor functions and setting their `prototype` property to an object that will be used as the prototype for the objects created with that constructor function.
+
+
+### Prototypal inheritance on Built-in objects in JavaScript
+
+Prototypal inheritance is a fundamental concept in JavaScript that allows objects to inherit properties and methods from other objects. In the case of built-in objects, such as arrays or strings, they inherit their properties and methods from their prototype object. This means that any instance of an array, for example, will have access to all the properties and methods defined on the Array.prototype object. Similarly, instances of strings will have access to the properties and methods defined on the String.prototype object. This feature makes JavaScript highly flexible and extensible.
+
+### Difference between Inheritance and classes
+
+In JavaScript, classes are blueprints for creating objects with specific properties and methods. Inheritance, on the other hand, is a mechanism that allows an object to inherit properties and methods from another object. 
+
+Classes provide a way to define objects with similar behavior and characteristics in a reusable way. They can be used to create multiple instances of an object with their own unique characteristics.
+
+Inheritance allows objects to share properties and methods with other objects, which can simplify code and avoid repetition. It provides a way to create new objects based on existing ones, inheriting their properties and methods while also adding or modifying them as needed.
+
+In summary, classes are used to define objects while inheritance is a mechanism for sharing properties and methods between objects.
+
+
+### How to use constructor functions ?
+
+Constructor functions in JavaScript are used to create objects with shared properties and methods. Here's an example of how to use a constructor function:
+
+1. Define the constructor function: 
+```
+function Person(name, age) {
+  this.name = name;
+  this.age = age;
+}
+```
+
+2. Create new instances of the object using the `new` keyword:
+```
+let person1 = new Person('John', 30);
+let person2 = new Person('Jane', 25);
+```
+
+3. Access the object's properties using dot notation:
+```
+console.log(person1.name); // Output: John
+console.log(person2.age); // Output: 25
+```
+
+You can also add methods to the constructor function's prototype, which will be shared by all instances of the object:
+```
+Person.prototype.sayHello = function() {
+  console.log(`Hello, my name is ${this.name}.`);
+}
+
+person1.sayHello(); // Output: Hello, my name is John.
+person2.sayHello(); // Output: Hello, my name is Jane.
+```