Description de la méthode:
Obtenez le vrai chemin.
Les chemins relatifs peuvent être résolus à l'aide de process.cwd.
grammaire:
La copie de code est la suivante:
fs.realpath (path, [cache], [rappel (err, résolvedpath)]))
Étant donné que cette méthode appartient au module FS, il est nécessaire d'introduire le module FS avant utilisation (var fs = require ("fs")))
Recevoir des paramètres:
chemin de chemin
Cache éventuellement, un chemin cartographié littéral peut être utilisé pour forcer un chemin spécifique pour résoudre ou éviter que Fsat supplémentaire doit connaître l'objet de chemin réel.
rappel
Err exception
Résolvedpath réelle adresse
exemple:
La copie de code est la suivante:
var cache = {'/ etc': '/ private / etc'};
fs.realpath ('/ etc / passwd', cache, fonction (err, résolvedpath) {
si (err) jetez ERR;
console.log (résolvedpath);
});
Code source:
La copie de code est la suivante:
fs.realPath = fonction realPath (p, cache, cb) {
if (! util.isfunction (cb)) {
CB = MayBecallback (cache);
cache = null;
}
// rendre p est absolu
p = pathmodule.resolve (p);
if (cache && object.prototype.hasownproperty.call (cache, p)) {
return process.NextTick (cb.bind (null, null, cache [p]));
}
var original = p,
Seelinks = {},
connuhard = {};
// position de caractère actuel dans P
var pos;
// le chemin partiel jusqu'à présent, y compris une barre oblique de fuite, le cas échéant
courant var;
// Le chemin partiel sans obstacle de fuite (sauf lorsque vous pointez une racine)
Var Base;
// Le chemin partiel scanné lors du tour précédent, avec une barre oblique
var précédent;
commencer();
fonction start () {
// saute les racines
var m = splitrootre.exec (p);
pos = m [0] .length;
courant = m [0];
base = m [0];
précédent = '';
// Sur Windows, vérifiez que la racine existe. Sur Unix, il n'y a pas besoin.
if (isWindows &&! Knowhard [base]) {
fs.lstat (base, fonction (err) {
if (err) return cb (err);
connuhard [base] = true;
BOUCLE();
});
} autre {
process.NextTick (Loop);
}
}
// marche sur le chemin, en échangeant des pathparts liés contre leur vrai
// valeurs
Fonction Loop () {
// Arrêtez-vous si scanné le passé du chemin
if (pos> = p.length) {
if (cache) cache [original] = p;
retour CB (null, p);
}
// Trouvez la partie suivante
NextPartre.LastIndex = pos;
var result = nextpartre.exec (p);
Précédent = courant;
courant + = résultat [0];
base = Résultat précédent + [1];
pos = nextPartre.LastIndex;
// Continuez sinon un lien symbolique
if (connuhard [base] || (cache && cache [base] === base)) {
return process.NextTick (Loop);
}
if (cache && object.prototype.hasownproperty.call (cache, base)) {
// Lien symbolique connu. Pas besoin de statistique à nouveau.
return goSRaSolvedLink (cache [base]);
}
return fs.lstat (base, gotstat);
}
fonction gotStat (err, stat) {
if (err) return cb (err);
// Si ce n'est pas un lien symbolique, passez à la partie du chemin suivant
if (! stat.issymboliclink ()) {
connuhard [base] = true;
if (cache) cache [base] = base;
return process.NextTick (Loop);
}
// stat et lire le lien s'il n'est pas lu avant
// appelle gottarget dès que la cible de liaison est connue
// Dev / INO renvoie toujours 0 sous Windows, alors sautez le chèque.
if (! Iswindows) {
var id = stat.dev.tostring (32) + ':' + stat.ino.tostring (32);
if (SeenLinks.hasownproperty (id)) {
return gottarget (null, seelinks [id], base);
}
}
fsat (base, fonction (err) {
if (err) return cb (err);
fs.readlink (base, fonction (err, cible) {
if (! isWindows) Seelinks [id] = cible;
gottarget (err, cible);
});
});
}
fonction gottarget (err, cible, base) {
if (err) return cb (err);
var résolvedLink = pathModule.resolve (précédent, cible);
if (cache) cache [base] = résolvedLink;
GoSRaSolvedLink (RésolvedLink);
}
fonction GotreSolvedLink (RésolvedLink) {
// résoudre le lien, puis recommencer
p = pathmodule.resolve (résolvelink, p.slice (pos));
commencer();
}
};