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

Methodenbeschreibung:

Synchronisierte Version von fs.realpath() .

Grammatik:

Code kopieren Der Code lautet wie folgt:

fs.realpathSync(path, [cache])

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.

Beispiel:

Code kopieren Der Code lautet wie folgt:

var fs = require('fs');

// Der Punkt gibt den Pfad der aktuellen Datei an
var str = fs.realpathSync('.');
console.log(str);

Quellcode:

Code kopieren Der Code lautet wie folgt:

fs.realpathSync = Funktion realpathSync(p, Cache) {
  // mache p absolut
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    Cache zurückgeben[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.lstatSync(base);
      knownHard[base] = true;
    }
  }
  // Gehe den Pfad entlang und tausche verknüpfte Pfadteile gegen ihre echten aus
  // Werte
  // NB: p.length ändert sich.
  while (pos < p.length) {
    // 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)) {
      weiter;
    }
    var gelöstLink;
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // ein bekannter symbolischer Link. Keine Notwendigkeit, es noch einmal zu sagen.
      gelöstLink = Cache[Basis];
    } sonst {
      var stat = fs.lstatSync(base);
      if (!stat.isSymbolicLink()) {
        knownHard[base] = true;
        if (cache) Cache[base] = base;
        weiter;
      }
      // Den Link lesen, falls er noch nicht gelesen wurde
      // dev/ino gibt unter Windows immer 0 zurück, also überspringe die Prüfung.
      var linkTarget = null;
      if (!isWindows) {
        var id = stat.dev.toString(32) ':' stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          linkTarget = seenLinks[id];
        }
      }
      if (util.isNull(linkTarget)) {
        fs.statSync(base);
        linkTarget = fs.readlinkSync(base);
      }
      gelöstLink = pathModule.resolve( previous, linkTarget);
      // Verfolgen Sie dies, wenn ein Cache vorhanden ist.
      if (cache) zwischenspeicher[base] = gelöstLink;
      if (!isWindows) seenLinks[id] = linkTarget;
    }
    // Den Link auflösen und dann von vorne beginnen
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  }
  if (cache) zwischenspeicher[original] = p;
  return p;
};