JavaScript: Overriding alert()


JavaScript: Overriding alert()

Has anyone got any experience with overriding the alert() function in JavaScript?

Which browsers support this?
Which browser-versions support this?
What are the dangers in overriding the function?


Solution 1:

It’s definitely “supported”. It is your web page, you do whatever you want to with it.

I already did this to track analytics events without modifying a library but by sneaking into events.

Use the proxy pattern:

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

You can also bypass the call to the original function if you want (proxied)

More info here: JQuery Types #Proxy Pattern

Solution 2:

Although most browsers support overriding it, be careful with what you’re doing with it.

Since the default alert box blocks the execution thread, some libraries that rely on this behaviour might not work anymore (at best).

You should be a good citizen and avoid touching the native API. If you do, you could break things up, when using 3rd party code.

Yet, if you want to redefine the alert behaviour in a specific context, you could enclose it with an anonymous function, like this:

/* 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!");


Solution 3:

There are no dangers in Overring alert function. Every browser supprts it.

for example:

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

alert('This is an override.');

Solution 4:

I think every Javascript implementation will support this, and there is no danger involved with it. It’s commonly done to replace the plain OS-styled alert boxes to something more elegant with HTML/CSS. Doing it this way means you don’t have to change existing code! The fact that it is possible makes Javascript awesome.

Solution 5:

As said in many of the other answers, you can just override the function with

window.alert = null


window.alert = function(){}

however, this doesn’t necessarily override the function on the prototype of the Window constructor (note the capital W), so the hacker can still type:

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

therefore, you also need to override that function with:

Window.prototype.alert = null


Window.prototype.alert = function(){}

Solution 6:

For IE8 you can redefine alert() like this way

 * 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') {
          else {
               document.write('<h1>I am redefiend alert()<br/>Alert say: '+message+'</h1>');

and call as

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