et qu'en est-il:

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

il nécessite le fichier comme s'il était requis à partir du fichier JS principal, donc il fonctionne assez bien tant que votre fichier JS principal est à la racine de votre projet... et c'est quelque chose que j'apprécie.

il y a une section très intéressante dans le Browserify Handbook :

à l'éviter ../../../../../../..

tout dans une application n'appartient pas correctement sur le public npm et les frais généraux de mise en place d'un npm privé ou git repo est toujours plutôt grand, dans de nombreux cas. Voici quelques approches pour éviter la ../../../../../../../ les chemins d'accès relatifs problème.

node_modules

les gens s'opposent parfois à la mise en place de modules spécifiques node_modules parce qu'il n'est pas évident comment vérifier dans votre interne modules sans vérifier également dans les modules tiers de npm.

la réponse est très simple! Si vous avez un fichier .gitignore qui ignore node_modules :

node_modules

vous pouvez juste ajouter une exception avec ! pour chacun de vos modules d'application:

node_modules/*
!node_modules/foo
!node_modules/bar

s'il vous Plaît noter que vous ne pouvez pas unignore un sous-répertoire, si le parent est déjà ignoré. Donc au lieu d'ignorer node_modules , vous devez ignorer chaque répertoire à l'intérieur node_modules avec le node_modules/* truc, et puis vous pouvez ajouter vos exceptions.

maintenant n'importe où dans votre application vous serez en mesure de require('foo') ou require('bar') sans avoir un parent très grand et fragile chemin.

si vous avez beaucoup de modules et que vous voulez les garder plus séparés de les modules tiers installés par npm, vous pouvez juste les mettre tous sous un répertoire dans node_modules tel que node_modules/app :

node_modules/app/foo
node_modules/app/bar

Maintenant vous pourrez require('app/foo') ou require('app/bar') à partir de n'importe où dans votre application.

dans votre .gitignore , il suffit d'ajouter une exception pour node_modules/app :

node_modules/*
!node_modules/app

si votre application avait des transformations configurées en paquet.json, vous aurez besoin de créer un paquet séparé.JSON avec son propre transform field en votre répertoire de composants node_modules/foo ou node_modules/app/foo parce que les transformations ne s'appliquent pas au-delà des limites des modules. Ce sera rendre vos modules plus robustes contre les changements de configuration dans votre application et il sera plus facile de réutiliser les paquets en dehors de votre application.

lien

un Autre truc utile si vous travaillez sur une application où vous pouvez faire des liens symboliques et n'ont pas besoin de support de windows est un lien symbolique lib/ ou app/ dossier dans node_modules . De la racine du projet, faire:

ln -s ../lib node_modules/app

et maintenant de n'importe où dans votre projet vous serez en mesure d'exiger des fichiers dans lib/ en faisant require('app/foo.js') pour obtenir lib/foo.js .

des chemins d'accès personnalisés

vous pourriez voir certains endroits parlent d'utiliser le $NODE_PATH variable d'environnement ou opts.paths pour ajouter des répertoires pour le noeud et browserify pour chercher des modules.

contrairement à la plupart des autres plates-formes, utilisant un tableau de chemin de style shell répertoires avec $NODE_PATH n'est pas aussi favorable dans le noeud par rapport à l'utilisation efficace de l' node_modules répertoire.

c'est parce que votre application est plus étroitement couplée à un runtime configuration de l'environnement de sorte qu'Il ya plus de pièces mobiles et votre l'application ne fonctionne que lorsque votre environnement est configuré correctement.

noeud et browserify soutiennent à la fois mais découragent l'utilisation de $NODE_PATH .

j'aime faire un nouveau dossier node_modules pour le code partagé, puis laisser le noeud et require faire ce qu'il fait le mieux.

par exemple:

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

par exemple, si vous êtes dans car/index.js vous pouvez require('helper') et le noeud le trouvera!

Comment node_modules Travail

noeud a un algorithme intelligent pour résoudre les modules qui est unique parmi les rivaux plate.

si vous require('./foo.js') de /beep/boop/bar.js , node cherchera ./foo.js dans /beep/boop/foo.js . Les chemins qui commencent par un ./ ou ../ sont toujours locaux au fichier qui appelle require() .

si toutefois vous avez besoin d'un nom non relatif tel que require('xyz') de /beep/boop/foo.js , le noeud recherche ces chemins dans l'ordre, s'arrêtant à la première correspondance et soulevant une erreur si rien n'est trouvé:

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

pour chaque répertoire xyz existant, le noeud cherchera d'abord un xyz/package.json pour voir s'il existe un champ "main" . Le champ "main" définit quel fichier doit prendre en charge si vous require() le chemin de répertoire.

par exemple, si /beep/node_modules/xyz est la première correspondance et /beep/node_modules/xyz/package.json a:

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

puis les exportations de /beep/node_modules/xyz/lib/abc.js seront retournées par require('xyz') .

S'il n'y a pas de champ package.json ou "main" , index.js est supposé:

/beep/node_modules/xyz/index.js

big picture

Il semble "vraiment mauvais", mais donnez-lui le temps. Il est, en fait, vraiment bon. Les require() s explicites donnent une transparence totale et une facilité de compréhension qui est comme une bouffée d'air frais pendant un cycle de vie de projet.

pensez-y de cette façon: vous lisez un exemple, trempant vos orteils dans le noeud.js et vous avez décidé que C'était "très mauvais IMO."Vous êtes des meneurs de second plan du noeud.la communauté de js, les gens qui ont enregistré plus d'heures d'écriture et de maintien de Nœud.applications js plus que quiconque. Quelle est la chance que l'auteur ait fait une telle erreur de débutant? (Et je suis d'accord, de mon Ruby et Python arrière-plan, il semble au premier abord comme une catastrophe.)

il y a beaucoup de battage et de contre-battage autour du noeud.js. Mais lorsque la poussière retombera, nous reconnaîtrons que les modules explicites et les paquets" locaux d'abord " ont été un moteur majeur de l'adoption.

bien sûr, node_modules de l'annuaire courant, puis le parent, puis grand-parent, arrière-grand-parent, etc. est recherché. Donc les paquets que vous avez installés fonctionnent déjà de cette façon. Habituellement, vous pouvez require("express") de n'importe où dans votre projet et il fonctionne très bien.

si vous vous retrouvez en train de charger des fichiers communs à partir de la racine de votre projet (peut-être parce qu'ils sont des fonctions Utilitaires communes), alors c'est un gros indice qu'il est temps de faire un paquet. Les paquets sont très simples: déplacez vos fichiers dans node_modules/ et mettez un package.json y. voilà! tout dans cet espace de noms est accessible à partir de votre projet entier. Les paquets sont la bonne façon d'introduire votre code dans un espace de noms global.

autres solutions de rechange

personnellement, je n'utilise pas ces techniques, mais elles répondent à votre question, et bien sûr vous connaissez votre propre situation mieux que moi.

vous pouvez définir $NODE_PATH à la racine de votre projet. Ce répertoire sera recherché quand vous require() .

ensuite, vous pouvez faire des compromis et exiger un fichier local commun à partir de tous vos exemples. Ce fichier commun réexporte simplement le vrai fichier dans le répertoire grand-parent.

exemples/téléchargements/app.js (et beaucoup d'autres comme elle)

var express = require('./express')

exemples/téléchargements/express.js

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

Maintenant, lorsque vous relocalisez ces fichiers, le pire des cas est de réparer le module shim .

regarder nœud-rfr .

c'est aussi simple que cela:

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

IMHO, la manière la plus simple est de définir votre propre fonction dans le cadre de GLOBAL objet. Créer projRequire.js dans la racine de votre projet avec le contenu suivant:

var projectDir = __dirname;

module.exports = GLOBAL.projRequire = function(module) {
  return require(projectDir + module);
}

dans votre fichier principal avant require "

// init projRequire
require('./projRequire');

après les travaux suivants pour moi:

// main file
projRequire('/lib/lol');

// index.js at projectDir/lib/lol/index.js
console.log('Ok');

j'utilise process.cwd() dans mes projets. Par exemple:

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

il pourrait être intéressant de noter que cela résultera en require in un chemin absolu, bien que je n'ai pas encore eu de problèmes avec cela.

il y a une bonne discussion de cette question ici .

j'ai rencontré le même problème d'architecture: vouloir une façon de donner à mon application plus d'organisation et des espaces de noms internes, sans:

• mélange de modules d'application avec des dépendances externes ou avec des repos npm privés pour le code spécifique à l'application
• en utilisant les besoins relatifs, qui font refacturation et la compréhension plus difficile
• utilisant des liens symboliques ou changeant le chemin du noeud, ce qui peut obscurcir les localisations des sources et ne joue pas bien avec le contrôle des sources

finalement, j'ai décidé d'organiser mon code en utilisant des conventions de nommage de fichier plutôt que des répertoires. Une structure ressemblerait à quelque chose comme:

• npm-shrinkwrap.json
• paquet.json
• node_modules
  • ...
• src
  • app.js
  • app.config.js
  • app.modèle.bar.js
  • app.modèle.foo.js
  • app.Web.js
  • app.Web.route.js
  • ...

puis dans le code:

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

ou juste

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

et les dépendances externes sont disponibles à partir de node_modules comme d'habitude:

var express = require('express');

de cette façon, tous les codes d'application sont hiérarchiquement organisés en modules et disponibles pour tous les autres codes par rapport à la racine de l'application.

le principal inconvénient est bien sûr que dans un navigateur de fichier, vous ne pouvez pas étendre/effondrer l'arbre comme s'il était réellement organisé en répertoires. Mais j'aime ça c'est très explicite sur l'origine de tout le code, et il n'utilise pas de "magie".

si la racine de votre projet est le répertoire courant, cela devrait fonctionner:

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

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

vous pouvez définir quelque chose comme ça dans votre application.js:

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

et puis chaque fois que vous voulez exiger quelque chose de la racine, peu importe où vous êtes, vous utilisez requireFromRoot au lieu de l'exigence de vanille. Fonctionne assez bien pour moi jusqu'à présent.

j'ai essayé plusieurs de ces solutions. J'ai fini par ajouter ceci en haut de mon fichier principal (par exemple index.js):

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

ajoute la racine du projet à NODE_PATH lorsque le script est chargé. Le me permet d'exiger n'importe quel fichier dans mon projet en faisant référence à son chemin relatif de la racine du projet tel que var User = require('models/user') . Cette solution devrait fonctionner aussi longtemps que vous exécutez un script principal dans la racine du projet avant l'exécution de toute autre chose dans votre projet.

vous pouvez utiliser un module que j'ai fait, annuler . Il n'est rien avancé, juste un helper afin que vous puissiez éviter ces points enfer avec simplicité.

exemple:

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

Imho la manière la plus simple d'y parvenir est de créer un lien symbolique sur le démarrage de l'application à node_modules/app (ou quel que soit son nom) qui pointe vers ../app . Alors vous pouvez simplement appeler require("app/my/module") . Des liens symboliques sont disponibles sur toutes les principales plateformes.

cependant, vous devez toujours diviser vos affaires en plus petits modules maintenables qui sont installés via npm. Vous pouvez également installer vos modules privés via git-url, il n'y a donc aucune raison d'en avoir un, monolithique app-répertoire.

dans votre propre projet, vous pouvez modifier n'importe lequel .fichier js qui est utilisé dans le répertoire racine et ajoute son chemin à une propriété de la variable process.env . Par exemple:

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

après vous pouvez accéder à la propriété partout:

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

certaines des réponses disent que la meilleure façon est d'ajouter le code au node_module en paquet, je suis d'accord et c'est probablement la meilleure façon de perdre le ../../../ dans require mais aucun d'entre eux ne donne réellement un moyen de le faire.

de la version 2.0.0 vous pouvez installer un paquet à partir de fichiers locaux, ce qui signifie que vous pouvez créer un dossier dans votre racine avec tous les paquets que vous voulez,

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

donc dans le paquet.json, vous pouvez ajouter le modules (ou foo et bar ) en tant que paquet sans publication ni utilisation de serveur externe comme ceci:

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

après cela vous faites npm install , et vous pouvez accéder au code avec var foo = require("foo") , tout comme vous le faites avec tous les autres paquets.

plus d'informations peuvent être trouvées ici:

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

et voici comment pour créer un paquet:

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

ce que j'aime faire est de tirer parti de la façon dont les noeuds se chargent à partir du répertoire node_module pour cela.

si on essaie de charger le module "chose", on ferait quelque chose comme

require('thing');

cherchera alors le répertoire "thing" dans le répertoire "node_module".

puisque node_module est normalement à la base du projet, nous pouvons tirer parti de cette cohérence. (Si node_module n'est pas à la racine, puis vous avez d'autres maux de tête auto-induits à gérer.)

si nous allons dans le répertoire et que nous nous en éloignons, nous pouvons obtenir un chemin cohérent vers la racine du projet de noeud.

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

alors si nous voulons accéder au répertoire /happy, nous le ferons.

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

bien qu'il soit un peu hacky, cependant je pense que si la fonctionnalité de comment node_modules charge change, il y aura des problèmes plus importants à traiter. Ce comportement devrait rester cohérent.

Pour clarifier les choses, je le fais, parce que le nom de module n'a pas d'importance.

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

Je l'ai utilisé récemment pour angular2. Je veux charger un service à partir de la racine.

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

une autre réponse:

imaginez cette structure de dossiers:

• node_modules
  • lodash
• src
  • subdir
    • foo.js
    • bar.js
  • principal.js

• essais

  • .js

puis dans .js , vous avez besoin de fichiers comme ceci:

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

et dans principal.js :

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

Maintenant vous pouvez utiliser babel et le babel-plugin-module-resolver avec ceci . babelrc fichier pour configurer 2 dossiers racine:

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

Maintenant, vous pouvez exiger des fichiers de la même manière dans tests et dans src :

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

et si vous voulez utiliser la module es6 syntaxe:

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

puis vous importez des fichiers dans essais et src comme ceci:

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

ne pouvait pas le répertoire examples contenir un node_modules avec un lien symbolique à la racine du projet project -> ../../ permettant ainsi aux exemples d'utiliser require('project') , bien que cela ne supprime pas la cartographie, il permet à la source d'utiliser require('project') plutôt que require('../../') .

j'ai testé ceci, et cela fonctionne avec v0.6.18.

liste de project répertoire:

$ 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 -> ../../

le contenu de index.js attribue une valeur à une propriété de l'objet exports et invoque console.log avec un message qui indique qu'il était requis. Le contenu de test.js est require('project') .

Si quelqu'un cherche encore une autre façon de contourner ce problème, voici ma contribution à l'effort:

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

l'idée de base: vous créez un fichier JSON dans la racine du projet qui établit une correspondance entre vos chemins de fichiers et les noms des raccourcis (ou obtenez use-automapper pour le faire pour vous). Vous pouvez alors demander vos fichiers / modules l'utilisation de ces noms. Comme ceci:

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

donc voilà.

j'ai écrit ce petit paquet qui vous permet d'avoir besoin des paquets par leur chemin relatif à partir de la racine du projet, sans introduire de variables globales ou de noeuds par défaut

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

ça marche comme ça

// 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()

j'ai créé un module de noeud appelé "rekiure"

il vous permet d'exiger sans l'utilisation de chemins relatifs

https://npmjs.org/package/rekuire

il est super facile à utiliser

Nous sommes sur le point d'essayer une nouvelle façon de s'attaquer à ce problème.

en prenant des exemples d'autres projets connus comme spring et guice, nous définirons un objet" context "qui contiendra toutes les instructions" require".

cet objet sera ensuite passé à tous les autres modules pour être utilisé.

par exemple

var context = {}

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

cela nous oblige à écrire chaque module comme une fonction qui reçoit opts, qui regarde pour nous, en tant que meilleure pratique de toute façon..

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

et ensuite vous vous référerez au contexte au lieu d'exiger des trucs.

var module1Ref = context.moduel1;

si vous voulez, vous pouvez facilement écrire une boucle pour faire les instructions require""

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

cela devrait rendre la vie plus facile quand vous voulez vous moquer (tests) et résout également votre problème en cours de route tout en rendant votre code réutilisable comme un paquet.

vous pouvez également réutiliser le code d'initialisation du contexte en séparant la déclaration beans de celle-ci. par exemple, votre fichier main.js pourrait ressembler à

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

cette méthode s'applique également aux bibliothèques externes, il n'est pas nécessaire de changer le code de leur nom chaque fois que nous en avons besoin - cependant il faudra un traitement spécial car leurs exportations ne sont pas des fonctions qui attendent le contexte..

plus tard, nous pouvons aussi définir haricots comme fonctions - qui nous permettra de require différents modules selon l'environnement - mais qu'il hors de la portée de ce fil.

j'avais des problèmes avec ce même problème, donc j'ai écrit un paquet appelé include .

Include handles comprendre le dossier racine de votre projet en localisant votre paquet.JSON file, passe ensuite l'argument path que vous lui donnez à la requête native() sans tout le désordre relatif path. J'imagine que ce n'est pas un remplacement pour require (), mais un outil pour exiger le traitement de fichiers non empaquetés / non-tiers ou des bibliothèques. Quelque chose comme

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

j'espère que cela peut être utile.

si le fichier point d'entrée js de votre application (c'est-à-dire celui sur lequel vous avez réellement lancé" node") se trouve dans le répertoire racine de votre projet, vous pouvez le faire très facilement avec le rootpath npm module . Il suffit de l'installer via

npm install --save rootpath

...puis, en haut du fichier de point d'entrée js, ajouter:

require('rootpath')();

à partir de ce moment tous les appels require sont maintenant relatifs à la racine du projet-par exemple require('../../../config/debugging/log'); devient require('config/debugging/log'); (où le dossier de configuration est dans la racine du projet).

en lignes simples, vous pouvez appeler votre propre dossier comme module:

Pour cela nous avons besoin: global et app-module-module path

ici "App-module-path" est le module ,il vous permet d'ajouter des répertoires supplémentaires au noeud.chemin de recherche du module js Et "global" est, tout ce que vous attachez à cet objet sera disponible partout dans votre application.

regardez maintenant cet extrait:

global.appBasePath = __dirname;

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

__dirname est le répertoire courant du noeud.Vous pouvez donner votre propre chemin ici pour rechercher le chemin du module.

Juste à suivre sur le grande réponse à partir de Paolo Moretti et Browserify. Si vous utilisez un transpondeur (par exemple babel, typescript) et que vous avez des dossiers séparés pour le code source et le code transpilé comme src/ et dist/ , vous pouvez utiliser une variante des solutions comme

node_modules

avec la structure de répertoire suivante:

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

vous pouvez alors laisser babel etc à transpile src répertoire à dist répertoire.

lien

en utilisant symlink nous pouvons nous débarrasser de certains niveaux de nidification:

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

Une mise en garde avec babel --la copie des fichiers Le --copy-files drapeau de la babel ne traite pas avec les liens symboliques. Il peut continuer à naviguer dans le lien symbolique .. et voir de façon récurrente des fichiers sans fin. Un la solution est d'utiliser la structure de répertoire suivante:

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

de cette façon, le code sous src aura toujours app résolu à src , alors que babel ne verrait plus de liens symboliques.

vient de tomber sur cet article qui mentionne app-module-path . Il vous permet de configurer une base comme ceci:

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

il y a quelque temps, j'ai créé module pour charger des modules relatifs à des chemins prédéfinis.

https://github.com/raaymax/irequire

Vous pouvez l'utiliser au lieu de l'exiger.

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

peut-être qu'il sera utile pour quelqu'un..

alors que ces réponses fonctionnent ils ne traitent pas le problème avec le test npm

si, par exemple, je crée une variable globale dans le serveur.js, il ne sera pas réglé pour mon exécution de la suite de test.

pour définir une variable appRoot globale qui évitera le ../../../ problème et seront disponibles dans les deux mnp de début ET de mnp test voir:

Moka tests supplémentaires, des options ou des paramètres

notez qu'il s'agit de la nouvelle solution officielle Moka .