Anweisungen zur Verwendung der fs.realpath-Methode in node.js_node.js

Methodenbeschreibung:

Erkennen Sie den wahren Weg.

Relative Pfade können mit „process.cwd“ aufgelöst werden.

Grammatik:

Code kopieren Der Code lautet wie folgt:

fs.realpath(path, [cache], [callback(err, gelösterPath)])

Da diese Methode zum fs-Modul gehört, muss das fs-Modul vor der Verwendung eingeführt werden (var fs= require(“fs“))

Empfangsparameter:

Pfad Pfad

Cache optional, der Zuordnungspfad eines Textes kann verwendet werden, um die Lösung eines bestimmten Pfads zu erzwingen oder zusätzliche fs.stat-Anforderungen zu vermeiden, um den tatsächlichen Pfad des Objekts zu kennen.

Rückruf                                                                            

Fehler-Ausnahme

resolvedPath Echte Adresse

Beispiel:

Code kopieren Der Code lautet wie folgt:

var Cache = {'/etc':'/private/etc'};
fs.realpath('/etc/passwd', Cache, Funktion (err, gelösterPath) {
if (err) throw err;
console.log(resolvedPath);
});

Quellcode:

Code kopieren Der Code lautet wie folgt:

fs.realpath = Funktion realpath(p, Cache, cb) {
  if (!util.isFunction(cb)) {
    cb = MaybeCallback(cache);
    Cache = null;
  }
  // mache p absolut
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return Process.nextTick(cb.bind(null, null, Cache[p]));
  }
  var original = p,
      seenLinks = {},
      knownHard = {};
  // aktuelle Zeichenposition in p
  var pos;
  // der bisherige Teilpfad, einschließlich eines abschließenden Schrägstrichs, falls vorhanden
  var current;
  // der Teilpfad ohne abschließenden Schrägstrich (außer beim Zeigen auf eine Wurzel)
  var base;
  // der Teilpfad, der in der vorherigen Runde gescannt wurde, mit Schrägstrich
  var previous;
  start();
  Funktion start() {
    // Wurzeln überspringen
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    aktuell = m[0];
    Basis = m[0];
    vorherige = '';
    // Überprüfen Sie unter Windows, ob der Root vorhanden ist. Unter Unix besteht keine Notwendigkeit.
    if (isWindows && !knownHard[base]) {
      fs.lstat(base, function(err) {
        if (err) return cb(err);
        knownHard[base] = true;
        LOOP();
      });
    } sonst {
      process.nextTick(LOOP);
    }
  }
  // Gehe den Pfad entlang und tausche verknüpfte Pfadteile gegen ihre echten aus
  // Werte
  Funktion LOOP() {
    // anhalten, wenn über das Ende des Pfads hinaus gescannt wird
    if (pos >= p.length) {
      if (cache) zwischenspeicher[original] = p;
      return cb(null, p);
    }
    // den nächsten Teil finden
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    vorherige = aktuell;
    current = result[0];
    Basis = vorheriges Ergebnis[1];
    pos = nextPartRe.lastIndex;
    // fortfahren, wenn kein Symlink
    if (knownHard[base] || (cache && Cache[base] === base)) {
      return process.nextTick(LOOP);
    }
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // bekannter symbolischer Link. Keine Notwendigkeit, es noch einmal zu sagen.
      return gotResolvedLink(cache[base]);
    }
    return fs.lstat(base, gotStat);
  }
  Funktion gotStat(err, stat) {
    if (err) return cb(err);
    // Wenn es sich nicht um einen Symlink handelt, springe zum nächsten Pfadteil
    if (!stat.isSymbolicLink()) {
      knownHard[base] = true;
      if (cache) Cache[base] = base;
      return process.nextTick(LOOP);
    }
    // stat & den Link lesen, falls nicht vorher gelesen
    // gotTarget aufrufen, sobald das Linkziel bekannt ist
    // dev/ino gibt unter Windows immer 0 zurück, also überspringe die Prüfung.
    if (!isWindows) {
      var id = stat.dev.toString(32) ':' stat.ino.toString(32);
      if (seenLinks.hasOwnProperty(id)) {
        return gotTarget(null, seenLinks[id], base);
      }
    }
    fs.stat(base, function(err) {
      if (err) return cb(err);
      fs.readlink(base, function(err, target) {
        if (!isWindows) seenLinks[id] = target;
        gotTarget(err, target);
      });
    });
  }
  Funktion gotTarget(err, target, base) {
    if (err) return cb(err);
    var gelöstLink = pathModule.resolve( previous, target);
    if (cache) zwischenspeicher[base] = gelöstLink;
    gotResolvedLink(resolvedLink);
  }
  Funktion gotResolvedLink(resolvedLink) {
    // Den Link auflösen und dann von vorne beginnen
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }
};