如何利用JavaScript的Array.prototype.reduce实现状态机，以及它在复杂状态转换中的可读性优势？

// 定义所有可能的状态
const ORDER_STATES = {
    PENDING: 'PENDING',
    PROCESSING: 'PROCESSING',
    SHIPPED: 'SHIPPED',
    DELIVERED: 'DELIVERED',
    CANCELLED: 'CANCELLED'
};

// 定义所有可能的事件
const ORDER_EVENTS = {
    START_PROCESSING: 'START_PROCESSING',
    SHIP: 'SHIP',
    DELIVER: 'DELIVER',
    CANCEL: 'CANCEL'
};

// 初始状态
const initialState = {
    status: ORDER_STATES.PENDING,
    orderId: 'ORD123',
    history: [{ timestamp: Date.now(), status: ORDER_STATES.PENDING, event: 'INITIALIZED' }]
};

// 状态转换逻辑（reducer函数）
const orderReducer = (state, event) => {
    // 每次状态更新，都返回一个新的状态对象，保持不可变性
    const newState = { ...state };
    const timestamp = Date.now();

    switch (state.status) {
        case ORDER_STATES.PENDING:
            if (event.type === ORDER_EVENTS.START_PROCESSING) {
                newState.status = ORDER_STATES.PROCESSING;
            } else if (event.type === ORDER_EVENTS.CANCEL) {
                newState.status = ORDER_STATES.CANCELLED;
            }
            break;
        case ORDER_STATES.PROCESSING:
            if (event.type === ORDER_EVENTS.SHIP) {
                newState.status = ORDER_STATES.SHIPPED;
            } else if (event.type === ORDER_EVENTS.CANCEL) {
                newState.status = ORDER_STATES.CANCELLED;
            }
            break;
        case ORDER_STATES.SHIPPED:
            if (event.type === ORDER_EVENTS.DELIVER) {
                newState.status = ORDER_STATES.DELIVERED;
            }
            // 订单已发货，不能再取消了，这里没有处理取消事件
            break;
        case ORDER_STATES.DELIVERED:
        case ORDER_STATES.CANCELLED:
            // 最终状态，不再接受任何事件
            console.warn(`Order ${state.orderId} is in final state (${state.status}), ignoring event: ${event.type}`);
            return state; // 返回原状态，不进行任何修改
    }

    // 记录状态变更历史
    newState.history = [...state.history, { timestamp, status: newState.status, event: event.type, payload: event.payload }];
    return newState;
};

// 模拟一系列事件
const events = [
    { type: ORDER_EVENTS.START_PROCESSING, payload: { processor: 'UserA' } },
    { type: ORDER_EVENTS.SHIP, payload: { carrier: 'FedEx', tracking: 'TRK456' } },
    { type: ORDER_EVENTS.DELIVER, payload: { deliveredBy: 'CourierB' } }
    // { type: ORDER_EVENTS.CANCEL, payload: { reason: 'Customer changed mind' } } // 尝试在不同阶段取消
];

// 使用 reduce 驱动状态机
const finalOrderState = events.reduce(orderReducer, initialState);

console.log('最终订单状态:', finalOrderState);
/*
输出示例：
最终订单状态: {
  status: 'DELIVERED',
  orderId: 'ORD123',
  history: [
    { timestamp: ..., status: 'PENDING', event: 'INITIALIZED' },
    { timestamp: ..., status: 'PROCESSING', event: 'START_PROCESSING', payload: { processor: 'UserA' } },
    { timestamp: ..., status: 'SHIPPED', event: 'SHIP', payload: { carrier: 'FedEx', tracking: 'TRK456' } },
    { timestamp: ..., status: 'DELIVERED', event: 'DELIVER', payload: { deliveredBy: 'CourierB' } }
  ]
}
*/

// reducer 返回 [newState, effectsToRun]
const orderReducerWithEffects = (state, event) => {
    const newState = { ...state };
    const effects = []; // 收集副作用

    switch (state.status) {
        case ORDER_STATES.PENDING:
            if (event.type === ORDER_EVENTS.START_PROCESSING) {
                newState.status = ORDER_STATES.PROCESSING;
                effects.push({ type: 'SEND_EMAIL', to: 'admin@example.com', subject: 'Order Started Processing' });
            }
            // ...
            break;
    }
    // ... 记录历史
    return [newState, effects];
};

// 然后在 reduce 外部，有一个专门处理这些副作用的逻辑
const eventsWithEffects = [
    { type: ORDER_EVENTS.START_PROCESSING, payload: { processor: 'UserA' } },
    // ...
];

let currentState = initialState;
for (const event of eventsWithEffects) {
    const [nextState, effects] = orderReducerWithEffects(currentState, event);
    currentState = nextState;
    // 执行副作用
    for (const effect of effects) {
        if (effect.type === 'SEND_EMAIL') {
            console.log(`Sending email to ${effect.to}: ${effect.subject}`);
        }
        // ... 其他副作用处理
    }
}
console.log('最终订单状态 (带副作用处理):', currentState);

// 假设事件结构为 { type: 'EVENT_TYPE', payload: { ... } }

const initialStateWithData = {
    cartItems: [],
    totalPrice: 0
};

const cartReducer = (state, event) => {
    const newState = { ...state };
    const { type, payload } = event; // 解构出类型和载荷

    switch (type) {
        case 'ADD_ITEM':
            const { itemId, name, price, quantity } = payload;
            const existingItemIndex = newState.cartItems.findIndex(item => item.itemId === itemId);

            if (existingItemIndex > -1) {
                // 如果商品已存在，更新数量和价格
                const updatedItems = [...newState.cartItems];
                const existingItem = updatedItems[existingItemIndex];
                updatedItems[existingItemIndex] = {
                    ...existingItem,
                    quantity: existingItem.quantity + quantity
                };
                newState.cartItems = updatedItems;
            } else {
                // 否则，添加新商品
                newState.cartItems = [...newState.cartItems, { itemId, name, price, quantity }];
            }
            newState.totalPrice += price * quantity;
            break;

        case 'REMOVE_ITEM':
            const { itemId: removeId } = payload;
            const itemToRemove = newState.cartItems.find(item => item.itemId === removeId);
            if (itemToRemove) {
                newState.cartItems = newState.cartItems.filter(item => item.itemId !== removeId);
                newState.totalPrice -= itemToRemove.price * itemToRemove.quantity;
            }
            break;

        case 'CLEAR_CART':
            newState.cartItems = [];
            newState.totalPrice = 0;
            break;
    }
    return newState;
};

const cartEvents = [
    { type: 'ADD_ITEM', payload: { itemId: 'P1', name: 'Laptop', price: 1200, quantity: 1 } },
    { type: 'ADD_ITEM', payload: { itemId: 'P2', name: 'Mouse', price: 25, quantity: 2 } },
    { type: 'ADD_ITEM', payload: { itemId: 'P1', name: 'Laptop', price: 1200, quantity: 1 } }, // 再加一个笔记本
    { type: 'REMOVE_ITEM', payload: { itemId: