Differences

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

--- java-script:function-context [2023/08/09 14:44] – odefta
+++ java-script:function-context [2023/08/09 14:52] (current) – odefta
@@ Line 218: / Line 218: @@
 </note>
-==== How to access the context of a parent function inside a nested (child) named function ====
+==== 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 function 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 function's scope.
+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 parentFunction = {
+const parentObject = {
   parentValue: 'Hello from parent!',
   childFunction: function() {
@@ Line 238: / Line 238: @@
 };
-parentFunction.childFunction(); // Outputs: Hello from parent!
+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.