Lassen Sie uns über allgemeine Toolfunktionen im Node.js-Pfadmodul sprechen

Während des Entwicklungsprozesses wird häufig Node.js verwendet, das die von V8 bereitgestellten Funktionen nutzt, um die Funktionen von JS zu erweitern. In Node.js können wir das Pfadmodul verwenden, das in JS nicht vorhanden ist. Damit wir mit der Anwendung besser vertraut werden, werfen wir einen Blick darauf.

Die Node.js-Version dieses Artikels ist 16.14.0 , und der Quellcode dieses Artikels stammt von dieser Version. Ich hoffe, dass es nach dem Lesen dieses Artikels für alle hilfreich sein wird, den Quellcode zu lesen.

Häufige Verwendungsszenarien für Pfade.

Pfad wird zum Verarbeiten der Pfade von Dateien und Verzeichnissen verwendet. Dieses Modul bietet einige Toolfunktionen, die Entwickler bequem entwickeln können, um uns bei komplexen Pfadbeurteilungen zu unterstützen und die Entwicklungseffizienz zu verbessern. Beispiel:

• Konfigurieren Sie Aliase im Projekt. Die Konfiguration des Alias ​​erleichtert uns die Referenzierung von Dateien und vermeidet die schrittweise Suche nach oben.

Auflösung: {
  Alias: {
    // __dirname Verzeichnispfad 'src', in dem sich die aktuelle Datei befindet: path.resolve(__dirname, './src'),
    // Process.cwd aktuelles Arbeitsverzeichnis '@': path.join(process.cwd(), 'src'),
  },
}

• Im Webpack kann der Ausgabepfad der Datei auch durch unsere eigene Konfiguration zum angegebenen Speicherort generiert werden.

module.exports = {
  Eintrag: './path/to/my/entry/file.js',
  Ausgabe: {
    Pfad: path.resolve(__dirname, 'dist'),
    Dateiname: „my-first-webpack.bundle.js“,
  },
};

• Oder für Ordneroperationen

let fs = require("fs");
let path = require("path");

// Den Ordner löschen let deleDir = (src) => {
    // Den Ordner lesen letchildren = fs.readdirSync(src);
    children.forEach(item => {
        let childpath = path.join(src, item);
        // Prüfen, ob die Datei existiert let file = fs.statSync(childpath).isFile();
        if (Datei) {
            // Datei löschen, falls vorhanden fs.unlinkSync(childpath)
        } anders {
            //Den Ordner weiterhin erkennen deleDir(childpath)
        }
    })
    // Den leeren Ordner löschen fs.rmdirSync(src)
}
deleDir("../floor")

erläutert kurz die Verwendungsszenarien des Pfads. Als Nächstes werden wir seinen Ausführungsmechanismus und seine Implementierung anhand seiner Verwendung untersuchen.

Pfadausführungsmechanismus

• Wenn das Pfadmodul eingeführt und die Werkzeugfunktion des Pfads aufgerufen wird, wird die Verarbeitungslogik des nativen Moduls eingegeben.

• Verwenden Sie die Funktion _load um den von Ihnen eingegebenen Modulnamen als ID zu verwenden, um festzustellen, ob es sich bei dem zu ladenden Modul um ein natives JS-Modul handelt. Anschließend wird die Funktion loadNativeModule verwendet, um anhand der ID den entsprechenden ASCII-Code aus _source zu finden. die Quellcodezeichenfolge, die das native JS-Modul speichert. Die Daten werden in das native JS-Modul geladen.

• Führen Sie die Datei lib/path.js aus und verwenden Sie den Prozess, um das Betriebssystem zu ermitteln. Bei der Dateiverarbeitung kann es zu unterschiedlichen Verarbeitungsvorgängen kommen, die Methode ist jedoch ungefähr dieselbe der Anrufer.

Kurze Analyse häufig verwendeter Werkzeugfunktionen.

