Is er een verschil bij het gebruik van zowelpath.joinals path.resolvemet __dirnamevoor het oplossen van absolute pad in Node.js?
Moet een van deze de voorkeur hebben als ze zo worden gebruikt (absolute padresoluties zijn 90% van de gebruiksgevallen)?
D.w.z.
const absolutePath = path.join(__dirname, some, dir);
vs.
const absolutePath = path.resolve(__dirname, some, dir);
Beide methoden normaliseren het pad.
Antwoord 1, autoriteit 100%
Ja, er is een verschil tussen de functies, maar de manier waarop u ze in dit geval gebruikt, resulteert in hetzelfde resultaat.
path.joinretourneert een genormaliseerd pad door twee paden samen te voegen. Het kan een absoluut pad retourneren, maar dat hoeft niet altijd.
Bijvoorbeeld:
path.join('app/libs/oauth', '/../ssl')
wordt opgelost in app/libs/ssl
path.resolvedaarentegen wordt omgezet in een absoluut pad.
Bijvoorbeeld, wanneer u uitvoert:
path.resolve('bar', '/foo');
Het geretourneerde pad is /fooaangezien dat het eerste absolute pad is dat kan worden geconstrueerd.
Als u echter het volgende uitvoert:
path.resolve('/bar/bae', '/foo', 'test');
Het geretourneerde pad is opnieuw /foo/testomdat dat het eerste absolute pad is dat van rechts naar links kan worden gevormd.
Als u geen pad opgeeft dat de hoofdmap specificeert, worden de paden die aan de functie resolvezijn gegeven, toegevoegd aan de huidige werkmap. Dus als uw werkmap /home/mark/project/was:
path.resolve('test', 'directory', '../back');
lost op met
/home/mark/project/test/back
Het gebruik van __dirnameis het absolute pad naar de map die het bronbestand bevat. Als je path.resolveof path.joingebruikt, zullen ze hetzelfde resultaat retourneren als je hetzelfde pad geeft na __dirname. In dergelijke gevallen is het gewoon een kwestie van voorkeur.
Antwoord 2, autoriteit 18%
const absolutePath = path.join(__dirname, some, dir);
vs.
const absolutePath = path.resolve(__dirname, some, dir);
path.joinzal __dirnamesamenvoegen, wat de directorynaam is van het huidige bestand, samengevoegd met waarden van someen dirmet platformspecifiek scheidingsteken.
Terwijl
path.resolvezal __dirname, someen dirverwerken, dwz van rechts naar links die eraan voorafgaan door te verwerken het.
Als een van de waarden van someof dirovereenkomt met een root-pad, dan wordt het vorige pad weggelaten en wordt de rest verwerkt door het als root< te beschouwen
Om het concept beter te begrijpen, wil ik beide als volgt wat meer in detail uitleggen:-
De path.joinen path.resolvezijn twee verschillende methoden of functies van de padmodule die door nodejs wordt geleverd.
Waar beide een lijst met paden accepteren, maar het verschil zit in het resultaat, d.w.z. hoe ze deze paden verwerken.
path.joinvoegt alle gegeven padsegmenten samen met het platformspecifieke scheidingsteken als scheidingsteken, en normaliseert vervolgens het resulterende pad. Terwijl de path.resolve()de reeks paden van rechts naar links verwerkt, waarbij elk volgend pad wordt toegevoegd totdat een absoluut pad is geconstrueerd.
Als er geen argumenten zijn opgegeven
Het volgende voorbeeld zal u helpen om beide concepten duidelijk te begrijpen:-
Mijn bestandsnaam is index.jsen de huidige werkmap is 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
Resultaat
λ node index.js
path.join() : .
path.resolve() : E:\MyFolder\Pjtz\node
path.resolve()methode zal het absolute pad uitvoeren terwijl de path.join()retourneert. die de huidige werkdirectory vertegenwoordigt als er niets is opgegeven
Wanneer een root-pad wordt doorgegeven als argumenten
const path=require('path');
console.log("path.join() : " ,path.join('abc','/bcd'));
console.log("path.resolve() : ",path.resolve('abc','/bcd'));
Resultaat i
λ node index.js
path.join() : abc\bcd
path.resolve() : E:\bcd
path.join()voegt alleen de invoerlijst samen met platformspecifiek scheidingsteken terwijl het path.resolve()de reeks paden van rechts naar links, waarbij elk volgend pad wordt toegevoegd totdat een absoluut pad is geconstrueerd.
Antwoord 3, autoriteit 3%
Van het document voor path.resolve:
Het resulterende pad wordt genormaliseerd en slashes worden verwijderd, tenzij het pad wordt omgezet naar de hoofdmap.
Maar path.joinblijft slashes achteraan
Dus
__dirname = '/';
path.resolve(__dirname, 'foo/'); // '/foo'
path.join(__dirname, 'foo/'); // '/foo/'
Antwoord 4
In de eenvoudigste bewoordingen:
Wanneer u path.resolve()gebruikt, doet dit het volgende
from left to right-
- voeg de meest rechtse parameters samen met
/rechtstreeks met het rootpad om een absoluut pad te maken (bekijk de voorbeelden) - en voegt dan alles samen zonder
/als directory
bijvoorbeeld
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
Tijdens het gebruik van join()voegt u eenvoudig elke parameter van links naar rechts samen, of ze nu /hebben of niet
path.join("/a", "b", "/c", "d") simply returns "\a\b\c\d"