node.js中的fs.realpath方法使用說明_node.js

方法說明：

取得真實路徑。

可以使用process.cwd解相對路徑。

文法：

複製程式碼 程式碼如下:

fs.realpath(path, [cache], [callback(err , resolvedPath)])

由於方法屬於fs模組，使用前需要引入fs模組（var fs= require(“fs”) ）

接收參數：

path                             路徑

cache                          

callback                       回復

err                               且為例外

resolvedPath               真實位址

範例：

複製程式碼 程式碼如下:

var cache = {'/etc':'/private/etc'};
fs.realpath('/etc/passwd', cache, function (err, resolvedPath) {
  if (err) throw err;
  console.log(resolvedPath);
});

原始碼：

複製程式碼 程式碼如下:

fs.realpath = 函數 realpath(p, 快取, cb) {
  if (!util.isFunction(cb)) {
    cb = MaybeCallback(快取);
    快取 = null;
  }
  // 使 p 為絕對值
  p = pathModule.resolve(p);
  if (cache && Object.prototype.hasOwnProperty.call(cache, p)) {
    return process.nextTick(cb.bind(null, null, cache[p]));
  }
  var 原始 = p,
      seeLinks = {},
      knownHard = {};
  // p
中的目前字元位置   var pos;
  // 到目前為止的部分路徑，包括尾部斜線（如果有）
  var 目前；
  // 沒有尾部斜線的部分路徑（指向根時除外）
  var 基；
  // 上一輪掃描的部分路徑，附斜線
  var 以前;
  開始（）；
  函數開始() {
    // 跳過根
    var m = splitRootRe.exec(p);
    pos = m[0].length;
    目前 = m[0];
    基數 = m[0];
    上一個 = '';
    // 在 Windows 上，檢查根目錄是否存在。在unix上不需要。
    if (isWindows && !knownHard[base]) {
      fs.lstat(基數, 函數(錯誤) {
        if (err) return cb(err);
        knownHard[base] = true;
        循環();
      });
    } 其他 {
      process.nextTick(LOOP);
    }
  }
  // 沿著路徑走，將連結的路徑部分替換為真實的
  // 值
  函數循環() {
    // 若掃描超過路徑末端則停止
    if (pos >= p.length) {
      if (快取) 快取[原] = p;
      return cb(null, p);
    }
    // 找到下一部分
    nextPartRe.lastIndex = pos;
    var result = nextPartRe.exec(p);
    上一個=當前；
    目前=結果[0];
    基數 = 先前結果[1];
    pos = nextPartRe.lastIndex;
    // 如果不是符號連結則繼續
    if (knownHard[base] || (cache && cache[base] === base)) {
      return process.nextTick(LOOP);
    }
    if (cache && Object.prototype.hasOwnProperty.call(cache, base)) {
      // 已知的符號連結。無需再次統計。
      return gotResolvedLink(cache[base]);
    }
    return fs.lstat(base, gotStat);
  }
  函數 getStat(err, stat) {
    if (err) return cb(err);
    // 如果不是符號鏈接，則跳到下一個路徑部分
    if (!stat.isSymbolicLink()) {
      knownHard[base] = true;
      if (快取) 快取[基] = 基;
      return process.nextTick(LOOP);
    }
    // 統計並讀取連結（如果之前沒有讀過）
    // 一旦知道連結目標就呼叫gotTarget
    // dev/ino 在 Windows 上總是回傳 0，因此跳過檢查。
    if (!isWindows) {
      var id = stat.dev.toString(32) ':' stat.ino.toString(32);
      if (seenLinks.hasOwnProperty(id)) {
        return gotTarget(null, sawLinks[id], base);
      }
    }
    fs.stat(基數, 函數(錯誤) {
      if (err) return cb(err);
      fs.readlink(base, function(err, target) {
        if (!isWindows) sawLinks[id] = target;
        gotTarget(err, 目標);
      });
    });
  }
  函數 gotTarget(err, 目標, 基數) {
    if (err) return cb(err);
    var returnedLink = pathModule.resolve(previous, target);
    if (cache) cache[base] =resolvedLink;
    gotResolvedLink(resolvedLink);
  }
  函數 getResolvedLink(resolvedLink) {
    // 解析鏈接，然後重新開始
    p = pathModule.resolve(resolvedLink, p.slice(pos));
    開始（）；
  }
};