Auflösung gibt den absoluten Pfad des aktuellen Pfads zurück.

Auflösung verbindet mehrere Parameter nacheinander, um einen neuen absoluten Pfad zu generieren.

lösen(...Argumente) {
  let aufgelöstDevice = '';
  let aufgelöstTail = '';
  let aufgelöstAbsolute = false;

  // Parameter von rechts nach links erkennen für (let i = args.length - 1; i >= -1; i--) {
    ...
  }

  //Normalisierter Pfad gelöstTail = normalizeString(resolvedTail, !resolvedAbsolute, '\', isPathSeparator);

  Rückgabe aufgelöstAbsolut?
    `${resolvedDevice}\${resolvedTail}` :
    `${resolvedDevice}${resolvedTail}` || '.';
}

Rufen Sie den Pfad gemäß den Parametern ab, durchlaufen Sie die empfangenen Parameter, beginnen Sie mit dem Spleißen, wenn die Länge der Parameter größer oder gleich 0 ist, und führen Sie eine Nicht-String-Überprüfung auf dem gespleißten Pfad durch, wenn Parameter vorhanden sind, die nicht übereinstimmen , throw new ERR_INVALID_ARG_TYPE(name, 'string', value) , wenn die Anforderungen erfüllt sind, wird die Länge des Pfades beurteilt. Wenn ein Wert vorhanden ist, wird += path für den nächsten Schritt verwendet.

Weg lassen;

if (i >= 0) {
  path = args[i];
  // intern/Validatoren
  validateString(path, 'path');
  // Wenn die Länge des Pfads 0 ist, springt er direkt aus der for-Schleife des obigen Codeblocks, wenn (path.length === 0) {
    weitermachen;
  }
} else if (resolvedDevice.length === 0) {
  //Die Länge von „resolvedDevice“ ist 0, weisen Sie den Wert „path“ als aktuelles Arbeitsverzeichnis zu path =process.cwd();
} anders {
  // Weisen Sie den Wert dem Umgebungsobjekt oder dem aktuellen Arbeitsverzeichnis zu path = process.env[`=${resolvedDevice}`] ||.
  if (Pfad === undefiniert ||
      (StringPrototypeToLowerCase(StringPrototypeSlice(path, 0, 2)) !==
      StringPrototypeToLowerCase(resolvedDevice) &&
      StringPrototypeCharCodeAt(path, 2) === CHAR_BACKWARD_SLASH)) {
    //Beurteilen Sie den Pfad nach nicht leeren und absoluten Pfaden, um den Pfad zu erhalten path = `${resolvedDevice}\`;
  }
}

Versuchen Sie, den Stammpfad abzugleichen, stellen Sie fest, ob es nur ein Pfadtrennzeichen ('') gibt oder der Pfad ein absoluter Pfad ist, markieren Sie dann den absoluten Pfad und setzen Sie rootEnd Abfangflag auf 1 (Index). Wenn das zweite Element immer noch ein Pfadtrennzeichen ('') ist, definieren Sie den Abfangwert als 2 (Index) und verwenden Sie last , um den Abfangwert für die spätere Beurteilung zu speichern.

Bestimmen Sie weiterhin, ob das dritte Element ein Pfadtrennzeichen ('') ist. Wenn ja, handelt es sich um einen absoluten Pfad und die rootEnd Abfangkennung ist 1 (Index), es kann sich jedoch auch um einen UNC-Pfad (ServernameFreigabename) handeln , Servername (Servername). Freigabename (Name der freigegebenen Ressource). Wenn andere Werte vorhanden sind, wird der abgefangene Wert weiter erhöht und die folgenden Werte gelesen. Mit firstPart wird der Wert des dritten Bits gespeichert, sodass der Wert beim Zusammenfügen des Verzeichnisses abgerufen werden kann, und die letzten und abgefangenen Werte bleiben erhalten konsequent, das Urteil zu beenden.

