在React中利用Promise实现HTML Dialog的异步交互-js教程-PHP中文网

在react中利用promise实现html dialog的异步交互

本文详细介绍了如何在React应用中，通过结合HTML的`

实现异步模态对话框的需求分析

在现代Web应用中，经常需要用户进行确认或输入才能继续执行某个操作。HTML5的

核心实现思路：Promise与全局状态管理

要实现上述需求，我们需要结合以下关键技术：

Promise机制：利用Promise的resolve和reject方法来控制异步流程，实现代码的“等待”和“恢复”。
全局状态管理：管理对话框的可见性，并存储Promise的resolve函数，以便在对话框内部用户交互时能够触发它。
HTML 元素：作为模态对话框的载体。

具体步骤如下：

立即学习“前端免费学习笔记（深入）”；

创建一个全局状态，用于控制元素的open属性（显示/隐藏）。
在触发对话框的函数中，创建一个新的Promise实例，并将Promise的resolve函数存储到另一个全局变量或状态中。
更新对话框的可见性状态，使其显示。
在组件内部，当用户点击某个按钮时，调用之前存储的resolve函数，并传入用户选择的结果。同时，更新对话框的可见性状态，使其隐藏。
调用对话框的函数将返回该Promise，调用方可以通过await关键字等待其结果。

示例代码与详细解析

我们将通过一个简化的全局状态管理器createAtom来演示，它类似于Jotai或Zustand等轻量级状态库，用于管理对话框的显示状态和Promise的解析器。

1. 全局状态管理器 createAtom

首先，定义一个简单的createAtom函数，用于创建响应式的全局状态。在实际项目中，你可以替换为React Context、Redux、Jotai、Zustand等。

// createAtom.js
function createAtom(_def) {
  const evt = new EventTarget(); // 使用EventTarget进行状态变更通知
  let _value = _def; // 状态的当前值

  // use hook：组件订阅状态变化
  function use() {
    const [, _refresher] = React.useState(0); // 强制组件重新渲染
    React.useEffect(() => {
      const listener = () => _refresher(c => c + 1);
      evt.addEventListener('notify', listener); // 监听状态变更事件
      return () => evt.removeEventListener('notify', listener); // 清理监听器
    }, []);
    return _value; // 返回当前状态值
  }

  // setValue：更新状态值并通知所有订阅者
  function setValue(v) {
    _value = v;
    evt.dispatchEvent(new Event('notify'));
  }

  // value：获取当前状态值（非响应式）
  const value = () => _value;
  return { value, setValue, use };
}

登录后复制

2. 定义全局状态变量

我们需要两个全局状态：

dialogOpen: 控制对话框的显示/隐藏（布尔值）。
info: 用于显示用户操作结果的信息。
dialogResolve: 用于存储Promise的resolve函数。

// globalState.js
const dialogOpen = createAtom(false); // 对话框是否打开
const info = createAtom(''); // 用于显示信息的全局状态
let dialogResolve; // 存储Promise的resolve函数

登录后复制

3. Dialog 组件

这个组件负责渲染HTML

百度文心百中

百度大模型语义搜索体验中心

263

查看详情

// Dialog.jsx
function Dialog() {
  const isOpen = dialogOpen.use(); // 订阅dialogOpen状态

  const handleButtonClick = (result) => {
    if (dialogResolve) {
      dialogResolve(result); // 解析Promise，返回结果
    }
    dialogOpen.setValue(false); // 关闭对话框
  };

  return (
    <dialog open={isOpen}>
      <h3>请确认您的操作</h3>
      <p>您确定要执行此操作吗？</p>
      <button onClick={() => handleButtonClick('Yes')}>是</button>
      <button onClick={() => handleButtonClick('Cancel')}>取消</button>
    </dialog>
  );
}

登录后复制

4. modal 函数：触发对话框并返回Promise

这是核心函数，它负责显示对话框并返回一个Promise，供调用方等待。

// modalService.js
function modal() {
  return new Promise((resolve) => {
    dialogOpen.setValue(true); // 显示对话框
    dialogResolve = resolve; // 存储resolve函数，供Dialog组件调用
  });
}

登录后复制

5. Test 组件：调用方

Test 组件模拟了需要用户确认的场景。它调用modal()函数，并使用async/await（或then）等待用户输入。

// Test.jsx
function Test() {
  const handleClick = async () => {
    // 触发模态对话框，并等待用户选择
    const result = await modal();
    info.setValue(`您点击了：${result} @ ${new Date().toLocaleTimeString()}`);
  };

  return (
    <div>
      <button onClick={handleClick}>触发确认对话框</button>
    </div>
  );
}

登录后复制

6. Info 组件：显示结果

一个简单的组件，用于显示info全局状态的内容。

// Info.jsx
function Info() {
  const txt = info.use();
  return <div style={{ marginTop: '20px', fontWeight: 'bold' }}>{txt}</div>;
}

登录后复制

7. Main 组件：组合应用

将所有组件组合在一起，渲染到DOM中。

// Main.jsx
function Main() {
  return (
    <React.Fragment>
      <h1>React Promise Dialog 示例</h1>
      <Test />
      <Info />
      <Dialog />
    </React.Fragment>
  );
}

// 渲染应用
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<Main />);

登录后复制

完整代码示例 (HTML & JavaScript)

为了方便测试，以下是包含所有JS代码和HTML骨架的完整示例：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>React Promise Dialog 示例</title>
    <style>
        body { font-family: sans-serif; margin: 20px; }
        dialog {
            border: 1px solid #ccc;
            padding: 20px;
            border-radius: 8px;
            box-shadow: 0 4px 6px rgba(0,0,0,0.1);
        }
        dialog::backdrop {
            background: rgba(0,0,0,0.5);
        }
        button {
            padding: 8px 15px;
            margin-right: 10px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            background-color: #007bff;
            color: white;
        }
        button:hover {
            background-color: #0056b3;
        }
        dialog button {
            background-color: #6c757d;
        }
        dialog button:hover {
            background-color: #5a6268;
        }
        dialog button:first-of-type {
            background-color: #28a745;
        }
        dialog button:first-of-type:hover {
            background-color: #218838;
        }
    </style>
</head>
<body>
    <div id="root"></div>

    <script crossorigin src="https://unpkg.com/react@18/umd/react.development.js"></script>
    <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.development.js"></script>
    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>

    <script type="text/babel">
        const { useState, useEffect } = React;

        // createAtom.js
        function createAtom(_def) {
            const evt = new EventTarget();
            let _value = _def;
            function use() {
                const [, _refresher] = useState(0);
                useEffect(() => {
                    const listener = () => _refresher(c => c + 1);
                    evt.addEventListener('notify', listener);
                    return () => evt.removeEventListener('notify', listener);
                }, []);
                return _value;
            }
            function setValue(v) {
                _value = v;
                evt.dispatchEvent(new Event('notify'));
            }
            const value = () => _value;
            return { value, setValue, use };
        }

        // globalState.js
        const dialogOpen = createAtom(false);
        const info = createAtom('');
        let dialogResolve; // 存储Promise的resolve函数

        // Dialog.jsx
        function Dialog() {
            const isOpen = dialogOpen.use();

            const handleButtonClick = (result) => {
                if (dialogResolve) {
                    dialogResolve(result);
                }
                dialogOpen.setValue(false);
            };

            return (
                <dialog open={isOpen}>
                    <h3>请确认您的操作</h3>
                    <p>您确定要执行此操作吗？</p>
                    <button onClick={() => handleButtonClick('Yes')}>是</button>
                    <button onClick={() => handleButtonClick('Cancel')}>取消</button>
                </dialog>
            );
        }

        // Info.jsx
        function Info() {
            const txt = info.use();
            return <div style={{ marginTop: '20px', fontWeight: 'bold' }}>{txt}</div>;
        }

        // modalService.js
        function modal() {
            return new Promise((resolve) => {
                dialogOpen.setValue(true);
                dialogResolve = resolve;
            });
        }

        // Test.jsx
        function Test() {
            const handleClick = async () => {
                // 触发模态对话框，并等待用户选择
                const result = await modal();
                info.setValue(`您点击了：${result} @ ${new Date().toLocaleTimeString()}`);
            };

            return (
                <div>
                    <button onClick={handleClick}>触发确认对话框</button>
                </div>
            );
        }

        // Main.jsx
        function Main() {
            return (
                <React.Fragment>
                    <h1>React Promise Dialog 示例</h1>
                    <Test />
                    <Info />
                    <Dialog />
                </React.Fragment>
            );
        }

        const root = ReactDOM.createRoot(document.getElementById('root'));
        root.render(<Main />);
    </script>
</body>
</html>

登录后复制

注意事项与最佳实践

全局变量的替代方案：在大型应用中，直接使用全局变量（如dialogResolve）可能导致命名冲突和维护困难。推荐使用更健壮的状态管理方案，例如：
- React Context API：将dialogOpen状态和setDialogResolve函数通过Context提供给整个应用。
- Redux/Jotai/Zustand：这些库提供了更强大的全局状态管理能力，可以更好地组织和管理对话框的状态和逻辑。
- 自定义Hook：封装对话框逻辑为一个自定义Hook，提供openModal函数和对话框组件。
错误处理：如果用户在对话框打开后没有做出选择，或者对话框被意外关闭，Promise将永远不会被解析。可以考虑在Promise中添加超时机制或reject路径来处理这些情况。
可访问性 (Accessibility)：确保元素具有适当的ARIA属性，并且键盘导航（Tab键、Enter键、Esc键）能够正常工作。原生的元素在这方面通常表现良好，但自定义内容时需注意。
UI/UX设计：除了功能实现，对话框的样式和用户体验也至关重要。确保对话框在不同设备上都能良好显示，并且提示信息清晰明了。
多个对话框实例：如果应用中需要同时或顺序显示多个不同类型的对话框，上述的dialogResolve全局变量可能需要扩展为一个队列或映射，以支持管理多个Promise。