JavaScript嵌套对象遍历与指定雇主人员过滤问题求助

环境 #

• Windows 11、VSCode、node v18.12.1

需求说明 #

需要遍历嵌套的JSON对象，通过filteredEmployers数组（值为['Megasystems', 'Bellkrieg']）过滤人员对象：排除所有employer属性包含数组中任意关键词的人员，返回剩余的完整人员对象，且该过滤数组需支持扩展。

当前可运行代码 #

现有代码可遍历所有层级对象，打印人员的name、city和employer字段：

let data = [{
    "Pagination": {
        "NumberOfPeople": 185,
        "PageSize": 200,
        "PageNumber": 1,
        "NumberOfPages": 1
    }, 
    "People": [
    {
    "name": "TJ",
    "job": "Software Engineer",
    "organization": {
        "company": {
        "employer": "amazon",
        "department": "IT"
            }
        },
    "location": {
    "city": "Boston",
    "state": "Massachusetts"
    }
},
{
    "name": "Dominique",
    "job": "CEO",
    "organization": {
        "company": {
        "employer": "IBM",
        "department": "IT"
            }
        },
    "city": "Seattle",
    "state": "Washington",
},
{
    "name": "Enrique",
    "job": "Engineer",
    "organization": {
        "company": {
        "employer": "Bellkrieg Megasystems",
        "department": "Construction"
            }
        },
    "location": {
    "address": {
    "state": "New York",
    "city": "New York City",
    "zip": "11323"
        }
    }
},
{
    "name": "Bob",
    "job": "Project Manager",
    "organization": {
        "company": {
        "employer": "Megasystems",
        "department": "R&D"
            }
        },
    "address": {
        "location": {
            "quadrant": {
                "block": 1,
                "state": "Texas",
                "city": "Austin"
            }
        }
    }
}
]}]

data.filter(item => {
    iterateObject(item);
});

function iterateObject(obj) {
    for(prop in obj) {
        if(typeof(obj[prop]) == "object"){
            iterateObject(obj[prop]);
        } else {
            if(prop == "name" || prop == "city" || prop == "employer") {
            console.log(prop.toUpperCase() + ': ', obj[prop]);
            }
            // 需要添加过滤逻辑：排除employer包含filteredEmployers中任意关键词的对象
        }
    }
}

当前代码输出 #

NAME:  TJ
EMPLOYER:  amazon
CITY:  Boston
NAME:  Dominique
EMPLOYER:  IBM
CITY:  Seattle
NAME:  Enrique
EMPLOYER:  Bellkrieg Megasystems
CITY:  New York City
NAME:  Bob
EMPLOYER:  Megasystems
CITY:  Austin

已尝试方案（不符合预期） #

尝试的代码如下，但返回结果多次包含完整的Pagination结构，且People字段仅显示[Object]，未得到预期的过滤后人员对象：

// 嵌套对象数据同上

filteredEmployers = ['Megasystems', 'Bellkrieg'];

data.filter(item => {
    iterateObject(item);
});

function iterateObject(obj) {
    for(prop in obj) {
        if(typeof(obj[prop]) == "object"){
            iterateObject(obj[prop]);
        } else {
                            
                checkPeople = Object.values(data).filter(({employer}) =>
    !filteredEmployers.some(filtered => employer?.match(filtered)));
                if(checkPeople !== null) {
            console.log(checkPeople);}
            }
        }
    }
}

预期输出 #

{
    "name": "TJ",
    "job": "Software Engineer",
    "organization": {
        "company": {
        "employer": "amazon",
        "department": "IT"
            }
        },
    "location": {
    "city": "Boston",
    "state": "Massachusetts"
    }
},
{
    "name": "Dominique",
    "job": "CEO",
    "organization": {
        "company": {
        "employer": "IBM",
        "department": "IT"
            }
        },
    "city": "Seattle",
    "state": "Washington"
}

解决方案 #

核心思路：

1. 编写递归工具函数，提取任意嵌套层级下的employer属性值
2. 直接针对People数组过滤，保留employer不匹配过滤关键词的对象

完整代码：

let data = [{
    "Pagination": {
        "NumberOfPeople": 185,
        "PageSize": 200,
        "PageNumber": 1,
        "NumberOfPages": 1
    }, 
    "People": [
    {
    "name": "TJ",
    "job": "Software Engineer",
    "organization": {
        "company": {
        "employer": "amazon",
        "department": "IT"
            }
        },
    "location": {
    "city": "Boston",
    "state": "Massachusetts"
    }
},
{
    "name": "Dominique",
    "job": "CEO",
    "organization": {
        "company": {
        "employer": "IBM",
        "department": "IT"
            }
        },
    "city": "Seattle",
    "state": "Washington",
},
{
    "name": "Enrique",
    "job": "Engineer",
    "organization": {
        "company": {
        "employer": "Bellkrieg Megasystems",
        "department": "Construction"
            }
        },
    "location": {
    "address": {
    "state": "New York",
    "city": "New York City",
    "zip": "11323"
        }
    }
},
{
    "name": "Bob",
    "job": "Project Manager",
    "organization": {
        "company": {
        "employer": "Megasystems",
        "department": "R&D"
            }
        },
    "address": {
        "location": {
            "quadrant": {
                "block": 1,
                "state": "Texas",
                "city": "Austin"
            }
        }
    }
}
]}]

const filteredEmployers = ['Megasystems', 'Bellkrieg'];

// 递归获取对象中的employer值
function getEmployer(obj) {
    for (const key in obj) {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            const result = getEmployer(obj[key]);
            if (result) return result;
        } else if (key === 'employer') {
            return obj[key];
        }
    }
    return null;
}

// 过滤People数组
const filteredPeople = data[0].People.filter(person => {
    const employer = getEmployer(person);
    // 判断employer是否不包含任何过滤关键词
    return !filteredEmployers.some(filter => employer?.includes(filter));
});

// 打印格式化后的结果
console.log(JSON.stringify(filteredPeople, null, 2));

代码说明 #

• getEmployer函数：递归遍历人员对象的所有层级，找到并返回employer属性值，解决嵌套位置不固定的问题
• 直接对data[0].People数组使用filter方法，结合some判断人员的employer是否包含过滤数组中的任意关键词，保留不匹配的对象
• 使用JSON.stringify格式化输出，确保能看到完整的嵌套结构

运行后即可得到预期的过滤后人员对象列表。

内容的提问来源于stack exchange，提问作者e-driver1