const len ​​​​= path.length;
let rootEnd = 0; // Path interception end subscript let device = ''; // Disk root D:, C:
let isAbsolute = false; // Ob es sich um den Root-Pfad der Festplatte handelt const code = StringPrototypeCharCodeAt(path, 0);

// Pfadlänge ist 1
if (len === 1) {
  // Es gibt nur ein Pfadtrennzeichen  für den absoluten Pfad if (isPathSeparator(code)) {
    rootEnd = 1;
    isAbsolute = true;
  }
} else if (isPathSeparator(code)) {
  // Könnte ein UNC-Stamm sein, beginnend mit einem Trennzeichen , von dem mindestens eines eine Art absoluter Pfad (UNC oder ein anderer) ist.
  isAbsolute = true;
  // Mit dem Abgleich des doppelten Pfadtrennzeichens beginnen if (isPathSeparator(StringPrototypeCharCodeAt(path, 1))) {
    sei j = 2;
    let last = j;
    // Übereinstimmung mit einem oder mehreren Nicht-Pfad-Trennzeichen while (j < len &&
    !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
      j++;
    }
    if (j < len && j !== last) {
      const firstPart = StringPrototypeSlice(path, last, j);
      last = j;
      // Übereinstimmung mit einem oder mehreren Pfadtrennzeichen while (j < len &&
              isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
        j++;
      }
      if (j < len && j !== last) {
        zuletzt = j;
        while (j < len &&
                !isPathSeparator(StringPrototypeCharCodeAt(path, j))) {
          j++;
        }
        if (j === len || j !== last) {
          Gerät=
            `\\${firstPart}\${StringPrototypeSlice(path, last, j)}`;
          rootEnd = j;
        }
      }
    }
  } anders {
    rootEnd = 1;
  }
// Erkennen Sie das übereinstimmende Beispiel des Festplattenstammverzeichnisses: D:, C:
} else if (isWindowsDeviceRoot(code) && StringPrototypeCharCodeAt(path, 1) === CHAR_COLON) {
  device = StringPrototypeSlice(path, 0, 2);
  rootEnd = 2;
  if (len > 2 && isPathSeparator(StringPrototypeCharCodeAt(path, 2))) {
    isAbsolute = true;
    rootEnd = 3;
  }
}

Ermitteln Sie den Pfad und generieren Sie ihn. Überprüfen Sie, ob das Stammverzeichnis der Festplatte vorhanden ist, oder ermitteln Sie, ob resolvedAbsolute ein absoluter Pfad ist.

//Erkennen Sie das Stammverzeichnis der Festplatte, wenn (device.length > 0) {
  // gelöstes Gerät hat Wert, wenn (resolvedDevice.length > 0) {
    if (StringPrototypeToLowerCase(device) !==
        StringPrototypeToLowerCase(resolvedDevice))
      weitermachen;
  } anders {
    // „resolvedDevice“ hat keinen Wert und erhält den Wert des Plattenstammverzeichnisses „resolvedDevice = device;
  }
}

// Absoluter Pfad if (resolvedAbsolute) {
  // Es gibt eine Endschleife, wenn das Festplattenstammverzeichnis vorhanden ist (resolvedDevice.length > 0)
    brechen;
} anders {
  // Holen Sie sich das Pfadpräfix für das Spleißen gelöstTail =
    `${StringPrototypeSlice(path, rootEnd)}\${resolvedTail}`;
  gelöstAbsolute = isAbsolute;
  if (isAbsolute && gelöstDevice.length > 0) {
    // Die Schleife endet, wenn das Festplattenstammverzeichnis existiert break;
  }
}

join führt Pfadspleißen basierend auf den eingehenden Pfadfragmenten durch

• Empfangen Sie mehrere Parameter, verwenden Sie bestimmte Trennzeichen als Trennzeichen, um alle Pfadparameter miteinander zu verbinden, und generieren Sie einen neuen normalisierten Pfad.

