Différence entre les appels path.resolve et path.join?

Y a-t-il une différence entre les invocations suivantes?

path.join(__dirname, 'app')

contre.

path.resolve(__dirname, 'app')

Lequel doit être préféré?

Les deux fonctions traitent des segments commençant par /des manières très différentes; joinle concaténera simplement avec l'argument précédent, mais resolvele traitera comme le répertoire racine et ignorera tous les chemins précédents - pensez-y comme le résultat de l'exécution cdavec chaque argument:

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

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

Une autre chose à noter est que cela path.resolvedonnera toujours une URL absolue et utilisera votre répertoire de travail comme base pour résoudre ce chemin. Mais comme __dirnamec'est un chemin absolu de toute façon, cela n'a pas d'importance dans votre cas.

Quant à celui que vous devriez utiliser, la réponse est: cela dépend de la façon dont vous voulez que les segments commencent à /se comporter - devraient-ils simplement être joints ou devraient-ils agir comme la nouvelle racine?

Si les autres arguments sont codés en dur, cela n'a pas vraiment d'importance, auquel cas vous devriez probablement considérer (a) comment cette ligne pourrait changer à l'avenir et (b) quelle est sa cohérence avec d'autres endroits du code.

Les opérations par défaut du chemin du système de fichiers varient en fonction du système d'exploitation, nous avons besoin de quelque chose qui l'abstrait. Le pathmodule fournit des utilitaires ou une API pour travailler avec les chemins de fichiers et de répertoires. vous pouvez l'inclure dans votre projet en utilisant

const path = require('path');

Le path.joinetpath.resolve sont deux méthodes différentes du module chemin.

Ces deux méthodes acceptent une séquence de chemins ou de segments de chemin.

La path.resolve()méthode résout une séquence de chemins ou de segments de chemin en un chemin absolu .

La path.join()méthode joint tous les segments de chemin donnés ensemble en utilisant le séparateur spécifique à la plate-forme comme délimiteur, puis normalise le chemin résultant.

Afin de mieux comprendre et différencier les comportements, laissez-moi vous l'expliquer avec différents scénarios.

1. Si nous ne fournissons aucun argument ou chaîne vide

dans mon cas, mon nom de fichier est index.jset le répertoire de travail actuel estE:\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

et sur le résultat en cours d'exécution est comme ci-dessous

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

L'inférence de l'expérience ci-dessus est que la path.resolve()méthode produira le chemin absolu où en tant que path.join()retour. représentant le répertoire de travail actuel ou le chemin relatif si rien n'est fourni

2. Ajout d'un chemin / comme l'un des arguments.

const path=require('path');

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

et le résultat est

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

L'inférence que nous pouvons trouver avec cette expérience est que path.join()ne concatène que la liste d'entrée avec un séparateur spécifique à la plate-forme tandis que le path.resolve()processus de la séquence de chemins de droite à gauche, avec chaque chemin suivant en préfixe jusqu'à ce qu'un chemin absolu soit construit.

path.join()concatène chaque argument avec des séparateurs spécifiques au système d'exploitation tout path.resolve()en résolvant chaque argument avec root et en produisant une sortie.

1) path.resolve crée le chemin absolu.

La méthode crée un chemin absoulte de droite à gauche jusqu'à ce qu'un chemin absolu soit construit.

Par exemple:

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

Si le chemin absolu n'est pas généré, la méthode utilisant le répertoire de travail actuel:

Par exemple:

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

2) path.join joint tous les chemins et normalise le résultat

Par exemple:

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