Feat:Demonstrate 'this' in functions, objects and constructors

Author: codezenashish

14_this_arro/ops.js

@@ -0,0 +1,64 @@
+// This code demonstrates the use of 'this' in a regular function and an arrow function.
+
+// The 'this' keyword behaves differently in regular functions and arrow functions.
+// In regular functions, 'this' refers to the object that calls the function.
+// Regular function
+function regularFunction() {
+  console.log(this);
+}
+// In non-strict mode, 'this' refers to the global object (window in browsers). in Node.js).
+// In strict mode, 'this' will be undefined.// If you want to see the difference, you can uncomment the line below to enable strict mode.
+// 'use strict'; // Uncomment this line to enable strict mode
+// Calling the regular function
+// regularFunction(); // In non-strict mode, this will refer to the global object (window
+// In strict mode, this will be undefined
+
+// Arrow function
+// In arrow functions, 'this' is lexically bound, meaning it takes 'this' from the surrounding context.
+// In this case, it will refer to the global object (window in browsers) or undefined
+// in strict mode.
+// Arrow function
+const arrowFunction = () => {
+  console.log(this);
+};
+// Calling the arrow function
+// arrowFunction(); // In non-strict mode, this will refer to the global object (window in browsers) or undefined in strict mode.
+// Example of 'this' in an object method
+// In an object method, 'this' refers to the object itself.
+// This is a simple object with a method that uses 'this' to refer to its properties.
+
+// Example of 'this' in an object method
+// In an object method, 'this' refers to the object itself.
+
+const user = {
+  userName: "Ashish Choudhary",
+  userAge: 29,
+  userDetails: function () {
+    console.log(this.userName + " is " + this.userAge + " years old.");
+    console.log(this);
+  },
+};
+
+// user.userDetails(); // This will log "Ashish Choudhary is 29 years old." and the user object itself.
+
+function userOne(userName, userAge, loginStatus) {
+  this.userName = userName;
+  this.userAge = userAge;
+  this.loginStatus = loginStatus;
+
+  return this;
+
+  // this.userDetails = function () {
+  //     console.log(this.userName + " is " + this.userAge + " years old.");
+  //     console.log(this);
+  // };
+}
+
+// const userOneobj1 = userOne("Ashish Choudhary", 29, true);  // without new value is overhide ocinstractear fucntion 
+const userOneobj1 = new userOne("Ashish Choudhary", 29, true); 
+const userOneobj2 = new userOne("khushi Choudhary", 25, false);
+
+
+console.log(userOneobj1); 
+console.log(userOneobj2); 
+

14_this_arro/ops.md

@@ -0,0 +1,35 @@
+## This usage in JavaScript
+-- `this` is a keyword in JavaScript that refers to the context in which a function is called. It can be used to access properties and methods of an object.
+-- The value of `this` depends on how a function is called, not where it is defined.
+-- In a regular function, `this` refers to the global object (or `undefined` in strict mode).
+-- In an object method, `this` refers to the object that the method is called on.
+-- In a constructor function, `this` refers to the newly created object.
+
+## Arrow functions and `this`
+-- Arrow functions do not have their own `this` context. Instead, they inherit `this` from the surrounding lexical context.
+-- This means that in an arrow function, `this` refers to the same value as it would in the surrounding code.   
+-- This is useful for preserving the context of `this` in callbacks and event handlers.
+## Example of `this` in a regular function
+```javascript
+function regularFunction() {
+  console.log(this);
+}
+regularFunction(); // In non-strict mode, this will log the global object (window in browsers).
+```
+## Example of `this` in a arrow function
+```javascript
+const arrowFunction = () => {
+  console.log(this);
+};
+arrowFunction(); 
+
+```// In an arrow function, `this` refers to the surrounding context, which is usually the global object or undefined in strict mode.
+```
+
+## New keyword and `this`
+-- The `new` keyword is used to create an instance of an object defined by a constructor function.
+-- When a function is called with `new`, `this` inside that function refers to the newly created object.
+
+
+## Empty `new` keyword output
+-- When you call a constructor function with `new`, it creates a new object and sets `this` to that object.