JavaScript: Sobreescribir alerta()

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

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

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

Sin embargo, si desea redefinir el comportamiento de alerta en un contexto específico, podría encerrarlo con un función anónima, así:

/* 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 excesiva. Cada navegador lo soporta.

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 soportará esto, y no hay peligro involucrado con ello. Comúnmente se hace para reemplazar las cajas de alerta de estilo simple del sistema operativo por algo más elegante con HTML / CSS. Hacerlo de esta manera significa que usted no tiene que cambiar el código existente! El hecho de que sea posible hace que Javascript sea impresionante.

Como se ha dicho en muchas de las otras respuestas, solo 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 constructor Window (tenga en cuenta la mayúscula W), por lo que el hacker todavía puede escribir:

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

Por lo tanto, también necesita anular esa función con:

Window.prototype.alert = null

O

Window.prototype.alert = function(){}

[2] Ladislav.
Para IE8 puedes 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 llamar como

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

Mi experiencia con sobreescribir la función alert () es que una vez la usamos para "hackear" la versión de prueba de la biblioteca JavaScript que mostraba "¡Por favor regístrese!"nag screen through alert time to time.

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

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

Todas las implementaciones de JavaScript en los navegadores modernos soportan sobreescritura.

Los peligros son simplemente, que volverías completamente loco a otros miembros del equipo anulando funciones comúnmente conocidas como alert().

Así que a menos que esté anulando funciones como una herramienta para quizás depurar o hackear código existente de alguna manera, no veo ninguna razón para hacerlo. Simplemente crea una nueva función.

Seguro que funciona en firefox e ie8. No veo que hubiera ningún navegador en el que no funcionara. Esto es bastante fundamental de cómo funciona javascript, a pesar de que uno no lo ve a menudo utilizado con funciones nativas como esa=)

Un truco rápido que hago para encontrar de dónde vienen 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.alert es preeminente y más conocido, las personas que no conocen js saben alert() rest tenga la seguridad de que es compatible con todos los navegadores en uso hoy y su fragmento de código también lo es. Sin embargo, no invalidaría (bueno, esto es más como refactorización en lugar de invalidar en el sentido de OOP) alert() para un caso de uso particular como el suyo porque cuando realmente necesita usar alert() sin plantilla, y probablemente lo hará, entonces necesitará otra no alerta función para hacerlo.