控制流与错误处理

3. throw 语句

// 抛出字符串（不推荐）
throw "发生错误";

// 抛出数字（不推荐）
throw 404;

// 抛出对象（不推荐）
throw { message: "错误", code: 500 };

// 抛出 Error 对象（推荐）
throw new Error("错误描述");

// 条件抛出
function getUser(id) {
    if (!id || id <= 0) {
        throw new Error("无效的用户ID");
    }
    // 获取用户逻辑...
}

// 在表达式中使用 throw
function getDefault(value) {
    return value || throw new Error("值不能为空");
}

高级控制流模式

1. 短路求值

// 逻辑与 (&&) 短路
let user = null;
let username = user && user.name; // 不会报错，返回 null

// 逻辑或 (||) 短路
let config = userConfig || defaultConfig;

// 空值合并运算符 ?? (ES2020)
let value = null ?? "default"; // "default"
let value2 = 0 ?? "default"; // 0 (与 || 不同)

// 可选链操作符 ?. (ES2020)
let street = user?.address?.street; // 不会报错

2. 条件链式调用

// 传统方式
let result;
if (obj) {
    if (obj.method1) {
        result = obj.method1();
        if (result && result.method2) {
            return result.method2();
        }
    }
}

// 链式调用
let result = obj?.method1?.()?.method2?.();

3. 使用函数式方法

// 替代 for 循环
const numbers = [1, 2, 3, 4, 5];

// 遍历
numbers.forEach(num => console.log(num));

// 过滤
const even = numbers.filter(num => num % 2 === 0);

// 映射
const doubled = numbers.map(num => num * 2);

// 查找
const firstEven = numbers.find(num => num % 2 === 0);

// 检查
const allPositive = numbers.every(num => num > 0);
const hasNegative = numbers.some(num => num < 0);

// 归约
const sum = numbers.reduce((total, num) => total + num, 0);

4. 生成器和迭代器

// 生成器函数
function* numberGenerator() {
    let num = 1;
    while (true) {
        yield num++;
    }
}

const gen = numberGenerator();
console.log(gen.next().value); // 1
console.log(gen.next().value); // 2

// 使用生成器控制流程
function* taskRunner() {
    console.log("开始任务1");
    yield;
    console.log("开始任务2");
    yield;
    console.log("所有任务完成");
}

const runner = taskRunner();
runner.next(); // 开始任务1
runner.next(); // 开始任务2
runner.next(); // 所有任务完成

错误处理最佳实践

1. 防御性编程

// 参数验证
function processData(data) {
    if (!data || typeof data !== "object") {
        throw new TypeError("参数必须是对象");
    }

    if (!Array.isArray(data.items)) {
        throw new TypeError("items 必须是数组");
    }

    // 安全地处理数据
    return data.items.map(item => ({
        ...item,
        processed: true,
    }));
}

// 使用默认值
function createUser(options = {}) {
    const defaults = {
        name: "匿名",
        age: 18,
        email: "",
    };

    return { ...defaults, ...options };
}

2. 异步错误处理

// Promise 错误处理
fetch("https://api.example.com/data")
    .then(response => {
        if (!response.ok) {
            throw new Error(`HTTP错误: ${response.status}`);
        }
        return response.json();
    })
    .then(data => console.log(data))
    .catch(error => console.error("请求失败:", error));

// async/await 错误处理
async function fetchData() {
    try {
        const response = await fetch("https://api.example.com/data");
        if (!response.ok) {
            throw new Error(`HTTP错误: ${response.status}`);
        }
        const data = await response.json();
        return data;
    } catch (error) {
        console.error("获取数据失败:", error);
        // 返回默认值或重新抛出
        throw error; // 或 return defaultValue;
    }
}

// 并行异步错误处理
async function fetchMultiple() {
    try {
        const [data1, data2] = await Promise.all([fetchData1(), fetchData2()]);
        return { data1, data2 };
    } catch (error) {
        // 处理第一个失败的情况
        console.error("并行请求失败:", error);
    }
}

3. 全局错误处理

// 全局错误事件
window.addEventListener("error", function (event) {
    console.error("全局错误:", event.error);
    // 发送到错误监控服务
    sendToErrorTracking(event.error);
    // 阻止默认错误处理
    event.preventDefault();
});

// 未处理的 Promise 拒绝
window.addEventListener("unhandledrejection", function (event) {
    console.error("未处理的 Promise 拒绝:", event.reason);
    event.preventDefault();
});

// Node.js 全局错误处理
process.on("uncaughtException", error => {
    console.error("未捕获的异常:", error);
    // 记录错误并优雅退出
    process.exit(1);
});

process.on("unhandledRejection", (reason, promise) => {
    console.error("未处理的 Promise 拒绝:", reason);
});

4. 错误恢复策略

// 重试机制
async function fetchWithRetry(url, maxRetries = 3) {
    for (let i = 0; i <= maxRetries; i++) {
        try {
            const response = await fetch(url);
            return await response.json();
        } catch (error) {
            if (i === maxRetries) {
                throw error;
            }
            console.log(`重试 ${i + 1}/${maxRetries}`);
            await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, i))); // 指数退避
        }
    }
}

// 降级策略
async function getData() {
    try {
        return await fetchFromPrimarySource();
    } catch (error) {
        console.warn("主数据源失败，使用备用源");
        try {
            return await fetchFromFallbackSource();
        } catch (fallbackError) {
            console.error("所有数据源都失败");
            return getCachedData(); // 返回缓存数据
        }
    }
}

调试技巧

1. 控制台方法

// 不同级别的日志
console.log("普通日志");
console.info("信息日志");
console.warn("警告日志");
console.error("错误日志");
console.debug("调试日志");

// 分组日志
console.group("用户信息");
console.log("姓名: 张三");
console.log("年龄: 25");
console.groupEnd();

// 表格显示
console.table([
    { name: "张三", age: 25 },
    { name: "李四", age: 30 },
]);

// 断言
console.assert(1 === 2, "1 不等于 2");

// 跟踪调用栈
console.trace("当前位置");

// 性能测量
console.time("操作耗时");
// 执行操作...
console.timeEnd("操作耗时");

2. debugger 语句

function complexOperation() {
    let result = 0;
    debugger; // 执行到这里会暂停，可以检查变量

    for (let i = 0; i < 10; i++) {
        result += i;
    }

    return result;
}

代码质量工具

1. ESLint 规则

// .eslintrc.js 中的控制流相关规则
module.exports = {
    rules: {
        "no-constant-condition": "error", // 禁止常量条件
        "no-unreachable": "error", // 禁止不可达代码
        "no-duplicate-case": "error", // 禁止重复 case
        "default-case": "warn", // 要求 switch 有 default
        "no-fallthrough": "error", // 禁止 case 穿透
        "no-labels": "warn", // 避免使用标签
        "no-unused-expressions": "error", // 禁止未使用的表达式
        "no-console": "warn", // 避免使用 console
        "consistent-return": "error", // 要求一致的返回值
        curly: ["error", "all"], // 要求使用大括号
        eqeqeq: ["error", "always"], // 要求使用 === 和 !==
        "no-throw-literal": "error", // 只能抛出 Error 对象
        "no-unsafe-finally": "error", // finally 中避免控制转移
    },
};