... < 链接到 = “/Home”> Home </Link >//相对链接导航到/Home 什么是‘1. . _ _ truediv _ _’? Python 有. . (“点点”)符号语法吗？

嗨，如果您正在使用反应路由器 v-6.0.0-beta 或 V6在这个版本重定向更改导航像这样

从“ response-router-dom”导入{ Navigate } ;//像 v6中的 CORRECT 一样 “路由”路径，我希望它去。然后在我的 App.js 中执行下面的操作(注意... ... 是其他代码，但是在这里做一个演示太多了) :

import React, { Component } from "react";
import { Route, Link } from "react-router-dom";
import { BrowserRouter as Router } from "react-router-dom";
import { Redirect } from 'react-router';
import Ansible from "./Development/Ansible";
import Code from "./Development/Code";
import Wood from "./WoodWorking";
import "./App.css";


class App extends Component {
render() {
const redirect = sessionStorage.getItem("redirect");


if(redirect) {
sessionStorage.removeItem("redirect");
}


return (
<Router>
{redirect ?<Redirect to={redirect}/> : ""}
<div className="App">
...
<Link to="/">
<li>Home</li>
</Link>
<Link to="/dev">
<li>Development</li>
</Link>
<Link to="/wood">
<li>Wood Working</li>
</Link>
...
<Route
path="/"
exact
render={(props) => (
<Home {...props} />
)}
/>
<Route
path="/dev"
render={(props) => (
<Code {...props} />
)}
/>
<Route
path="/wood"
render={(props) => (
<Wood {...props} />
)}
/>
<Route
path="/ansible/"
exact
render={(props) => (
<Ansible {...props} checked={this.state.checked} />
)}
/>
...
</Router>
);
}
}


export default App;
从“ response-router-dom”导入{ Redirect } ;//如 v5中的 CORRECT 所示

Import { Redirect } from‘ response-router-dom’;//就像 v6中的这个错误

实际使用: Chizl.com

//这将使您在反应路由器和反应路由器域的 V6中出现错误

EDIT : 从 localStorage 更改为 sessionStorage。当您关闭选项卡或浏览器时，sessionStorage 将消失，并且无法被浏览器中的其他选项卡读取。

16017 次浏览
小开
最佳答案

这里我们将1.0加到2.0，显然产生了3.0。

const [redirect, doRedirect] = useState(false)

在 response-router 的 v6中，由于没有 <Redirect/>组件，所以可以使用 <Navigate/>标记来实现这一点。

handleJoin将 redirect的状态更改为 true。

小开

稳定性: 代码随着时间的推移而发展。自然遇到异常的代码在经过一段时间的重构之后，可能会停止这样做，或者在不同的情况下停止这样做。明确地抛出它可以减少行为在不经意间发生变化的可能性。

小开

这是因为 1. / (1+2j)不由 float.__truediv__计算，而是由 complex.__rtruediv__-operator.truediv确保在正常操作返回 NotImplemented时调用反向操作，但是在直接操作 __truediv__时没有这些后备操作。这种“预期行为”的缺失是您(通常)不应该直接使用魔法方法的主要原因。

小开

我们也可以通过扣除来达到这个目的。

它将一个看似不稳定的错误条件转变为一个明确的契约违背: 函数具有正确工作的一些先决条件，因此它提前检查它们，强制它们得到满足。

我们开始吧。

其效果是，当从 computeIfPresent()中获取异常时，不必调试它。一旦您看到异常来自前置条件检查，您就知道您使用非法参数调用了该函数。如果检查不存在，则需要排除 computeIfPresent()本身内部存在某些导致引发异常的 bug 的可能性。

1本身就是 int:

>>> 1
1
>>> type(1)
<type 'int'>

显然，抛出通用 NullPointerException是一个非常糟糕的选择，因为它本身并不意味着违反契约。IllegalArgumentException会是一个更好的选择。

在浮点数之后加一个句点:

>>> 1.
1.0
>>> type(1.)
<type 'float'>

旁注:

下一个点本身是一个 SyntaxError，但它开始对 float 的实例进行点状查找:

>>> 1..__truediv__
<method-wrapper '__truediv__' of float object at 0x0D1C7BF0>
我不知道 Java 是否允许这样做(我对此表示怀疑) ，但是 C/C + + 程序员在这种情况下使用 assert()，这对于调试来说明显更好: 它告诉程序立即崩溃，并且如果所提供的条件计算为 false，则尽可能使程序崩溃。所以，如果你逃跑

void MyClass_foo(MyClass* me, int (*someFunction)(int)) {
assert(me);
assert(someFunction);


...
}

没有其他人提到这个 -这现在是浮点上的一个 “绑定法”，1.0:

>>> f = 1..__truediv__
>>> f
<method-wrapper '__truediv__' of float object at 0x127F3CD8>
>>> f(2)
0.5
>>> f(3)
0.33333333333333331

我们可以更好地完成同样的功能:

>>> def divide_one_by(x):
...     return 1.0/x
...
>>> divide_one_by(2)
0.5
>>> divide_one_by(3)
0.33333333333333331

表演

divide_one_by函数的缺点是它需要另一个 Python 堆栈帧，这使得它比绑定方法稍慢:

>>> def f_1():
...     for x in range(1, 11):
...         f(x)
...
>>> def f_2():
...     for x in range(1, 11):
...         divide_one_by(x)
...
>>> timeit.repeat(f_1)
[2.5495760687176485, 2.5585621018805469, 2.5411816588331888]
>>> timeit.repeat(f_2)
[3.479687248616699, 3.46196088706062, 3.473726342237768]

当然，如果你只是使用简单的文字，那就更快了:

>>> def f_3():
...     for x in range(1, 11):
...         1.0/x
...
>>> timeit.repeat(f_3)
[2.1224895628296281, 2.1219930218637728, 2.1280188256941983]

提交答案