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.