JavaScript: le remplacement d'alerte()

bien que la plupart des navigateurs prennent en charge passer outre, soyez prudent avec ce que vous faites avec elle.

puisque la boîte d'alerte par défaut bloque le thread d'exécution, certaines bibliothèques qui se fient à ce comportement pourraient ne plus fonctionner (au mieux).

vous devez être un bon citoyen et éviter de toucher L'API native. Si vous le faites, vous pourriez briser les choses, en utilisant le code de tiers.

Pourtant, si vous voulez redéfinir l'alerte comportement dans un contexte spécifique, on pourrait l'enfermer dans une fonction anonyme, comme celle-ci:

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

il n'y a aucun danger à surcharger la fonction d'alerte. Chaque navigateur le supprime.

par exemple:

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

alert('This is an override.');

je pense que chaque implémentation Javascript supporte cela, et il n'y a aucun danger. Il est généralement fait pour remplacer les boîtes d'alerte simples de style OS à quelque chose de plus élégant avec HTML/CSS. Le faire de cette façon signifie que vous n'avez pas à changer le code existant! Le fait que ce soit possible rend Javascript impressionnant.

Comme dit dans beaucoup d'autres réponses, vous pouvez simplement remplacer la fonction avec

window.alert = null

ou

window.alert = function(){}

cependant, cela ne remplace pas nécessairement la fonction sur le prototype du constructeur Window (notez la majuscule W ), de sorte que le pirate peut encore taper:

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

par conséquent, vous devez également annuler cette fonction avec:

Window.prototype.alert = null

ou

Window.prototype.alert = function(){}

Ladislav.

Pour IE8 vous pouvez redéfinir alert () comme ceci

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

et appelez

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

D'après mon expérience avec la fonction overriding alert (), nous l'avons déjà utilisé pour "hacker" la version d'essai de la bibliothèque JavaScript qui affichait "please register!"nag screen à travers les temps d'alerte.

nous venons de définir notre propre fonction alert() et voila.

C'était pour des fins de test uniquement, nous avons acheté la version complète pour plus tard, donc rien d'immoral qui se passe ici ;-)

toutes les implémentations JavaScript dans les navigateurs modernes prennent en charge l'overriding.

les dangers sont tout simplement, que vous conduiriez les autres membres de l'équipe absolument fou en outrepassant les fonctions communément connues telles que alert().

donc à moins que vous ne soyez en train de supplanter des fonctions en tant qu'outil pour peut-être déboguer ou pirater du code existant d'une certaine manière, je ne vois aucune raison de le faire. Il suffit de créer une nouvelle fonction.

ça marche avec firefox et ie8. Je ne vois pas de navigateur qui ne fonctionnerait pas. C'est assez fondamental du fonctionnement de javascript, même si on ne le voit pas souvent utilisé avec des fonctions natives comme cela=)

un hack rapide que je fais pour trouver d'où viennent les alertes, est d'aller à la console et puis entrer ce

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

quand il s'agit de fonctions de navigateur js window.alert est prééminent et le plus connu, les gens qui ne savent pas js savent alert() -- soyez assuré qu'il est pris en charge dans tous les navigateurs en usage aujourd'hui et votre code snippet est ainsi. Cependant, je ne voudrais pas outrepasser (bien c'est plus comme refactoring plutôt que override dans le sens OOP) alert() pour un cas d'utilisation particulier comme le vôtre parce que lorsque vous avez réellement besoin d'utiliser alert() sans modèle, et vous probablement will, alors vous aurez besoin d'une autre fonction de non-alerte pour le faire.