Come posso ottenere il percorso dello script corrente con Node.js?

Come posso ottenere il percorso dello script in Node.js?

So che c'è process.cwd, ma ciò si riferisce solo alla directory in cui è stato chiamato lo script, non allo script stesso. Ad esempio, dire che sono dentro /home/kyle/ed eseguo il comando seguente:

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

Se chiamo process.cwd(), ricevo /home/kyle/, no /home/kyle/some/dir/. C'è un modo per ottenere quella directory?

L'ho trovato dopo aver consultato di nuovo la documentazione. Quello che cercavo era la __filenamee __dirnamevariabili a livello di modulo.

• __filenameè il nome del file del modulo corrente. Questo è il percorso assoluto risolto del file del modulo corrente. (es: /home/kyle/some/dir/file.js)
• __dirnameè il nome della directory del modulo corrente. (es: /home/kyle/some/dir)

Quindi in pratica puoi farlo:

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

Usa resol () invece di concatenare con '/' o '\' altrimenti incontrerai problemi multipiattaforma.

Nota: __dirname è il percorso locale del modulo o dello script incluso. Se stai scrivendo un plugin che deve conoscere il percorso dello script principale è:

require.main.filename

oppure, per ottenere solo il nome della cartella:

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

Questo comando restituisce la directory corrente:

var currentPath = process.cwd();

Ad esempio, per utilizzare il percorso per leggere il file:

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

Usa __dirname !!

__dirname

Il nome della directory del modulo corrente. Questo è lo stesso del path.dirname () di __filename.

Esempio: esecuzione del nodo example.js da / Users / mjr

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

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

Per i moduli ESM vorresti usare: import.meta.url

Quando si tratta dello script principale è semplice come:

process.argv[1]

Dalla documentazione di Node.js :

process.argv

Un array contenente gli argomenti della riga di comando. Il primo elemento sarà 'nodo', il secondo elemento sarà il percorso del file JavaScript . I prossimi elementi saranno eventuali argomenti della riga di comando aggiuntivi.

Se è necessario conoscere il percorso di un file del modulo, utilizzare __filename .

Node.js 10 supporta i moduli ECMAScript , dove __dirnamee __filenamenon sono più disponibili .

Quindi per ottenere il percorso del modulo ES corrente è necessario utilizzare:

import { fileURLToPath } from 'url';

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

E per la directory che contiene il modulo corrente:

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

Ogni programma Node.js ha alcune variabili globali nel suo ambiente, che rappresenta alcune informazioni sul tuo processo e una di esse lo è __dirname.

So che questo è piuttosto vecchio, e la domanda originale a cui stavo rispondendo è contrassegnata come duplicata e diretta qui, ma ho riscontrato un problema nel tentativo di far funzionare i giornalisti di gelsomini e non mi piaceva l'idea che dovevo effettuare il downgrade per farlo funzionare. Ho scoperto che jasmine-reporter non stava risolvendo correttamente savePath e stava effettivamente inserendo l'output della cartella dei report nella directory jasmine-reporter anziché nella directory principale in cui ho eseguito gulp. Per farlo funzionare correttamente ho finito con process.env.INIT_CWD per ottenere la directory di lavoro corrente iniziale che dovrebbe essere la directory in cui hai eseguito gulp. Spero che questo aiuti qualcuno.

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

È possibile utilizzare process.env.PWD per ottenere il percorso della cartella dell'app corrente.

Se stai usando pkgper impacchettare la tua app, troverai utile questa espressione:

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

• process.pkgindica se l'app è stata impacchettata da pkg.

• process.execPathcontiene il percorso completo dell'eseguibile, che è /usr/bin/nodeo simile per invocazioni dirette di script ( node test.js) o dell'app in pacchetto.

• require.main.filename contiene l'intero percorso dello script principale, ma è vuoto quando Node viene eseguito in modalità interattiva.

• __dirnamecontiene l'intero percorso dello script corrente , quindi non lo sto usando (anche se potrebbe essere quello che OP richiede; quindi meglio usare appDirectory = process.pkg ? require('path').dirname(process.execPath) : (__dirname || require('path').dirname(process.argv[0]));notando che in modalità interattiva __dirnameè vuoto.

• Per la modalità interattiva, utilizzare process.argv[0]per ottenere il percorso dell'eseguibile Nodo o process.cwd()per ottenere la directory corrente.

Utilizzare il basenamemetodo del pathmodulo:

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

Qui la documentazione da cui è tratto l'esempio sopra.

Come ha sottolineato Dan, Node sta lavorando su moduli ECMAScript con il flag "--experimental-modules". Il nodo 12 supporta__dirname__filename ancora e come sopra.

Se stai usando la --experimental-modulesbandiera, c'è un approccio alternativo .

L'alternativa è ottenere il percorso al modulo ES corrente :

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

E per la directory che contiene il modulo corrente:

import path from 'path';

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

Se vuoi qualcosa di più simile a $ 0 in uno script di shell, prova questo:

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;
    }
}