This post was mentioned on Twitter by major_code: http://tinyurl.com/cwomvm
A Better Javascript Memoizer | Unscriptable.com…

    var arity = func.arity || func.length;
    return memoizeArg(arity ? arity - 1 : 0);

-m

On the surface, Nicolas’ implementation looks good, but it’s not robust. Here’s why:

1. It adds properties to the function instance, f.
2. args.toString() is not guaranteed to be unique for all combinations of arguments.

Regarding the first point, any general-purpose function should avoid interfering with other code as much as possible. By assigning properties to the function instance, you have limited the calling code from using a similarly-named property on the function instance. This may seem like a minor point, but if all general-purpose functions worked this way, we’d eventually encounter conflicts — and this would result in some really nasty debugging sessions.

The second point is much more important. All Javascript property names must be strings, so the array is serialized to a string when it is used as a property name (f.memoized[args]). In Javascript, Arrays serialze to a CSV-like representation. For example, [1, 2, 3, 'foo'] will serialize to “1,2,3,foo”. This becomes a problem when objects are introduced — or even strings containing commas. Here’s what you’d get when you pass the following arguments:

[1, 'commas,are,in,here', {foo: 'bar'}] ⇒ “1,commas,are,in,here,[object Object]”

Unfortunately, the following arguments yield the same exact property name when serialized:

[1, 'commas', 'are', 'in', 'here', {prop: 'val'}] ⇒ “1,commas,are,in,here,[object Object]“

function memoize(f) {
  return function () {
      var args = Array.prototype.slice.call(arguments);
      f.memoized = f.memoized || {};
      return (args in f.memoized) ?
        f.memoized[args] :
        f.memoized[args] = f.apply(this, args);
  };
}

Courtesy of http://blog.thejit.org/