Разница между вызовами path.resolve и path.join?

Есть ли какая-то разница между следующими вызовами?

path.join(__dirname, 'app')

против

path.resolve(__dirname, 'app')

Какой из них должен быть предпочтительным?

Эти две функции имеют дело с сегментами, начинающимися с /очень разных способов; joinпросто объединит его с предыдущим аргументом, однако resolveбудет рассматривать его как корневой каталог и игнорирует все предыдущие пути - думайте об этом как о результате выполнения cdс каждым аргументом:

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

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

Еще одна вещь, на которую стоит обратить внимание, это то, что path.resolveэто всегда приведет к абсолютному URL и будет использовать ваш рабочий каталог в качестве базы для разрешения этого пути. Но так как __dirnameэто абсолютный путь, в любом случае это не имеет значения.

Что касается того, какой из них вы должны использовать, ответ таков: это зависит от того, как вы хотите, чтобы сегменты, начиная с самого начала, /вели себя - должны ли они просто соединяться или они должны действовать как новый корень?

Если другие аргументы жестко запрограммированы, это на самом деле не имеет значения, и в этом случае вы, вероятно, должны рассмотреть (а) как эта строка может измениться в будущем и (б) насколько она совместима с другими местами в коде.

Операции по умолчанию для пути к файловой системе варьируются в зависимости от операционной системы, нам нужна некоторая вещь, которая абстрагирует ее. pathМодуль предоставляет утилиты или API для работы с файлами и каталогами путями. Вы можете включить его в свой проект, используя

const path = require('path');

path.joinИ path.resolveдва различных метода модуля пути.

Оба эти метода принимают последовательность путей или сегментов пути.

path.resolve()Метод решает последовательность путей или сегментов пути в абсолютный путь .

path.join()Метод объединяет все заданные отрезки пути вместе с помощью конкретной платформы разделителя в качестве разделителя, а затем нормализует получившийся путь.

Чтобы лучше понять и дифференцировать поведение, позвольте мне объяснить это различными сценариями.

1. Если мы не предоставили никаких аргументов или пустую строку

в моем случае мое имя файла index.jsи текущий рабочий каталог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 of the node process

и на бегу результат, как показано ниже

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

Вывод из приведенного выше эксперимента заключается в том, что path.resolve()метод выведет абсолютный путь, где в качестве path.join()возвращаемых значений. представляет текущий рабочий каталог или относительный путь, если ничего не указано

2. Добавление пути / в качестве любого из аргументов.

const path=require('path');

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

и результат

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

Вывод, который мы можем найти в этом эксперименте, заключается в том, что path.join()только входной список объединяется с определенным платформой разделителем, в то время path.resolve()как последовательность путей обрабатывается справа налево, причем каждый последующий путь добавляется до построения абсолютного пути.

path.join()объединяет каждый аргумент с разделителями, специфичными для ОС, в то время как path.resolve()каждый аргумент разрешается с корнем и выдает результат.

1) path.resolve создает абсолютный путь.

Метод создает абсолютный путь справа налево, пока не будет создан абсолютный путь.

Например:

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

Если абсолютный путь не генерируется, метод использует текущий рабочий каталог:

Например:

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

2) path.join объединяет все пути и нормализует результат

Например:

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