假设我有一个变量 myvar，而我没有有一个变量 myvar2。我可以毫无问题地运行以下命令:

typeof myvar
// ⇒ 'string'
typeof myvar2
// ⇒ 'undefined'

typeof 和 delete 是我所知道的唯一在给定这样的未定义参数时不会抛出错误的函数。我看了the language spec for typeof在我外行看来，它似乎使用了 IsUnresolvableReference 等内部函数。

^{Edit: I'd been working in a language that checks type with a synonymous function, and hadn't noticed typeof is actually an operator in JavaScript. I've removed parentheses from the code here but left the above as written.}

当我创建一个函数时:

function myFunc(input_variable) {
  return("hello");
}

...正如预期的那样，当将 myvar2 作为参数传递时，这会抛出一个 ReferenceError，除非我运行 var myvar2;。

如果我将返回包装在 try/catch 语句中以处理 myvar2 not defined 情况，我仍然会遇到相同的错误，因为变量似乎在进入函数时(在运行时？)检查了可解析的引用:

function myFunc(input_var) {
  try {
    return "hello";
  } catch(error) {
    if (error.name === 'ReferenceError'){
      return "world";
    }
  }
}

我想知道如何创建一个接受未解析引用的函数。我的一般猜测是，如果它是函数的标准行为，那么也许我可以专门为此构造修改一些原型(prototype)......？我知道原型(prototype)是针对对象的，我想知道是否可以通过某种方式对 function 进行这种级别的控制？

根据上下文，我总是发现自己在写 function(input_var) :

if (typeof input_var == 'undefined' || my_settings.input_var_is_optional === true)
  var input_var = 'Sometimes variables are optional. This is my default value.';
  return dealWith(input_var);
} else if (typeof input_var == 'string') {
    return dealWith(input_var);
} else {
  // Already checked that input_var isn't optional, so we have a problem
  return false; // or throw a TypeError or something like that
}

但是所有那些简单的冗长内容让我无法在我的代码中编写类型检查，这使得更自由地使用函数或传递给其他开发人员的功能变得不那么健壮。

我想写一个类型处理函数，例如

For a function myFunc(input_var), if the variable passed in as parameter input_var has been defined, check if it's a string, else set it as "default_value". If it wasn't defined, also set it as "default_value", else it's a valid string, so just use input_var as is.

...但由于我实际上无法传递未定义的任何内容这一事实而受到破坏，这有效地阻止了我将这种复杂性隔离在一个单独的函数中，我可以向该函数传递 2 个参数:input_var(真正的交易，不仅仅是它的名字)和 expected_type。

function typeTest(input_var, expected_type) {
  var is_optional_value = (typeof expected_type != 'undefined'
                                                 && expected_type === true);
  var optional_str = is_optional_value ? "|(undefined)" : ''
  var type_test_regex = RegExp('^(?!' + expected_type + optional_str + '$)');
  var is_expected_type = type_test_regex.test(typeof(input_var));
}

例如，要检查传递给函数的可选变量是否已定义，并且被定义为字符串，

var myvar = 'abc'
//  myvar2 is never defined

// Mandatory type (expecting a string):
typeTest(myvar, 'string'); // true
// if (/^(?!string)$)/.test(typeof(myvar))
typeTest(myvar2, 'string'); // throws error

// Mandatory type (expecting a number):
typeTest(myvar, 'number'); // false
typeTest(myvar2, 'number'); // throws error

// Optional type ("expected is true"):
typeTest(myvar, true); // true
// if (/^(?!string|(undefined)$)/.test(typeof(myvar))
typeTest(myvar2, true); // throws error

最佳答案

I was wondering how I can make a function that accepts unresolved references.

你不能。当您访问未声明的变量时，ReferenceError 甚至在函数被调用之前就会发生。您无法在函数内部执行任何操作来从中恢复，因为它甚至还没有被调用。

typeof and delete are the only functions I know of which don't throw errors when given an undefined parameter like this.

typeof 和 delete 不是函数。这就是为什么。

For example, to check that an optional variable passed into a function was both defined, and was defined as a string.

没有什么能阻止您这样做。两者之间存在差异:

• 值为undefined 的变量
• 没有传值的参数
• 未声明的变量。

处理前两个没有问题:

function hasType(val, type) {
  return typeof val === type;
}

function myFunc(param1, param2) {
  console.log('param1: ', hasType(param1, 'string'));
  console.log('param2: ', hasType(param2, 'string'));
}

myFunc('hello');

无需检查是否有人试图使用未声明 变量调用您的函数。如果是，那么问题出在他们的代码上，他们需要修复它。如果他们利用可选参数，那就另当别论了，您可以很好地处理这种情况。

关于javascript - 是否可以在 Javascript 中将未声明的变量作为参数传递？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/29104997/