¿Diferencia entre path.resolve y path.join invocation?

¿Hay alguna diferencia entre las siguientes invocaciones?

path.join(__dirname, 'app')

vs.

path.resolve(__dirname, 'app')

¿Cuál debería ser el preferido?

Las dos funciones tratan con segmentos que comienzan de /maneras muy diferentes; joinsolo lo concatenará con el argumento anterior, sin embargo resolve, tratará esto como el directorio raíz e ignorará todas las rutas anteriores; piense en ello como el resultado de la ejecución cdcon cada argumento:

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

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

Otra cosa a tener en cuenta es que path.resolvesiempre dará como resultado una URL absoluta y usará su directorio de trabajo como base para resolver esta ruta. Pero como __dirnamees un camino absoluto de todos modos, esto no importa en su caso.

En cuanto a cuál debería usar, la respuesta es: depende de cómo desee que se comiencen /a comportar los segmentos : ¿deberían simplemente unirse o deberían actuar como la nueva raíz?

Si los otros argumentos están codificados, realmente no importa, en cuyo caso probablemente debería considerar (a) cómo podría cambiar esta línea en el futuro y (b) qué tan coherente es con otros lugares en el código.

Las operaciones predeterminadas de la ruta del sistema de archivos varían según el sistema operativo, necesitamos algo que lo abstraiga. El pathmódulo proporciona utilidades o API para trabajar con rutas de archivos y directorios. puedes incluirlo en tu proyecto usando

const path = require('path');

El path.joiny path.resolveson dos métodos diferentes del módulo de ruta.

Ambos métodos aceptan una secuencia de rutas o segmentos de ruta.

El path.resolve()método resuelve una secuencia de rutas o segmentos de ruta en una ruta absoluta .

El path.join()método une todos los segmentos de ruta dados juntos usando el separador específico de la plataforma como delimitador, luego normaliza la ruta resultante.

Para comprender y diferenciar mejor los comportamientos, permítanme explicarlo con diferentes escenarios.

1. Si no proporcionamos ningún argumento o cadena vacía

en mi caso, mi nombre de archivo es index.jsy el directorio de trabajo actual esE:\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

y en el resultado de ejecución es el siguiente

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

La inferencia del experimento anterior es que el path.resolve()método generará la ruta absoluta donde se path.join()devuelve. representando el directorio de trabajo actual o la ruta relativa si no se proporciona nada

2. Agregar una ruta / como cualquiera de los argumentos.

const path=require('path');

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

y el resultado es

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

La inferencia que podemos encontrar con este experimento es que path.join()solo concatena la lista de entrada con un separador específico de la plataforma mientras path.resolve()procesa la secuencia de rutas de derecha a izquierda, con cada ruta posterior antepuesta hasta que se construya una ruta absoluta.

path.join()concatena cada argumento con separadores específicos del sistema operativo mientras path.resolve()resuelve cada argumento con root y produce resultados.

1) path.resolve crea la ruta absoluta.

El método crea una ruta absoluta de derecha a izquierda hasta que se construye una ruta absoluta.

Por ejemplo:

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 no se genera la ruta absoluta, el método utiliza el directorio de trabajo actual:

Por ejemplo:

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

2) path.join une todas las rutas y normaliza el resultado

Por ejemplo:

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