Получить значение функции по умолчанию?

Поскольку у нас нет классического отражения в JS, которое вы можете найти в C#, Ruby и т. д., мы должны полагаться на один из моих любимых инструментов, регулярные выражения, чтобы сделать эту работу за нас:

let b = "foo";
function fn (x = 10, /* woah */ y = 20, z, a = b) { /* ... */ }

fn.toString()
  .match(/^function\s*[^\(]*\(\s*([^\)]*)\)/m)[1] // Get the parameters declaration between the parenthesis
  .replace(/(\/\*[\s\S]*?\*\/)/mg,'')             // Get rid of comments
  .split(',')
  .reduce(function (parameters, param) {          // Convert it into an object
    param = param.match(/([_$a-zA-Z][^=]*)(?:=([^=]+))?/); // Split parameter name from value
    parameters[param[1].trim()] = eval(param[2]); // Eval each default value, to get strings, variable refs, etc.

    return parameters;
  }, {});

// Object { x: 10, y: 20, z: undefined, a: "foo" }

Если вы собираетесь использовать это, просто убедитесь, что вы кэшируете регулярные выражения для повышения производительности.

Спасибо bubersson за советы по первым двум регулярным выражениям.

Я бы решил это, извлекая параметры из строковой версии функции:

// making x=3 into {x: 3}
function serialize(args) {
  var obj = {};
  var noWhiteSpace = new RegExp(" ", "g");
  args = args.split(",");
  args.forEach(function(arg) {
    arg = arg.split("=");
    var key = arg[0].replace(noWhiteSpace, "");
    obj[key] = arg[1];
  });
  return obj;
  }

 function foo(x=5, y=7, z='foo') {}

// converting the function into a string
var fn = foo.toString();

// magic regex to extract the arguments 
var args = /\(\s*([^)]+?)\s*\)/.exec(fn);

//getting the object
var argMap = serialize(args[1]); //  {x: "5", y: "7", z: "'foo'"}

метод извлечения аргумента был взят отсюда: Регулярное выражение для получения списка параметров из определения функции

ваше здоровье!

PS. как видите, он преобразует целые числа в строки, что иногда может раздражать. просто убедитесь, что вы заранее знаете тип ввода или убедитесь, что это не имеет значения.

Как говорится в вопросе, использование toString является ограниченным решением. Это даст результат, который может быть чем угодно, от литерала значения до вызова метода. Однако это относится к самому языку — он допускает такие объявления. Преобразование всего, что не является буквальным значением, в значение в лучшем случае является эвристическим предположением. Рассмотрим следующие 2 фрагмента кода:

let def;
function withDef(v = def) {
  console.log(v);
}

getDefaultValues(withDef); // undefined, or unknown?

def = prompt('Default value');
withDef();

function wrap() {
  return (new Function(prompt('Function body')))();
  // mutate some other value(s) --> side effects
}

function withDef(v = wrap()) {
  console.log(v);
}
withDef();
getDefaultValues(withDef); // unknown?

В то время как первый пример может быть оценен (при необходимости рекурсивно) для извлечения undefined, а затем для любого другого значения, второй действительно не определен, поскольку значение по умолчанию не является детерминированным. Конечно, вы можете заменить prompt() на любой другой внешний вход/генератор случайных чисел.

Так что лучший ответ тот, который у вас уже есть. Используйте toString и, если хотите, eval() то, что вы извлекаете, но это будет иметь побочные эффекты.

Есть ли способ получить значение по умолчанию x здесь?

Нет, для таких вещей нет встроенной функции отражения, и в любом случае это совершенно невозможно, учитывая то, как параметры по умолчанию спроектированы в JavaScript.

Обратите внимание, что toString()ing функция не будет работать, так как она сломается при значениях по умолчанию, которые не являются постоянными.

Конечно. Единственный способ узнать это — вызвать функцию, так как значения по умолчанию могут зависеть от вызова. Просто подумайте о

function(x, y=x) { … }

и попытайтесь получить разумное представление для значения по умолчанию ys.

В других языках вы можете получить доступ к значениям по умолчанию либо потому, что они являются постоянными (оцениваются во время определения), либо их отражение позволяет вам разбивать выражения и оценивать их в контексте, в котором они были определены.

Напротив, JS оценивает выражения инициализатора параметров при каждом вызове функции (если требуется). параметры? подробнее. И эти выражения, как если бы они были частью тела функции, недоступны программно, так же как любые значения, на которые они ссылаются, скрыты в закрытой области действия функции.
Если у вас есть API-интерфейс отражения, который разрешает доступ к значениям закрытия (например, API отладки движка), вы также можете получить доступ к значениям по умолчанию.

Совершенно невозможно отличить function(x, y=x) {…} от function(x) { var y=x; …} по их общедоступным свойствам или по их поведению, единственный способ - .toString(). И вы не хотите полагаться на это обычно.