Este dilema se puede solucionar de diversas maneras, pero nosotros te enseñamos la resolución más completa para nosotros.
Solución:
Las dos funciones tratan con segmentos que comienzan con / de formas muy diferentes; join simplemente 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 ejecutar cd con cada argumento:
path.join('/a', '/b') // Outputs '/a/b'
path.resolve('/a', '/b') // Outputs '/b'
Otra cosa a tener en cuenta es que path.resolve siempre dará como resultado una URL absoluta y utilizará su directorio de trabajo como base para resolver esta ruta. Pero como __dirname es una ruta absoluta de todos modos, esto no importa en su caso.
En cuanto a cuál debe usar, la respuesta es: depende de cómo desea que los segmentos comiencen en / comportarse: ¿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 consistente 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. los path El módulo proporciona utilidades o API para trabajar con rutas de archivos y directorios. puedes incluirlo en tu proyecto usando
const path = require('path');
los path.join y path.resolve son dos métodos diferentes del módulo de ruta.
Ambos métodos aceptan una secuencia de caminos o segmentos de camino.
los path.resolve() El método resuelve una secuencia de caminos o segmentos de caminos en un camino absoluto.
los path.join() El método une todos los segmentos de ruta dados usando el separador específico de la plataforma como delimitador, luego normaliza la ruta resultante.
Para comprender mejor y diferenciar los comportamientos, permítanme explicarlo con diferentes escenarios.
1. Si no proporcionamos ningún argumento o vacíamos string
en mi caso, mi nombre de archivo es index.js y el directorio de trabajo actual es E:MyFolderPjtznode
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 el resultado en ejecución es el siguiente
λ node index.js
path.join() : .
path.resolve() : E:MyFolderPjtznode
La inferencia del experimento anterior es que path.resolve() El método generará el camino absoluto mientras que el path.join() devoluciones . que representa el directorio de trabajo actual o camino relativo si no se proporciona nada
2. Agregar un /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() : abcbcd
path.resolve() : E:bcd
La inferencia que podemos encontrar con este experimento es que path.join() solo concatena la lista de entrada con el separador específico de la plataforma mientras que el path.resolve() procesar la secuencia de rutas de derecha a izquierda, con cada ruta subsiguiente antepuesta hasta que se construya una ruta absoluta.
path.join() concatena cada argumento con separadores específicos del sistema operativo mientras path.resolve() resolverá cada argumento con root y producirá una salida.
1) path.resolve crea la ruta absoluta.
El método crea una ruta absoluta. de derecha a izquierda hasta que se construye un camino absoluto.
Por ejemplo:
path.resolve('/a', 'b', 'c'); // C:abc
path.resolve('/a', '/b', 'c'); // C:bc
path.resolve('/a', '/b', '/c'); // C:c
Si no se genera la ruta absoluta, el método que usa el directorio de trabajo actual:
Por ejemplo:
path.resolve('a', 'b', 'c'); // C:current_working_directoryabc
2) path.join une todas las rutas y normaliza el resultado
Por ejemplo:
path.join('/a', '/b', '/c'); // abc
path.join('/a', '/b', 'c'); // abc
path.join('/a', 'b', 'c'); // abc
path.join('a', 'b', 'c'); // abc