JavaScript, this and arguments in JS

Function Context Variables Explained
When a JavaScript function is invoked then two variables - this and arguments - are automatically created. Comment.
Answer: Yes, in JavaScript, when a function is invoked, two special variables, 'this' and 'arguments', are automatically created within the function context.The 'this' keyword in JavaScript refers to the object that the function is a property of. Its value is determined by how a function is called (runtime binding). Here's how it typically behaves in different scenarios:
- Global Context: When a function is called in the global context (i.e., not as a method of an object), 'this' refers to the global object (window in browsers, global in Node.js). In strict mode, 'this' is 'undefined'.

function globalFunction() {
console.log(this); // In non-strict mode, it logs the global object (window)
}
globalFunction();

- Method Context: When a function is called as a method of an object, 'this' refers to the object that the method is called on.

const obj = {
method: function() {
console.log(this); // Logs obj
}
};
obj.method();

- Constructor Context: When a function is used as a constructor (with the 'new' keyword), 'this' refers to the newly created instance.

function ConstructorFunction() {
console.log(this); // Logs the new instance
}
const instance = new ConstructorFunction();

- Explicit Binding: Using 'call', 'apply', or 'bind', you can explicitly set 'this'.

function exampleFunction() {
console.log(this);
}
const obj = { value: 42 };
exampleFunction.call(obj); // Logs obj
The 'arguments' object is an array-like object accessible inside functions that contains the values of the arguments passed to that function.
- Array-like: Although it is not a real array, it has a length property and can be accessed using index notation.

function exampleFunction() {
console.log(arguments); // Logs the arguments object
console.log(arguments[0]); // Logs the first argument
}
exampleFunction(1, 2, 3); // Logs [1, 2, 3] and 1

- Function Arguments: It allows functions to handle more arguments than they are formally declared to accept.

function sum() {
let total = 0;
for (let i = 0; i < arguments.length; i++) {
total += arguments[i];
}
return total;
}
console.log(sum(1, 2, 3, 4)); // Logs 10

- Not Available in Arrow Functions: The 'arguments' object is not available in arrow functions. Instead, they capture the 'arguments' object of the nearest non-arrow function.

function exampleFunction() {
const arrowFunction = () => {
console.log(arguments); // Logs the arguments object of exampleFunction
};
arrowFunction(4, 5, 6);
}
exampleFunction(1, 2, 3); // Logs [1, 2, 3]

Understanding how 'this' and 'arguments' work is fundamental to mastering function behavior and scope in JavaScript.