Instructions d'utilisation de la méthode fs.realpathSync dans node.js_node.js

Description de la méthode :

Version synchronisée de fs.realpath() .

Grammaire :

Copier le code Le code est le suivant :

fs.realpathSync(chemin, [cache])

Puisque cette méthode appartient au module fs, le module fs doit être introduit avant utilisation (var fs= require(“fs”) )

Paramètres de réception :

chemin Chemin

cache                                                                                                                                 ‐ ‐ ‐ ‐ ‐ Facultativement, un chemin mappé littéral peut être utilisé pour forcer la résolution d'un chemin spécifique ou pour éviter d'avoir besoin d'un fichier fs.stat supplémentaire pour connaître le véritable objet chemin.

Exemple :

Copier le code Le code est le suivant :

var fs = require('fs');

// Le point indique le chemin du fichier courant
var str = fs.realpathSync('.');
console.log(str);

Code source :

Copier le code Le code est le suivant :

fs.realpathSync = fonction realpathSync(p, cache) {
  // fait que p est absolu
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    retourner le cache[p];
  >
  var original = p,
      vuLiens = {},
      connuHard = {};
  // position actuelle du caractère dans p
  var pos;
  // le chemin partiel jusqu'à présent, y compris une barre oblique finale le cas échéant
  var courant ;
  // le chemin partiel sans barre oblique finale (sauf lorsqu'il pointe vers une racine)
  var base;
  // le chemin partiel scanné au tour précédent, avec slash
  var précédent ;
  start();
  fonction start() {
    // Sauter les racines
    var m = splitRootRe.exec(p);
    pos = m[0].longueur;
    courant = m[0];
    base = m[0];
    précédent = '';
    // Sous Windows, vérifiez que la racine existe. Sous Unix, ce n'est pas nécessaire.
    if (isWindows && !knownHard[base]) {
      fs.lstatSync(base);
      connuHard[base] = true;
    >
  >
  // parcourez le chemin, en échangeant les parties du chemin liées contre leurs véritables
  // valeurs
  // NB : p.length changements.
  while (pos < p.length) {
    // trouve la partie suivante
    nextPartRe.lastIndex = pos;
    var résultat = nextPartRe.exec(p);
    précédent = actuel;
    actuel = résultat[0];
    base = résultat précédent[1];
    pos = nextPartRe.lastIndex;
    // continue si ce n'est pas un lien symbolique
    if (knownHard[base] || (cache && cache[base] === base)) {
      continuer ;
    >
    var résoluLien;
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // un lien symbolique connu. pas besoin de stat à nouveau.
      résoluLink = cache[base];
    } autre {
      var stat = fs.lstatSync(base);
      si (!stat.isSymbolicLink()) {
        connuHard[base] = true;
        si (cache) cache[base] = base;
        continuer ;
      >
      // lit le lien s'il n'a pas été lu auparavant
      // dev/ino renvoie toujours 0 sous Windows, alors ignorez la vérification.
      var lienTarget = null;
      si (!estWindows) {
        var id = stat.dev.toString(32) ':' stat.ino.toString(32);
        if (seenLinks.hasOwnProperty(id)) {
          linkTarget = vuLiens[id];
        >
      >
      if (util.isNull(linkTarget)) {
        fs.statSync(base);
        linkTarget = fs.readlinkSync(base);
      >
      solveLink = pathModule.resolve(previous, linkTarget);
      // suivez cela, si on vous donne un cache.
      if (cache) cache[base] =solvingLink;
      if (!isWindows) sawLinks[id] = linkTarget;
    >
    // résout le lien, puis recommence
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  >
  if (cache) cache[original] = p;
  retourner p;
};