JavaScript: anulación de alerta ()

¿Alguien tiene alguna experiencia para anular la alert()función en JavaScript?

• ¿Qué navegadores admiten esto?
• ¿Qué versiones de navegador admiten esto?
• ¿Cuáles son los peligros de anular la función?

Definitivamente es "compatible". Es tu página web, haces lo que quieras con ella.

Ya hice esto para rastrear eventos analíticos sin modificar una biblioteca, sino escabulléndome en eventos.

Use el patrón proxy:

(function(proxied) {
  window.alert = function() {
    // do something here
    return proxied.apply(this, arguments);
  };
})(window.alert);

También puede omitir la llamada a la función original si lo desea (proxy)

Más información aquí: JQuery Tipos #Proxy Patrón

Aunque la mayoría de los navegadores admiten anularlo, tenga cuidado con lo que está haciendo con él.

Dado que el cuadro de alerta predeterminado bloquea el hilo de ejecución, algunas bibliotecas que dependen de este comportamiento podrían dejar de funcionar (en el mejor de los casos).

Debes ser un buen ciudadano y evitar tocar la API nativa. Si lo hace, podría dividir las cosas cuando use un código de terceros.

Sin embargo, si desea redefinir el comportamiento de alerta en un contexto específico, puede encerrarlo con una función anónima, como esta:

/* new funky alert */
function myFunkyAlert(msg) { 
    /* here goes your funky alert implementation */
    alert("Look ma!\n" + msg);
}

(function(alert) { // anonymous function redefining the "alert"

    /* sample code */
    alert("Hello World!");

})(myFunkyAlert);

No hay peligros en la función de alerta Overring. Todos los navegadores lo admiten.

por ejemplo:

// function over riding. Redirecting to Console with Firebug installed.
function alert(message) { 
    console.info(message);
} 

alert('This is an override.');

Creo que cada implementación de Javascript lo soportará, y no hay ningún peligro involucrado en ello. Comúnmente se hace para reemplazar los cuadros de alerta de estilo OS por algo más elegante con HTML / CSS. ¡Hacerlo de esta manera significa que no tiene que cambiar el código existente! El hecho de que sea posible hace que Javascript sea increíble.

Como se dijo en muchas de las otras respuestas, puede anular la función con

window.alert = null

o

window.alert = function(){}

sin embargo, esto no necesariamente anula la función en el prototipo del Windowconstructor (tenga en cuenta la mayúscula W), por lo que el hacker aún puede escribir:

Window.prototype.alert.apply(window, ["You were hacked!"]);

por lo tanto, también debe anular esa función con:

Window.prototype.alert = null

o

Window.prototype.alert = function(){}

Ladislav.
Para IE8 puede redefinir alert () de esta manera

/** 
 * Definition of global attached to window properties <br/>
 */ 
    (function() {
      nalert = window.alert;
      Type = {
          native: 'native',
          custom: 'custom'
      };
    })();

/**
 * Factory method for calling alert(). 
 * It will be call a native alert() or a custom redefined alert() by a Type param.
 * This defeinition need for IE
 */ 
    (function(proxy) {

          proxy.alert = function () {
          var message = (!arguments[0]) ? 'null': arguments[0];
          var type = (!arguments[1]) ? '': arguments[1];

          if(type && type == 'native') {
           nalert(message);
          }
          else {
               document.write('<h1>I am redefiend alert()<br/>Alert say: '+message+'</h1>');
          }     
      };
   })(this);

y llama como

alert('Hello, hacker!');
nalert('I am native alert');
alert('Hello, user!', Type.custom);

Mi experiencia con la anulación de la función alert () es que una vez la usamos para "piratear" la versión de prueba de la biblioteca de JavaScript que mostraba "¡Por favor regístrese!" molesta pantalla a través de alertas de vez en cuando.

Acabamos de definir nuestra propia función alert () y listo.

Fue solo con fines de prueba, compramos la versión completa más tarde, así que no pasa nada inmoral aquí ;-)

Todas las implementaciones de JavaScript en los navegadores modernos admiten la anulación.

Los peligros son bastante simples: volvería locos a otros miembros del equipo al anular funciones comúnmente conocidas como alert ().

Entonces, a menos que esté anulando las funciones como una herramienta para quizás depurar o piratear el código existente de alguna manera, no veo ninguna razón para hacerlo. Solo crea una nueva función.

Seguro funciona en firefox y ie8. No puedo ver que haya ningún navegador en el que no funcione. Esto es más o menos fundamental de cómo funciona JavaScript, a pesar de que uno no lo ve a menudo usado con funciones nativas como esa =)

Un truco rápido que hago para encontrar de dónde provienen las alertas es ir a la consola y luego ingresar esto

function alert(message) { 
  console.info(message);
  debugger;
} 

Cuando se trata de las funciones del navegador js window.alertes preeminente y más conocido, las personas que no conocen js lo saben alert(): pueden estar seguros de que es compatible con todos los navegadores en uso hoy en día y su fragmento de código también. Sin embargo, no anularía (bueno, esto es más como refactorizar en lugar de anular en el sentido OOP) alert()para un caso de uso particular como el suyo porque cuando realmente necesite usar alert()sin plantilla, y probablemente lo hará, entonces necesitará otra función no alerta para hacerlo.

Me he enfrentado al requisito de mostrar un mensaje predeterminado junto con los mensajes de alerta reales. Así es como logré hacerlo.

    const actualAlertFunc = window.alert;
    window.alert = function(msg) {
         actualAlertFunc('some default message '+ msg);
    }

Lo he probado en cromo. No estoy seguro de si es una buena práctica, pero sirve para ese propósito.