Descrição do método:
Pegue o caminho real.
Caminhos relativos podem ser resolvidos usando o processo.cwd.
gramática:
A cópia do código é a seguinte:
fs.realpath (caminho, [cache], [retorno de chamada (err, resolvido)]))
Como esse método pertence ao módulo FS, é necessário introduzir o módulo FS antes do uso (var fs = requer ("fs")))
Receber parâmetros:
caminho do caminho
Cache Opcionalmente, um caminho mapeado literal pode ser usado para forçar um caminho específico para resolver ou evitar o F.Stat adicional precisa conhecer o objeto Real Path.
retorno de chamada de retorno
ERRO EXCECTION
Endereço real resolvido
exemplo:
A cópia do código é a seguinte:
var cache = {'/etc': '/privado/etc'};
fs.realpath ('/etc/passwd', cache, função (err, resolvido) {
se (err) lançar err;
console.log (resolvido);
});
Código -fonte:
A cópia do código é a seguinte:
fs.realPath = função realpath (p, cache, cb) {
if (! Util.isfunction (cb)) {
CB = Maybecallback (cache);
cache = nulo;
}
// make p é absoluto
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 = {},
conhecidohard = {};
// posição atual do caractere em p
var pos;
// o caminho parcial até agora, incluindo uma barra de arco, se houver
Var Current;
// O caminho parcial sem uma barra de direita (exceto quando apontando para uma raiz)
var base;
// O caminho parcial digitalizado na rodada anterior, com barra
var anterior;
começar();
função start () {
// pula sobre raízes
var m = splitrootre.exec (p);
pos = m [0] .Length;
corrente = m [0];
base = m [0];
anterior = '';
// No Windows, verifique se a raiz existe. No Unix, não há necessidade.
if (iswindows &&! conhecidohard [base]) {
fs.lstat (base, função (err) {
se (err) retornar cb (err);
conhecidohard [base] = true;
LAÇO();
});
} outro {
process.NextTick (loop);
}
}
// Ande pelo caminho, trocando o caminho vinculado
// valores
função loop () {
// pare se digitalizado no passado do caminho
if (pos> = p.length) {
if (cache) cache [original] = p;
Retornar CB (NULL, P);
}
// Encontre a próxima parte
nextpartre.LastIndex = POS;
var resultado = nextPartre.exec (p);
anterior = atual;
corrente += resultado [0];
base = resultado anterior + [1];
pos = nextPartre.LastIndex;
// Continue, se não um symblink
if (conhecidohard [base] || (cache && cache [base] === base)) {
Return Process.NextTick (Loop);
}
if (cache && object.prototype.hasownproperty.call (cache, base)) {
// Link simbólico conhecido. Não há necessidade de estatística novamente.
retornar gotResolvedLink (cache [base]);
}
retornar fs.lstat (base, gotstat);
}
função gotstat (err, stat) {
se (err) retornar cb (err);
// Se não for um symlink, pule para a próxima parte do caminho
if (! stat.issymbolicLink ()) {
conhecidohard [base] = true;
if (cache) cache [base] = base;
Return Process.NextTick (Loop);
}
// stat & leia o link se não lido antes
// Ligue para Gottarget assim que o alvo do link for conhecido
// dev/ino sempre retorna 0 no Windows, então pule o cheque.
if (! iswindows) {
var id = stat.dev.toString (32) + ':' + stat.ino.toString (32);
if (seredlinks.HasownProperty (id)) {
retornar gottarget (nulo, seelinks [id], base);
}
}
fs.stat (base, função (err) {
se (err) retornar cb (err);
fs.readlink (base, função (err, destino) {
if (! iswindows) seelinks [id] = destino;
gottarget (err, destino);
});
});
}
função gottarget (err, destino, base) {
se (err) retornar cb (err);
var resolvedLink = pathmodule.resolve (anterior, destino);
if (cache) cache [base] = resolvidolink;
GotResolvedLink (ResolvedLink);
}
função gotResolvedLink (resolvedlink) {
// Resolva o link e comece de novo
p = pathmodule.Resolve (resolvedlink, p.slice (pos));
começar();
}
};