Does having unused parameters in javascript functions slow down execution? Does it take up memory? I often write functions with parameters that are never actually used for example function has an event as a parameter, but the event is never used for anything.

Does having unused parameters in javascript functions slow down execution? Does it take up memory? I often write functions with parameters that are never actually used for example function has an event as a parameter, but the event is never used for anything.

• javascript
• performance
• optimization

• 6 I often write functions with parameters that are never actually used - Why? O.o – Andreas Commented Jan 8, 2015 at 7:56
• 1 Well I mean, I add parameters when writing the function and then I don't need them later but I may leave them there. And some times you have some sample code that has events or other parameters that aren't needed. I am just wondering if its worth removing those parameters for performance. – Firze Commented Jan 8, 2015 at 7:59
• 1 @Andreas It looks like he is creating DOM event callbacks (addEventHandler), and just adds the event parameter to the function by default, even though it might not be used. Lots of people do this... It also means the arguments are passed (and available in arguments) anyway, making the difference even smaller than it already was. – Martin Tournoij Commented Jan 8, 2015 at 8:04
• It's worth removing unused parameters to keep your code clean - in the function signature as well as the call sites. Since event handlers are passed an event argument anyway you may as well leave those parameters in, for clarity's sake. Either way, if performance or memory consumption is a problem, determine the bottlenecks and look for better algorithms and data structures first. – Pieter Witvoet Commented Jan 8, 2015 at 8:42

4 Answers 4

slow down execution?

The running time depends upon the operation being performed on the input. May it be a search or a sort or any simple operation. The running time of the operation determines the speed of its execution. So when you don't pass any parameter, that means no action is being performed on that parameter and hence the running time is stable.

Does it take up memory?

But as far as memory allocation is concerned, they are generally allocated a Lexical Environment.

When the function runs, on every function call, the new LexicalEnvironment is created and populated with arguments, variables and nested function declarations.

So for the below function:

function sayHi(name) {
/* LexicalEnvironment = { name: passedvalue, 
                        phrase: undefined }*/  // created at this point.
  var phrase = "Hi, " + name
  alert(phrase)
}

So when you invoke it as sayHi(), the lexical envirmonemt looks like:

LexicalEnvironment = { name: undefined, phrase: undefined};

Hence, each parameters and function variables are allocated memory when the interpreter interprets the function.

When the interpreter is preparing to start function code execution, before the first line is run, an empty LexicalEnvironment is created and populated with arguments, local variables and nested functions.

JavaScript anyways stores parameters sent to every function in the arguments array, irrespective of you allocating local variables for them.

function test() {
    console.log(arguments)
}

test('these','are','passed')

//logs ["these','are',passed']

My point is that the unused parameters are anyways taking up memory, you are only referencing them using another variable name.

Does having unused parameters in javascript functions slow down execution?

Probably not in modern engines (it's trivial dead code elimination). Anyway, allocating variables on stack is cheap.

Does it take up memory?

At least few bytes used to save function's body as string.

I often write functions with parameters that are never actually used for example function has an event as a parameter, but the event is never used for anything.

You shouldn't care about micro optimizations without benchmarking. And don't try to outsmart piler, V8 and SpiderMonkey do a great job at optimizing code.

I'm interested in a sub-set of this question: is the code to generate unused parameters evaluated? My use-case is for debug log messages: does leaving in debugging code slow down my script when I set the log level to something less than "debug"? I ran the benchmark test at https://jsperf./log-parameters/1 to find out. That showed that the code was evaluated and did slow down the script.

Test Description

Preparation code

Benchmark.prototype.setup = function() {

  var generate_message = function() {
    // Do some calculations to generate a dummy message.
    var s = ''
    for (var i = 1; i < 512; i++) {
      var a = Math.random()
      var b = Math.random()
      s += String.fromCharCode(48 + Math.floor(128*a*b))
    }
    return s
  }

  var Log = {
    level: 1, /* 1 = FATAL, 4 = DEBUG */
    fatal: function(msg) {this.log(1, msg)},
    debug: function(msg) {this.log(4, msg)},
    log: function(lvl, msg) {
           if (lvl <= this.level) {
             if (typeof msg === 'function') msg = msg()
             console.log([new Date(), lvl, msg].join('::'))
           }
         },
  }

};

Test 1: always evaluate

Log.debug(generate_message())

Test 2: conditionally evaluate

Log.debug(generate_message)

Results

always evaluate

36,047 ±1.45% ops/sec

conditionally evaluate

30,326,171 ±5.55% ops/sec