JavaScript中检测和处理非数字（NaN）结果的策略

/**
 * 执行一个数学操作并验证结果是否为有效数字。
 * @param {string} operation - 操作类型，例如 'sqrt' (平方根) 或 'multiply' (乘法)。
 * @param {...any} args - 操作所需的参数。
 * @returns {number|string} 如果结果有效则返回数字，否则返回错误字符串。
 */
function calculateAndValidate(operation, ...args) {
    let result;

    switch (operation) {
        case 'sqrt':
            const numToSqrt = args[0];
            if (typeof numToSqrt !== 'number') {
                result = NaN; // 非数字输入导致NaN
            } else if (numToSqrt < 0) {
                result = Math.sqrt(numToSqrt); // 负数开方，结果为NaN
            } else {
                result = Math.sqrt(numToSqrt);
            }
            break;
        case 'multiply':
            const val1 = args[0];
            const val2 = args[1];
            // 尝试进行乘法运算，如果其中一个参数是非数字字符串，可能导致NaN
            result = val1 * val2;
            break;
        case 'divide':
            const numerator = args[0];
            const denominator = args[1];
            if (typeof numerator !== 'number' || typeof denominator !== 'number') {
                result = NaN;
            } else if (denominator === 0) {
                // 除以0会得到 Infinity 或 -Infinity，而不是 NaN (除非 0/0)
                result = numerator / denominator;
            } else {
                result = numerator / denominator;
            }
            break;
        default:
            result = NaN; // 未知操作默认为NaN
    }

    // 使用 isNaN() 检查结果
    if (isNaN(result)) {
        console.error(`错误：操作 "${operation}" 产生了无效的数值结果。`);
        return 'Error: Invalid number result.';
    } else {
        console.log(`操作 "${operation}" 结果为：${result}`);
        return result;
    }
}

// 测试用例
console.log("--- 平方根测试 ---");
calculateAndValidate('sqrt', -4);      // 预期输出：错误 (NaN)
calculateAndValidate('sqrt', 9);       // 预期输出：3
calculateAndValidate('sqrt', 'abc');   // 预期输出：错误 (NaN)

console.log("\n--- 乘法测试 ---");
calculateAndValidate('multiply', 5, 2);     // 预期输出：10
calculateAndValidate('multiply', 5, 'a');   // 预期输出：错误 (NaN)

console.log("\n--- 除法测试 ---");
calculateAndValidate('divide', 10, 2);     // 预期输出：5
calculateAndValidate('divide', 10, 0);     // 预期输出：Infinity (不是NaN，通过检查)
calculateAndValidate('divide', 0, 0);      // 预期输出：错误 (NaN，因为 0/0 = NaN)
calculateAndValidate('divide', 'x', 5);    // 预期输出：错误 (NaN)

console.log("\n--- isNaN() vs Number.isNaN() ---");
console.log(`isNaN(NaN): ${isNaN(NaN)}`);             // true
console.log(`Number.isNaN(NaN): ${Number.isNaN(NaN)}`); // true

console.log(`isNaN("hello"): ${isNaN("hello")}`);     // true (因为 Number("hello") 是 NaN)
console.log(`Number.isNaN("hello"): ${Number.isNaN("hello")}`); // false (因为 "hello" 不是 number 类型)

console.log(`isNaN(undefined): ${isNaN(undefined)}`); // true (因为 Number(undefined) 是 NaN)
console.log(`Number.isNaN(undefined): ${Number.isNaN(undefined)}`); // false (因为 undefined 不是 number 类型)

console.log(`isNaN({}): ${isNaN({})}`);               // true (因为 Number({}) 是 NaN)
console.log(`Number.isNaN({}): ${Number.isNaN({})}`);   // false (因为 {} 不是 number 类型)

console.log(`isNaN(123): ${isNaN(123)}`);             // false
console.log(`Number.isNaN(123): ${Number.isNaN(123)}`); // false