CODEWITHSUNDEEP
javascriptnode.jsecmascript-6
user2110845
user2110845

Reputation: 401

Get function parameter length including default params

If you make use of the Function.length property, you get the total amount of arguments that function expects.

However, according to the documentation (as well as actually trying it out), it does not include Default parameters in the count.

This number excludes the rest parameter and only includes parameters before the first one with a default value - Function.length

Is it possible for me to somehow get a count (from outside the function) which includes Default parameters as well?

Upvotes: 6

Views: 1045

Answers (3)

KooiInc
KooiInc

Reputation: 122946

Here is a function to retrieve the 'length' of a function (expression or object) or an arrow function expression (afe). It uses a regular expression to extract the arguments part from the stringified function/afe (the part between () or before =>) and a regular expression to cleanup default values that are strings. After the cleanups, it counts the comma's, depending on the brackets within the arguments string.

Note This will always be an approximation. There are edge cases that won't be covered. See the tests in this Stackblitz snippet

const determineFnLength = fnLenFactory();

console.log(`fnTest.length: ${determineFnLength(fnTest)}`);

function fnTest(a, 
  b, 
  c = 'with escaped \' quote and, comma', 
  d = "and double \" quotes, too!" ) { console.log(`test123`); }

function fnLenFactory() {
  const fnExtractArgsRE = /(^[a-z_](?=(=>|=>{)))|((^\([^)].+\)|\(\))(?=(=>|{)))/g;
  const valueParamsCleanupRE = /(?<=[`"'])([^\`,].+?)(?=[`"'])/g;
  const countArgumentsByBrackets = params => {
    let [commaCount, bracketCount, bOpen, bClose] = [0, 0, [...`([{`], [...`)]}`]];
    [...params].forEach( chr => {
      bracketCount += bOpen.includes(chr) ? 1 : bClose.includes(chr) ? -1 : 0;
      commaCount += chr === ',' && bracketCount === 1 ? 1 : 0; } );
    return commaCount + 1; };
  const extractArgumentsPartFromFunction = fn => {
    let fnStr = fn.toString().replace(RegExp(`\\s|function|${fn.name}`, `g`), ``);
    fnStr = (fnStr.match(fnExtractArgsRE) || [fn])[0]
              .replace(valueParamsCleanupRE, ``);
    return !fnStr.startsWith(`(`) ? `(${fnStr})` : fnStr; };

  return (func, forTest = false) => {
    const params = extractArgumentsPartFromFunction(func);
    const nParams = params === `()` ? 0 : countArgumentsByBrackets(params);
    return forTest ? [params, nParams] : nParams;
  };
}

Upvotes: 0

Mogzol
Mogzol

Reputation: 1405

Copying my answer over to here from a duplicate question:

Well, it's a bit of a mess but I believe this should cover most edge cases.

It works by converting the function to a string and counting the commas, but ignoring commas that are in strings, in function calls, or in objects/arrays. I can't think of any scenarios where this won't return the proper amount, but I'm sure there is one, so this is in no way foolproof, but should work in most cases.

UPDATE: It's been pointed out to me that this won't work for cases such as getNumArgs(a => {}) or getNumArgs(function(a){}.bind(null)), so be aware of that if you try to use this.

function getNumArgs(func) {
  var funcStr = func.toString();
  var commaCount = 0;
  var bracketCount = 0;
  var lastParen = 0;
  var inStrSingle = false;
  var inStrDouble = false;
  for (var i = 0; i < funcStr.length; i++) {
    if (['(', '[', '{'].includes(funcStr[i]) && !inStrSingle && !inStrDouble) {
      bracketCount++;
      lastParen = i;
    } else if ([')', ']', '}'].includes(funcStr[i]) && !inStrSingle && !inStrDouble) {
      bracketCount--;
      if (bracketCount < 1) {
        break;
      }
    } else if (funcStr[i] === "'" && !inStrDouble && funcStr[i - 1] !== '\\') {
      inStrSingle = !inStrSingle;
    } else if (funcStr[i] === '"' && !inStrSingle && funcStr[i - 1] !== '\\') {
      inStrDouble = !inStrDouble;
    } else if (funcStr[i] === ',' && bracketCount === 1 && !inStrSingle && !inStrDouble) {
      commaCount++;
    }
  }

  // Handle no arguments (last opening parenthesis to the last closing one is empty)
  if (commaCount === 0 && funcStr.substring(lastParen + 1, i).trim().length === 0) {
    return 0;
  }

  return commaCount + 1;
}

Here are a few tests I tried it on: https://jsfiddle.net/ekzuvL0c/

Upvotes: 2

Arg0n
Arg0n

Reputation: 8423

Maybe you can parse it yourself, something like:

function getNumArguments(func) {
    var s = func.toString();
    var index1 = s.indexOf('(');
    var index2 = s.indexOf(')');
    return s.substr(index1 + 1, index2 - index1 - 1).split(',').length;
}

console.log(getNumArguments(function(param1, param3 = 'test', ...param2) {})); //3

Upvotes: 2

Related Questions