Comments on: arguments: A JavaScript Oddity

By: eric d.

eric d. — Mon, 19 Jan 2009 14:01:46 +0000

Hi, thanks for that brilliant article. Made a lot of things a lot clearer! Note: new RegExp("%([1-" + arguments.length + "])", "g"); will fail passed 9 arguments (the regexp would be "%([1-10])" so it will only match %0 and %1). I think an easy fix would be something like:

function format(string) {
  var args = arguments;
  var pattern = new RegExp("%([0-9]+)", "g");
  return String(string).replace(pattern, function(match, index) {
    if (index == 0 || index >= args.length)
      throw "Invalid index in format string";
    return args[index];
  });  
	};

(Sorry for nitpicking, I understand it was only an example and brevety is the main objective, but its a great function to have)

By: brothercake

brothercake — Thu, 13 Nov 2008 01:16:22 +0000

But don’t use arguments just for the sake of it – only if you really need to access them as a collection – because this:

function colorize() { ... }

is not as easy to understand at a glance, as this:

function colorize(foreground, background) { ... }

By: polvero

polvero — Wed, 12 Nov 2008 19:57:46 +0000

instead of…
var args = Array.prototype.slice.call(arguments);
do this…
var args = [].slice.call(arguments, 0);

By: Andrew Tetlaw

Andrew Tetlaw — Wed, 12 Nov 2008 00:21:28 +0000

Trep, yeah I didn't explain the closures that are used in the above code. you'll notice the variable times, is passed to the outer function, but used in the anonymous function. Which is fine, JavaScript let's us do that. However, every time a function is called the local variable arguments is created. So I can use it safely inside the inner anonymous function here:

fn.apply(null, arguments);

Because I know that when that anonymous function is eventually called, arguments will contain the arguments that are supplied at the time it's called, not at the time when we are defining the anonymous function. However, to use setTimeout I have to create yet another anonymous function, the one that calls apply:

function(){self.apply(null,args)}

However, to the apply call I need to pass the original arguments that were supplied to the outer anonymous function... so I use yet another closure:

var args = Array.prototype.slice.call(arguments);

The args variable is defined in the outer anonymous function, but used within the inner anonymous function. Phew!

By: Trep

Trep — Wed, 12 Nov 2008 00:07:27 +0000

Errata: the third paragraph should read:
«I made some experiments and it works just as well if you call it on the “args” array created by splicing “arguments”».

By: Trep

Trep — Wed, 12 Nov 2008 00:05:04 +0000

Hmmm… that repeat() function is really one of those little thingy to sit down and meditate on! ;-)
-

I was wondering: the “apply” method should take an array as its second argument, yet you call it successfully as
–
fn.apply(null, arguments);
–
if made some experiments and it works just as well if you call on the “args” array created by splicing “arguments”.
-
On the other hand “self.apply(null,args)” doesn’t work if you call it on “arguments” instead of “args”.
-
Hm… ok, I got it. “self.apply(null,args)” is inside another anonymous function so “arguments” get stomped over by the new one. The power of meditation!

By: Jesse

Jesse — Tue, 11 Nov 2008 23:56:29 +0000

Don’t get me wrong, I’m a big fan of Javascript and consider it one of the most expressive languages I’ve worked with, but while it allows for some incredibly elegant solutions to problems, it also fosters a tremendous amount in-elegance in readability and clarity of purpose. I was just wondering if there are any best-practices for code layout, naming, commenting, beyond the usual programming conventions.

By: awasson

awasson — Tue, 11 Nov 2008 23:33:30 +0000

Really cool article!

A couple of years ago I stumbled upon the arguments variable while writing a quick-n-dirty slideshow script. I only learned enough to do the job so it’s great to get some more insight & info from your article.

Thanks,
Andrew

By: Andrew Tetlaw

Andrew Tetlaw — Tue, 11 Nov 2008 22:58:17 +0000

Jessie, yeah, it’s hard to write, hard to work out what the code does if you didn’t write it, and just as hard to explain what it’s dong in a blog post like this :)

There’s lots of invisible forces at work, especially regarding scope. But once, you are familiar with the patterns, you can identify and write them easy enough.

It makes JavaScript so expressive though, and that makes it worth persisting with.

By: Andrew Tetlaw

Andrew Tetlaw — Tue, 11 Nov 2008 22:29:42 +0000

Dougal, you're right! Sorry for making such a noob mistake. The correct way to check is this:

  var a = [];
  alert(a.constructor.toString());

In Firefox that will return:

function Array() { [native code] }

Inside a function, if you call:

  alert(arguments.constructor.toString());

You'll get:

function Object() { [native code] }