path.join vs path.resolve avec __dirname

Existe-t-il une différence lors de l’utilisation de path.join et path.resolve avec __dirname pour résoudre le chemin absolu dans Node.js?

Est-ce que l’un d’entre eux devrait être préféré lorsqu’il est utilisé comme ça (les résolutions de chemin absolu sont 90% des cas d’utilisation)?

C’est à dire

 const absolutePath = path.join(__dirname, some, dir); 

contre.

 const absolutePath = path.resolve(__dirname, some, dir); 

Les deux méthodes normalisent le chemin.

Ce n’est pas une duplication de cette question car la réponse acceptée est fausse.

Oui, il y a une différence entre les fonctions, mais la manière dont vous les utilisez dans ce cas aboutira au même résultat.

path.join renvoie un chemin normalisé en fusionnant deux chemins ensemble. Il peut renvoyer un chemin absolu, mais pas toujours.

Par exemple:

 path.join('app/libs/oauth', '/../ssl') 

se résout en app/libs/ssl

path.resolve , d’autre part, se résoudra en un chemin absolu.

Par exemple, lorsque vous exécutez:

 path.resolve('bar', '/foo'); 

Le chemin retourné sera /foo car c’est le premier chemin absolu pouvant être construit.

Cependant, si vous exécutez:

 path.resolve('/bar/bae', '/foo', 'test'); 

Le chemin retourné sera /foo/test nouveau parce que c’est le premier chemin absolu pouvant être formé de droite à gauche.

Si vous ne fournissez pas de chemin qui spécifie le répertoire racine, les chemins donnés à la fonction resolve sont ajoutés au répertoire de travail en cours. Donc, si votre répertoire de travail était /home/mark/project/ :

 path.resolve('test', 'directory', '../back'); 

décide de

/home/mark/project/test/back

Utiliser __dirname donne un chemin absolu vers votre répertoire de travail actuel. Lorsque vous utilisez path.resolve ou path.join ils path.join le même résultat si vous __dirname le même chemin après __dirname . Dans de tels cas, c’est vraiment une question de préférence.

 const absolutePath = path.join(__dirname, some, dir); 

contre.

 const absolutePath = path.resolve(__dirname, some, dir); 

path.join concaténera __dirname qui est le nom du répertoire du fichier en cours concaténé avec les valeurs some et dir avec un séparateur spécifique à la plateforme

tandis que

path.resolve traitera __dirname , some et dir c.-à-d. de gauche à droite avant de le traiter.

si l’une des valeurs de some ou dir correspond à un chemin racine, le chemin précédent sera omis et traitera le rest en le considérant comme root

Afin de mieux comprendre le concept, laissez-moi vous expliquer un peu les détails suivants:

path.join et path.resolve sont deux méthodes ou fonctions différentes du module de chemin fourni par nodejs.

Où les deux acceptent une liste de chemin mais la différence entre dans le résultat, c’est-à-dire comment ils traitent ces chemins.

path.join concatène tous les segments de chemin donnés en utilisant le séparateur spécifique à la plate-forme comme délimiteur, puis normalise le chemin résultant. tandis que path.resolve() traite la séquence de chemins de droite à gauche, chaque chemin suivant étant ajouté à l’avance jusqu’à ce qu’un chemin absolu soit construit.

Quand aucun argument fourni

L’exemple suivant vous aidera à comprendre clairement les deux concepts: –

mon nom de fichier est index.js et le répertoire de travail actuel est 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 

Résultat

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

path.resolve() méthode path.resolve() affichera le chemin absolu où retourne path.join() . représentant le répertoire de travail en cours si rien n’est fourni

Quand un chemin racine est passé en argument

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

Résultat i

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

path.join() concatène uniquement la liste d’entrée avec un séparateur spécifique à la plate-forme, tandis que path.resolve() traite la séquence de chemins de droite à gauche, chaque chemin suivant étant ajouté jusqu’à ce qu’un chemin absolu soit construit.