import Data.Text.Lazy as DTL

str1 :: String
str1 = DTL.unpack $DTL.replace key value text
  where key = DTL.pack "<<name>>"
        value = DTL.pack "Joyce"
        text = DTL.pack "Hello,<<name>>."

str2 :: String
str2 = DTL.unpack $DTL.replace key value text
  where key = DTL.pack "<<" `DTL.append` DTL.pack "name" 
                            `DTL.append` DTL.pack ">>"
        value = DTL.pack "Joyce"
        text = DTL.pack "Hello,<<name>>."

str3 :: String
str3 = DTL.unpack $DTL.replace key value text
  where key = DTL.pack $"<<" ++ "name" ++ ">>"
        value = DTL.pack "Joyce"
        text = DTL.pack "Hello,<<name>>."

main :: IO ()
main = do putStrLn str1
          putStrLn str2
          putStrLn str3

Hello,Joyce.
Hello,<<name>>.
Hello,Joyce.

解决方法

是的，在启用了 concurrent mode 的 useTransition() 中，您可以创建一个自定义路由器以将 navigation methods 上的每个 history object 包装在一个悬念转换中：

import { useState,unstable_useTransition as useTransition } from ''react'';
import { Router } from ''react-router-dom'';
const SuspenseRouter = ({ children,history,...config }) => {
  const [startTransition,isPending] = useTransition(config);
  const [suspenseHistory] = useState(() => {
    const { push,replace,go } = history;
    history.push = (...args) => {
      startTransition(() => { push.apply(history,args); });
    };
    history.replace = (...args) => {
      startTransition(() => { replace.apply(history,args); });
    };
    history.go = (...args) => {
      startTransition(() => { go.apply(history,args); });
    };
  });
  suspenseHistory.isPending = isPending;
  return (
    <Router history={suspenseHistory}>
      {children}
    </Router>
  );
};
export default SuspenseRouter;

示例用法可能如下所示：

import { Suspense,lazy,unstable_createRoot as createRoot } from ''react'';
import { Switch,Route } from ''react-router-dom'';
import { createBrowserHistory } from ''history'';
import SuspenseRouter from ''./components/SuspenseRouter'';
const history = createBrowserHistory();
const Home = lazy(() => import(''./routes/Home''));
const About = lazy(() => import(''./routes/About''));
const App = () => (
  <SuspenseRouter history={history} timeoutMs={2000}>
    <Suspense fallback="Loading...">
      <Switch>
        <Route path="/" exact={true} component={Home} />
        <Route path="/about" component={About} />
      </Switch>
    </Suspense>
  </SuspenseRouter>
);
createRoot(document.getElementById(''root'')).render(<App />);

如果您想在之前的路线上无限期等待，请将 timeoutMs 设置为 Infinity。在上面的示例中，将其设置为 2000 应该在前一路线上等待最多 2 秒，然后如果所请求路线的代码尚未下载，则显示 fallback。

这是另一种选择：您可以暂停屏幕更改，而不是暂停 url 更改。

Package react-router-loading 允许在切换屏幕之前显示加载栏并获取一些数据。

只需使用此包中的 Switch 和 Route 而不是 react-router-dom：

import { Switch,Route } from "react-router-loading";

将 loading 道具添加到您要等待的路线：

<Route path="/my-component" component={MyComponent} loading/>

然后在 MyComponent 中获取逻辑末尾的某处添加 loadingContext.done();：

import { LoadingContext } from "react-router-loading";
const loadingContext = useContext(LoadingContext);
const loading = async () => {
    //fetching some data
    //call method to indicate that fetching is done and we are ready to switch
    loadingContext.done();
};