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

Description de la méthode :

Obtenez le vrai chemin.

Les chemins relatifs peuvent être résolus à l'aide de process.cwd.

Grammaire :

Copier le code Le code est le suivant :

fs.realpath(chemin, [cache], [callback(err,solvingPath)])

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.

rappel                                                                          

erreur Exception

resolvedPath Adresse réelle

Exemple :

Copier le code Le code est le suivant :

var cache = {'/etc':'/private/etc'};
fs.realpath('/etc/passwd', cache, fonction (err, wantedPath) {
si (erreur) lance erreur ;
console.log(resolvedPath);
});

Code source :

Copier le code Le code est le suivant :

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();
  >
};