遍历深层对象指定层级的属性

# 深度优先遍历对象属性

# 问题

对于一个深层嵌套的对象，我们需要实现一个深度优先遍历函数，能够遍历到指定层级的属性。

/**
 * 深度优先遍历对象属性
 * @param {Object} obj - 要遍历的对象
 * @param {number} depth - 遍历的深度层级
 */
function dfs(obj, depth) {
    // 基本实现（与题目一致）
    if (depth <= 0) {
        return;
    }
    
    for (const key in obj) {
        // 输出当前属性键
        console.log(key);
        
        // 检查属性值是否为对象（非null）
        const value = obj[key];
        if (typeof value === 'object' && value !== null) {
            // 递归遍历嵌套对象
            dfs(value, depth - 1);
        }
    }
}

// 测试对象
const obj = {
    a: 1,
    b: {
        c: 2
    },
    d: {
        e: {
            f: 3
        }
    },
    g: {
        h: {
            i: {
                j: 4
            }
        }
    }
};

// 测试不同深度
console.log('===== 深度 0 =====');
dfs(obj, 0); // 无输出

console.log('\n===== 深度 1 =====');
dfs(obj, 1); 
// 输出: a, b, d, g

console.log('\n===== 深度 2 =====');
dfs(obj, 2); 
// 输出: a, b, c, d, e, g, h

console.log('\n===== 深度 3 =====');
dfs(obj, 3); 
// 输出: a, b, c, d, e, f, g, h, i

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# 代码解析（严格遵循题目要求）

# 1. 函数实现完全符合题目要求

function dfs(obj, depth) {
    if (depth <= 0) {
        return;
    }
    
    for (const key in obj) {
        console.log(key);
        
        const value = obj[key];
        if (typeof value === 'object' && value !== null) {
            dfs(value, depth - 1);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

保持原始函数签名不变
使用相同的递归逻辑
保持相同的深度控制机制

# 2. 增强点（不影响核心实现）

添加了JSDoc注释：说明函数参数和用途
添加了null检查：value !== null 避免对null值进行递归
添加了测试用例：展示不同深度下的输出结果

# 3. 输出结果说明

# 深度 0

无输出（因为depth <= 0直接返回）

# 深度 1

a
b
d
g

1
2
3
4

只输出第一层属性

# 深度 2

a
b
c   // b的子属性
d
e   // d的子属性
g
h   // g的子属性

1
2
3
4
5
6
7

输出第一层和第二层属性

# 深度 3

a
b
c   // b的子属性
d
e   // d的子属性
f   // e的子属性
g
h   // g的子属性
i   // h的子属性

1
2
3
4
5
6
7
8
9

输出第一层到第三层属性

# 核心算法解析

# 深度优先遍历流程

检查深度：如果depth <= 0，立即返回
遍历属性：使用for...in循环遍历当前对象的所有可枚举属性
输出键名：打印当前属性的键
递归检查：如果属性值是对象（非null），递归调用dfs函数，depth减1

# 递归调用栈示意图（depth=2）

dfs(obj, 2)
├─ 输出 'a'
├─ 输出 'b'
│   └─ dfs(b, 1)
│       ├─ 输出 'c'
├─ 输出 'd'
│   └─ dfs(d, 1)
│       ├─ 输出 'e'
├─ 输出 'g'
│   └─ dfs(g, 1)
│       ├─ 输出 'h'

1
2
3
4
5
6
7
8
9
10
11

# 关键特性

深度控制：通过depth参数精确控制遍历深度
递归实现：使用递归自然地实现深度优先遍历
对象检测：使用typeof检测对象类型
null处理：避免对null值进行递归
属性顺序：遵循JavaScript的对象属性枚举顺序

# 实际应用场景

这个函数非常适合处理：

配置解析：分析嵌套的配置对象
数据检查：检查对象结构的完整性
调试工具：快速查看对象结构
序列化准备：为对象序列化做准备
数据转换：将嵌套对象转换为扁平结构

编辑

上次更新: 2025/08/07, 01:44:52

← 扩展运算符一文弄懂typeof和instanceof→