javascript

Chapter 3: Language Basics
It’s recommended that a function either always return a value or never return a value. Writing a
function that sometimes returns a value causes confusion, especially during debugging.
Understanding Arguments
Function arguments in ECMAScript don ’ t behave in the same way as function arguments in most other
languages. An ECMAScript function doesn ’ t care how many arguments are passed in, nor does it care
about the data types of those arguments. Just because you define a function to accept two arguments
doesn ’ t mean you can pass in only two arguments. You could pass in one or three or none, and the
interpreter won ’ t complain. This happens because arguments in ECMAScript are represented as an array
internally. The array is always passed to the function, but the function doesn ’ t care what (if anything) is
in the array. If the array arrives with zero items, that ’ s fine; if it arrives with more, that ’ s okay too. In fact,
there actually is an arguments object that can be accessed while inside a function to retrieve the values
of each argument that was passed in.
The arguments object acts like an array (though it isn ’ t an instance of Array ) in that you can access each
argument using bracket notation (the first argument is arguments[0] , the second is arguments[1] ,
and so on) and determine how many arguments were passed in by using the length property. In the
previous example, the sayHi() function ’ s first argument is named name . The same value can be
accessed by referencing arguments[0] . Therefore, the function can be rewritten without naming the
arguments explicitly, like this:
function sayHi() {
alert(“Hello “ + arguments[0] + “,” + arguments[1]);
}
In this rewritten version of the function, there are no named arguments. The name and message
arguments have been removed, yet the function will behave appropriately. This illustrates an important
point about functions in ECMAScript: named arguments are a convenience, not a necessity. Unlike in
other languages, naming your arguments in ECMAScript does not create a function signature that must
be matched later on; there is no validation against named arguments.
The arguments object can also be used to check the number of arguments passed into the function via
the length property. The following example outputs the number of arguments passed into the function
each time it is called:
function howManyArgs() {
alert(arguments.length);
}
howManyArgs(“string”, 45); //2
howManyArgs(); //0
howManyArgs(12); //1
74