我正在用PHP做一个在线测试应用程序。我想限制用户在考试中返回。
我尝试了下面的脚本，但它停止了我的计时器。
我该怎么办?
定时器存储在cdtimer.js文件中。
<script type="text/javascript">
window.history.forward();
function noBack()
{
window.history.forward();
}
</script>
<body onLoad="noBack();" onpageshow="if (event.persisted) noBack();" onUnload="">
我有一个考试计时器，它从一个MySQL值中获取考试的持续时间。计时器随之启动，但当我输入禁用后退按钮的代码时，它就停止了。我有什么问题?
有很多原因可以解释为什么禁用后退按钮实际上不起作用。最好的办法是警告用户:
window.onbeforeunload = function() { return "Your work will be lost."; };
本页确实列出了一些禁用后退按钮的方法，但都不保证:
http://www.irt.org/script/311.htm
重写web浏览器的默认行为通常不是一个好主意。出于安全原因，客户端脚本没有足够的特权来执行此操作。
还有一些类似的问题，
如何防止退格键导航回? 我如何可以防止浏览器的默认历史后退动作退格按钮与JavaScript?
你不能禁用浏览器的后退按钮。然而，你可以使用你的逻辑来阻止用户返回，这将创造一个像它被禁用的印象。这是如何-检查以下片段。
(function (global) {
if(typeof (global) === "undefined") {
throw new Error("window is undefined");
}
var _hash = "!";
var noBackPlease = function () {
global.location.href += "#";
// Making sure we have the fruit available for juice (^__^)
global.setTimeout(function () {
global.location.href += "!";
}, 50);
};
global.onhashchange = function () {
if (global.location.hash !== _hash) {
global.location.hash = _hash;
}
};
global.onload = function () {
noBackPlease();
// Disables backspace on page except on input fields and textarea..
document.body.onkeydown = function (e) {
var elm = e.target.nodeName.toLowerCase();
if (e.which === 8 && (elm !== 'input' && elm !== 'textarea')) {
e.preventDefault();
}
// Stopping the event bubbling up the DOM tree...
e.stopPropagation();
};
}
})(window);
这是纯JavaScript，所以它可以在大多数浏览器中工作。它也会禁用退格键，但该键将在输入字段和文本区域内正常工作。
建议设置:
将此片段放在单独的脚本中，并将其包含在需要此行为的页面上。在当前设置中，它将执行DOM的onload事件，这是这段代码的理想入口点。
工作演示!
它在以下浏览器中进行了测试和验证，
铬。 Firefox。 ie浏览器(8-11)和Edge。 Safari。
我觉得jordanhollinger.com上的这篇文章是最好的选择。与Razor的答案相似，但更清楚一些。下面的代码;全部归功于Jordan Hollinger:
页面:
<a href="/page-of-no-return.htm#no-back>You can't go back from the next page</a>
no return的JavaScript页面:
// It works without the History API, but will clutter up the history
var history_api = typeof history.pushState !== 'undefined'
// The previous page asks that it not be returned to
if ( location.hash == '#no-back' ) {
// Push "#no-back" onto the history, making it the most recent "page"
if ( history_api ) history.pushState(null, '', '#stay')
else location.hash = '#stay'
// When the back button is pressed, it will harmlessly change the url
// hash from "#stay" to "#no-back", which triggers this function
window.onhashchange = function() {
// User tried to go back; warn user, rinse and repeat
if ( location.hash == '#no-back' ) {
alert("You shall not pass!")
if ( history_api ) history.pushState(null, '', '#stay')
else location.hash = '#stay'
}
}
}
<html>
<head>
<title>Disable Back Button in Browser - Online Demo</title>
<style type="text/css">
body, input {
font-family: Calibri, Arial;
}
</style>
<script type="text/javascript">
window.history.forward();
function noBack() {
window.history.forward();
}
</script>
</head>
<body onload="noBack();" onpageshow="if (event.persisted) noBack();" onunload="">
<H2>Demo</H2>
<p>This page contains the code to avoid Back button.</p>
<p>Click here to Goto <a href="noback.html">NoBack Page</a></p>
</body>
</html>
<script>
window.location.hash = "no-back-button";
// Again because Google Chrome doesn't insert
// the first hash into the history
window.location.hash = "Again-No-back-button";
window.onhashchange = function(){
window.location.hash = "no-back-button";
}
</script>
这就是我实现它的方法。
奇怪的是，换窗口。在谷歌Chrome和Safari浏览器中，location无法正常工作。
它发生在那个位置。hash不会在Chrome和Safari的历史记录中创建条目。所以你必须使用推力器。
这在所有浏览器中都适用。
history.pushState({ page: 1 }, "title 1", "#nbb");
window.onhashchange = function (event) {
window.location.hash = "nbb";
};
This code will disable the back button for modern browsers which support the HTML5 History API. Under normal circumstances, pushing the back button goes back one step, to the previous page. If you use history.pushState(), you start adding extra sub-steps to the current page. The way it works is, if you were to use history.pushState() three times, then start pushing the back button, the first three times it would navigate back in these sub-steps, and then the fourth time it would go back to the previous page.
如果您将此行为与popstate事件上的事件侦听器结合在一起，您实际上可以建立一个无限循环的子状态。因此，您加载页面，按下一个子状态，然后点击返回按钮，弹出一个子状态，并按下另一个子状态，因此，如果您再次按下返回按钮，它将永远不会没有子状态可按。如果你觉得有必要禁用后退按钮，这将使你达到目的。
history.pushState(null, null, 'no-back-button');
window.addEventListener('popstate', function(event) {
history.pushState(null, null, 'no-back-button');
});
<script src="~/main.js" type="text/javascript"></script>
<script type="text/javascript">
window.history.forward();
function noBack() {
window.history.forward();
}
</script>
你不能也不应该这么做。然而，这可能会有所帮助:
<script type = "text/javascript" >
history.pushState(null, null, 'pagename');
window.addEventListener('popstate', function(event) {
history.pushState(null, null, 'pagename');
});
</script>
这在我的谷歌Chrome和Firefox中工作。
我创建一个HTML页面(index.html)。我还在脚本文件夹/目录中创建了一个one (mechanism.js)。然后，根据需要使用form、table、span和div标记将所有内容放在(index.html)中。现在，这里有一个技巧，可以让后退/前进什么都不做!
首先，你只有一页!其次，使用JavaScript与span / div标签隐藏和显示内容在同一页面上，当需要通过常规链接!
在“index . html”:
<td width="89px" align="right" valign="top" style="letter-spacing:1px;">
<small>
<b>
<a href="#" class="traff" onClick="DisplayInTrafficTable();">IN</a>
</b>
</small>
[ <span id="inCountSPN">0</span> ]
</td>
在“mechanism.js”:
function DisplayInTrafficTable()
{
var itmsCNT = 0;
var dsplyIn = "";
for (i=0; i<inTraffic.length; i++)
{
dsplyIn += "<tr><td width='11'></td><td align='right'>" + (++itmsCNT) + "</td><td width='11'></td><td><b>" + inTraffic[i] + "</b></td><td width='11'></td><td>" + entryTimeArray[i] + "</td><td width='11'></td><td>" + entryDateArray[i] + "</td><td width='11'></td></tr>";
}
document.getElementById('inOutSPN').innerHTML =
"" +
"<table border='0' style='background:#fff;'><tr><th colspan='21' style='background:#feb;padding:11px;'><h3 style='margin-bottom:-1px;'>INCOMING TRAFFIC REPORT</h3>" +
DateStamp() +
" - <small><a href='#' style='letter-spacing:1px;' onclick='OpenPrintableIn();'>PRINT</a></small></th></tr><tr style='background:#eee;'><td></td><td><b>###</b></td><td></td><td><b>ID #</b></td><td></td><td width='79'><b>TYPE</b></td><td></td><td><b>FIRST</b></td><td></td><td><b>LAST</b></td><td></td><td><b>PLATE #</b></td><td></td><td><b>COMPANY</b></td><td></td><td><b>TIME</b></td><td></td><td><b>DATE</b></td><td></td><td><b>IN / OUT</b></td><td></td></tr>" +
dsplyIn.toUpperCase() +
"</table>" +
"";
return document.getElementById('inOutSPN').innerHTML;
}
它看起来很复杂，但请注意函数名和调用、嵌入的HTML和span标记id调用。这是为了展示如何将不同的HTML注入到同一页面上的同一个span标签!向后/向前如何影响这个设计?它不能，因为您正在隐藏对象并在同一页面上替换其他对象!
我们如何隐藏和展示?是:
在' mechanism.js '中的函数中，根据需要使用:
document.getElementById('textOverPic').style.display = "none"; //hide
document.getElementById('textOverPic').style.display = ""; //display
在' index.html '内部通过链接调用函数:
<img src="images/someimage.jpg" alt="" />
<span class="textOverPic" id="textOverPic"></span>
and
<a href="#" style="color:#119;font-size:11px;text-decoration:none;letter-spacing:1px;" onclick="HiddenTextsManager(1);">Introduction</a>
对我来说，这是一个购物订单。所以我禁用了按钮。当用户单击返回时，该按钮仍然被禁用。当他们再次点击返回，然后点击页面按钮继续前进时。我知道他们的订单已经提交，然后跳转到另一页。
在页面实际刷新的情况下，将使按钮(理论上)可用;然后，我能够在页面加载反应，订单已经提交，然后也重定向。
尝试以下方法来防止ie浏览器中的退格键默认为“后退”:
<script language="JavaScript">
$(document).ready(function() {
$(document).unbind('keydown').bind('keydown', function (event) {
var doPrevent = false;
if (event.keyCode === 8 ) {
var d = event.srcElement || event.target;
if ((d.tagName.toUpperCase() === 'INPUT' &&
(
d.type.toUpperCase() === 'TEXT' ||
d.type.toUpperCase() === 'PASSWORD' ||
d.type.toUpperCase() === 'FILE' ||
d.type.toUpperCase() === 'EMAIL' ||
d.type.toUpperCase() === 'SEARCH' ||
d.type.toUpperCase() === 'DATE' )
) ||
d.tagName.toUpperCase() === 'TEXTAREA') {
doPrevent = d.readOnly || d.disabled;
}
else {
doPrevent = true;
}
}
if (doPrevent) {
event.preventDefault();
}
try {
document.addEventListener('keydown', function (e) {
if ((e.keyCode === 13)) {
//alert('Enter keydown');
e.stopPropagation();
e.preventDefault();
}
}, true);
}
catch (err) {
}
});
});
</script>
这似乎在禁用浏览器上的后退按钮，以及退格键带你回到工作。
history.pushState(null, null, $(location).attr('href'));
window.addEventListener('popstate', function () {
history.pushState(null, null, $(location).attr('href'));
});
我遇到了这个问题，需要一个在各种浏览器上正确工作的解决方案，包括Mobile Safari(在发布时是iOS 9)。没有一个解决方案是完全正确的。我提供以下建议(在Internet Explorer 11、Firefox、Chrome和Safari上进行了测试):
history.pushState(null, document.title, location.href);
window.addEventListener('popstate', function (event)
{
history.pushState(null, document.title, location.href);
});
注意事项:
history.forward() (my old solution) does not work on Mobile Safari --- it seems to do nothing (i.e., the user can still go back). history.pushState() does work on all of them. the third argument to history.pushState() is a url. Solutions which pass a string like 'no-back-button' or 'pagename' seem to work OK, until you then try a Refresh/Reload on the page, at which point a "Page not found" error is generated when the browser tries to locate a page with that as its URL. (The browser is also likely to include that string in the address bar when on the page, which is ugly.) location.href should be used for the URL. the second argument to history.pushState() is a title. Looking around the web most places say it is "not used", and all the solutions here pass null for that. However, in Mobile Safari at least, that puts the page's URL into the history dropdown the user can access. But when it adds an entry for a page visit normally, it puts in its title, which is preferable. So passing document.title for that results in the same behaviour.
它基本上是分配窗口的“onbeforeunload”事件以及正在进行的文档“mouseenter”/“mouseleave”事件，因此警报只在单击超出文档范围时触发(然后可以是浏览器的后退或前进按钮)
美元(文档)。On ('mouseenter'，函数(e) { 窗口。Onbeforeunload = null; ｝ ); 美元(文档)。On ('mouseleave'，函数(e) { 窗口。onbeforeunload = function(){返回"你的工作将会丢失";}; ｝ );
如何阻止反向功能:
历史。pushState(null, null, location.href); 窗口。Onpopstate = function () { history.go (1); };
轻松尝试一下:
history.pushState(null, null, document.title);
window.addEventListener('popstate', function () {
history.pushState(null, null, document.title);
});
非常简单和干净的函数打破向后箭头，而不干扰页面之后。
好处:
Loads instantaneously and restores original hash, so the user isn't distracted by URL visibly changing. The user can still exit by pressing back 10 times (that's a good thing), but not accidentally No user interference like other solutions using onbeforeunload It only runs once and doesn't interfere with further hash manipulations in case you use that to track state Restores original hash, so almost invisible. Uses setInterval, so it doesn't break slow browsers and always works. Pure JavaScript, does not require HTML5 history, works everywhere. Unobtrusive, simple, and plays well with other code. Does not use unbeforeunload which interrupts user with modal dialog. It just works without fuss.
注意:其他一些解决方案使用onbeforeunload。请不要为此目的使用onbeforeunload，当用户试图关闭窗口、点击反向箭头等时，onbeforeunload会弹出一个对话框。像onbeforeunload这样的情态动词通常只适用于很少的情况，比如当它们实际上在屏幕上做了更改并且没有保存它们时，不是为了这个目的。
工作原理
在页面加载时执行 保存您的原始散列(如果URL中有一个)。 依次追加#/noop/{1..10}到哈希 恢复原始哈希
就是这样。没有更多的混乱，没有后台事件监控，没有其他。
在一秒钟内使用它
要部署，只需在页面或JavaScript代码中添加这个:
<script>
/* Break back button */
window.onload = function(){
var i = 0;
var previous_hash = window.location.hash;
var x = setInterval(function(){
i++;
window.location.hash = "/noop/" + i;
if (i==10){
clearInterval(x);
window.location.hash = previous_hash;
}
}, 10);
}
</script>
//"use strict";
function stopBackSpace(e) {
var ev = e || window.event;
var obj = ev.target || ev.srcElement;
var t = obj.type || obj.getAttribute('type');
var vReadOnly = obj.getAttribute('readonly');
var vEnabled = obj.getAttribute('enabled');
// null
vReadOnly = (vReadOnly == null) ? false : vReadOnly;
vEnabled = (vEnabled == null) ? true : vEnabled;
// when click Backspace,judge the type of obj.
var flag1 = ((t == 'password' || t == 'text' || t == 'textarea') && ((vReadOnly == true || vReadOnly == 'readonly') || vEnabled != true)) ? true : false;
var flag2 = (t != 'password' && t != 'text' && t != 'textarea') ? true : false;
if (flag2) {
e.keyCode = 0;
e.cancelBubble = true;
return false;
}
if (flag1) {
e.keyCode = 0;
e.cancelBubble = true;
return false;
}
}
if (typeof($) == 'function') {
$(function() {
$(document).keydown(function(e) {
if (e.keyCode == 8) {
return stopBackSpace(e);
}
});
});
} else {
document.onkeydown = stopBackSpace;
}
history.pushState(null, null, document.URL);
window.addEventListener('popstate', function () {
history.pushState(null, null, document.URL);
});
此JavaScript代码不允许任何用户返回(适用于Chrome, Firefox, Internet Explorer和Edge)。
在现代浏览器中，这似乎是可行的:
// https://developer.mozilla.org/en-US/docs/Web/API/History_API
let popHandler = () => {
if (confirm('Go back?')) {
window.history.back()
} else {
window.history.forward()
setTimeout(() => {
window.addEventListener('popstate', popHandler, {once: true})
}, 50) // delay needed since the above is an async operation for some reason
}
}
window.addEventListener('popstate', popHandler, {once: true})
window.history.pushState(null,null,null)
限制浏览器返回事件:
window.history.pushState(null, "", window.location.href);
window.onpopstate = function () {
window.history.pushState(null, "", window.location.href);
};
你可以放一个小脚本，然后检查。它将不允许您访问前一页。
这是用JavaScript完成的。
<script type="text/javascript">
function preventbackbutton() { window.history.forward(); }
setTimeout("preventbackbutton()", 0);
window.onunload = function () { null };
</script>
窗外。Onunload函数当您试图通过浏览器访问返回或上一页时触发。
这段代码在最新的Chrome和Firefox浏览器上进行了测试。
<script type="text/javascript">
history.pushState(null, null, location.href);
history.back();
history.forward();
window.onpopstate = function () { history.go(1); };
</script>
在Chrome 79中，被点赞最多的答案没有一个对我有效。看起来Chrome在75版之后改变了后退按钮的行为。在这里看到的:
https://support.google.com/chrome/thread/8721521?hl=en
然而，在谷歌的帖子中，Azrulmukmin Azmi在最后提供的答案确实起作用了。这是他的解。
<script>
history.pushState(null, document.title, location.href);
history.back();
history.forward();
window.onpopstate = function () {
history.go(1);
};
</script>
Chrome的问题是它不会触发onpopstate事件 除非你做出浏览器动作(即调用history.back)。这就是为什么 我已经将这些添加到脚本中。
我不完全明白他写了什么，但显然现在需要一个额外的history.back() / history.forward()来阻止Chrome 75+中的返回。
我有这个问题与React(类组件)。
我很容易就解决了:
componentDidMount() {
window.addEventListener("popstate", e => {
this.props.history.goForward();
}
}
我已经从react-router-dom中使用了HashRouter。
只需设置location.hash="Something"。在按下返回按钮时，散列将从URL中删除，但页面不会返回。
此方法用于防止意外返回，但出于安全性考虑，您应该设计用于防止应答的后端。
这是另一种方法。我们可以添加简短的SessionStorage条件，而不是仅仅尝试避免Back按钮功能(它不可靠地工作)。
假设我们有三个不同的页面(page1、page2和page3)。在每个页面上，我们都有一个链接，点击进入下一个页面，我们不希望用户能够回到上一页。
在第一个页面(page1.html)，我们创建了一个SI (sessionStorage Item)与一个虚拟的“prev”代码和另一个与“page1”代码(SI“now”):
PAGE 1 <button onclick="goto()">PAGE 2</button>
-------------------
let thispage = '1' // Or 123456 if preferred or make sense
// You can replace this fixed 'thispage' value on each page with a script counting the clicks
// or any other way to increase its value, i.e., thispage++
// or what you want, even counting the url.length (lol)
sessionStorage.setItem('prev', '0') // Dummy code
sessionStorage.setItem('now', thispage)
// You can here make this page unreachable with page2/page3 SI same conditions
function goto(){
window.location = "page2.html"
}
在page2.html上，我们使用通常的NoBack脚本(如果它有效的话)，只在来自page1时更新si:
PAGE 2 <button onclick="goto()">PAGE 3</button>
-------------------
// If it works, let it work :-)
history.pushState(null, null, location.href);
history.back();
history.forward();
window.onpopstate = function () {
history.go(1);
};
// else
let thispage = '2' // 456789
let thisprev = sessionStorage.getItem('now')
if(sessionStorage.getItem('prev')==thispage) {
console.log('USER is back on PAGE 2')
setTimeout(function() { goto() }, 1000); // Remove log + setTimeout
}
if(thisprev !== thispage) {
if(thisprev < thispage) {
console.log('USER is coming from PAGE 1')
sessionStorage.setItem('prev', thisprev)
sessionStorage.setItem('now', thispage)
}
else {
console.log('USER try to reload this page')
setTimeout(function() { goto() }, 1000);
}
}
function goto(){
window.location = "page3.html"
}
在page3.html上:
PAGE 3 <button onclick="goto()">BACK TO PAGE 1</button>
-------------------
history.pushState(null, null, location.href);
history.back();
history.forward();
window.onpopstate = function () {
history.go(1);
};
let thispage = '3' // 999999
let thisprev = sessionStorage.getItem('now')
if(sessionStorage.getItem('prev') == thispage) {
goto()
}
if(thisprev !== thispage) {
if(thisprev < thispage) {
sessionStorage.setItem('prev', thisprev)
sessionStorage.setItem('now', thispage)
}
else {
goto()
}
}
function goto(){
window.location = "page1.html" // Reinit test
}
这样做的好处是，即使用户手动重新加载前一个页面(如果他有时间查看并记住URL)，它仍然可以工作。它没有在所有设备上进行测试，但似乎在Firefox + Chrome + Edge Windows 10和Firefox + Chrome在OS X上运行良好。
这里的一些解决方案不会阻止回退事件的发生——它们让回退事件发生(浏览器内存中关于页面的数据丢失)，然后它们播放一个向前事件，试图隐藏回退事件刚刚发生的事实。如果页面处于暂时状态，则该方法将不成功。
我为React写了这个解决方案(当React路由器不被使用时)，它是基于vrfvr的答案。
它将真正阻止后退按钮做任何事情，除非用户确认弹出:
const onHashChange = useCallback(() => {
const confirm = window.confirm(
'Warning - going back will cause you to loose unsaved data. Really go back?',
);
window.removeEventListener('hashchange', onHashChange);
if (confirm) {
setTimeout(() => {
window.history.go(-1);
}, 1);
} else {
window.location.hash = 'no-back';
setTimeout(() => {
window.addEventListener('hashchange', onHashChange);
}, 1);
}
}, []);
useEffect(() => {
window.location.hash = 'no-back';
setTimeout(() => {
window.addEventListener('hashchange', onHashChange);
}, 1);
return () => {
window.removeEventListener('hashchange', onHashChange);
};
}, []);
反应
对于React项目中的模态组件，打开或关闭模态，控制浏览器返回是一个必要的动作。
The stopBrowserBack: the stop of the browser back button functionality, also get a callback function. This callback function is what you want to do: const stopBrowserBack = callback => { window.history.pushState(null, "", window.location.href); window.onpopstate = () => { window.history.pushState(null, "", window.location.href); callback(); }; }; The startBrowserBack: the revival of the browser back button functionality: const startBrowserBack = () => { window.onpopstate = undefined; window.history.back(); };
在项目中的使用:
handleOpenModal = () =>
this.setState(
{ modalOpen: true },
() => stopBrowserBack(this.handleCloseModal)
);
handleCloseModal = () =>
this.setState(
{ modalOpen: false },
startBrowserBack
);
只需立即运行代码片段并尝试返回 历史。pushState(null, null, window.location.href); history.back (); 窗口。Onpopstate = () => history.forward();
这段代码是完整的javascript。 把这个放在你的主页或者其他你需要的地方当有人返回时，它会把他们带到他们之前所在的页面。
<script type="text/javascript">
function preventBack() {
window.history.forward();
}
setTimeout("preventBack()", 0);
window.onunload = function () { null };
</script>
这是我为谷歌查询“禁用后退按钮”获得的第一个命中。我的用例与最初发布的问题略有不同。我需要“禁用后退按钮”的用户已登录的一个安全的网站(即防止一个用户从注销，然后另一个用户能够从以前的用户通过点击后退按钮查看信息)。
简而言之，这里的目标是防止用户在登录的用户注销后看到应用程序页面。
这可以通过向经过身份验证的应用程序的页面中添加如下所示的代码来实现。
下面是使用Apache Shiro的完整示例:
https://github.com/NACHC-CAD/web-security-example/releases/tag/v2.0.0
<meta http-equiv="Pragma" content="no-cache" />
<meta http-equiv="Expires" content="-1" />
<meta http-equiv="CACHE-CONTROL" content="NO-CACHE" />
<script>
if(performance.navigation.type == 2){
console.log("Doing reload");
location.reload(true);
console.log("Done with reload");
}
console.log("Script loaded.")
</script>
试试这个: 假设有两个页面Page1和Page2, Page1重定向到Page2
为了防止用户使用返回按钮访问Page1，您需要将上面的脚本放在Page1中
$(document).ready(async function (){
history.pushState(null, null, location.href);
window.onpopstate = function () {
history.go(1);
};
})
基于@Franklin Innocent F的回答
Kotlin/JS (React)的解决方案:
import org.w3c.dom.events.Event
import kotlin.browser.document
import kotlin.browser.window
...
override fun componentDidMount() {
window.history.pushState(null, "", window.location.href)
window.history.back()
window.history.forward()
window.addEventListener("popstate", browserBackButtonHandler)
}
...
private val browserBackButtonHandler: (Event?) -> Unit = {
window.history.go(1)
}
如果你使用的是angular，只需在div或容器div中使用*ngIf=loggedout即可。
在组件中设置变量。如果为真，显示其他路由器将重定向到主页。根据你在路由器文件上的配置。
这工作的登录和注销使用用户名为例。至于其他账户相关页面或内部页面，这将是有点难以防止。您可能需要禁用整个浏览器的nav选项卡。
经历了大多数现有的答案，没有解决方案，工作在chrome。
这个想法是让浏览器在会话历史中向前移动一页，有效地防止使用后退浏览器按钮离开该页。通过调用History.forward()方法，在页面中放置下面的行，可以做到这一点。
window.history.forward();
我在mdn web docs找到了这个解决方案，它在chrome中工作。
如果你使用React，你可以使用NPM模块:use-history-back-trap。这是一个自定义的React钩子，它拦截向后导航，并允许在需要时恢复它。
用法超级简单:
const SomeFunctionalReactComponent = () => {
useHistoryBackTrap(approveNavigation)
// ...
}
其中approveNavigation是你的函数，当你想继续向后导航时，它返回true(或Promise)。
