Changing JavaScript function's parameter value using arguments array not working
I am learning JavaScript and am pretty confused with the arguments property array. Let me elaborate.
I have a function that takes a single argument and returns it. When I am passing the parameter and reassigning it using arguments[0] = value
, it's updating the value.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
But when I call the same function with no parameters it return undefined.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
also if I pass undefined then also the value is updating.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
I thought if you do not pass a parameter to a JavaScript function it automatically creates it and assigns the value to undefined and after updating it should reflect the updated value right? Also a()
and a(undefined)
are the same thing right?
javascript arrays function arguments variable-assignment
add a comment |
I am learning JavaScript and am pretty confused with the arguments property array. Let me elaborate.
I have a function that takes a single argument and returns it. When I am passing the parameter and reassigning it using arguments[0] = value
, it's updating the value.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
But when I call the same function with no parameters it return undefined.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
also if I pass undefined then also the value is updating.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
I thought if you do not pass a parameter to a JavaScript function it automatically creates it and assigns the value to undefined and after updating it should reflect the updated value right? Also a()
and a(undefined)
are the same thing right?
javascript arrays function arguments variable-assignment
add a comment |
I am learning JavaScript and am pretty confused with the arguments property array. Let me elaborate.
I have a function that takes a single argument and returns it. When I am passing the parameter and reassigning it using arguments[0] = value
, it's updating the value.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
But when I call the same function with no parameters it return undefined.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
also if I pass undefined then also the value is updating.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
I thought if you do not pass a parameter to a JavaScript function it automatically creates it and assigns the value to undefined and after updating it should reflect the updated value right? Also a()
and a(undefined)
are the same thing right?
javascript arrays function arguments variable-assignment
I am learning JavaScript and am pretty confused with the arguments property array. Let me elaborate.
I have a function that takes a single argument and returns it. When I am passing the parameter and reassigning it using arguments[0] = value
, it's updating the value.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
But when I call the same function with no parameters it return undefined.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
also if I pass undefined then also the value is updating.
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
I thought if you do not pass a parameter to a JavaScript function it automatically creates it and assigns the value to undefined and after updating it should reflect the updated value right? Also a()
and a(undefined)
are the same thing right?
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(1)); //returns 2
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a()); //returns undefined
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
function a(b) {
arguments[0] = 2;
return b;
}
console.log(a(undefined)); //returns 2
javascript arrays function arguments variable-assignment
javascript arrays function arguments variable-assignment
edited 15 mins ago
Islam Elshobokshy
2,3301428
2,3301428
asked 31 mins ago
Amit DasAmit Das
8910
8910
add a comment |
add a comment |
6 Answers
6
active
oldest
votes
Assigning to arguments
indicies will only change the associated argument value (let's call it the n
-th argument) if the function was called with at least n
arguments. The arguments
object's numeric-indexed properties are essentially setters (and getters):
http://es5.github.io/#x10.6
Italics in the below are my comments on how the process relates to the question:
(Let)
args
(be) the actual arguments passed to the [[Call]] internal method
Let
len
be the number of elements in args.
Let
indx
=len - 1
.
Repeat while
indx >= 0
, (so, the below loop will not run when no arguments are passed to the function:)
(assign to the arguments object being created, here called
map
:)
- Add
name
as an element of the listmappedNames
.
- Let
g
be the result of calling theMakeArgGetter
abstract operation with argumentsname
andenv
.
- Let
p
be the result of calling theMakeArgSetter
abstract operation with argumentsname
andenv
.
- Call the [[DefineOwnProperty]] internal method of
map
passing ToString(indx
), the Property Descriptor {[[Set]]:p
, [[Get]]:g
, [[Configurable]]:true
}, andfalse
as arguments.
So, if the function is invoked with no arguments, there will not be a setter on arguments[0]
, so reassigning it won't change the parameter at index 0.
The same sort of thing occurs for other indicies as well - if you invoke a function with 1 parameter, but the function accepts two parameters, assigning to arguments[1]
will not change the second parameter, because arguments[1]
does not have a setter:
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
So
a()
anda(undefined)
are the same thing right?
is not the case, because the second results in an arguments
object with a setter and a getter on index 0, while the first doesn't.
add a comment |
ECMA 262 9.0 2018 describes this behaviour in 9.4.4 Arguments Exotic Objects with
NOTE 1:
The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
In short,
if in
'sloppy mode'
, then all arguments are mapped to there named variables, if the length correspond to the given parameter, orif in
'strict mode'
, then the binding is lost after handing over the arguments.
Whis is only readable in an older version in ECMA 262 7.0 2016 describes this behaviour in 9.4.4 Arguments Exotic Objects with
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
add a comment |
This is the undefined value definition from javascript spec :
primitive value used when a variable has not been assigned a value.
so if you do not specify the function return type it will return undefined.
so a() and a(undefined) it is not same thing. returning undefined is based on return type is defined or not.
for more clarification similar_problem
New contributor
add a comment |
it's because arguments it's not like a Array, it's a object with integer indexed data keys, and property length, And if length equal zero it's mean you don't have a arguments
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
add a comment |
When you are not providing any parameter then arguments
array has length
equal to 0. Then you are trying to set the non existing element of array to 2
which causes returning undefined
You can simply test this with this snippet:
function a(b){
alert(arguments.length) // It will prompt 0 when calling a() and 1 when calling a(undefined)
arguments[0] = 2;
return b;
}
add a comment |
My understanding is that the arguments object only tracks what is passed into the function. Since you've not initially passed anything, b
is not bound and at that point arguments
is not 'tracking' b
. Next, you assign a value to the initialised but empty Array-like object arguments
and finally return b, which is undefined.
To delve into this further:
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
and
function func(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func(10); // 99
When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
func(10); // 10
and
function func(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
func(10); // 10
and
// An untracked default parameter
function func(a = 55) {
console.log(arguments[0]);
}
func(); // undefined
Source: MDN Web docs
"at that point arguments is undefined" - that's not true.arguments
is not undefined - it has only length equal to0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
add a comment |
Your Answer
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54323086%2fchanging-javascript-functions-parameter-value-using-arguments-array-not-working%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
6 Answers
6
active
oldest
votes
6 Answers
6
active
oldest
votes
active
oldest
votes
active
oldest
votes
Assigning to arguments
indicies will only change the associated argument value (let's call it the n
-th argument) if the function was called with at least n
arguments. The arguments
object's numeric-indexed properties are essentially setters (and getters):
http://es5.github.io/#x10.6
Italics in the below are my comments on how the process relates to the question:
(Let)
args
(be) the actual arguments passed to the [[Call]] internal method
Let
len
be the number of elements in args.
Let
indx
=len - 1
.
Repeat while
indx >= 0
, (so, the below loop will not run when no arguments are passed to the function:)
(assign to the arguments object being created, here called
map
:)
- Add
name
as an element of the listmappedNames
.
- Let
g
be the result of calling theMakeArgGetter
abstract operation with argumentsname
andenv
.
- Let
p
be the result of calling theMakeArgSetter
abstract operation with argumentsname
andenv
.
- Call the [[DefineOwnProperty]] internal method of
map
passing ToString(indx
), the Property Descriptor {[[Set]]:p
, [[Get]]:g
, [[Configurable]]:true
}, andfalse
as arguments.
So, if the function is invoked with no arguments, there will not be a setter on arguments[0]
, so reassigning it won't change the parameter at index 0.
The same sort of thing occurs for other indicies as well - if you invoke a function with 1 parameter, but the function accepts two parameters, assigning to arguments[1]
will not change the second parameter, because arguments[1]
does not have a setter:
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
So
a()
anda(undefined)
are the same thing right?
is not the case, because the second results in an arguments
object with a setter and a getter on index 0, while the first doesn't.
add a comment |
Assigning to arguments
indicies will only change the associated argument value (let's call it the n
-th argument) if the function was called with at least n
arguments. The arguments
object's numeric-indexed properties are essentially setters (and getters):
http://es5.github.io/#x10.6
Italics in the below are my comments on how the process relates to the question:
(Let)
args
(be) the actual arguments passed to the [[Call]] internal method
Let
len
be the number of elements in args.
Let
indx
=len - 1
.
Repeat while
indx >= 0
, (so, the below loop will not run when no arguments are passed to the function:)
(assign to the arguments object being created, here called
map
:)
- Add
name
as an element of the listmappedNames
.
- Let
g
be the result of calling theMakeArgGetter
abstract operation with argumentsname
andenv
.
- Let
p
be the result of calling theMakeArgSetter
abstract operation with argumentsname
andenv
.
- Call the [[DefineOwnProperty]] internal method of
map
passing ToString(indx
), the Property Descriptor {[[Set]]:p
, [[Get]]:g
, [[Configurable]]:true
}, andfalse
as arguments.
So, if the function is invoked with no arguments, there will not be a setter on arguments[0]
, so reassigning it won't change the parameter at index 0.
The same sort of thing occurs for other indicies as well - if you invoke a function with 1 parameter, but the function accepts two parameters, assigning to arguments[1]
will not change the second parameter, because arguments[1]
does not have a setter:
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
So
a()
anda(undefined)
are the same thing right?
is not the case, because the second results in an arguments
object with a setter and a getter on index 0, while the first doesn't.
add a comment |
Assigning to arguments
indicies will only change the associated argument value (let's call it the n
-th argument) if the function was called with at least n
arguments. The arguments
object's numeric-indexed properties are essentially setters (and getters):
http://es5.github.io/#x10.6
Italics in the below are my comments on how the process relates to the question:
(Let)
args
(be) the actual arguments passed to the [[Call]] internal method
Let
len
be the number of elements in args.
Let
indx
=len - 1
.
Repeat while
indx >= 0
, (so, the below loop will not run when no arguments are passed to the function:)
(assign to the arguments object being created, here called
map
:)
- Add
name
as an element of the listmappedNames
.
- Let
g
be the result of calling theMakeArgGetter
abstract operation with argumentsname
andenv
.
- Let
p
be the result of calling theMakeArgSetter
abstract operation with argumentsname
andenv
.
- Call the [[DefineOwnProperty]] internal method of
map
passing ToString(indx
), the Property Descriptor {[[Set]]:p
, [[Get]]:g
, [[Configurable]]:true
}, andfalse
as arguments.
So, if the function is invoked with no arguments, there will not be a setter on arguments[0]
, so reassigning it won't change the parameter at index 0.
The same sort of thing occurs for other indicies as well - if you invoke a function with 1 parameter, but the function accepts two parameters, assigning to arguments[1]
will not change the second parameter, because arguments[1]
does not have a setter:
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
So
a()
anda(undefined)
are the same thing right?
is not the case, because the second results in an arguments
object with a setter and a getter on index 0, while the first doesn't.
Assigning to arguments
indicies will only change the associated argument value (let's call it the n
-th argument) if the function was called with at least n
arguments. The arguments
object's numeric-indexed properties are essentially setters (and getters):
http://es5.github.io/#x10.6
Italics in the below are my comments on how the process relates to the question:
(Let)
args
(be) the actual arguments passed to the [[Call]] internal method
Let
len
be the number of elements in args.
Let
indx
=len - 1
.
Repeat while
indx >= 0
, (so, the below loop will not run when no arguments are passed to the function:)
(assign to the arguments object being created, here called
map
:)
- Add
name
as an element of the listmappedNames
.
- Let
g
be the result of calling theMakeArgGetter
abstract operation with argumentsname
andenv
.
- Let
p
be the result of calling theMakeArgSetter
abstract operation with argumentsname
andenv
.
- Call the [[DefineOwnProperty]] internal method of
map
passing ToString(indx
), the Property Descriptor {[[Set]]:p
, [[Get]]:g
, [[Configurable]]:true
}, andfalse
as arguments.
So, if the function is invoked with no arguments, there will not be a setter on arguments[0]
, so reassigning it won't change the parameter at index 0.
The same sort of thing occurs for other indicies as well - if you invoke a function with 1 parameter, but the function accepts two parameters, assigning to arguments[1]
will not change the second parameter, because arguments[1]
does not have a setter:
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
So
a()
anda(undefined)
are the same thing right?
is not the case, because the second results in an arguments
object with a setter and a getter on index 0, while the first doesn't.
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
function fn(a, b) {
arguments[1] = 'bar';
console.log(b);
}
fn('foo');
edited 5 mins ago
answered 11 mins ago
CertainPerformanceCertainPerformance
81.6k143966
81.6k143966
add a comment |
add a comment |
ECMA 262 9.0 2018 describes this behaviour in 9.4.4 Arguments Exotic Objects with
NOTE 1:
The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
In short,
if in
'sloppy mode'
, then all arguments are mapped to there named variables, if the length correspond to the given parameter, orif in
'strict mode'
, then the binding is lost after handing over the arguments.
Whis is only readable in an older version in ECMA 262 7.0 2016 describes this behaviour in 9.4.4 Arguments Exotic Objects with
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
add a comment |
ECMA 262 9.0 2018 describes this behaviour in 9.4.4 Arguments Exotic Objects with
NOTE 1:
The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
In short,
if in
'sloppy mode'
, then all arguments are mapped to there named variables, if the length correspond to the given parameter, orif in
'strict mode'
, then the binding is lost after handing over the arguments.
Whis is only readable in an older version in ECMA 262 7.0 2016 describes this behaviour in 9.4.4 Arguments Exotic Objects with
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
add a comment |
ECMA 262 9.0 2018 describes this behaviour in 9.4.4 Arguments Exotic Objects with
NOTE 1:
The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
In short,
if in
'sloppy mode'
, then all arguments are mapped to there named variables, if the length correspond to the given parameter, orif in
'strict mode'
, then the binding is lost after handing over the arguments.
Whis is only readable in an older version in ECMA 262 7.0 2016 describes this behaviour in 9.4.4 Arguments Exotic Objects with
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
ECMA 262 9.0 2018 describes this behaviour in 9.4.4 Arguments Exotic Objects with
NOTE 1:
The integer-indexed data properties of an arguments exotic object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. If the arguments object is an ordinary object, the values of its properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
In short,
if in
'sloppy mode'
, then all arguments are mapped to there named variables, if the length correspond to the given parameter, orif in
'strict mode'
, then the binding is lost after handing over the arguments.
Whis is only readable in an older version in ECMA 262 7.0 2016 describes this behaviour in 9.4.4 Arguments Exotic Objects with
For non-strict functions the integer indexed data properties of an arguments object whose numeric name values are less than the number of formal parameters of the corresponding function object initially share their values with the corresponding argument bindings in the function's execution context. This means that changing the property changes the corresponding value of the argument binding and vice-versa. This correspondence is broken if such a property is deleted and then redefined or if the property is changed into an accessor property. For strict mode functions, the values of the arguments object's properties are simply a copy of the arguments passed to the function and there is no dynamic linkage between the property values and the formal parameter values.
edited 38 secs ago
answered 25 mins ago
Nina ScholzNina Scholz
180k1492160
180k1492160
add a comment |
add a comment |
This is the undefined value definition from javascript spec :
primitive value used when a variable has not been assigned a value.
so if you do not specify the function return type it will return undefined.
so a() and a(undefined) it is not same thing. returning undefined is based on return type is defined or not.
for more clarification similar_problem
New contributor
add a comment |
This is the undefined value definition from javascript spec :
primitive value used when a variable has not been assigned a value.
so if you do not specify the function return type it will return undefined.
so a() and a(undefined) it is not same thing. returning undefined is based on return type is defined or not.
for more clarification similar_problem
New contributor
add a comment |
This is the undefined value definition from javascript spec :
primitive value used when a variable has not been assigned a value.
so if you do not specify the function return type it will return undefined.
so a() and a(undefined) it is not same thing. returning undefined is based on return type is defined or not.
for more clarification similar_problem
New contributor
This is the undefined value definition from javascript spec :
primitive value used when a variable has not been assigned a value.
so if you do not specify the function return type it will return undefined.
so a() and a(undefined) it is not same thing. returning undefined is based on return type is defined or not.
for more clarification similar_problem
New contributor
New contributor
answered 12 mins ago
sathish kumarsathish kumar
111
111
New contributor
New contributor
add a comment |
add a comment |
it's because arguments it's not like a Array, it's a object with integer indexed data keys, and property length, And if length equal zero it's mean you don't have a arguments
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
add a comment |
it's because arguments it's not like a Array, it's a object with integer indexed data keys, and property length, And if length equal zero it's mean you don't have a arguments
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
add a comment |
it's because arguments it's not like a Array, it's a object with integer indexed data keys, and property length, And if length equal zero it's mean you don't have a arguments
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
it's because arguments it's not like a Array, it's a object with integer indexed data keys, and property length, And if length equal zero it's mean you don't have a arguments
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
function a(b) {
arguments[0] = 2;
console.log(arguments.length)
return b;
}
a(1); // length 1 returns 2
console.log(a()); // length 0 returns undefined
answered 21 mins ago
Vadim HulevichVadim Hulevich
6359
6359
add a comment |
add a comment |
When you are not providing any parameter then arguments
array has length
equal to 0. Then you are trying to set the non existing element of array to 2
which causes returning undefined
You can simply test this with this snippet:
function a(b){
alert(arguments.length) // It will prompt 0 when calling a() and 1 when calling a(undefined)
arguments[0] = 2;
return b;
}
add a comment |
When you are not providing any parameter then arguments
array has length
equal to 0. Then you are trying to set the non existing element of array to 2
which causes returning undefined
You can simply test this with this snippet:
function a(b){
alert(arguments.length) // It will prompt 0 when calling a() and 1 when calling a(undefined)
arguments[0] = 2;
return b;
}
add a comment |
When you are not providing any parameter then arguments
array has length
equal to 0. Then you are trying to set the non existing element of array to 2
which causes returning undefined
You can simply test this with this snippet:
function a(b){
alert(arguments.length) // It will prompt 0 when calling a() and 1 when calling a(undefined)
arguments[0] = 2;
return b;
}
When you are not providing any parameter then arguments
array has length
equal to 0. Then you are trying to set the non existing element of array to 2
which causes returning undefined
You can simply test this with this snippet:
function a(b){
alert(arguments.length) // It will prompt 0 when calling a() and 1 when calling a(undefined)
arguments[0] = 2;
return b;
}
answered 15 mins ago
puffy.bunpuffy.bun
1205
1205
add a comment |
add a comment |
My understanding is that the arguments object only tracks what is passed into the function. Since you've not initially passed anything, b
is not bound and at that point arguments
is not 'tracking' b
. Next, you assign a value to the initialised but empty Array-like object arguments
and finally return b, which is undefined.
To delve into this further:
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
and
function func(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func(10); // 99
When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
func(10); // 10
and
function func(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
func(10); // 10
and
// An untracked default parameter
function func(a = 55) {
console.log(arguments[0]);
}
func(); // undefined
Source: MDN Web docs
"at that point arguments is undefined" - that's not true.arguments
is not undefined - it has only length equal to0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
add a comment |
My understanding is that the arguments object only tracks what is passed into the function. Since you've not initially passed anything, b
is not bound and at that point arguments
is not 'tracking' b
. Next, you assign a value to the initialised but empty Array-like object arguments
and finally return b, which is undefined.
To delve into this further:
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
and
function func(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func(10); // 99
When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
func(10); // 10
and
function func(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
func(10); // 10
and
// An untracked default parameter
function func(a = 55) {
console.log(arguments[0]);
}
func(); // undefined
Source: MDN Web docs
"at that point arguments is undefined" - that's not true.arguments
is not undefined - it has only length equal to0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
add a comment |
My understanding is that the arguments object only tracks what is passed into the function. Since you've not initially passed anything, b
is not bound and at that point arguments
is not 'tracking' b
. Next, you assign a value to the initialised but empty Array-like object arguments
and finally return b, which is undefined.
To delve into this further:
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
and
function func(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func(10); // 99
When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
func(10); // 10
and
function func(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
func(10); // 10
and
// An untracked default parameter
function func(a = 55) {
console.log(arguments[0]);
}
func(); // undefined
Source: MDN Web docs
My understanding is that the arguments object only tracks what is passed into the function. Since you've not initially passed anything, b
is not bound and at that point arguments
is not 'tracking' b
. Next, you assign a value to the initialised but empty Array-like object arguments
and finally return b, which is undefined.
To delve into this further:
If a non-strict function does not contain rest, default, or destructured parameters, then the values in the arguments object do change in sync with the values of the argument variables. See the code below:
function func(a) {
arguments[0] = 99; // updating arguments[0] also updates a
console.log(a);
}
func(10); // 99
and
function func(a) {
a = 99; // updating a also updates arguments[0]
console.log(arguments[0]);
}
func(10); // 99
When a non-strict function does contain rest, default, or destructured parameters, then the values in the arguments object do not track the values of the arguments. Instead, they reflect the arguments provided when the function was called:
function func(a = 55) {
arguments[0] = 99; // updating arguments[0] does not also update a
console.log(a);
}
func(10); // 10
and
function func(a = 55) {
a = 99; // updating a does not also update arguments[0]
console.log(arguments[0]);
}
func(10); // 10
and
// An untracked default parameter
function func(a = 55) {
console.log(arguments[0]);
}
func(); // undefined
Source: MDN Web docs
edited 7 mins ago
answered 16 mins ago
BarzevBarzev
6810
6810
"at that point arguments is undefined" - that's not true.arguments
is not undefined - it has only length equal to0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
add a comment |
"at that point arguments is undefined" - that's not true.arguments
is not undefined - it has only length equal to0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
"at that point arguments is undefined" - that's not true.
arguments
is not undefined - it has only length equal to 0
– puffy.bun
14 mins ago
"at that point arguments is undefined" - that's not true.
arguments
is not undefined - it has only length equal to 0
– puffy.bun
14 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
@puffy.bun you're absolutely right, I've updated my answer
– Barzev
9 mins ago
add a comment |
Thanks for contributing an answer to Stack Overflow!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
To learn more, see our tips on writing great answers.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f54323086%2fchanging-javascript-functions-parameter-value-using-arguments-array-not-working%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown