javascript atrás - ¿Cómo puedo evitar que la tecla de retroceso vuelva a navegar?




cuál chrome (25)

En IE puedo hacer esto con jQuery (terriblemente no estándar, pero en funcionamiento)

if ($.browser.msie)
    $(document).keydown(function(e) { if (e.keyCode == 8) window.event.keyCode = 0;});

¿Pero es posible hacerlo de una manera que funcione en Firefox, o en una forma de navegador cruzado para obtener un bono?

Para el registro:

$(document).keydown(function(e) { if (e.keyCode == 8) e.stopPropagation(); });

no hace nada.

$(document).keydown(function(e) { if (e.keyCode == 8) e.preventDefault(); });

resuelve el problema, pero deja inutilizable la tecla de retroceso en la página, que es aún peor que el comportamiento original.

EDITAR: La razón por la que hago esto es que no estoy creando una página web simple sino una aplicación grande. Es increíblemente molesto perder 10 minutos de trabajo solo porque presionaste la tecla de retroceso en el lugar equivocado. La proporción de prevención de errores frente a usuarios molestos debe estar muy por encima de 1000/1 al evitar que la tecla de retroceso retroceda.

EDIT2: No estoy tratando de evitar la navegación de la historia, solo accidentes.

EDIT3: comentario de @brentonstrines (movido aquí ya que la pregunta es muy popular): Este es un 'arreglo' a largo plazo, pero podrías lanzar tu apoyo detrás del error de Chromium para cambiar este comportamiento en el kit web.


Answers

Una solución mucho más limpia.

$(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();
});

Alternativamente, solo puedes comprobar si

$(document.activeElement).is('body')

Este código resuelve el problema en todos los navegadores:

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();
       }

  }

Tuve algunos problemas con la solución aceptada y el complemento Select2.js; No pude eliminar los caracteres en el cuadro editable porque se estaba impidiendo la acción de eliminar. Esta fue mi solución:

//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 crea un intervalo con un atributo de "contentEditable" que se establece en verdadero para el cuadro combinado editable en él. Agregué un código para tener en cuenta el tagName de los spans y el atributo diferente. Esto solucionó todos mis problemas.

Edición: Si no está utilizando el complemento combobox Select2 para jQuery, es posible que no necesite esta solución y que la solución aceptada sea mejor.


¿Actuación?

Estaba preocupado por el rendimiento e hice un violín: http://jsfiddle.net/felvhage/k2rT6/9/embedded/result/

var stresstest = function(e, method, index){...

He analizado los métodos más prometedores que he encontrado en este hilo. Resulta que todos fueron muy rápidos y lo más probable es que no causen un problema en términos de "lentitud" al escribir. El método más lento que observé fue de aproximadamente 125 ms para 10.000 llamadas en IE8. Lo que es 0.0125ms por carrera.

Descubrí que los métodos publicados por Codenepal y Robin Maben son los más rápidos ~ 0.001 ms (IE8) pero ten cuidado con las diferentes semánticas.

Quizás esto sea un alivio para alguien que introduce este tipo de funcionalidad en su código.


No estoy seguro de por qué nadie acaba de responder a esto; parece una pregunta técnica perfectamente razonable para preguntar si es posible.

No, no creo que haya una forma de navegador para desactivar el botón de retroceso. Sé que no está habilitado por defecto en FF en estos días sin embargo.


Modificación de la Respuesta de erikkallen para abordar diferentes tipos de entrada

Descubrí que un usuario emprendedor podría presionar la tecla de retroceso en una casilla de verificación o un botón de radio en un vano intento de borrarlo y en su lugar, navegarían hacia atrás y perderían toda su información.

Este cambio debe abordar ese problema.

Nueva edición para direccionar contenido editable 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();
    });

Ejemplo
Para probar hacer 2 archivos.

starthere.htm - abre esto primero para que tengas un lugar para volver a

<a href="./test.htm">Navigate to here to test</a>

test.htm: navegará hacia atrás cuando se presione la tecla de retroceso, mientras que la casilla de verificación o el envío tienen enfoque (logrado mediante tabulación). Reemplazar con mi código para arreglar.

<html>
<head>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.6.4/jquery.min.js" type="text/javascript"></script>
<script type="text/javascript">

    $(document).keydown(function(e) {
        var doPrevent;
        if (e.keyCode == 8) {
            var d = e.srcElement || e.target;
            if (d.tagName.toUpperCase() == 'INPUT' || d.tagName.toUpperCase() == 'TEXTAREA') {
                doPrevent = d.readOnly || d.disabled;
            }
            else
                doPrevent = true;
        }
        else
            doPrevent = false;

        if (doPrevent)
            e.preventDefault();
    });
