JavaScript 程序如何知道全局属性名称是否由 ECMA-262 定义？

Question

Consider a hypothetical function called isEcmaGlobal that returns true for string names of ECMA-262 globals.

$ node
> isEcmaGlobal('Array')
true
> isEcmaGlobal('process')
false

How would one design this function?

Answer 1

Lets be careful here. We need to ask another question before this answer will make sense: Are we categorizing globals by what ECMA-262 ("the standard") says now , or by the standard governing our program's runtime?

Put another way: Should multiple machines see the same answers?

Going by the Current Standard

Let's say we want isEcmaGlobal to return true in terms of what the standard says right now . I won't show any code here because if you care about this kind of problem, then you probably already thought to download or scrape standard global names.

Going by the Current Runtime

Now let's assume we want isEcmaGlobal to return true in terms of offline information available in the current runtime. It's not as easy as iterating over the "own" property names of the global object and checking them against a hard-coded array like ['Array', 'Object', ...] . If we did that, then we'd have to verify our array is correct. We can't verify hard-coded data because it assumes isEcmaGlobal is already written for that exact runtime, We cannot paste in global names from ECMA-262. because we don't know if the version of that document is in parity with the runtime. We also can't check the Internet because we assumed an offline solution.

So we can't hard code, but we can try something else. I'll use Node.js v14.16.0 and its built-in vm module. This program exploits vm 's need to provide standard globals in a new evaluator. We tell vm to evaluate code using an empty global object, but that global object simply won't be empty.

const vm = require('vm');

function isEcmaGlobal(identifier) {
  try {
    // Lol, what security?
    vm.runInContext(identifier, vm.createContext({}))
    return true;
  } catch (e) {
    return false;
  }
}

Couple of things here.

First, a warning: This example uses unsanitized code execution for illustration and brevity. Do not put it on your clipboard with intent to take a shortcut.

Second, you can see our goal is to create a fresh evaluator with only standard globals defined, and no visibility into what's going on outside of the evaluator ( eval does not do either of these things). If we get that evaluator, then you can just toss Object.getOwnPropertyNames(new Function('return this')()) into it and we all go home.

But we're making a predicate, so assuming the "lean" global object is correct, evaluation will throw a ReferenceError for non-standard identifiers.

Unfortunately, somehting isn't right.

> isEcmaGlobal('Array')
true
> isEcmaGlobal('process')
false // yes!
> isEcmaGlobal('global')
false // yes!!
> isEcmaGlobal('console')
true  // no!!!

Darn, we still have a Node global for some reason. So at this point you could say I'm making this all too complicated because Node.js doesn't add that many globals , or that I missed a configuration option or existing predicate. You'd be right on all counts, but that's missing the point of the question. The question started with "Can a JavaScript program know...?", and my use of Node is meant to illustrate a way to approach the problem without hard-coding standard global names and creating a contradiction. Even if Node.js added only one non-standard global, the problem remains if we can't get a clean evaluator.

Recap

To implement isEcmaGlobal in some JavaScript runtime, that runtime needs to give you a way to run a bare-bones JS evaluator, free of all host-specific extensions. eval doesn't count. Make it such that that you only accept identifiers, and then evaluate those identifiers. Interpret an exception as reason to return false .