如何使用Ramda屏蔽对象路径中的指定值

一、核心思路 #

要实现你需要的灵活值屏蔽功能，我们可以拆成两个核心步骤：

1. 路径模式匹配：根据传入的规则（精确一级、嵌套路径、通配符层级），遍历对象找出所有符合条件的目标路径。
2. 路径值替换：利用找到的路径列表，将对应位置的数值替换为屏蔽值（比如***）。

二、实现路径匹配函数 getPaths #

首先我们需要一个能解析路径模式、遍历对象并输出匹配路径的函数。下面是针对你提到的三种模式的实现：

1. 代码实现 #

// 辅助工具：判断是否为纯对象（排除数组、null等）
const isPlainObject = (val) => typeof val === 'object' && val !== null && !Array.isArray(val);

// 核心函数：接收模式数组，返回遍历对象匹配路径的函数
function getPaths(patterns) {
  // 将每个模式拆分为路径片段数组（比如'save.password' → ['save', 'password']）
  const parsedPatterns = patterns.map(pattern => pattern.split('.'));
  
  return (targetObj) => {
    const matchedPaths = [];
    
    // 递归遍历对象，跟踪当前路径
    function traverse(currentObj, currentPath) {
      if (!isPlainObject(currentObj)) return;
      
      Object.keys(currentObj).forEach(key => {
        const newPath = [...currentPath, key];
        const value = currentObj[key];
        
        // 检查当前路径是否匹配任意传入的模式
        parsedPatterns.forEach(pattern => {
          if (matchesRule(newPath, pattern)) {
            matchedPaths.push(newPath);
          }
        });
        
        // 递归遍历子对象
        traverse(value, newPath);
      });
    }
    
    traverse(targetObj, []);
    return matchedPaths;
  };
}

// 路径与模式的匹配规则判断
function matchesRule(path, pattern) {
  // 规则1：单一键名（如'password'）→ 仅匹配根层级的该键
  if (pattern.length === 1) {
    return path.length === 1 && path[0] === pattern[0];
  }
  
  // 规则2：精确嵌套路径（如'save.password'）→ 完全匹配路径长度和每一段
  if (!pattern.includes('*')) {
    if (path.length !== pattern.length) return false;
    return path.every((segment, idx) => segment === pattern[idx]);
  }
  
  // 规则3：通配符层级（如'*.password'）→ 匹配任意层级下的目标键
  if (pattern[0] === '*' && pattern.length === 2) {
    return path.length >= 2 && path[path.length - 1] === pattern[1];
  }
  
  // 可扩展更多规则，比如多段通配符'save.*.password'
  return false;
}

2. 测试路径匹配 #

用你提供的对象测试三种模式：

const obj = { 
  name: 'Jane Doe', 
  password: 'pass', 
  url: '/game?session=0123456789', 
  save: { 
    url: '/save?session:0123456789', 
    password: 'anotherPass', 
    deep: { 
      password: 'deepPass' 
    } 
  }, 
};

// 测试1：仅匹配根层级password
console.log(getPaths(['password'])(obj)); 
// 输出：[ ['password'] ]

// 测试2：匹配指定嵌套路径save.password
console.log(getPaths(['save.password'])(obj)); 
// 输出：[ ['save', 'password'] ]

// 测试3：匹配所有层级的password
console.log(getPaths(['*.password'])(obj)); 
// 输出：[ ['password'], ['save', 'password'], ['save', 'deep', 'password'] ]

三、实现值屏蔽函数 #

有了匹配的路径列表，我们可以轻松实现值替换：

// 根据路径列表屏蔽对象值，默认用***作为屏蔽符
function maskValues(targetObj, paths, mask = '***') {
  // 深拷贝原对象，避免修改源数据
  const clonedObj = JSON.parse(JSON.stringify(targetObj));
  
  paths.forEach(path => {
    let currentNode = clonedObj;
    // 遍历路径到倒数第二个节点
    for (let i = 0; i < path.length - 1; i++) {
      currentNode = currentNode[path[i]];
      if (!currentNode) break; // 路径不存在则跳过
    }
    // 设置屏蔽值
    if (currentNode && typeof currentNode === 'object') {
      currentNode[path[path.length - 1]] = mask;
    }
  });
  
  return clonedObj;
}

测试屏蔽效果 #

// 屏蔽所有层级的password
const maskedResult = maskValues(obj, getPaths(['*.password'])(obj));
console.log(maskedResult);
/* 输出：
{
  name: 'Jane Doe',
  password: '***',
  url: '/game?session=0123456789',
  save: {
    url: '/save?session:0123456789',
    password: '***',
    deep: { password: '***' }
  }
}
*/

四、扩展说明 #

如果需要支持更复杂的通配符（比如save.*.password匹配save下任意层级的password），可以修改matchesRule函数：

function matchesRule(path, pattern) {
  // 支持多段通配符：每个片段要么相等，要么是*
  if (path.length !== pattern.length) return false;
  return pattern.every((seg, idx) => seg === '*' || seg === path[idx]);
}

内容的提问来源于stack exchange，提问作者Luiz Correia