</script>
</head>
<body>
<input type="text" />
<input type="radio" />
<input type="checkbox" />
<input type="submit" />
</body>
</html>

La mayoría de las respuestas están en jQuery. Puede hacerlo perfectamente en Javascript puro, simple y sin necesidad de biblioteca. This artículo fue un buen punto de partida para mí, pero como keyIdentifier está en desuso, quería que este código fuera más seguro, así que agregué || e.keyCode == 8 a la declaración if. Además, el código no funcionaba bien en Firefox, así que agregué return false; y ahora funciona perfectamente bien. Aquí está:

<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>

Este código funciona muy bien porque,

  1. Está en javascript puro (no se requiere biblioteca).
  2. No solo verifica la tecla presionada, sino que también confirma si la acción es realmente una acción "atrás" del navegador.
  3. Junto con lo anterior, el usuario puede escribir y eliminar el texto de los cuadros de texto de entrada en la página web sin ningún problema mientras evita la acción del botón Atrás.
  4. Es corto, limpio, rápido y directo al grano.

Puede agregar console.log (e); para sus propósitos de prueba, y presione F12 en Chrome, vaya a la pestaña "consola" y presione "retroceso" en la página y mire dentro de ella para ver qué valores se devuelven, luego puede apuntar a todos esos parámetros para mejorar aún más el código arriba para satisfacer sus necesidades.


Para elaborar un poco sobre la excelente respuesta de @ erikkallen, aquí hay una función que permite todos los tipos de entrada basados ​​en teclado, incluidos los introducidos en 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();
    }
});

Según los comentarios, parece que desea evitar que las personas pierdan información en los formularios, si presionan la tecla de retroceso para eliminar pero el campo no está enfocado.

En cuyo caso, desea ver el controlador de eventos onunload . lo usa: si intentas dejar una página cuando empiezas a escribir una respuesta, aparece una advertencia.


Esta solución es similar a otras que se han publicado, pero utiliza una lista blanca simple que la hace fácilmente personalizable para permitir el retroceso en elementos especificados simplemente configurando el selector en la función .is ().

Lo uso en este formulario para evitar que el retroceso en las páginas se desplace hacia atrás:

$(document).on("keydown", function (e) {
    if (e.which === 8 && !$(e.target).is("input:not([readonly]), textarea")) {
        e.preventDefault();
    }
});

He estado usando esto en mi código desde hace algún tiempo. Escribo exámenes en línea para los estudiantes y encontré el problema cuando los estudiantes presionaban la tecla de retroceso durante el examen y los llevaría a la pantalla de inicio de sesión. ¡Frustrante! Funciona en FF seguro.

document.onkeypress = Backspace;
function Backspace(event) {
    if (event.keyCode == 8) {
        if (document.activeElement.tagName == "INPUT") {
            return true;
        } else {
            return false;
        }
    }
}

    document.onkeydown = function (e) {    
        e.stopPropagation();
        if ((e.keyCode==8  ||  e.keyCode==13) &&
            (e.target.tagName != "TEXTAREA") && 
            (e.target.tagName != "INPUT")) { 
            return false;
        }
    };

Aquí está mi reescritura de la respuesta más votada. Intenté verificar element.value! == undefined (ya que algunos elementos como puede no tener un atributo html pero pueden tener una propiedad de valor de javascript en algún lugar de la cadena de prototipos), sin embargo, no funcionó muy bien y tenía muchos casos de borde. Parece que no hay una buena manera de hacer esto para el futuro, por lo que una lista blanca parece la mejor opción.

Esto registra el elemento al final de la fase de burbuja de evento, por lo que si desea manejar el retroceso de cualquier forma personalizada, puede hacerlo en otros controladores.

Esto también verifica la instancia de HTMLTextAreElement ya que uno podría tener teóricamente un componente web que se hereda de eso.

Esto no verifica el contenido editable (se combina con otras respuestas).

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

Respuesta erikkallen modificada:

$(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;
    }
});

Las otras respuestas aquí han establecido que esto no se puede hacer sin los elementos de la lista blanca en los que se permite Retroceso. Esta solución no es ideal porque la lista blanca no es tan sencilla como las simples entradas de texto y texto / contraseña, pero se encuentra repetidamente como incompleta y necesita ser actualizada.

