Using Parameterless Functions

Problem You want to take advantage of parameterless functions in JavaScript. Theory JavaScript functions for the most part have parameters. You may think that the previous sentence states the obvious after all, without parameters, what data could be passed to a function? JavaScript has the ability to declare functions that have no parameters, even though the caller of the function has passed parameters to the function. For example, let’s look at an addition function that uses the num1 and num2 parameters.

    Source: /website/ROOT/ajaxrecipes/javascript/parameterlessfunctions.html
    function AddTwoNumbers(num1, num2) {
    return num1 + num2;
 }

The num1 and num2 parameters are added and the result is returned. Solution Another way to write the same function is to drop the parameters and use the arguments object, as follows:

    function AddTwoNumbers() {
    return arguments[0] + arguments[1];
 }

In this modified version of the function, there are no parameters, but the addition is still possible. And if the method is called like this, an addition occurs: AddTwoNumbers( 2, 2); Here the function is passed two parameters, but the function declaration has none. There can be one, two, or ten parameters it does not matter. Maybe one, or two, or ten of all the parameters will be assigned, or maybe none of them will be assigned. This uncertainty poses an additional challenge because you are left wondering if the parameter is assigned or not. For example, consider the following function declaration.

    Source: /website/ROOT/ajaxrecipes/javascript/parameterlessfunctions.html
    function TooManyParametersNotEnoughArguments(  param1, param2, param3) {
    info(  "TooManyParametersNotEnoughArguments", typeof( param3));
    assertEquals( "undefined", typeof(  param3));
 }

The TooManyParametersNotEnoughArguments function expects three parameters, but it is going to be called with only two parameters, as illustrated by the following calling code: TooManyParametersNotEnoughArguments( 1, 2); There is a disjoint between the caller and the function, and the third parameter is left dangling. To see if a parameter is left dangling, you use the typeof operator and test if the result is undefined.

Do not test for a null value because the third parameter is not null; it is undefined. As a general rule of thumb, don’t use null as a way of testing state. null is ambiguous and can mean different things in different contexts. The value of undefined is not ambiguous it clearly indicates that the variable has not been assigned. Another way of testing whether or not the third parameter has been assigned is to see how many arguments have been passed to the function, as illustrated by the following modified TooManyParametersNotEnoughArguments function:

    function TooManyParametersNotEnoughArguments(  param1, param2, param3) {
    info(  "TooManyParametersNotEnoughArguments", typeof( param3));
    assertEquals( "undefined", typeof(  param3));
    assertEquals(  2, arguments.length);
 }

The bold code is an additional test of the argument.length property that verifies the caller of TooManyParametersNotEnoughArguments is passing in only two arguments. The arguments object is defined locally in the context of the function, thus the arguments instance of one function call will not match the arguments call of another function. It’s important to realize that arguments are arrays that you can manipulate. When you implement functions that have no parameters, you should consider the following:

• If you implement a function and it is declared with three parameters, don’t expect the function to be called with more or fewer parameters. Coding with JavaScript is about convention and expectations. Code with more or fewer parameters when a certain number is expected confuses the developer.

• If you are going to accept a varying number of arguments, then declare the function without arguments, meaning that you will use the arguments objects. Somebody who then reads the function understands that the function will accept a varying number of parameters, again fulfilling the expectations requirement when writing JavaScript code.

• If you declare a function without parameters, and you will be using one index of the arguments object throughout the function, consider assigning the index to a variable identifier so that the parameter’s purpose is apparent.

• If you are going to accept a variable number of arguments, remember to generate explicit and verbose errors whenever you expect more or fewer arguments.