可通过 map() 配合字段配置和混淆逻辑动态脱敏敏感字段，如手机号、身份证号、邮箱、姓名等，需先定义映射规则并封装通用混淆函数，在数据解析后用 map 转换，支持嵌套字段与配置驱动，且不修改原数组。
可以通过 map() 配合字段配置和混淆逻辑，对 API 响应中的敏感字段（如手机号、身份证号、邮箱）进行动态脱敏，但需注意：map 本身不处理异步或副作用，它只负责“转换”，真正混淆要靠你传入的回调函数来实现。
明确哪些字段需要混淆
先定义一个敏感字段映射表，比如：
- phone → 保留前3位 + **** + 后2位（如 138****12）
- idCard → 保留前6位 + ******** + 后4位
- email → 用户名首尾 + *** + 域名（如 z***@gmail.com）
- realName → 只显示姓 + *（如 张*）
封装可复用的混淆函数
写一个通用混淆器，根据字段名自动选择规则：
const obfuscateField = (key, value) => {
if (value == null) return value;
switch (key) {
case 'phone':
return value.replace(/(\d{3})\d{4}(\d{2})/, '$1****$2');
case 'idCard':
return value.replace(/^(\d{6})\d{8}(\d{4})$/, '$1********$2');
case 'email':
return value.replace(/^(.)(.*?)(?=@)/, (_, a, b) => a + '*'.repeat(b.length));
case 'realName':
return value.length > 1 ? value[0] + '*' : value;
default:
return value;
}
};在 map 中动态应用混淆
假设 API 返回的是用户列表数组，你可以在解析后立即用 map 处理：
fetch('/api/users')
.then(res => res.json())
.then(data => {
const sensitiveKeys = ['phone', 'idCard', 'email', 'realName'];
const obfuscatedList = data.map(item => {
const newItem = { ...item };
sensitiveKeys.forEach(key => {
if (key in newItem) {
newItem[key] = obfuscateField(key, newItem[key]);
}
});
return newItem;
});
console.log(obfuscatedList); // 已脱敏数据
});进阶：支持嵌套字段与配置驱动
如果敏感字段在深层（如 user.profile.phone），可用路径字符串（如 'profile.phone'）配合 Lodash 的 set/get 或手写路径访问逻辑。也可把规则抽成配置对象，让 map 回调更声明式：
const obfuscationRules = {
'phone': v => v?.replace(/(\d{3})\d{4}(\d{2})/, '$1****$2'),
'profile.email': v => v?.replace(/^(.)(.*?)(?=@)/, (_, a, b) => a + '*'.repeat(b.length))
};
<p>const applyObfuscation = (obj, rules) => {
const result = { ...obj };
Object.entries(rules).forEach(([path, fn]) => {
const keys = path.split('.');
let ref = result;
for (let i = 0; i < keys.length - 1; i++) {
if (ref[keys[i]] == null) return;
ref = ref[keys[i]];
}
const lastKey = keys[keys.length - 1];
if (ref && lastKey in ref) {
ref[lastKey] = fn(ref[lastKey]);
}
});
return result;
};</p><p>// 使用
data.map(item => applyObfuscation(item, obfuscationRules));不复杂但容易忽略：map 不修改原数组，也不处理异步请求本身；混淆必须在数据落地后、渲染或传输前完成。关键是把“字段识别”和“混淆逻辑”解耦，才能做到真正动态可配。
