node.jsを絶対パスにする方法（相対ではなく）

Question

私は自分のファイルを常に現在のモジュールからではなく自分のプロジェクトのルートから要求したいと思います。

たとえば、 https://github.com/visionmedia/express/blob/2820f2227de0229c5d7f28009aa432f9f3a7b5f9/examples/downloads/app.js 6行目を見るとわかります。

express = require('../../')

それは本当に悪いIMOです。私のすべての例を1レベルだけルートの近くに配置したいと想像してください。私は30を超える例を更新しなければならず、また各例の中で何度も更新しなければならないので、それは不可能です。これに：

express = require('../')

私の解決策は、ルートベースの特殊なケースを持つことです。文字列が$で始まる場合、それはプロジェクトのルートフォルダに対する相対パスです。

任意の助けは大歓迎です、ありがとう

アップデート2

今私はrequire.jsを使っています。これは一方向に書くことを可能にし、クライアントとサーバーの両方で動作します。 Require.jsではカスタムパスを作成することもできます。-"

アップデート3

今度はwebpack + gulpに移行し、サーバー側のモジュールを処理するためにenhanced-requireを使用します。ここで理論的根拠を参照してください。 http://hackhat.com/p/110/module-loader-webpack-vs-requirejs-vs-browserify/

Answer 1

これが私が6ヶ月以上行っている実際の方法です。私はnode_modulesという名前のフォルダーをプロジェクトのルートフォルダーとして使用します。このようにして、絶対必要と呼ばれるあらゆる場所から常にそのフォルダーを検索します。

• node_modules
  • 私のプロジェクト
    • index.js require（ "./ someFolder/hey.js"）の代わりにrequire（ "myProject/someFolder/hey.js"）を使用できます。
    • hey.jsを含むsomeFolder

これは、フォルダにネストされている場合や、絶対パスで設定されている場合はファイルの場所を変更する作業が少なくて済む場合に便利です。私は アプリ全体 の中で相対的な要求を2つだけ使用します。

Answer 2

そして何について：

var myModule = require.main.require('./path/to/module');

メインのjsファイルから要求されているかのようにファイルを必要とするので、メインのjsファイルがプロジェクトのルートにある限りはうまく機能します。

Answer 3

Browserifyハンドブック に本当に興味深いセクションがあります。

避けてください../../../../../../ ..

アプリケーション内のすべてが正しくパブリックnpmに属しているわけではなく、プライベートnpmまたはgitリポジトリを設定することによるオーバーヘッドは、多くの場合、まだかなり大きいです。 ../../../../../../../相対パスの問題を回避するためのいくつかの方法があります。

node_modules

Npmからサードパーティ製のモジュールもチェックインせずに内部モジュールをチェックインする方法が明確でないため、人々はアプリケーション固有のモジュールをnode_modulesに入れることに反対することがあります。

答えはとても簡単です。 .gitignoreを無視するnode_modulesファイルがある場合：

node_modules

内部アプリケーションモジュールごとに!で例外を追加するだけです。

