161 votes

path.join vs path.resolve avec __dirname

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.

0 votes

Cette question est en cours de discussion sur méta

2 votes

0 votes

Il semble que la réponse acceptée ait été retirée

170voto

Mike Points 2234

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.

29 votes

Nit : __dirname est le chemin d'accès absolu au répertoire contenant le fichier source en cours d'exécution, et non le chemin d'accès à la base de données. le répertoire de travail actuel . La première sera toujours la même (à moins que vous ne déplaciez le fichier) ; la seconde est une paramètre valable pour l'ensemble du processus qui varie en fonction de la façon dont vous avez lancé le nœud et si vous avez ou non l'a changé .

2 votes

Il n'y a donc aucune différence entre __dirname y path.resolve(__dirname) ?

1 votes

@georaldc : J'en ai trouvé un : node <<"path=require('path') ; console.log(__dirname) ; console.log(path.resolve(__dirname))".

31voto

Samuel J Mathew Points 2853
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.

0 votes

La question portait spécifiquement sur path.join vs path.resolve avec __dirname .

0 votes

J'ai mis à jour la réponse en fonction de vos commentaires. Merci pour la mise à jour.

5voto

lonr Points 11

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/'

0 votes

Que signifie le mot "normalisé" dans ce contexte ?

1 votes

1voto

Abraham Points 441

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"

0 votes

directement avec le chemin Root pour faire un chemin absolu - il ne se contente pas de concaténer mais considère les chemins absolus /a et /b, ceux d'Unix sont précédés de la lettre du disque actuel sous Windows.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X