path.join vs path.resolve avec __dirname

Question

Y a-t-il une différence lorsqu'on utilise les deux path.join y path.resolve con __dirname pour résoudre le chemin absolu dans Node.js ?

Faut-il préférer l'une d'entre elles lorsqu'elle est utilisée de cette manière (les résolutions de chemins absolus représentent 90 % des cas d'utilisation) ?

I.e.

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

vs.

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

Les deux méthodes normalisent le chemin.

Answer 1

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

path.join renvoie un chemin normalisé en fusionnant deux chemins ensemble. Elle peut renvoyer un chemin absolu, mais ne le fait pas nécessairement toujours.

Par exemple :

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

se résout à app/libs/ssl

path.resolve d'autre part, sera résolu en un chemin absolu.

Par exemple, lorsque vous exécutez :

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

Le chemin renvoyé sera /foo puisque c'est le premier chemin absolu qui peut être construit.

Cependant, si vous exécutez :

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

Le chemin renvoyé sera /foo/test encore une fois parce que c'est le premier chemin absolu qui peut être formé de droite à gauche.

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

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

se résout à

/home/mark/project/test/back

Utilisation de __dirname est le chemin absolu vers le répertoire contenant le fichier source. Lorsque vous utilisez path.resolve o path.join ils retourneront le même résultat si vous donnez le même chemin suivant __dirname . Dans ce cas, ce n'est qu'une question de préférence.

Answer 2

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

vs.

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

path.join concaténera __dirname qui est le nom du répertoire du fichier courant concaténé avec les valeurs de some y dir avec un séparateur spécifique à la plate-forme.

Considérant que

path.resolve traitera __dirname , some y dir c'est-à-dire de la droite vers la gauche, en le traitant au préalable.

Si l'une des valeurs de some o dir correspond à un chemin racine, le chemin précédent sera omis et le reste sera traité en le considérant comme un chemin racine.

Afin de mieux comprendre le concept, permettez-moi d'expliquer les deux en détail comme suit:-

El path.join y path.resolve sont deux méthodes ou fonctions différentes du module path fourni par nodejs.

Les deux acceptent une liste de chemins, mais la différence réside dans le résultat, c'est-à-dire la manière dont 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. Bien que le path.resolve() traite la séquence de chemins de droite à gauche, chaque chemin suivant étant ajouté au début jusqu'à ce qu'un chemin absolu soit construit.

Si aucun argument n'est fourni

L'exemple suivant vous aidera à comprendre clairement ces 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 equivalent to __dirname

Résultat

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

path.resolve() affichera le chemin absolu, tandis que la méthode path.join() retourne . représentant le répertoire de travail actuel si rien n'est fourni

Quand un chemin de racine est passé comme 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 la méthode path.resolve() traite la séquence de chemins de droite à gauche, chaque chemin suivant étant ajouté au début jusqu'à ce qu'un chemin absolu soit construit.

Answer 3

Extrait du document pour path.resolve :

Le chemin d'accès résultant est normalisé et les barres obliques de fin de ligne sont supprimées, sauf si le chemin d'accès est résolu dans le répertoire racine.

Mais path.join conserve les barres obliques

Alors

__dirname = '/';
path.resolve(__dirname, 'foo/'); // '/foo'
path.join(__dirname, 'foo/'); // '/foo/'

Answer 4

Dans les termes les plus simples :

Lorsque vous utilisez path.resolve() Il fait ce qui suit

from left to right-

• concaténer la plupart des paramètres de droite avec / directement avec le chemin de la racine pour obtenir un chemin absolu (voir les exemples).
• et concatène ensuite tout ce qui n'est pas / comme un répertoire

par exemple

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

---

En utilisant join() concatène simplement chaque paramètre de gauche à droite, qu'ils aient / ou non

path.join("/a", "b", "/c", "d")   simply returns   "\a\b\c\d"