node_modules/*
!node_modules/foo
!node_modules/bar

親がすでに無視されている場合、unignoreサブディレクトリにすることはできません。 node_modulesを無視する代わりに、すべてのディレクトリinsidenode_modulesをnode_modules/*トリックで無視する必要があります。その後、例外を追加できます。

これで、アプリケーションのどこにでも、非常に大きく壊れやすい相対パスを指定せずにrequire('foo')またはrequire('bar')を使用できるようになります。

たくさんのモジュールがあり、それらをnpmによってインストールされたサードパーティ製のモジュールからもっと分離したい場合は、それらすべてをnode_modulesのようなnode_modules/appのディレクトリの下に置くことができます。

node_modules/app/foo
node_modules/app/bar

これで、アプリケーションのどこからでもrequire('app/foo')またはrequire('app/bar')を使用できるようになります。

.gitignoreに、node_modules/appの例外を追加するだけです。

node_modules/*
!node_modules/app

アプリケーションのpackage.jsonに変換が設定されている場合は、変換がモジュールの境界を越えて適用されないため、node_modules/fooまたはnode_modules/app/fooコンポーネントディレクトリに独自の変換フィールドを持つ個別のpackage.jsonを作成する必要があります。これはあなたのモジュールをあなたのアプリケーションの設定変更に対してより堅牢にするでしょう、そしてあなたのアプリケーションの外で独自にパッケージを再利用することはより簡単になるでしょう。

シンボリックリンク

シンボリックリンクを作成でき、ウィンドウをサポートする必要がないアプリケーションで作業している場合のもう1つの便利なトリックは、lib/またはapp/フォルダをnode_modulesにシンボリックリンクすることです。プロジェクトルートから、次のようにします。

ln -s ../lib node_modules/app

そしてプロジェクトのどこからでもlib/を取得するためにrequire('app/foo.js')を実行することでlib/foo.js内のファイルを要求することができます。

カスタムパス

$NODE_PATH環境変数またはopts.pathsを使用してnode用のディレクトリを追加し、browserifyでモジュールを探すために使用することについて話しているところがあるかもしれません。

他のほとんどのプラットフォームとは異なり、$NODE_PATHでシェル形式のパスディレクトリの配列を使用することは、node_modulesディレクトリを効果的に使用することと比較して、ノードではそれほど有利ではありません。

これは、アプリケーションが実行時環境設定とより密接に関連しているため、動く部分が増え、アプリケーションが動作するのは環境が正しく設定されている場合に限られるためです。

nodeとbrowserifyは両方のサポートをサポートしますが、$NODE_PATHの使用は推奨しません。

Answer 4

私は共有コード用に新しいnode_modulesフォルダを作成し、それからnodeとrequireにそれが最善を尽くさせるようにします。

例えば：

- node_modules // => these are loaded from your package.json
- app
  - node_modules // => add node-style modules
    - helper.js
  - models
    - user
    - car
- package.json
- .gitignore

例えば、あなたがcar/index.jsにいるなら、あなたはrequire('helper')をすることができ、nodeはそれを見つけるでしょう！

node_modulesのしくみ

nodeは、競合するプラットフォーム間でユニークなモジュールを解決するための巧妙なアルゴリズムを持っています。

/beep/boop/bar.jsからrequire('./foo.js')を入力した場合、nodeは./foo.js内で/beep/boop/foo.jsを探します。 ./または../で始まるパスは、常にrequire()を呼び出すファイルに対してローカルです。

ただし、/beep/boop/foo.jsのrequire('xyz')のような非相対的な名前が必要な場合、nodeは最初の一致で停止し、何も見つからない場合はエラーを発生させます。

/beep/boop/node_modules/xyz
/beep/node_modules/xyz
/node_modules/xyz

存在するxyzディレクトリごとに、nodeは最初にxyz/package.jsonを探して"main"フィールドが存在するかどうかを確認します。 "main"フィールドは、ディレクトリパスをrequire()にした場合にどのファイルを担当するかを定義します。

たとえば、/beep/node_modules/xyzが最初の一致で、/beep/node_modules/xyz/package.jsonが次のようになっているとします。

{
  "name": "xyz",
  "version": "1.2.3",
  "main": "lib/abc.js"
}

/beep/node_modules/xyz/lib/abc.jsからのエクスポートはrequire('xyz')によって返されます。

package.jsonまたは"main"フィールドがない場合、index.jsが想定されます。

/beep/node_modules/xyz/index.js

Answer 5

大きな絵

「本当に悪い」ようですが、時間をかけてください。それは、実のところ、本当に良いことです。明示的なrequire()sは、プロジェクトのライフサイクルにおける新鮮な空気のような完全な透明性と理解のしやすさを提供します。

このように考えてみてください。あなたはつま先をNode.jsに浸して例を読んでいて、それは「本当に悪いIMO」であると判断しました。あなたは、Node.jsコミュニティのリーダーであり、Node.jsアプリケーションを他の誰よりも多くの時間を書いて保守してきた人々です。作者がそのような新人の間違いをした可能性は何ですか？ （私のRubyとPythonの経歴からすると、これは最初は災害のように思えます。）

Node.jsを取り巻く多くの誇大宣伝と反抗的な感情があります。しかし、ほこりが落ち着くと、明示的なモジュールと "local first"パッケージが採用の主な原動力となったことを認めます。

一般的なケース

もちろん、現在のディレクトリからnode_modules、次に親、そして祖父母、曾祖父などが検索されます。だからあなたがインストールしたパッケージはすでにこのように動作します。通常、プロジェクトのどこからでもrequire("express")を実行でき、それはうまく機能します。

あなたが自分のプロジェクトのルートから共通ファイルをロードしていることに気づいたら（おそらくそれらは共通のユーティリティ関数であるため）、それがパッケージを作る時が来たという大きな手がかりです。パッケージは非常に単純です。ファイルをnode_modules/に移動し、そこにpackage.jsonを配置します。 Voila！その名前空間のすべてにプロジェクト全体からアクセスできます。パッケージは、コードをグローバル名前空間に変換するための正しい方法です。

その他の回避策

私は個人的にはこれらのテクニックを使用しませんが、彼らはあなたの質問に答えます、そしてもちろんあなたはあなた自身の状況を私よりよく知っています。

$NODE_PATHをあなたのプロジェクトルートに設定することができます。 require()を実行するとそのディレクトリが検索されます。

次に、妥協して、すべての例から共通のローカルファイルを要求する可能性があります。その共通ファイルは単に祖父母ディレクトリの本当のファイルを再エクスポートします。

examples/downloads/app.js（そしてそれ以外の多くの人が）

var express = require('./express')

examples/downloads/express.js

module.exports = require('../../')

これらのファイルを移動したときの最悪の場合は、shimモジュールを修正することです。

Answer 6

node-rfr をご覧ください。

それはこれと同じくらい簡単です：

var rfr = require('rfr');
var myModule = rfr('projectSubDir/myModule');

Answer 7

私は自分のプロジェクトでprocess.cwd()を使います。例えば：

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

まだ問題に遭遇していないけれども、これがrequireを絶対パスにすることになることは注目に値するかもしれません。

Answer 8

プロジェクトのルートが現在の作業ディレクトリであると仮定すると、これでうまくいくはずです。

// require built-in path module
path = require('path');

// require file relative to current working directory
config = require( path.resolve('.','config.js') );

Answer 9

npmの代わりにyarnを使う場合は、 ワークスペース 。

もっと簡単に要求したいフォルダservicesがあるとしましょう。

.
├── app.js
├── node_modules
├── test
├── services
│   ├── foo
│   └── bar
└── package.json

Yarnワークスペースを作成するには、package.json内にservices folderファイルを作成します。

{
  "name": "myservices",
  "version": "1.0.0"
}

メインのpackage.jsonに以下を追加してください。

"private": true,
"workspaces": ["myservices"]

プロジェクトのルートからyarn installを実行します。

それから、あなたのコードのどこでも、あなたはすることができます：

const { myFunc } = require('myservices/foo')

のようなものの代わりに：

const { myFunc } = require('../../../../../../services/foo')

Answer 10

この問題については良い議論があります ここ 。

私は同じアーキテクチャ上の問題に出くわしました：私のアプリケーションにもっと多くの組織と内部の名前空間を与える方法を望んでいます。

• アプリケーションモジュールと外部の依存関係を混在させたり、アプリケーション固有のコードのためのプライベートなnpmリポジトリに迷惑をかけたりする
• リファクタリングと理解を難しくする、相対的なrequireの使用
• シンボリックリンクを使用したりノードパスを変更したりすると、ソースの場所がわかりにくくなり、ソース管理とうまく連携しないことがあります。

結局、ディレクトリではなくファイル命名規則を使用してコードを編成することにしました。構造は次のようになります。

• 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');

このようにして、すべてのアプリケーションコードは階層的にモジュールに編成され、アプリケーションルートを基準にした他のすべてのコードで利用可能になります。

主なデメリットは、もちろんファイルブラウザでは、実際にはディレクトリにまとめられているかのようにツリーを展開したり折りたたんだりできないことです。しかし、私はそれがすべてのコードがどこから来ているのかについて非常に明白であり、そしてそれが少しの「魔法」も使用しないことが好きです。

Answer 11

答えのいくつかは、パッケージとしてnode_moduleにコードを追加することが最善の方法であると言っています、私は同意し、requireで../../../を失うことがおそらく最善の方法ですが、実際にそうする方法はありません。

バージョン2.0.0から、あなたはローカルファイルからパッケージをインストールすることができます、それはあなたが望むすべてのパッケージであなたのルートにフォルダを作成することができることを意味します、

-modules
 --foo
 --bar 
-app.js
-package.json

そのため、package.jsonでは、次のように公開または外部サーバーを使用せずにmodules（またはfooとbar）をパッケージとして追加できます。

{
  "name": "baz",
  "dependencies": {
    "bar": "file: ./modules/bar",
    "foo": "file: ./modules/foo"
  }
}

その後はnpm installを実行し、他のすべてのパッケージと同様にvar foo = require("foo")を使用してコードにアクセスできます。

より多くの情報はここで見つけることができます：

https://docs.npmjs.com/files/package.json#local-paths

そしてここでパッケージを作成する方法：

https://docs.npmjs.com/getting-started/creating-node-modules

Answer 12

あなたはあなたのapp.jsでこのような何かを定義することができます：

requireFromRoot = (function(root) {
    return function(resource) {
        return require(root+"/"+resource);
    }
})(__dirname);

そして、どこからでもルートから何かを要求したいときはいつでも、Vanilla requireの代わりにrequireFromRootを使うだけです。これまでのところ私にとってはかなりうまくいきます。

Answer 13

私はこれらの解決策の多くを試しました。私はこれを私のメインファイル（例えばindex.js）の先頭に追加しました。

process.env.NODE_PATH = __dirname;
require('module').Module._initPaths();

これにより、スクリプトがロードされたときにプロジェクトルートがNODE_PATHに追加されます。これにより、var User = require('models/user')のようなプロジェクトルートからの相対パスを参照することで、プロジェクト内の任意のファイルを要求することができます。このソリューションは、プロジェクト内で何か他のものを実行する前に、プロジェクトルートでメインスクリプトを実行している限り、うまくいくはずです。

Answer 14

私が作ったモジュール ndot を使うことができます。これは高度なものではなく、単なるヘルパーなので、簡単にドットヘルを回避できます。

例：

var undot = require('undot');
var User = undot('models/user');
var config = undot('config');
var test = undot('test/api/user/auth');

Answer 15

自分のプロジェクトでは、ルートディレクトリで使用されている任意の.jsファイルを変更し、そのパスをprocess.env変数のプロパティに追加できます。例えば：

// in index.js
process.env.root = __dirname;

その後、あなたはどこでもプロパティにアクセスすることができます。

// in app.js
express = require(process.env.root);

Answer 16

これを達成するための最も簡単な方法はnode_modules/appを指す../app（またはあなたがそれを呼び出すものは何でも）でアプリケーションの起動時にシンボリックリンクを作成することです。それならrequire("app/my/module")を呼び出せます。シンボリックリンクはすべての主要プラットフォームで利用可能です。

しかしながら、あなたはまだあなたのものをnpmを通してインストールされるより小さくて保守可能なモジュールに分割するべきです。 git-urlを使ってプライベートモジュールをインストールすることもできるので、モノリシックなappディレクトリを1つ持つ理由はありません。

Answer 17

私がやりたいことは、node_moduleディレクトリからnodeがどのようにロードされるかを利用することです。

モジュール「もの」をロードしようとすると、次のようになります。

require('thing');

その後、Nodeは 'node_module'ディレクトリの中の 'thing'ディレクトリを探します。

Node_moduleは通常プロジェクトのルートにあるため、この一貫性を利用できます。 （node_moduleが根元にない場合は、他に自己誘導による頭痛の種があります。）

ディレクトリに移動してそこから戻ると、ノードプロジェクトのルートへの一貫したパスを取得できます。

require('thing/../../');

それから/ happyディレクトリにアクセスしたい場合は、これを行います。

require('thing/../../happy');

これはかなり厄介ですが、node_modulesがどのように負荷をかけるかの機能が変わったとしたら、もっと大きな問題があるでしょう。この動作は一貫しているはずです。

物事を明確にするために、私はこれをします、なぜならモジュールの名前は重要ではないからです。

require('root/../../happy');

最近、Angular 2に使用しました。ルートからサービスをロードしたいです。

import {MyService} from 'root/../../app/services/http/my.service';

Answer 18

もう一つの答え：

このフォルダ構造を想像してみてください。

• node_modules
  • ロダッシュ
• src
  • subdir
    • foo.js
    • bar.js
  • main.js

• テスト

  • test.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");

これで babel と babel-plugin-module-resolver を使うことができます。babelrcファイルで2つのルートフォルダを設定できます。 ：

{
    "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"

Answer 19

この小さなパッケージは、グローバル変数を導入したりノードのデフォルトを上書きしたりすることなく、プロジェクトルートからの相対パスでパッケージを要求できるようにしたものです。

https://github.com/Gaafar/pkg-require

それはこのように動作します

// create an instance that will find the nearest parent dir containing package.json from your __dirname
const pkgRequire = require('pkg-require')(__dirname);

// require a file relative to the your package.json directory 
const foo = pkgRequire('foo/foo')

// get the absolute path for a file
const absolutePathToFoo = pkgRequire.resolve('foo/foo')

// get the absolute path to your root directory
const packageRootPath = pkgRequire.root()

Answer 20

誰かがこの問題を回避するためのさらに別の方法を探しているなら、ここに努力への私自身の貢献があります：

https://www.npmjs.com/package/use-import

基本的な考え方：プロジェクトのルートにファイルパスを短縮名にマップするJSONファイルを作成します（またはそれを実行するために se-automapper を取得します）。あなたはそれらの名前を使ってあなたのファイル/モジュールを要求することができます。そのようです：

var use = require('use-import');
var MyClass = use('MyClass');

それでそれがあります。

Answer 21

examplesディレクトリにプロジェクトnode_modulesのルートへのシンボリックリンクを持つproject -> ../../を含めることはできませんでした。そのため、例ではrequire('project')を使用できますが、マッピングは削除されませんが、ソースはrequire('project')ではなくrequire('../../')を使用できます。

私はこれをテストしました、そしてそれはv0.6.18で動きます。

projectディレクトリのリスト：

$ ls -lR project
project:
drwxr-xr-x 3 user user 4096 2012-06-02 03:51 examples
-rw-r--r-- 1 user user   49 2012-06-02 03:51 index.js

project/examples:
drwxr-xr-x 2 user user 4096 2012-06-02 03:50 node_modules
-rw-r--r-- 1 user user   20 2012-06-02 03:51 test.js

project/examples/node_modules:
lrwxrwxrwx 1 user user 6 2012-06-02 03:50 project -> ../../

index.jsの内容は、値をexportsオブジェクトのプロパティに割り当て、それが要求されたことを示すメッセージを付けてconsole.logを呼び出します。 test.jsの内容はrequire('project')です。

Answer 22

アプリケーションのエントリポイントのjsファイル（つまり、実際に "node"を実行したもの）がプロジェクトのルートディレクトリにある場合は、 rootpath npmモジュール を使用すると、これを簡単に実行できます。単にそれを介してそれをインストール

npm install --save rootpath

...そして、エントリポイントのjsファイルの一番上に、以下を追加します。

require('rootpath')();

それ以降は、すべてのrequire呼び出しはプロジェクトルートに対する相対パスになります。 require('../../../config/debugging/log');はrequire('config/debugging/log');になります（configフォルダーはプロジェクトのルートにあります）。

Answer 23

たった今出会った この記事 言及している app-module-path 。それはあなたがこのようにベースを設定することを可能にします：

require('app-module-path').addPath(baseDir);

Answer 24

簡単な行で、あなた自身のフォルダをモジュールとして呼び出すことができます。

そのために必要なのは、globalとapp-module-pathモ​​ジュールです。

ここで "App-module-path"はモジュールです、それはあなたがNode.jsモジュール検索パスに追加のディレクトリを追加することを可能にしますそして "global"は、あなたがこのオブジェクトにつけるものはあなたのアプリの至る所で利用できるでしょう。

このスニペットを見てください。

global.appBasePath = __dirname;

require('app-module-path').addPath(appBasePath);

__dirnameはノードの現在の実行ディレクトリです。モジュールのパスを検索するには、ここで独自のパスを指定できます。

Answer 25

私達はこの問題に取り組むための新しい方法を試みようとしています。

Springやguiceのような他の既知のプロジェクトから例を取り上げて、すべての "require"文を含む "context"オブジェクトを定義します。

その後、このオブジェクトは他のすべてのモジュールに渡されて使用されます。

例えば

var context = {}

context.module1 = require("./module1")( { "context" : context } )
context.module2 = require("./module2")( { "context" : context } )

これは各モジュールをoptsを受け取る関数として書くことを要求します。それはとにかくベストプラクティスとして私たちには見えます。

module.exports = function(context){ ... }

そして、あなたはものを要求する代わりにコンテキストを参照するでしょう。

var module1Ref = context.moduel1;

必要に応じて、requireステートメントを実行するためのループを簡単に書くことができます。

var context = {};
var beans = {"module1" : "./module1","module2" : "./module2" }; 
for ( var i in beans ){
    if ( beans.hasOwnProperty(i)){
         context[i] = require(beans[i])(context);
    }
};

これをモック（テスト）したいときには楽にし、コードをパッケージとして再利用できるようにしながら問題を解決します。

また、Beanの宣言とコードを分離して、コンテキスト初期化コードを再利用することもできます。たとえば、main.jsファイルは以下のようになります。

var beans = { ... }; // like before
var context = require("context")(beans); // this example assumes context is a node_module since it is reused.. 

このメソッドは外部ライブラリにも適用されます。必要になるたびに名前をハードコードする必要はありません。ただし、エクスポートはコンテキストを期待する機能ではないため、特別な処理が必要になります。

後で、Beanを関数として定義することもできます。これにより、環境に応じてさまざまなモジュールをrequireできるようになりますが、それはこのスレッドの範囲外です。

Answer 26

私はこれと同じ問題に悩んでいたので、 include というパッケージを書きました。

Include あなたのpackage.jsonファイルを見つけることによってあなたのプロジェクトのルートフォルダを見つけ出すことを処理し、そして相対的なパスの混乱の全てなしであなたがそれに与えるパス引数をネイティブなrequire（）に渡します。これはrequire（）に代わるものではなく、パッケージ化されていない/サードパーティ以外のファイルやライブラリの処理を要求するためのツールとして考えてください。何かのようなもの

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

これが役に立つことを願っています。

Answer 27

"rekiure"というノードモジュールを作成しました

相対パスを使用せずに要求することができます

https://npmjs.org/package/rekuire

それは超使いやすいです

Answer 28

Paolo Morettiから 素晴らしい答え をフォローアップしてBrowserifyしたいだけです。 transpiler（例えば、babel、TypeScript）を使用していて、src/とdist/のようなソースコードとトランスコードされたコードのために別々のフォルダーがある場合、

node_modules

次のようなディレクトリ構造になります。

app
  node_modules
    ... // normal npm dependencies for app
  src
    node_modules
      app
        ... // source code
  dist
    node_modules
      app
        ... // transpiled code

その後、babelなどにsrcディレクトリをdistディレクトリに変換させることができます。

シンボリックリンク

シンボリックリンクを使うと、いくつかのレベルのネストを取り除くことができます。

app
  node_modules
    ... // normal npm dependencies for app
  src
    node_modules
      app // symlinks to '..'
    ... // source code
  dist
    node_modules
      app // symlinks to '..'
    ... // transpiled code

babel --copy-filesに関する警告babelの--copy-filesフラグはシンボリックリンクをうまく扱えません。それは..シンボリックリンクにナビゲートし続けて、そして終わりを知らないファイルを見ているかもしれません。回避策は、次のディレクトリ構造を使用することです。

app
  node_modules
    app // symlink to '../src'
    ... // normal npm dependencies for app
  src
    ... // source code
  dist
    node_modules
      app // symlinks to '..'
    ... // transpiled code

このようにして、srcの下のコードはまだappをsrcに解決しますが、babelはシンボリックリンクを見なくなります。

Answer 29

これらの答えはうまくいきますが、npmテストでは問題を解決できません

たとえば、server.jsにグローバル変数を作成した場合、それはテストスイートの実行には設定されません。

../../../問題を回避し、npm startとnpm testの両方で利用可能になるグローバルなappRoot変数を設定するには、以下を参照してください。

Mochaは追加のオプションやパラメータを使ってテストします

これは新しい公式モカソリューションです。

Answer 30

少し前に、定義済みパスに関連してモジュールをロードするためのモジュールを作成しました。

https://github.com/raaymax/irequire

Requireの代わりにそれを使うことができます。

irequire.prefix('controllers',join.path(__dirname,'app/master'));
var adminUsersCtrl = irequire("controllers:admin/users");
var net = irequire('net');

たぶんそれは誰にとっても役に立つでしょう..

Answer 31

Asappを使ってみてください。

npm install --save asapp

https://www.npmjs.com/package/asapp

var { controller, helper, middleware, route, schema, model, APP, ROOT } = require('asapp')

代わりにcontroller('home')require('../../controllers/home)

Answer 32

ES5の構文を使用している場合は、 asapp を使用できます。 ES6では、 babel-plugin-module-resolver のような設定ファイルを使用します。

.babelrc

{
  "plugins": [
    ["module-resolver", {
      "root": ["./"],
      "alias": {
        "app": "./app",
        "config": "./app/config",
        "schema": "./app/db/schemas",
        "model": "./app/db/models",
        "controller": "./app/http/controllers",
        "middleware": "./app/http/middleware",
        "route": "./app/http/routes",
        "locale": "./app/locales",
        "log": "./app/logs",
        "library": "./app/utilities/libraries",
        "helper": "./app/utilities/helpers",
        "view": "./app/views"
      }
    }]
  ]
}