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

fs.realpath = fonction realpath(p, cache, cb) {
  si (!util.isFunction(cb)) {
    cb = peut-êtreCallback(cache);
    cache = nul;
  >
  // fait que p est absolu
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return process.nextTick(cb.bind(null, null, 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.lstat(base, fonction(err) {
        if (err) return cb(err);
        connuHard[base] = true;
        BOUCLE();
      });
    } autre {
      processus.nextTick(LOOP);
    >
  >
  // parcourez le chemin, en échangeant les parties du chemin liées contre leurs véritables
  // valeurs
  fonction BOUCLE() {
    // s'arrête si scanné après la fin du chemin
    if (pos >= p.length) {
      if (cache) cache[original] = p;
      retourner cb(null, p);
    >
    // 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)) {
      return process.nextTick(LOOP);
    >
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // lien symbolique connu. pas besoin de stat à nouveau.
      return gotResolvedLink(cache[base]);
    >
    retourner fs.lstat(base, gotStat);
  >
  fonction gotStat(err, stat) {
    if (err) return cb(err);
    // s'il ne s'agit pas d'un lien symbolique, passez à la partie suivante du chemin
    si (!stat.isSymbolicLink()) {
      connuHard[base] = true;
      si (cache) cache[base] = base;
      return process.nextTick(LOOP);
    >
    // stat & lis le lien s'il n'est pas lu avant
    // appelle gotTarget dès que la cible du lien est connue
    // dev/ino renvoie toujours 0 sous Windows, alors ignorez la vérification.
    si (!estWindows) {
      var id = stat.dev.toString(32) ':' stat.ino.toString(32);
      if (seenLinks.hasOwnProperty(id)) {
        return gotTarget(null, sawLinks[id], base);
      >
    >
    fs.stat(base, fonction(err) {
      if (err) return cb(err);
      fs.readlink (base, fonction (erreur, cible) {
        if (!isWindows) sawLinks[id] = target;
        gotTarget(err, cible);
      });
    });
  >
  fonction gotTarget(err, cible, base) {
    if (err) return cb(err);
    varsolvingLink = pathModule.resolve(previous, target);
    if (cache) cache[base] =solvingLink;
    gotResolvedLink(resolvedLink);
  >
  fonction gotResolvedLink(resolvedLink) {
    // résout le lien, puis recommence
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    start();
  >
};