在尝试回答这个问题之前，您需要考虑一些事情。

以Object构造函数为例。它是一个“标准内置对象”。

window.status是Window界面的一部分。

显然，您不想status引用window.status，但是您想Object引用window.Object吗？

您无法重新定义它的问题的解决方案是使用 IIFE 或module，无论如何您都应该这样做。

(() => {
  var status = false;
  if (!status) {
    console.log('status is now false.');
  }
})();

为了防止意外使用全局变量，我只会设置你的 linter 来警告它。使用类似的解决方案强制它with (fake_global)不仅会在运行时出现错误，这可能不会被捕获，而且速度会更慢。

特别是使用 ESLint，我似乎找不到“好的”解决方案。启用浏览器全局变量允许隐式读取。

我建议没有隐式的全局变量（如你不应该反正污染全球范围内，并防止var status不定义任何问题），也没有使所有的浏览器全局，只是，说window，document，console，setInterval，等，就像你在评论中所说的那样。

查看ESLint 环境以了解您要启用哪些环境。默认情况下，像Object和Array这样的东西在全局范围内，但像上面列出的那样的东西atob不在。

要看到全局的确切名单，它们被定义此文件中ESLint和的globalsNPM包。我会从（组合）“es6”、“worker”或“shared-node-browser”中挑选。

eslintrc 文件将具有：

{
    "rules": {
        "no-implicit-globals": "error"
    },
    "globals": {
        "window": "readonly",
        "document": "readonly"
    },
    "env": {
        "browser": false,
        "es6": [true/false],
        "worker": [true/false],
        "shared-node-browser": [true/false]
    }
}

如果在严格模式不是，一种可能性是遍历全球（或属性名称withED）的对象，并从这些特性，它的getter和setter方法都会抛出创建另一个对象ReferenceErrors，并在随后巢代码另一个 with过那个对象。请参阅下面代码中的注释。

这不是一个很好的解决方案，但这是我唯一能想到的解决方案：

const makeObjWhosePropsThrow = inputObj => Object.getOwnPropertyNames(inputObj)
  .reduce((a, propName) => {
    const doThrow = () => { throw new ReferenceError(propName + ' is not defined!'); };
    Object.defineProperty(a, propName, { get: doThrow, set: doThrow });
    return a;
  }, {});

// (using setTimeout so that console shows both this and the next error)
setTimeout(() => {
  const windowWhichThrows = makeObjWhosePropsThrow(window);
  with (windowWhichThrows) {
    /* Use an IIFE
     * so that variables with the same name declared with "var" inside
     * create a locally scoped variable
     * rather than try to reference the property, which would throw
     */
    (() => { 
      // Declaring any variable name will not throw:
      var alert = true;  // window.alert
      const open = true; // window.open
      
      // Referencing a property name without declaring it first will throw:
      const foo = location;
    })();
  }
});

const obj = { prop1: 'prop1' };
with (obj) {
  const inner = makeObjWhosePropsThrow(obj);
  with (inner) {
    // Referencing a property name without declaring it first will throw:
    console.log(prop1);
  }
}

.as-console-wrapper {
  max-height: 100% !important;
}

注意事项：

• 这明确使用with，这在严格模式下是禁止的
• 这并没有完全转义隐式with(global)作用域或with(obj)作用域：外部作用域中与属性同名的变量将不可引用。
• window有一个属性window，它指的是window。window.window === window. 所以，window在里面引用with会抛出。要么明确排除该window属性，要么先保存另一个引用window。

比@CertainPerformance 的答案更容易实现，您可以使用 aProxy来捕获对除window. 唯一的警告是你不能在严格模式下运行它：

const strictWindow = Object.create(
  new Proxy(window, {
    get (target, property) {
      if (typeof property !== 'string') return undefined
      console.log(`implicit access to ${property}`)
      throw new ReferenceError(`${property} is not defined`)
    }
  }),
  Object.getOwnPropertyDescriptors({ window })
)

with (strictWindow) {
  try {
    const foo = location
  } catch (error) {
    window.console.log(error.toString())
  }

  // doesn't throw error
  const foo = window.location
}

请注意，evenconsole必须具有显式引用才能不抛出。如果要将其添加为另一个异常，只需strictWindow使用另一个自己的属性进行修改

Object.getOwnPropertyDescriptors({ window, console })

事实上，您可能希望为许多标准内置对象添加例外，但这超出了本答案的范围（无意双关语）。

在我看来，这提供的好处不及在严格模式下运行的好处。更好的解决方案是使用正确配置的 linter 在开发期间而不是在非严格模式下在运行时捕获隐式引用。

也许稍微清洁一点（YMMV）是设置吸气剂陷阱（就像你做的那样），但在一个工人中，这样你就不会污染你的主要全局范围。我不需要使用with，所以也许这是一个改进。

工人“线程”

//worker; foo.js
addEventListener('message', function ({ data }) {
  try {
    eval(`
      for (k in self) {
        Object.defineProperty(self, k, {
          get: function () {
            throw new ReferenceError(':(');
          }
        });
      }
      // code to execute
      ${data}
    `);
    postMessage('no error thrown ');
  } catch (e) {
    postMessage(`error thrown: ${e.message}`);
  }
});

主“线程”

var w = new Worker('./foo.js');
w.addEventListener('message', ({data}) => console.log(`response: ${data}`));
w.postMessage('const foo = location');

另一个可能值得探索的选项是Puppeteer。

只需使用"use strict". 更多关于严格模式。