Sin embargo, dado que el propósito de suprimir la funcionalidad de retroceso es simplemente evitar que los usuarios pierdan datos accidentalmente, la solución antes de la descarga es buena porque la ventana emergente modal es sorprendente: las ventanas emergentes modales son malas cuando se activan como parte de un flujo de trabajo estándar. porque el usuario se acostumbra a despedirlos sin leerlos, y son molestos. En este caso, la ventana emergente modal solo aparecería como una alternativa a una acción rara y sorprendente, y por lo tanto es aceptable.

El problema es que no debe aparecer un modo onbeforeunload cuando el usuario navega fuera de la página (por ejemplo, al hacer clic en un enlace o al enviar un formulario), y no queremos comenzar a incluir listas negras o negras en condiciones específicas antes de descargar.

La combinación ideal de compensaciones para una solución generalizada es la siguiente: realizar un seguimiento de si se presiona la tecla de retroceso, y solo aparece el modo de carga antes de la descarga si es así. En otras palabras:

function confirmBackspaceNavigations () {
    // http://.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

Esto ha sido probado para funcionar en IE7 +, FireFox, Chrome, Safari y Opera. Simplemente coloque esta función en su archivo global.js y llámela desde cualquier página donde no desee que los usuarios pierdan accidentalmente sus datos.

Tenga en cuenta que esto no se activará en eventos de cambio de hash, sin embargo, en ese contexto, puede utilizar otras técnicas para evitar que los usuarios pierdan accidentalmente sus datos.


Combinando soluciones dadas por "thetoolman" && "Biff MaGriff"

El siguiente código parece funcionar correctamente en 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();
    });
}); 

Versión javascript pura, que funciona en todos los navegadores:

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;
    }
  }
}

Por supuesto, puede usar "ENTRADA, TEXTAREA" y usar "if (! Regex.test (elements))" entonces. El primero funcionó bien para mí.


Este código funciona en todos los navegadores y traga la tecla de retroceso cuando no está en un elemento de formulario, o si el elemento de formulario está deshabilitado | solo lectura. También es eficiente, lo cual es importante cuando se ejecuta en todas las teclas introducidas.

$(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();
            }
        }
    });
});

Creé un proyecto NPM con una versión limpia de la actualmente aceptada (de erikkallen)

https://github.com/slorber/backspace-disabler

Utiliza básicamente los mismos principios pero:

  • Sin dependencia
  • Soporte para contenteditable
  • Base de código más legible / mantenible
  • Será soportado ya que será utilizado en producción por mi empresa.
  • Licencia MIT
var Backspace = 8;

// See http://.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://.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);
};

Este código resuelve el problema, al menos en IE y Firefox (no he probado ningún otro, pero le doy una posibilidad razonable de que funcione si el problema existe en otros navegadores).

// 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;
        }
    }
});

Una solución más elegante / concisa:

$(document).on('keydown',function(e){
  var $target = $(e.target||e.srcElement);
  if(e.keyCode == 8 && !$target.is('input,[contenteditable="true"],textarea'))
  {
    e.preventDefault();
  }
})

Otro método utilizando 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>

¡Deja de navegar este código funciona!

$(document).on("keydown", function (event) {        
   if (event.keyCode === 8) {
      event.preventDefault();
    }
  });

Pero para no restringir campos de texto sino otros.

$(document).on("keydown", function (event) {
  if (event.which === 8 && !$(event.target).is("input, textarea")) {
   event.preventDefault();
  }
});

Para prevenirlo por campo específico simplemente use

$('#myOtherField').on("keydown", function (event) {
  if (event.keyCode === 8 || event.which === 8) { 
   event.preventDefault(); 
  } 
});

¡Refiriéndose a éste abajo!

Evita que BACKSPACE vuelva a navegar con jQuery (como la página de inicio de Google)


JavaScript - jQuery forma:

$(document).on("keydown", function (e) {
    if (e.which === 8 && !$(e.target).is("input, textarea")) {
        e.preventDefault();
    }
});

Javascript - la forma nativa, que funciona para mí:

<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>

Ya hay tantas respuestas disponibles. Pero lo siguiente puede ser útil en algunos escenarios.

// One can specify all values against which you consider truthy
var TRUTHY_VALUES = [true, 'true', 1];

function getBoolean(a) {
    return TRUTHY_VALUES.some(function(t) {
        return t === a;
    });
}

Esto puede ser útil cuando uno ejemplos con valores no booleanos.

getBoolean('aa'); // false
getBoolean(false); //false
getBoolean('false'); //false

getBoolean('true'); // true
getBoolean(true); // true
getBoolean(1); // true




javascript jquery internet-explorer firefox cross-browser