Descripción del método:
Obtenga el camino real.
Las rutas relativas se pueden resolver usando Process.cwd.
gramática:
La copia del código es la siguiente:
fs.RealPath (ruta, [caché], [devolución de llamada (err, resuelvePath)]))
Dado que este método pertenece al módulo FS, es necesario introducir el módulo FS antes de usar (var fs = require ("fs")))
Recibir parámetros:
camino
Cache opcionalmente, se puede usar una ruta mapeada literal para forzar una ruta específica para resolver o evitar que FS.Stat sea para conocer el objeto de ruta real.
devolución de llamada de devolución de llamada
excepción errónea
Dirección real de resuelto
ejemplo:
La copia del código es la siguiente:
var cache = {'/etc': '/private/etc'};
fs.RealPath ('/etc/passwd', caché, función (err, resueldPath) {
if (err) tirar err;
console.log (resueltopath);
});
Código fuente:
La copia del código es la siguiente:
fs.RealPath = function realPath (p, caché, cb) {
if (! Util.isfunction (CB)) {
CB = MayBecallback (caché);
caché = nulo;
}
// hacer p es absoluto
p = PathModule.resolve (P);
if (cache && object.prototype.hasownproperty.call (cache, p)) {
return process.nexttick (cb.bind (nulo, nulo, caché [p]));
}
var original = p,
seelinks = {},
conoceHard = {};
// Posición actual del personaje en P
var pos;
// El camino parcial hasta ahora, incluida una barra de corte, si es que hay alguno
VAR Corriente;
// El camino parcial sin una barra de arrastre (excepto cuando apunta a una raíz)
base var;
// El camino parcial escaneó en la ronda anterior, con Slash
var anterior;
comenzar();
función start () {
// omita las raíces
var m = splitrootre.exec (p);
pos = m [0] .length;
corriente = m [0];
base = m [0];
anterior = '';
// En Windows, verifique que exista la raíz. En Unix no hay necesidad.
if (iswindows &&! conoceHard [base]) {
fs.lstat (base, function (err) {
if (err) return cb (err);
conocidoHard [base] = verdadero;
BUCLE();
});
} demás {
process.nextTick (bucle);
}
}
// Camina por el camino, cambiando PathParts vinculados por su real
// valores
function loop () {
// Detente si se escanea más allá del final del camino
if (pos> = p.length) {
if (caché) caché [original] = p;
devolver CB (NULL, P);
}
// Encuentra la siguiente parte
nextpartre.lastIndex = pos;
resultado var = nextpartre.exec (p);
anterior = corriente;
corriente += resultado [0];
base = anterior + resultado [1];
pos = nextpartre.lastIndex;
// Continuar si no es un enlace simbólico
if (conoceHard [base] || (caché && cache [base] === base)) {
return process.nextTick (bucle);
}
if (cache && object.prototype.hasownproperty.call (cache, base)) {
// Enlace simbólico conocido. No hay necesidad de estadísticas nuevamente.
return gotResolvedlink (caché [base]);
}
return fs.lstat (base, gotstat);
}
función gotStat (err, stat) {
if (err) return cb (err);
// Si no es un enlace simbólico, omita a la siguiente parte de la ruta
if (! stat.issymboliclink ()) {
conocidoHard [base] = verdadero;
if (caché) caché [base] = base;
return process.nextTick (bucle);
}
// stat y lea el enlace si no se lee antes
// llame a gottarget tan pronto como se conozca el objetivo del enlace
// dev/ino siempre devuelve 0 en las ventanas, así que omita el cheque.
if (! iswindows) {
var id = stat.dev.toString (32) + ':' + stat.ino.ToString (32);
if (SeenLinks.HasownProperty (id)) {
devolver gottarget (nulo, seelinks [id], base);
}
}
fs.stat (base, function (err) {
if (err) return cb (err);
fs.ReadLink (base, function (err, target) {
if (! iswindows) seelinks [id] = target;
gottarget (err, objetivo);
});
});
}
función gottarget (err, target, base) {
if (err) return cb (err);
var resueldlink = pathmodule.resolve (anterior, target);
if (cache) cache [base] = resuelveLink;
gotResolvedlink (resueldlink);
}
función gotResolvedlink (resuelveLink) {
// Resolver el enlace, luego comenzar de nuevo
p = PathModule.resolve (resuelveLink, p.slice (pos));
comenzar();
}
};