如何为带索引属性的nestedObj类型创建Type Guard类型守卫

问题背景 #

定义了如下嵌套对象类型：

type nestedObj = {[key: string]: nestedObj} | {[key: string]: number}

需要为该类型创建对应的Type Guard类型守卫，同时补充规则：

• 对象不能为null或undefined
• 每一层对象必须恰好只有一个键
• 最终嵌套的末端值必须是数字

示例符合要求的对象：

const testObj1 = { a: { b: { c: 42 } } };
const testObj2 = { ab: { bc: { cd: { d: 2 } } } };
const testObj3 = { xy: 3};

自己尝试实现的类型守卫代码：

const isNestedObj = (obj: any): obj is nestedObj => {
    // 终止条件
    if (typeof obj !== 'object' || obj === null || obj === undefined)
        return false
    
    // 键的数量不为1则返回false
    const objKeys = Object.keys(obj);
    if (objKeys.length !== 1)
        return false
    
    // 若嵌套的下一层是数字则返回true
    if (typeof obj[objKeys[0]] === 'number')
        return true

    else return isNestedObj(obj[objKeys[0]]);
}

疑问：该实现似乎有效，但不确定是否为最优方案。

分析与优化 #

你的原始实现逻辑完全正确，完美匹配需求：通过递归逐层检查对象的键数量，直到末端值为数字，同时排除了非法的null/undefined和非对象类型。

可以从以下几个方面优化，让代码更严谨、稳定：

1. 简化冗余判断 #

obj === null || obj === undefined可以用obj == null替代（== null会同时匹配null和undefined），合并后代码更简洁：

if (obj == null || typeof obj !== 'object')
    return false;

2. 用循环替代递归避免栈溢出 #

递归实现在遇到极深层嵌套的对象时，可能触发JavaScript的栈溢出错误。改用循环遍历的方式，能避免这个问题，同时逻辑保持一致。

3. 用unknown替代any提升类型安全性 #

unknown是TypeScript中更安全的顶层类型，相比any，它要求显式的类型检查才能使用，符合类型安全原则。

优化后的完整代码 #

const isNestedObj = (obj: unknown): obj is nestedObj => {
    let current = obj;
    while (true) {
        // 排除null/undefined和非对象类型
        if (current == null || typeof current !== 'object') {
            return false;
        }
        const keys = Object.keys(current);
        if (keys.length !== 1) {
            return false;
        }
        const value = current[keys[0]];
        // 末端是数字则符合要求
        if (typeof value === 'number') {
            return true;
        }
        // 继续检查下一层嵌套
        current = value;
    }
};

边界情况验证 #

优化后的代码能正确处理以下场景：

• 空对象{}：键数量为0，返回false
• 多键对象{a:1, b:2}：键数量不为1，返回false
• 非对象/非数字值（如"test"、[1,2]）：返回false
• 极深层嵌套对象：不会触发栈溢出

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