Как я могу предотвратить обратную навигацию ключа backspace?
на IE я могу сделать это с помощью (ужасно нестандартного, но рабочего) jQuery
if ($.browser.msie)
$(document).keydown(function(e) { if (e.keyCode == 8) window.event.keyCode = 0;});
но можно ли это сделать таким образом, который работает на Firefox, или кросс-браузерным способом для бонуса?
Для справки:
$(document).keydown(function(e) { if (e.keyCode == 8) e.stopPropagation(); });
ничего не делает.
$(document).keydown(function(e) { if (e.keyCode == 8) e.preventDefault(); });
решает проблему, но делает ключ backspace непригодным для использования на странице, что еще хуже, чем исходное поведение.
изменить: Причина я делаю это, что я не создание простой веб-страницы, но большое приложение. Это невероятно раздражает, чтобы потерять 10 минут работы только потому, что вы нажали backspace в неправильном месте. Соотношение предотвращения ошибок и раздражающих пользователей должно быть намного выше 1000/1, не позволяя клавише backspace перемещаться назад.
EDIT2: я не пытаясь предотвратить навигацию по истории, просто несчастные случаи.
EDIT3: @ brentonstrines комментарий (переехал сюда, так как вопрос настолько популярен): это это долгосрочное "исправление", но вы можете бросить свою поддержку за Chromium ошибка, чтобы изменить это поведение в webkit
30 ответов:
этот код решает проблему, по крайней мере в IE и Firefox (не проверял любые другие, но я даю ему шанс работать, если проблема существует и в других браузерах).
// Prevent the backspace key from navigating back. $(document).unbind('keydown').bind('keydown', function (event) { if (event.keyCode === 8) { var doPrevent = true; var types = ["text", "password", "file", "search", "email", "number", "date", "color", "datetime", "datetime-local", "month", "range", "search", "tel", "time", "url", "week"]; var d = $(event.srcElement || event.target); var disabled = d.prop("readonly") || d.prop("disabled"); if (!disabled) { if (d[0].isContentEditable) { doPrevent = false; } else if (d.is("input")) { var type = d.attr("type"); if (type) { type = type.toLowerCase(); } if (types.indexOf(type) > -1) { doPrevent = false; } } else if (d.is("textarea")) { doPrevent = false; } } if (doPrevent) { event.preventDefault(); return false; } } });
этот код работает во всех браузерах и проглатывает клавишу backspace, когда не на элементе формы, или если элемент формы отключен|только для чтения. Он также эффективен, что важно, когда он выполняется на каждом введенном ключе.
$(function(){ /* * this swallows backspace keys on any non-input element. * stops backspace -> back */ var rx = /INPUT|SELECT|TEXTAREA/i; $(document).bind("keydown keypress", function(e){ if( e.which == 8 ){ // 8 == backspace if(!rx.test(e.target.tagName) || e.target.disabled || e.target.readOnly ){ e.preventDefault(); } } }); });
другие ответы здесь установили, что это не может быть сделано без белых элементов, в которых забой разрешается. Это решение не идеально, потому что белый список не так прост, как просто текстовые области и ввод текста/пароля, но неоднократно оказывается неполным и нуждается в обновлении.
однако, поскольку целью подавления функции backspace является просто предотвращение случайной потери данных пользователями, решение beforeunload это хорошо, потому что модальное всплывающее окно удивительно-модальные всплывающие окна плохи, когда они запускаются как часть стандартного рабочего процесса, потому что пользователь привыкает отклонять их, не читая их, и они раздражают. В этом случае модальное всплывающее окно будет отображаться только как альтернатива редкому и удивительному действию и поэтому приемлемо.
проблема в том, что модальное значение onbeforeunload не должно появляться всякий раз, когда пользователь переходит от страницы (например, при нажатии кнопки a ссылка или отправка формы), и мы не хотим начинать белый список или черный список конкретных условий onbeforeunload.
идеальная комбинация компромиссов для обобщенного решения выглядит следующим образом: следите за тем, нажата ли backspace, и только всплывает модальный onbeforeunload, если это так. Другими словами:
function confirmBackspaceNavigations () { // http://stackoverflow.com/a/22949859/2407309 var backspaceIsPressed = false $(document).keydown(function(event){ if (event.which == 8) { backspaceIsPressed = true } }) $(document).keyup(function(event){ if (event.which == 8) { backspaceIsPressed = false } }) $(window).on('beforeunload', function(){ if (backspaceIsPressed) { backspaceIsPressed = false return "Are you sure you want to leave this page?" } }) } // confirmBackspaceNavigations
Это было протестировано для работы в IE7+, FireFox, Chrome, Safari и Opera. Просто поместите эту функцию в свой глобальный.js и вызвать его с любой страницы где вы не хотите, чтобы пользователи случайно потерять свои данные.
более элегантное / лаконичное решение:
$(document).on('keydown',function(e){ var $target = $(e.target||e.srcElement); if(e.keyCode == 8 && !$target.is('input,[contenteditable="true"],textarea')) { e.preventDefault(); } })
модификация ответа эриккаллена для решения различных типов ввода
я обнаружил, что предприимчивый пользователь может нажать backspace на флажок или переключатель в тщетной попытке очистить его, и вместо этого они будут перемещаться назад и потерять все свои данные.
Это изменение должно решить эту проблему.
новое редактирование для адресации редактируемого контента ДИВС
//Prevents backspace except in the case of textareas and text inputs to prevent user navigation. $(document).keydown(function (e) { var preventKeyPress; if (e.keyCode == 8) { var d = e.srcElement || e.target; switch (d.tagName.toUpperCase()) { case 'TEXTAREA': preventKeyPress = d.readOnly || d.disabled; break; case 'INPUT': preventKeyPress = d.readOnly || d.disabled || (d.attributes["type"] && $.inArray(d.attributes["type"].value.toLowerCase(), ["radio", "checkbox", "submit", "button"]) >= 0); break; case 'DIV': preventKeyPress = d.readOnly || d.disabled || !(d.attributes["contentEditable"] && d.attributes["contentEditable"].value == "true"); break; default: preventKeyPress = true; break; } } else preventKeyPress = false; if (preventKeyPress) e.preventDefault(); });
пример
Для теста сделайте 2 файла.starthere.htm-откройте это сначала, так что у вас есть место, чтобы вернуться к
<a href="./test.htm">Navigate to here to test</a>
судя по комментариям, вы хотите остановить людей, теряющих информацию в формах, если они нажимают backspace для удаления, но поле не сфокусировано.
в этом случае, вы хотите посмотреть на onunload обработчик событий. Stack Overflow использует его - если вы попытаетесь оставить страницу, когда вы начали писать ответ, он всплывает предупреждение.
остановить от навигации этот код работает!
$(document).on("keydown", function (event) { if (event.keyCode === 8) { event.preventDefault(); } });
но не для ограничения текстовых полей, а других
$(document).on("keydown", function (event) { if (event.which === 8 && !$(event.target).is("input, textarea")) { event.preventDefault(); } });
чтобы предотвратить его для конкретного поля просто используйте
$('#myOtherField').on("keydown", function (event) { if (event.keyCode === 8 || event.which === 8) { event.preventDefault(); } });
ссылаясь на это!
запретить BACKSPACE от навигации обратно с помощью jQuery (например, домашняя страница Google)
Не уверен, почему никто просто не ответил на это-кажется, совершенно разумный технический вопрос, чтобы спросить, возможно ли это.
Нет, я не думаю, что есть кросс-браузер способ отключить кнопку backspace. Я знаю, что это не включено по умолчанию в FF в эти дни, хотя.
объединение решений, заданных "thetoolman" & & "Biff MaGriff"
следующий код, кажется, работает правильно в IE 8 / Mozilla / Chrome
$(function () { var rx = /INPUT|TEXTAREA/i; var rxT = /RADIO|CHECKBOX|SUBMIT/i; $(document).bind("keydown keypress", function (e) { var preventKeyPress; if (e.keyCode == 8) { var d = e.srcElement || e.target; if (rx.test(e.target.tagName)) { var preventPressBasedOnType = false; if (d.attributes["type"]) { preventPressBasedOnType = rxT.test(d.attributes["type"].value); } preventKeyPress = d.readOnly || d.disabled || preventPressBasedOnType; } else {preventKeyPress = true;} } else { preventKeyPress = false; } if (preventKeyPress) e.preventDefault(); }); });
большинство ответов находятся в jquery. Вы можете сделать это совершенно в чистом JavaScript, простой и не требуется библиотека. этой статья была хорошей отправной точкой для меня, но так как идентификатор_ключа устарел, я хотел, чтобы этот код был более безопасным, поэтому я добавил / / e. keyCode= = 8 в случае, если заявление. Кроме того, код не работает в Firefox, поэтому я добавил return false; и теперь он прекрасно работает. Вот оно это:
<script type="text/javascript"> window.addEventListener('keydown',function(e){if(e.keyIdentifier=='U+0008'||e.keyIdentifier=='Backspace'||e.keyCode==8){if(e.target==document.body){e.preventDefault();return false;}}},true); </script>
этот код отлично работает, потому что,
- это в чистом JavaScript (не требуется библиотека).
- он не только проверяет нажатую клавишу, но и подтверждает, что действие действительно является действием браузера "назад".
- вместе с вышеизложенным пользователь может вводить и удалять текст из текстовых полей ввода на веб-странице без каких-либо проблем, по-прежнему предотвращая Действие кнопки "Назад".
- он короткий, чистый, быстрый и прямой к точка.
вы можете добавить консоль.журнал (e); для ваших целей тестирования и нажмите F12 в chrome, перейдите на вкладку "консоль" и нажмите "backspace" на странице и посмотрите внутри нее, чтобы увидеть, какие значения возвращаются, затем вы можете настроить все эти параметры для дальнейшего улучшения кода выше в соответствии с вашими потребностями.
Это решение похоже на другие, которые были опубликованы, но оно использует простой белый список, что делает его легко настраиваемым, чтобы разрешить обратное пространство в указанных элементах, просто установив селектор в функции .is ().
Я использую его в этой форме, чтобы предотвратить обратное пространство на страницах от навигации назад:
$(document).on("keydown", function (e) { if (e.which === 8 && !$(e.target).is("input:not([readonly]), textarea")) { e.preventDefault(); } });
чтобы немного уточнить @erikkallen's отличный ответ, вот функция, которая позволяет все типы ввода на основе клавиатуры, в том числе те, которые введены в HTML5:
$(document).unbind('keydown').bind('keydown', function (event) { var doPrevent = false; var INPUTTYPES = [ "text", "password", "file", "date", "datetime", "datetime-local", "month", "week", "time", "email", "number", "range", "search", "tel", "url"]; var TEXTRE = new RegExp("^" + INPUTTYPES.join("|") + "$", "i"); if (event.keyCode === 8) { var d = event.srcElement || event.target; if ((d.tagName.toUpperCase() === 'INPUT' && d.type.match(TEXTRE)) || d.tagName.toUpperCase() === 'TEXTAREA') { doPrevent = d.readOnly || d.disabled; } else { doPrevent = true; } } if (doPrevent) { event.preventDefault(); } });
JavaScript-jQuery путь:
$(document).on("keydown", function (e) { if (e.which === 8 && !$(e.target).is("input, textarea")) { e.preventDefault(); } });
Javascript-родной способ, который работает для меня:
<script type="text/javascript"> //on backspace down + optional callback function onBackspace(e, callback){ var key; if(typeof e.keyIdentifier !== "undefined"){ key = e.keyIdentifier; }else if(typeof e.keyCode !== "undefined"){ key = e.keyCode; } if (key === 'U+0008' || key === 'Backspace' || key === 8) { if(typeof callback === "function"){ callback(); } return true; } return false; } //event listener window.addEventListener('keydown', function (e) { switch(e.target.tagName.toLowerCase()){ case "input": case "textarea": break; case "body": onBackspace(e,function(){ e.preventDefault(); }); break; } }, true); </script>
мне было трудно найти не-JQUERY ответ. Спасибо Стасу, что вывел меня на трассу.
Chrome: Если вам не нужна поддержка кросс-браузера, вы можете просто использовать черный список, а не белый список. Эта чистая версия JS работает в Chrome, но не в IE. Не уверен насчет FF.
в Chrome (ver. 36, середина 2014), нажатия клавиш не на вход или contenteditable элемент, кажется, нацелены на
<BODY>
. Это позволяет использовать черный список, который я предпочитаю белый. IE использует цель последнего щелчка-так что это может быть div или что-то еще. Это делает это бесполезным в IE.window.onkeydown = function(event) { if (event.keyCode == 8) { //alert(event.target.tagName); //if you want to see how chrome handles keypresses not on an editable element if (event.target.tagName == 'BODY') { //alert("Prevented Navigation"); event.preventDefault(); } } }
Кросс-Браузер: для чистого javascript, я нашел ответ Стаса, чтобы быть лучшим. Добавление еще одной проверки условий для contenteditable заставило его работать для меня*:
document.onkeydown = function(e) {stopDefaultBackspaceBehaviour(e);} document.onkeypress = function(e) {stopDefaultBackspaceBehaviour(e);} function stopDefaultBackspaceBehaviour(event) { var event = event || window.event; if (event.keyCode == 8) { var elements = "HTML, BODY, TABLE, TBODY, TR, TD, DIV"; var d = event.srcElement || event.target; var regex = new RegExp(d.tagName.toUpperCase()); if (d.contentEditable != 'true') { //it's not REALLY true, checking the boolean value (!== true) always passes, so we can use != 'true' rather than !== true/ if (regex.test(elements)) { event.preventDefault ? event.preventDefault() : event.returnValue = false; } } } }
*обратите внимание, что IEs [edit: и Spartan / TechPreview] имеют "функцию", которая делает элементы, связанные с таблицей, не редактируются. Если вы нажмете один из них а затем нажмите backspace, он будет перемещаться назад. Если у вас нет редактируемого
<td>
s, это не проблема.
У меня были некоторые проблемы с принятым решением и Select2.JS plugin; я не смог удалить символы в редактируемом поле, поскольку действие удаления было предотвращено. Это было мое решение:
//Prevent backwards navigation when trying to delete disabled text. $(document).unbind('keydown').bind('keydown', function (event) { if (event.keyCode === 8) { var doPrevent = false, d = event.srcElement || event.target, tagName = d.tagName.toUpperCase(), type = (d.type ? d.type.toUpperCase() : ""), isEditable = d.contentEditable, isReadOnly = d.readOnly, isDisabled = d.disabled; if (( tagName === 'INPUT' && (type === 'TEXT' || type === 'PASSWORD')) || tagName === 'PASSWORD' || tagName === 'TEXTAREA') { doPrevent = isReadOnly || isDisabled; } else if(tagName === 'SPAN'){ doPrevent = !isEditable; } else { doPrevent = true; } } if (doPrevent) { event.preventDefault(); } });
Select2 создает диапазон с атрибутом "contentEditable", который имеет значение true для редактируемого поля со списком в нем. Я добавил код для учета spans tagName и другого атрибута. Это решило все мои проблемы.
изменить: если вы не используете плагин Select2 combobox для jquery, тогда это решение может вам не понадобиться, и принятое решение может быть лучше.
document.onkeydown = function (e) { e.stopPropagation(); if ((e.keyCode==8 || e.keyCode==13) && (e.target.tagName != "TEXTAREA") && (e.target.tagName != "INPUT")) { return false; } };
этот код решает проблему во всех браузерах:
onKeydown:function(e) { if (e.keyCode == 8) { var d = e.srcElement || e.target; if (!((d.tagName.toUpperCase() == 'BODY') || (d.tagName.toUpperCase() == 'HTML'))) { doPrevent = false; } else { doPrevent = true; } } else { doPrevent = false; } if (doPrevent) { e.preventDefault(); } }
самый простой способ предотвратить навигацию при нажатии backspace
$(document).keydown(function () { if (event.keyCode == 8) { if (event.target.nodeName == 'BODY') { event.preventDefault(); } } });
используя Dojo toolkit 1.7, это работает в IE 8:
require(["dojo/on", "dojo/keys", "dojo/domReady!"], function(on, keys) { on(document.body,"keydown",function(evt){if(evt.keyCode == keys.BACKSPACE)evt.preventDefault()}); });
вы пробовали очень простое решение, просто добавив следующий атрибут в текстовое поле только для чтения:
onkeydown= " return false;"
Это не позволит браузеру вернуться в историю, когда клавиша Backspace нажата в текстовом поле только для чтения. Возможно, мне не хватает вашего истинного намерения, но, похоже, это было бы самым простым решением вашей проблемы.
гораздо более аккуратное решение -
$(document).on('keydown', function (e) { var key = e == null ? event.keyCode : e.keyCode; if(key == 8 && $(document.activeElement.is(':not(:input)'))) //select, textarea e.preventDefault(); });
поочередно, вы можете только проверить, если
$(document.activeElement).is('body')
чистая версия javascript, которая работает во всех браузерах:
document.onkeydown = function(e) {stopDefaultBackspaceBehaviour(e);} document.onkeypress = function(e) {stopDefaultBackspaceBehaviour(e);} function stopDefaultBackspaceBehaviour(event) { var event = event || window.event; if (event.keyCode == 8) { var elements = "HTML, BODY, TABLE, TBODY, TR, TD, DIV"; var d = event.srcElement || event.target; var regex = new RegExp(d.tagName.toUpperCase()); if (regex.test(elements)) { event.preventDefault ? event.preventDefault() : event.returnValue = false; } } }
конечно, вы можете использовать "INPUT, TEXTAREA" и использовать "if (!регулярное выражение.тест(элементы))" тогда. Первый работал нормально для меня.
производительность?
Я беспокоился о производительности и сделал скрипку:http://jsfiddle.net/felvhage/k2rT6/9/embedded/result/
var stresstest = function(e, method, index){...
Я проанализировал наиболее перспективные методы, которые я нашел в этой теме. Оказывается, все они были очень быстрыми и скорее всего не вызывали проблем в плане "медлительности" при наборе текста. Самый медленный метод, на который я смотрел, был около 125 мс для 10 000 вызовов в IE8. Который составляет 0,0125 МС в Ход.
Я обнаружил, что методы, опубликованные Codenepal и Robin Maben, являются самыми быстрыми ~ 0.001 ms (IE8), но остерегайтесь различной семантики.
возможно, это облегчение для кого-то, кто вводит такую функциональность в свой код.
изменен erikkallen ответ:
$(document).unbind('keydown').bind('keydown', function (event) { var doPrevent = false, elem; if (event.keyCode === 8) { elem = event.srcElement || event.target; if( $(elem).is(':input') ) { doPrevent = elem.readOnly || elem.disabled; } else { doPrevent = true; } } if (doPrevent) { event.preventDefault(); return false; } });
Это решение работало очень хорошо при тестировании.
Я добавил некоторый код для обработки некоторых полей ввода, не помеченных вводом, и для интеграции в приложение Oracle PL/SQL, которое генерирует форму ввода для моей работы.
мои "два цента":
if (typeof window.event != ''undefined'') document.onkeydown = function() { //////////// IE ////////////// var src = event.srcElement; var tag = src.tagName.toUpperCase(); if (event.srcElement.tagName.toUpperCase() != "INPUT" && event.srcElement.tagName.toUpperCase() != "TEXTAREA" || src.readOnly || src.disabled ) return (event.keyCode != 8); if(src.type) { var type = ("" + src.type).toUpperCase(); return type != "CHECKBOX" && type != "RADIO" && type != "BUTTON"; } } else document.onkeypress = function(e) { //////////// FireFox var src = e.target; var tag = src.tagName.toUpperCase(); if ( src.nodeName.toUpperCase() != "INPUT" && tag != "TEXTAREA" || src.readOnly || src.disabled ) return (e.keyCode != 8); if(src.type) { var type = ("" + src.type).toUpperCase(); return type != "CHECKBOX" && type != "RADIO" && type != "BUTTON"; } }
Я создал проект NPM с чистой версией принятого в настоящее время (erikkallen)
https://github.com/slorber/backspace-disabler
Он использует в основном те же принципы, но:
- никаких зависимостей
- поддержка contenteditable
- более читабельным / ремонтопригодным кода
- будет поддержано по мере того как оно будет использовано в продукции моей компанией
- MIT лицензия
var Backspace = 8; // See http://stackoverflow.com/questions/12949590/how-to-detach-event-in-ie-6-7-8-9-using-javascript function addHandler(element, type, handler) { if (element.addEventListener) { element.addEventListener(type, handler, false); } else if (element.attachEvent) { element.attachEvent("on" + type, handler); } else { element["on" + type] = handler; } } function removeHandler(element, type, handler) { if (element.removeEventListener) { element.removeEventListener(type, handler, false); } else if (element.detachEvent) { element.detachEvent("on" + type, handler); } else { element["on" + type] = null; } } // Test wether or not the given node is an active contenteditable, // or is inside an active contenteditable function isInActiveContentEditable(node) { while (node) { if ( node.getAttribute && node.getAttribute("contenteditable") === "true" ) { return true; } node = node.parentNode; } return false; } var ValidInputTypes = ['TEXT','PASSWORD','FILE','EMAIL','SEARCH','DATE']; function isActiveFormItem(node) { var tagName = node.tagName.toUpperCase(); var isInput = ( tagName === "INPUT" && ValidInputTypes.indexOf(node.type.toUpperCase()) >= 0 ); var isTextarea = ( tagName === "TEXTAREA" ); if ( isInput || isTextarea ) { var isDisabled = node.readOnly || node.disabled; return !isDisabled; } else if ( isInActiveContentEditable(node) ) { return true; } else { return false; } } // See http://stackoverflow.com/questions/1495219/how-can-i-prevent-the-backspace-key-from-navigating-back function disabler(event) { if (event.keyCode === Backspace) { var node = event.srcElement || event.target; // We don't want to disable the ability to delete content in form inputs and contenteditables if ( isActiveFormItem(node) ) { // Do nothing } // But in any other cases we prevent the default behavior that triggers a browser backward navigation else { event.preventDefault(); } } } /** * By default the browser issues a back nav when the focus is not on a form input / textarea * But users often press back without focus, and they loose all their form data :( * * Use this if you want the backspace to never trigger a browser back */ exports.disable = function(el) { addHandler(el || document,"keydown",disabler); }; /** * Reenable the browser backs */ exports.enable = function(el) { removeHandler(el || document,"keydown",disabler); };
вот мой переписать топ-голосовали ответ. Я попытался проверить элемент.ценность!= = undefined (поскольку некоторые элементы, например, могут не иметь атрибута html, но могут иметь свойство javascript value где-то в цепочке прототипов), однако это не очень хорошо работало и имело много крайних случаев. Кажется, что нет хорошего способа доказать это в будущем, поэтому белый список кажется лучшим вариантом.
это регистрирует элемент в конце фазы пузырька событий, поэтому, если вы хотите обработать Backspace любым пользовательским способом, вы можете сделать это в других обработчиках.
Это также проверяет instanceof HTMLTextAreElement, так как теоретически можно иметь веб-компонент, который наследует от этого.
Это не проверяет contentEditable (в сочетании с другими ответами).
https://jsfiddle.net/af2cfjc5/15/
var _INPUTTYPE_WHITELIST = ['text', 'password', 'search', 'email', 'number', 'date']; function backspaceWouldBeOkay(elem) { // returns true if backspace is captured by the element var isFrozen = elem.readOnly || elem.disabled; if (isFrozen) // a frozen field has no default which would shadow the shitty one return false; else { var tagName = elem.tagName.toLowerCase(); if (elem instanceof HTMLTextAreaElement) // allow textareas return true; if (tagName=='input') { // allow only whitelisted input types var inputType = elem.type.toLowerCase(); if (_INPUTTYPE_WHITELIST.includes(inputType)) return true; } return false; // everything else is bad } } document.body.addEventListener('keydown', ev => { if (ev.keyCode==8 && !backspaceWouldBeOkay(ev.target)) { //console.log('preventing backspace navigation'); ev.preventDefault(); } }, true); // end of event bubble phase
Sitepoint: отключить назад для Javascript
event.stopPropagation()
иevent.preventDefault()
ничего не делать в IE. Я должен был отправить возвращениеevent.keyCode == 11
(Я просто выбрал что-то) вместо того, чтобы просто сказать"if not = 8, run the event"
чтобы заставить его работать,.event.returnValue = false
тоже работает.
другой метод с использованием jquery
<script type="text/javascript"> //set this variable according to the need within the page var BACKSPACE_NAV_DISABLED = true; function fnPreventBackspace(event){if (BACKSPACE_NAV_DISABLED && event.keyCode == 8) {return false;}} function fnPreventBackspacePropagation(event){if(BACKSPACE_NAV_DISABLED && event.keyCode == 8){event.stopPropagation();}return true;} $(document).ready(function(){ if(BACKSPACE_NAV_DISABLED){ //for IE use keydown, for Mozilla keypress //as described in scr: http://www.codeproject.com/KB/scripting/PreventDropdownBackSpace.aspx $(document).keypress(fnPreventBackspace); $(document).keydown(fnPreventBackspace); //Allow Backspace is the following controls var jCtrl = null; jCtrl = $('input[type="text"]'); jCtrl.keypress(fnPreventBackspacePropagation); jCtrl.keydown(fnPreventBackspacePropagation); jCtrl = $('input[type="password"]'); jCtrl.keypress(fnPreventBackspacePropagation); jCtrl.keydown(fnPreventBackspacePropagation); jCtrl = $('textarea'); jCtrl.keypress(fnPreventBackspacePropagation); jCtrl.keydown(fnPreventBackspacePropagation); //disable backspace for readonly and disabled jCtrl = $('input[type="text"][readonly="readonly"]') jCtrl.keypress(fnPreventBackspace); jCtrl.keydown(fnPreventBackspace); jCtrl = $('input[type="text"][disabled="disabled"]') jCtrl.keypress(fnPreventBackspace); jCtrl.keydown(fnPreventBackspace); } }); </script>
Я использую это в своем коде уже некоторое время. Я пишу онлайн-тесты для студентов и столкнулся с проблемой, когда студенты нажимали backspace во время своего теста, и это вернет их на экран входа в систему. Разочарование! Он работает на FF наверняка.
document.onkeypress = Backspace; function Backspace(event) { if (event.keyCode == 8) { if (document.activeElement.tagName == "INPUT") { return true; } else { return false; } } }