global-require

要求将 require() 调用置于顶层模块作用域

在 Node.js 中，模块依赖使用 require() 函数引入，例如：

🌐 In Node.js, module dependencies are included using the require() function, such as:

var fs = require("fs");
1

虽然 require() 可以在代码中的任何地方调用，但一些风格指南规定它应该只在模块的顶层调用，以便更容易识别依赖。例如，当依赖深度嵌套在函数和其他语句内部时，很难识别依赖：

🌐 While require() may be called anywhere in code, some style guides prescribe that it should be called only in the top level of a module to make it easier to identify dependencies. For instance, it’s arguably harder to identify dependencies when they are deeply nested inside of functions and other statements:

function foo() {
    if (condition) {
        var fs = require("fs");
    }
}
1
2
3
4
5

由于 require() 执行同步加载，当在其他位置使用时可能会导致性能问题。

🌐 Since require() does a synchronous load, it can cause performance problems when used in other locations.

此外，ES6 模块规定 import 和 export 语句只能出现在模块主体的顶层。

🌐 Further, ES6 modules mandate that import and export statements can only occur in the top level of the module’s body.

规则详情

🌐 Rule Details

此规则要求所有对 require() 的调用都必须位于模块的顶层，类似于 ES6 的 import 和 export 语句，它们也只能出现在顶层。

🌐 This rule requires all calls to require() to be at the top level of the module, similar to ES6 import and export statements, which also can occur only at the top level.

此规则的错误代码示例：

🌐 Examples of incorrect code for this rule:

/*eslint global-require: "error"*/

// calling require() inside of a function is not allowed
function readFile(filename, callback) {
    var fs = require("fs");
    fs.readFile(filename, callback);
}

// conditional requires like this are also not allowed
if (DEBUG) {
    require("debug");
}

// a require() in a switch statement is also flagged
switch (x) {
    case "1":
        require("1");
        break;
}

// you may not require() inside an arrow function body
var getModule = (name) => require(name);

// you may not require() inside of a function body as well
function getModule(name) {
    return require(name);
}

// you may not require() inside of a try/catch block
try {
    require(unsafeModule);
} catch (e) {
    console.log(e);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

符合此规则的正确代码示例：

🌐 Examples of correct code for this rule:

/*eslint global-require: "error"*/

// all these variations of require() are ok
require("x");
var y = require("y");
var z;
z = require("z").initialize();

// requiring a module and using it in a function is ok
var fs = require("fs");
function readFile(filename, callback) {
    fs.readFile(filename, callback);
}

// you can use a ternary to determine which module to require
var logger = DEBUG ? require("dev-logger") : require("logger");

// if you want you can require() at the end of your module
function doSomethingA() {}
function doSomethingB() {}
var x = require("x"),
    z = require("z");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

何时不使用

🌐 When Not To Use It

如果你有一个模块必须使用来自文件系统的信息进行初始化，或者如果一个模块只在非常少见的情况下使用并且加载它会造成显著的开销，那么禁用该规则可能是合理的。如果你需要在 try/catch 中 require() 一个可选依赖，你可以使用 // eslint-disable-line global-require 注释仅对该依赖禁用此规则。

🌐 If you have a module that must be initialized with information that comes from the file-system or if a module is only used in very rare situations and will cause significant overhead to load it may make sense to disable the rule. If you need to require() an optional dependency inside of a try/catch, you can disable this rule for just that dependency using the // eslint-disable-line global-require comment.

版本

此规则是在 ESLint v1.4.0 中引入。

资源

• 规则源码
• 测试源码