Differenza tra invocazione path.resolve e path.join?

C'è qualche differenza tra le seguenti invocazioni?

path.join(__dirname, 'app')

vs.

path.resolve(__dirname, 'app')

Quale dovrebbe essere preferito?

Le due funzioni hanno a che fare con segmenti che iniziano /in modi molto diversi; joinlo concatenerà con l'argomento precedente, tuttavia resolvelo tratterà come la directory principale e ignorerà tutti i percorsi precedenti - pensalo come il risultato dell'esecuzione cdcon ogni argomento:

path.join('/a', '/b') // Outputs '/a/b'

path.resolve('/a', '/b') // Outputs '/b'

Un'altra cosa da notare è che path.resolvesi tradurrà sempre in un URL assoluto e utilizzerà la directory di lavoro come base per risolvere questo percorso. Ma poiché __dirnameè un percorso assoluto, questo non ha importanza nel tuo caso.

Quanto a quale dovresti usare, la risposta è: dipende da come vuoi che i segmenti inizino /a comportarsi - dovrebbero essere semplicemente uniti o dovrebbero agire come la nuova radice?

Se gli altri argomenti sono hard coded, in realtà non importa, nel qual caso dovresti probabilmente considerare (a) come questa linea potrebbe cambiare in futuro e (b) quanto sia coerente con altre posizioni nel codice.

Le operazioni predefinite del percorso del file system variano in base al sistema operativo di cui abbiamo bisogno per renderlo astratto. Il pathmodulo fornisce utilità o API per lavorare con i percorsi di file e directory. puoi includerlo nel tuo progetto usando

const path = require('path');

I path.joine path.resolvesono due diversi metodi del modulo path.

Entrambi questi metodi accettano una sequenza di percorsi o segmenti di percorso.

Il path.resolve()metodo risolve una sequenza di percorsi o segmenti di percorso in un percorso assoluto .

Il path.join()metodo unisce tutti i segmenti di percorso indicati utilizzando il separatore specifico della piattaforma come delimitatore, quindi normalizza il percorso risultante.

Per comprendere meglio e differenziare i comportamenti, lasciatemi spiegare con diversi scenari.

1. Se non forniamo alcun argomento o stringa vuota

nel mio caso, il mio nome file è index.jse la directory di lavoro corrente èE:\MyFolder\Pjtz\node

const path = require('path');

console.log("path.join() : ", path.join());
// outputs .
console.log("path.resolve() : ", path.resolve());
// outputs current directory or equalent to __dirname of the node process

e il risultato della corsa è il seguente

λ node index.js
path.join() :  .
path.resolve() :  E:\MyFolder\Pjtz\node

L'inferenza di cui sopra è l'esperimento che il path.resolve()metodo produrrà il percorso assoluto dove come path.join()ritorna. che rappresenta la directory di lavoro corrente o il relativo percorso se non viene fornito nulla

2. Aggiunta di un percorso / come qualsiasi argomento.

const path=require('path');

console.log("path.join() : " ,path.join('abc','/bcd'));
console.log("path.resolve() : ",path.resolve('abc','/bcd'));

e il risultato è

λ node index.js
path.join() :  abc\bcd
path.resolve() :  E:\bcd

L'inferenza che possiamo trovare con questo esperimento è che path.join()concatena solo l'elenco di input con un separatore specifico della piattaforma mentre il path.resolve()processo la sequenza di percorsi da destra a sinistra, con ogni percorso successivo anteposto fino alla costruzione di un percorso assoluto.

path.join()concatena ogni argomento con separatori specifici del sistema operativo, mentre path.resolve()risolverà ogni argomento con root e produrrà output.

1) path.resolve crea il percorso assoluto.

Il metodo crea un percorso assoluto da destra a sinistra fino a quando non viene creato un percorso assoluto.

Per esempio:

path.resolve('/a', 'b', 'c');     //    C:\a\b\c
path.resolve('/a', '/b', 'c');    //    C:\b\c
path.resolve('/a', '/b', '/c');   //    C:\c

Se non viene generato il percorso assoluto, il metodo che utilizza la directory di lavoro corrente:

Per esempio:

path.resolve('a', 'b', 'c');     //    C:\{current_working_directory}\a\b\c

2) path.join unisce tutti i percorsi e normalizza il risultato

Per esempio:

path.join('/a', '/b', '/c');   //   \a\b\c
path.join('/a', '/b', 'c');    //   \a\b\c
path.join('/a', 'b', 'c');     //   \a\b\c
path.join('a', 'b', 'c');      //   \a\b\c