Comment obtenir le chemin d'accès au script actuel avec Node.js?

Comment puis-je obtenir le chemin d'accès au script dans Node.js?

Je sais qu'il y en a process.cwd, mais cela ne fait référence qu'au répertoire où le script a été appelé, pas au script lui-même. Par exemple, disons que je suis dedans /home/kyle/et que j'exécute la commande suivante:

node /home/kyle/some/dir/file.js

Si j'appelle process.cwd(), je reçois /home/kyle/, non /home/kyle/some/dir/. Existe-t-il un moyen d'obtenir ce répertoire?

Je l'ai trouvé après avoir parcouru à nouveau la documentation. Ce que je cherchais, c'était les variables de niveau module __filenameet __dirname.

• __filenameest le nom de fichier du module actuel. Il s'agit du chemin absolu résolu du fichier de module actuel. (ex: /home/kyle/some/dir/file.js)
• __dirnameest le nom du répertoire du module actuel. (ex: /home/kyle/some/dir)

Donc, fondamentalement, vous pouvez le faire:

fs.readFile(path.resolve(__dirname, 'settings.json'), 'UTF-8', callback);

Utilisez resolver () au lieu de concaténer avec '/' ou '\' sinon vous rencontrerez des problèmes multiplates-formes.

Remarque: __dirname est le chemin local du module ou du script inclus. Si vous écrivez un plugin qui a besoin de connaître le chemin du script principal c'est:

require.main.filename

ou, pour obtenir simplement le nom du dossier:

require('path').dirname(require.main.filename)

Cette commande renvoie le répertoire courant:

var currentPath = process.cwd();

Par exemple, pour utiliser le chemin d'accès pour lire le fichier:

var fs = require('fs');
fs.readFile(process.cwd() + "\\text.txt", function(err, data)
{
    if(err)
        console.log(err)
    else
        console.log(data.toString());
});

Utilisez __dirname !!

__dirname

Le nom du répertoire du module actuel. C'est la même chose que le path.dirname () du __filename.

Exemple: exécution de node example.js à partir de / Users / mjr

console.log(__dirname);
// Prints: /Users/mjr
console.log(path.dirname(__filename));
// Prints: /Users/mjr

https://nodejs.org/api/modules.html#modules_dirname

Pour les ESModules, vous souhaitez utiliser: import.meta.url

En ce qui concerne le script principal, c'est aussi simple que:

process.argv[1]

Dans la documentation Node.js :

process.argv

Un tableau contenant les arguments de la ligne de commande. Le premier élément sera «nœud», le deuxième élément sera le chemin d'accès au fichier JavaScript . Les éléments suivants seront tous les arguments de ligne de commande supplémentaires.

Si vous avez besoin de connaître le chemin d'un fichier de module, utilisez __filename .

Node.js 10 prend en charge les modules ECMAScript , où __dirnameet __filenamene sont plus disponibles .

Ensuite, pour obtenir le chemin vers le module ES actuel, il faut utiliser:

import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);

Et pour le répertoire contenant le module courant:

import { dirname } from 'path';
import { fileURLToPath } from 'url';

const __dirname = dirname(fileURLToPath(import.meta.url));

var settings = 
    JSON.parse(
        require('fs').readFileSync(
            require('path').resolve(
                __dirname, 
                'settings.json'),
            'utf8'));

Chaque programme Node.js a des variables globales dans son environnement, qui représentent des informations sur votre processus et l'une d'elles __dirname.

Je sais que c'est assez vieux, et la question d'origine à laquelle je répondais est marquée comme dupliquée et dirigée ici, mais j'ai rencontré un problème en essayant de faire travailler les reporters de jasmin et je n'aimais pas l'idée que je devais rétrograder dans pour qu'il fonctionne. J'ai découvert que jasmine-reporters ne résolvait pas correctement le savePath et mettait en fait la sortie du dossier de rapports dans le répertoire jasmine-reporters au lieu du répertoire racine de l'endroit où j'ai exécuté gulp. Pour que cela fonctionne correctement, j'ai fini par utiliser process.env.INIT_CWD pour obtenir le répertoire de travail actuel initial qui devrait être le répertoire où vous avez exécuté gulp. J'espère que cela aide quelqu'un.

var reporters = require('jasmine-reporters');
var junitReporter = new reporters.JUnitXmlReporter({
  savePath: process.env.INIT_CWD + '/report/e2e/',
  consolidateAll: true,
  captureStdout: true
 });

Vous pouvez utiliser process.env.PWD pour obtenir le chemin du dossier d'application actuel.

Si vous utilisez pkgpour empaqueter votre application, vous trouverez cette expression utile:

appDirectory = require('path').dirname(process.pkg ? process.execPath : (require.main ? require.main.filename : process.argv[0]));

• process.pkgindique si l'application a été mise en package par pkg.

• process.execPathcontient le chemin complet de l'exécutable, qui est /usr/bin/nodeou similaire pour les appels directs de scripts ( node test.js), ou de l'application empaquetée.

• require.main.filename contient le chemin complet du script principal, mais il est vide lorsque Node s'exécute en mode interactif.

• __dirnamecontient le chemin complet du script actuel , donc je ne l'utilise pas (bien que ce soit peut-être ce que demande OP; alors mieux vaut appDirectory = process.pkg ? require('path').dirname(process.execPath) : (__dirname || require('path').dirname(process.argv[0]));noter qu'en mode interactif __dirnameest vide.

• Pour le mode interactif, utilisez soit process.argv[0]pour obtenir le chemin d'accès à l'exécutable Node, soit process.cwd()pour obtenir le répertoire courant.

Utilisez la basenameméthode du pathmodule:

var path = require('path');
var filename = path.basename(__filename);
console.log(filename);

Voici la documentation dont l'exemple ci-dessus est tiré.

Comme Dan l'a souligné, Node travaille sur des modules ECMAScript avec l'indicateur "--experimental-modules". Le noeud 12 prend__dirname__filename toujours en charge et comme ci-dessus.

Si vous utilisez le --experimental-modulesdrapeau, il existe une approche alternative .

L'alternative est d'obtenir le chemin vers le module ES actuel :

const __filename = new URL(import.meta.url).pathname;

Et pour le répertoire contenant le module courant:

import path from 'path';

const __dirname = path.dirname(new URL(import.meta.url).pathname);

Si vous voulez quelque chose de plus comme $ 0 dans un script shell, essayez ceci:

var path = require('path');

var command = getCurrentScriptPath();

console.log(`Usage: ${command} <foo> <bar>`);

function getCurrentScriptPath () {
    // Relative path from current working directory to the location of this script
    var pathToScript = path.relative(process.cwd(), __filename);

    // Check if current working dir is the same as the script
    if (process.cwd() === __dirname) {
        // E.g. "./foobar.js"
        return '.' + path.sep + pathToScript;
    } else {
        // E.g. "foo/bar/baz.js"
        return pathToScript;
    }
}