Differences

This shows you the differences between two versions of the page.

--- java-script:function-context [2023/08/09 14:30] – odefta
+++ java-script:function-context [2023/08/09 14:52] (current) – odefta
@@ Line 217: / Line 217: @@
 In the second example, we have defined sayHello as a regular function. **Regular functions have their own this** context, which refers to the object they are called on. So, when we call person.sayHello(), this inside the sayHello method refers to the person object, and this.name evaluates to 'Preston'. The second div (text2) will have the content "**Hello - Preston**".
 </note>
+==== How to access the context of a parent object inside a nested (child) named function ====
+Here we'll need to assign the context of the parent object to a variable that the nested function can access. \\ This is commonly done by **assigning this to a variable, often named self or that**, in the parent object's scope.
+Example:
+<code javascript>
+const parentObject = {
+  parentValue: 'Hello from parent!',
+  childFunction: function() {
+    const self = this; // Storing parent's context
+    function namedFunction() {
+      // Accessing parent's context through 'self'
+      console.log(self.parentValue);
+    }
+    namedFunction();
+  }
+};
+parentObject.childFunction(); // Outputs: Hello from parent!
+</code>
+==== How to access the context of a parent object inside a nested (child) arrow function ====
+Using an **arrow function** can simplify the code because arrow functions **don't have their own this** context; they inherit it from the enclosing function. This means you don't need to store the parent's context in a separate variable. \\
+Same example with arrow function:
+<code javascript>
+const parentObject = {
+  parentValue: 'Hello from parent!',
+  childFunction: function() {
+    const arrowFunction = () => {
+      // Accessing parent's context through 'this' directly
+      console.log(this.parentValue);
+    };
+    arrowFunction();
+  }
+};
+parentObject.childFunction(); // Outputs: Hello from parent!
+</code>
+By using an arrow function for the inner function, we automatically capture the value of this from the enclosing childFunction method. This allows the inner function to access the properties and methods of the parentObject without needing to assign this to a separate variable.
+\\ It's a cleaner and more concise way to write code that depends on maintaining the context of this across different levels of nested functions.