Как я могу помешать клавише backspace перемещаться назад?

этот код работает во всех браузерах и проглатывает клавишу 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. Это решение не идеально, потому что белый список не так прост, как просто textareas и ввод текста/пароля, но неоднократно оказывается неполным и нуждается в обновлении.

однако, поскольку целью подавления функции backspace является просто предотвращение случайной потери данных пользователями, решение beforeunload хорошо, потому что модальное всплывающее окно удивительно-модальные всплывающие окна плохи, когда они запускаются как часть стандартного рабочего процесса, потому что пользователь привыкает отклонять их, не читая их, и они раздражают. В этом случае модальное всплывающее окно будет отображаться только как альтернатива редкому и удивительному действию и поэтому приемлемо.

проблема в том, что модал onbeforeunload не должен появляться всякий раз, когда пользователь переходит от страницы (например, при нажатии ссылка или отправка формы), и мы не хотим начинать белый список или черный список конкретных условий 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. Просто поместите эту функцию в свой global.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 на флажке или переключателе в тщетной попытке очистить его, и вместо этого они будут перемещаться назад и терять все свои данные.

Это изменение должно решить эту проблему.

новый изменить адрес контент редактируемым divs

    //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, простой и не требуется библиотека. этой статья была хорошей отправной точкой для меня, но с keyIdentifier устарел, я хотел, чтобы этот код был более безопасным, поэтому я добавил ||Эл.данные keyCode==8 к оператору if. Кроме того, код не работает в Firefox, поэтому я добавил вернуть 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>

этот код отлично работает, потому что,

1. он находится в чистом javascript (не требуется библиотека).
2. он не только проверяет нажатую клавишу, он подтверждает, действительно ли действие браузера "назад".
3. вместе с вышеизложенным пользователь может вводить и удалять текст из текстовых полей ввода на веб-странице без каких-либо проблем, по-прежнему предотвращая Действие кнопки "Назад".
4. она коротка, чиста, быстра и прямо к точка.

вы можете добавить консоль.журнал (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, mid 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; я не смог удалить символы в редактируемом поле, поскольку действие удаления было предотвращено. Вот мое решение:--2-->

//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 для редактируемого поля со списком в нем. Я добавил код для учета tagName spans и другого атрибута. Это решило все мои проблемы.

Edit: если вы не используете плагин 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 любым пользовательским способом, вы можете сделать это в других обработчиках.

Это также проверяет экземпляр 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. Я должен был отправить return 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;
        }
    }
}