我在我的项目中使用process.cwd()。例如:

var Foo = require(process.cwd() + '/common/foo.js');

值得注意的是，这将导致需要一个绝对路径，尽管我还没有在这方面遇到问题。

另一个答案是:

想象一下这个文件夹结构:

node_modules lodash src 子目录 foo.js bar.js main.js 测试 . js

然后在test.js中，你需要这样的文件:

const foo = require("../src/subdir/foo");
const bar = require("../src/subdir/bar");
const main = require("../src/main");
const _ = require("lodash");

在main.js中:

const foo = require("./subdir/foo");
const bar = require("./subdir/bar");
const _ = require("lodash");

现在你可以使用。babelrc文件中的babel和babel插件模块解析器来配置两个根文件夹:

{
    "plugins": [
        ["module-resolver", {
            "root": ["./src", "./src/subdir"]
        }]
    ]
}

现在你可以在测试和src中以同样的方式要求文件:

const foo = require("foo");
const bar = require("bar");
const main = require("main");
const _ = require("lodash");

如果你想使用es6模块语法:

{
    "plugins": [
        ["module-resolver", {
            "root": ["./src", "./src/subdir"]
        }],
        "transform-es2015-modules-commonjs"
    ]
}

然后像这样在测试和SRC中导入文件:

import foo from "foo"
import bar from "bar"
import _ from "lodash"

这里有关于这个问题的很好的讨论。

我遇到了同样的架构问题:想要给我的应用程序更多的组织和内部名称空间，但没有:

将应用程序模块与外部依赖项混合，或者为特定于应用程序的代码使用私有NPM回购 使用相对要求，使得重构和理解更加困难 使用符号链接或更改节点路径，这可能会模糊源代码位置，并且不能很好地进行源代码控制

最后，我决定使用文件命名约定而不是目录来组织我的代码。结构应该是这样的:

npm-shrinkwrap.json package.json node_modules .．. src app.js app.config.js app.models.bar.js app.models.foo.js app.web.js app.web.routes.js .．.

然后在代码中:

var app_config = require('./app.config');
var app_models_foo = require('./app.models.foo');

或者只是

var config = require('./app.config');
var foo = require('./app.models.foo');

和往常一样，外部依赖项可以从node_modules中获得:

var express = require('express');

通过这种方式，所有应用程序代码都按层次结构组织成模块，相对于应用程序根，所有其他代码都可以使用。

当然，主要的缺点是在文件浏览器中，您不能展开/折叠树，就好像它实际上被组织成目录一样。但我喜欢它非常明确所有代码的来源，而且它没有使用任何“魔法”。

在Browserify手册中有一个非常有趣的章节:

avoiding ../../../../../../.. Not everything in an application properly belongs on the public npm and the overhead of setting up a private npm or git repo is still rather large in many cases. Here are some approaches for avoiding the ../../../../../../../ relative paths problem. node_modules People sometimes object to putting application-specific modules into node_modules because it is not obvious how to check in your internal modules without also checking in third-party modules from npm. The answer is quite simple! If you have a .gitignore file that ignores node_modules: node_modules You can just add an exception with ! for each of your internal application modules: node_modules/* !node_modules/foo !node_modules/bar Please note that you can't unignore a subdirectory, if the parent is already ignored. So instead of ignoring node_modules, you have to ignore every directory inside node_modules with the node_modules/* trick, and then you can add your exceptions. Now anywhere in your application you will be able to require('foo') or require('bar') without having a very large and fragile relative path. If you have a lot of modules and want to keep them more separate from the third-party modules installed by npm, you can just put them all under a directory in node_modules such as node_modules/app: node_modules/app/foo node_modules/app/bar Now you will be able to require('app/foo') or require('app/bar') from anywhere in your application. In your .gitignore, just add an exception for node_modules/app: node_modules/* !node_modules/app If your application had transforms configured in package.json, you'll need to create a separate package.json with its own transform field in your node_modules/foo or node_modules/app/foo component directory because transforms don't apply across module boundaries. This will make your modules more robust against configuration changes in your application and it will be easier to independently reuse the packages outside of your application. symlink Another handy trick if you are working on an application where you can make symlinks and don't need to support windows is to symlink a lib/ or app/ folder into node_modules. From the project root, do: ln -s ../lib node_modules/app and now from anywhere in your project you'll be able to require files in lib/ by doing require('app/foo.js') to get lib/foo.js. custom paths You might see some places talk about using the $NODE_PATH environment variable or opts.paths to add directories for node and browserify to look in to find modules. Unlike most other platforms, using a shell-style array of path directories with $NODE_PATH is not as favorable in node compared to making effective use of the node_modules directory. This is because your application is more tightly coupled to a runtime environment configuration so there are more moving parts and your application will only work when your environment is setup correctly. node and browserify both support but discourage the use of $NODE_PATH.

我也遇到了同样的问题，所以我编写了一个名为include的包。

包含通过定位包来确定项目根文件夹的句柄。Json文件，然后传递路径参数，你给它的本地require()没有所有的相对路径混乱。我认为这不是require()的替代品，而是需要处理非打包/非第三方文件或库的工具。类似的

var async = require('async'),
    foo   = include('lib/path/to/foo')

我希望这对你有用。

我认为你不需要用你描述的方式来解决这个问题。如果您想在大量文件中更改相同的字符串，请使用sed。在你的例子中，

find . -name "*.js" -exec sed -i 's/\.\.\/\.\.\//\.\.\//g' {} +

/../变成了../

或者，您可以要求配置文件存储包含库路径的变量。如果您将以下文件存储为config.js在示例目录中

var config = {};
config.path = '../../';

在你的例子文件中

myConfiguration = require('./config');
express = require(config.path);

您将能够从一个文件控制每个示例的配置。

这只是个人喜好。