Déterminer la racine du projet à partir d'un nœud en cours d'exécution.application js

__dirname n'est pas un global; il est local au module actuel, donc chaque fichier a sa propre valeur locale et différente.

Si vous voulez le répertoire racine du processus en cours, vous voulez probablement utiliser process.cwd().

Si vous voulez de la prévisibilité et de la fiabilité, vous devez probablement exiger de votre application qu'une certaine variable d'environnement soit définie. Votre application recherche MY_APP_HOME (ou autre) et si elle est là, et que l'application existe dans ce répertoire, tout est Bien. S'il n'est pas défini ou si le répertoire ne contient pas votre application, il devrait sortir avec une erreur invitant l'utilisateur à créer la variable. Il pourrait être défini dans le cadre d'un processus d'installation.

Vous pouvez lire les variables d'environnement dans le nœud avec quelque chose comme process.env.MY_ENV_VARIABLE.

1 - créer un fichier dans la racine du projet de l'appeler paramètres.js

2-à l'intérieur de ce fichier ajouter ce code

module.exports = {
    POST_MAX_SIZE : 40 , //MB
    UPLOAD_MAX_FILE_SIZE: 40, //MB
    PROJECT_DIR : __dirname
};

3 - inside node_modules créer un nouveau nom de module "paramètres" et à l'intérieur de l'index du module.js écrire ce code:

module.exports = require("../../settings");

4-et chaque fois que vous voulez que votre répertoire de projet utilise simplement

var settings = require("settings");
settings.PROJECT_DIR; 

De cette façon, vous aurez tous les répertoires de Projet relatifs à ce fichier ;)

Le moyen le plus simple d'obtenir la racine globale (en supposant que vous utilisez NPM pour exécuter votre nœud.js app 'npm démarrer", etc)

var appRoot = process.env.PWD;

Si vous voulez vérifier le{[8 ci-dessus]}

Dites que vous voulez recouper process.env.PWD avec les paramètres de votre nœud.application js. si vous voulez que certains tests d'exécution vérifient la validité de process.env.PWD, Vous pouvez le recouper avec ce code (que j'ai écrit et qui semble bien fonctionner). Vous pouvez recouper le nom du dernier dossier dans appRoot avec le npm_package_name dans votre paquet.fichier json, par exemple:

    var path = require('path');

    var globalRoot = __dirname; //(you may have to do some substring processing if the first script you run is not in the project root, since __dirname refers to the directory that the file is in for which __dirname is called in.)

    //compare the last directory in the globalRoot path to the name of the project in your package.json file
    var folders = globalRoot.split(path.sep);
    var packageName = folders[folders.length-1];
    var pwd = process.env.PWD;
    var npmPackageName = process.env.npm_package_name;
    if(packageName !== npmPackageName){
        throw new Error('Failed check for runtime string equality between globalRoot-bottommost directory and npm_package_name.');
    }
    if(globalRoot !== pwd){
        throw new Error('Failed check for runtime string equality between globalRoot and process.env.PWD.');
    }

Vous pouvez également utiliser ce module NPM: require('app-root-path') qui fonctionne très bien à cet effet

J'ai trouvé que cela fonctionne de manière cohérente pour moi, même lorsque l'application est appelée à partir d'un sous-dossier, comme cela peut être le cas avec certains frameworks de test, comme Mocha:

process.mainModule.paths[0].split('node_modules')[0].slice(0, -1);

Pourquoi cela fonctionne:

Au noeud d'exécution crée un registre des chemins complets de tous les fichiers chargés. Les modules sont chargés en premier, et donc en haut de ce registre. En sélectionnant le premier élément du registre et en retournant le chemin avant le répertoire 'node_modules', nous sommes en mesure de déterminer la racine du application.

C'est juste une ligne de code, mais pour des raisons de simplicité (mon bien), je l'ai encadré en noir dans un module NPM:

Https://www.npmjs.com/package/node-root.pddivine

Profitez!

Tous ces "root dirs" ont surtout besoin de résoudre un chemin virtuel vers un chemin de pile réel, alors peut-être que vous devriez regarder path.resolve?