• Überprüfen Sie die Parameter nach dem Empfang. Wenn keine Parameter vorhanden sind, werden die einzelnen Parameter direkt über die integrierte Methode validateString throw new ERR_INVALID_ARG_TYPE(name, 'string', value)； durchlaufen und überprüft. throw new ERR_INVALID_ARG_TYPE(name, 'string', value)；

• join Funktion des Escape-Zeichens besteht darin, dass es bei alleiniger Verwendung als Escape-Zeichen für die Zeichenfolge nach dem Schrägstrich betrachtet wird. Daher werden doppelte Backslashes verwendet, um den Backslash ('') zu maskieren.

• Abschließend wird die verkettete Zeichenfolge überprüft und im Format zurückgegeben.

if (arg. Länge === 0)
    zurückkehren '.';

lass dich verbinden;
let firstPart;
// Parameter von links nach rechts erkennen für (let i = 0; i < args.length; ++i) {
  const arg = args[i];
  // intern/Validatoren
  validateString(arg, 'path');
  if (argumentierte Länge > 0) {
    if (verbunden === undefiniert)
      // Weisen Sie den ersten String Join zu und verwenden Sie die Variable firstPart, um den ersten String für die spätere Verwendung zu speichern join = firstPart = arg;
    anders
      // Join hat einen Wert, führe += Spleißvorgang durch Join += `\${arg}`;
  }
}

if (verbunden === undefiniert)
  return '.';

Unter dem Windows-System ist eine Netzwerkpfadverarbeitung aufgrund der Verwendung von Backslash ('') und UNC-Pfad (bezieht sich hauptsächlich auf den vollständigen Windows 2000-Namen der Ressourcen im LAN) erforderlich. stellt ein Netzwerkpfadformat dar, sodass die unter Win32 bereitgestellte join Methode standardmäßig abfängt.

Wenn ein Backslash ('') übereinstimmt, wird slashCount erhöht. Solange mehr als zwei Backslashes ('') übereinstimmen, wird der gespleißte Pfad abgefangen und manuell gespleißt und maskiert. '').

let needReplace = true;
let slashCount = 0;
// Den Codecode der ersten Zeichenfolge der Reihe nach gemäß StringPrototypeCharCodeAt extrahieren und ihn über die isPathSeparator-Methode mit dem definierten Codecode abgleichen if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 0))) {
  ++slashCount;
  const firstLen = firstPart.length;
  if (firstLen > 1 &&
      isPathSeparator(StringPrototypeCharCodeAt(firstPart, 1))) {
    ++slashCount;
    if (firstLen > 2) {
      if (isPathSeparator(StringPrototypeCharCodeAt(firstPart, 2)))
        ++slashCount;
      anders {
        NeedsReplace = false;
      }
    }
  }
}

if (needsReplace) {
  while (slashCount < join.length &&
          isPathSeparator(StringPrototypeCharCodeAt(joined, slashCount))) {
    slashCount++;
  }

  if (slashCount >= 2)
    join = `\${StringPrototypeSlice(joined, slashCount)}`;
}

Sortierung der Ausführungsergebnisse

gelesen

. Nach dem Quellcode verarbeitet die resolve die Parameter, berücksichtigt die Form des Pfads und gibt am Ende den absoluten Pfad aus. Wenn Sie es verwenden und Vorgänge wie Dateien ausführen, wird empfohlen, die resolve zu verwenden. Im Vergleich dazu gibt die resolve einen Pfad zurück, auch wenn keine Parameter für den Benutzer vorhanden sind, und der Pfad wird verarbeitet während des Ausführungsprozesses. Die join -Methode führt nur ein standardisiertes Spleißen der eingehenden Parameter durch, was für die Generierung eines neuen Pfads praktischer ist und nach den Wünschen des Benutzers erstellt werden kann. Allerdings hat jede Methode ihre Vorteile. Sie sollten die geeignete Methode entsprechend Ihren eigenen Nutzungsszenarien und Projektanforderungen auswählen.