var path= require('path');
var filePath = path.resolve('our/virtual/path.ext");

Peut-être que vous pouvez essayer de traverser vers le haut à partir de __filename jusqu'à ce que vous trouviez un package.json, et décidez que c'est le répertoire principal auquel appartient votre fichier actuel.

Une technique que j'ai trouvée utile lors de l'utilisation d'express consiste à ajouter ce qui suit à l'application.js avant que l'une de vos autres routes ne soit définie

// set rootPath
app.use(function(req, res, next) {
  req.rootPath = __dirname;
  next();
});

app.use('/myroute', myRoute);

Pas besoin d'utiliser des globals et vous avez le chemin du répertoire racine comme propriété de l'objet request.

Cela fonctionne si votre application.js est à la racine de votre projet qui, par défaut, il est.

En fait, je trouve la solution peut-être triviale aussi la plus robuste: vous placez simplement le fichier suivant dans le répertoire racine de votre projet: root-path.js qui a le code suivant:

import * as path from 'path' const projectRootPath = path.resolve(__dirname) export const rootPath = projectRootPath

J'utilise ceci.

Pour mon module nommé mymodule

var BASE_DIR = __dirname.replace(/^(.*\/mymodule)(.*)$/, '$1')

Créer une fonction dans l'application.js

/*Function to get the app root folder*/

var appRootFolder = function(dir,level){
    var arr = dir.split('\\');
    arr.splice(arr.length - level,level);
    var rootFolder = arr.join('\\');
    return rootFolder;
}

// view engine setup
app.set('views', path.join(appRootFolder(__dirname,1),'views'));

En haut du fichier principal Ajouter:

mainDir = __dirname;

Ensuite, utilisez-le dans n'importe quel fichier dont vous avez besoin:

console.log('mainDir ' + mainDir);

• {[2] } est défini globalement, Si vous en avez besoin uniquement dans le fichier actuel-utilisez __dirname à la place.
• le fichier principal est généralement dans le dossier racine du projet et est nommé comme main.js, index.js, gulpfile.js.

Rendez-le sexy .

const users = require('../../../database/users'); //  what you have
// OR
const users = require('$db/users'); //  no matter how deep you are
const products = require('/database/products'); //  alias or pathing from root directory

Trois étapes simples pour résoudre le problème du chemin laid.

1. Installer le paquet: npm install sexy-require --save
   

2. Incluez require('sexy-require') Une fois en haut de votre fichier d'application principal.

   require('sexy-require');
   const routers = require('/routers');
   const api = require('$api');
   ...
   

3. Étape facultative. La configuration du chemin peut être définie dans le fichier .paths du répertoire racine de votre projet.

   $db = /server/database
   $api-v1 = /server/api/legacy
   $api-v2 = /server/api/v2
   

process.mainModule.paths
  .filter(p => !p.includes('node_modules'))
  .shift()

Récupère tous les chemins dans les modules principaux et filtre ceux avec " node_modules", ensuite, obtenez le premier de la liste de chemin restante. Un comportement inattendu ne lancera pas d'erreur, juste un undefined.

Fonctionne bien pour moi, même en appelant ie $ mocha.

Vous pouvez simplement ajouter le chemin du répertoire racine dans la variable express app et obtenir ce chemin à partir de l'application. Pour cela, ajoutez app.set('rootDirectory', __dirname); dans votre index.js ou de l'application.fichier js. Et utilisez req.app.get('rootDirectory') pour obtenir le chemin du répertoire racine dans votre code.

Ancienne question, je sais, mais aucune mention de question à utiliser progress.argv. Le tableau argv inclut un chemin d'accès complet et un nom de fichier (avec ou sans .extension js) qui a été utilisé comme paramètre à exécuter par le nœud. Parce que cela peut également contenir des drapeaux, vous devez filtrer cela.

Ce n'est pas un exemple que vous pouvez utiliser directement (en raison de l'utilisation de mon propre framework) mais je pense que cela vous donne une idée de la façon de le faire. J'utilise également une méthode de cache pour éviter que l'appel de cette fonction ne mette trop l'accent sur le système, surtout quand aucune extension n'est spécifiée (et qu'un fichier existe est requis), par exemple:

node myfile

Ou

node myfile.js

C'est la raison pour laquelle je le cache, voir aussi le code ci-dessous.

function getRootFilePath()
{
        if( !isDefined( oData.SU_ROOT_FILE_PATH ) )
        {
            var sExt = false;

            each( process.argv, function( i, v )
            {
                 // Skip invalid and provided command line options
                if( !!v && isValidString( v ) && v[0] !== '-' )
                {
                    sExt = getFileExt( v );

                    if( ( sExt === 'js' ) || ( sExt === '' && fileExists( v+'.js' )) )
                    {

                        var a = uniformPath( v ).split("/"); 

                         // Chop off last string, filename
                        a[a.length-1]='';

                         // Cache it so we don't have to do it again.
                        oData.SU_ROOT_FILE_PATH=a.join("/"); 

                         // Found, skip loop
                        return true;
                    }
                }
            }, true ); // <-- true is: each in reverse order
        }

        return oData.SU_ROOT_FILE_PATH || '';
    }
}; 

Ajoutez ceci quelque part vers le début de votre fichier d'application principal (par exemple, app.js):

global.__basedir = __dirname;

Cela définit une variable globale qui sera toujours équivalente au répertoire de base de votre application. S'utilise comme n'importe quelle autre variable:

const yourModule = require(__basedir + '/path/to/module.js');

Simple...

Essayez path._makeLong('some_filename_on_root.js');

Exemple:

cons path = require('path');
console.log(path._makeLong('some_filename_on_root.js');

Qui retournera le chemin complet de la racine de votre application node (même position du paquet.json)

Pour obtenir le chemin du fichier actuel:

définir dans ce fichier:

    var get_stack = function() {
        var orig = Error.prepareStackTrace;
        Error.prepareStackTrace = function(_, stack) {
            return stack;
        };
        var err = new Error;
        Error.captureStackTrace(err, arguments.callee);
        var stack = err.stack;
        Error.prepareStackTrace = orig;
        return stack;
    };

Utilisation dans ce fichier:

    console.log(get_stack()[0].getFileName());

API:
StackTrace