La compensation d'une jquery document.prêt() appel

Comment puis-je effacer des fonctions anonymes qui sont réglé pour se déclencher via jquery document.prêt() appel?

Par exemple:

<script type="text/javascript">
    //some code sets a doc ready callback
    $(document).ready(function ()
    {
        alert('ready');
    });

    //my attempt to prevent the callback from happening
    window.onload = null;
    $(document).unbind("ready");

</script>

L'alerte se produit indépendamment de mes tentatives de le contourner. Est-il possible de le faire??

Il est possible de définir plus d'un ready fonction, donc je ne suis pas surpris que unbind ne fonctionne pas. Un hacky solution serait de définir une variable globale, et tout envelopper à l'intérieur de la ready de la fonction dans un if pour tester la valeur il suffit de changer la valeur et tout le ready fonction sera toujours exécuté, c'est le contenu ne sera pas...

OriginalL'auteur Shane N | 2011-10-18

5

Vous auriez probablement obtenir la réponse la plus appropriée si vous décrit ce problème vous êtes vraiment essayer de résoudre.

jQuery n'a pas publiquement documentés de manière à annuler ou de bloquer document.prêt() gestionnaires. Si vous contrôlez le code, vous pouvez utiliser une variable globale et une condition comme ceci:
```
var skipReady = false;
$(document).ready(function ()
{
    if (!skipReady) {
        alert('ready');
    }
});

//skip the document.ready code, if it hasn't already fired
skipReady = true;
```
Ou, si vous voulez pirater jQuery un peu (au-delà de la documentation de l'interface), vous pouvez le faire:
```
$(document).ready(function() {
    alert("ready");
});

//stop the ready handler
$.isReady = true;
```
Vous pouvez le voir, cette dernière œuvre ici: http://jsfiddle.net/jfriend00/ZjH2k/. Cela fonctionne parce que jQuery utilise la propriété: $.isReady de garder une trace de savoir si elle a déjà tiré le prêt des gestionnaires ou pas. La valeur true permet il pense qu'il a déjà tiré eux afin de ne pas tous les faire à nouveau.

Je ne maîtrise pas le code. Je me suis créer un bout de code javascript qui peut être inclus sur un site internet du client, qui va remplacer certains de leur contenu. Malheureusement, ils ont rappels qui attendent de l'remplacé content d'être là, d'où une erreur. J'ai pensé que si je pouvais remplacer leur doc prêt appels en quelque sorte, alors il serait possible de résoudre le problème.
Wow - vous êtes à essayer de bloquer tous jQuery.prêt de code d'initialisation. J'espère que vous savez ce que vous faites parce que beaucoup de choses peuvent se briser si vous faites cela. Qu'en est légitime code d'initialisation qui n'a besoin pour s'exécuter? De toute façon, j'ai ajouté une autre option qui peut être fait sans modifiant le code à l'intérieur du prêt gestionnaire. Il me semble que vous devriez laisser la régulière code prêt à l'emploi et régulière le contenu de la page exécuter, PUIS, après qu'il a exécuté, vous remplacez des trucs dans la page.
Ouais, je comprends combien cela semble effrayant, mais nous en avons l'autorisation pour ce faire. Je suis ouvert à pirater jquery un peu, mais nous avons quelques autres du code qui n'a besoin pour s'exécuter sur la doc.prêt. Le 2ème exemple semble faire exactement ce dont j'ai besoin...bien que cela semble contre-intuitif - réglage isready à vrai me ferait penser que nous sommes le déclenchement de doc.prêt...
Si vous regardez le jQuery source, isReady est juste un drapeau qu'il utilise pour garder une trace de savoir si il a déjà été exécuté le prêt des gestionnaires ou pas, de sorte qu'il n'est jamais à plus d'une fois. Il ne déclenche pas. Il le fait parce qu'il y a plusieurs événements qui peuvent déclencher et il veut aller seulement sur le premier événement qui se déclenche.
Il est publiquement documentés pour tenir à distance d'exécuter les fonctions liées à $(document).ready(fn), à l'aide de $.holdReady(bool). Passer true pour les faire patienter, passer false de laisser le feu. Ajouté dans jQuery 1.6 - api.jquery.com/jQuery.holdReady

OriginalL'auteur jfriend00
1

Cela fonctionne:
```
$(document).bind("ready", function () { alert("hey!"); });
$(document).unbind("ready");
```
Semble comme un bug pour moi - tout autres événements dans jQuery sont en mesure d'être indépendant. En omettant celui-ci est incompatible.

Pas une réponse directe à l'omission, mais voici quelques infos de jQuery docs:
Tous les trois, les syntaxes suivantes sont équivalentes:
- $(document).ready(handler)
- $().ready(handler) (ce n'est pas recommandé)
- $(handler)
Il est également $(document).bind("ready", handler). Ce comportement est similaire à la méthode de prêt, mais avec une exception: Si le prêt événement a déjà tiré, et vous essayez de .bind("ready") le gestionnaire ne sera pas exécuté. Prêt gestionnaires lié de cette manière sont exécutées après tout lié par les trois autres méthodes ci-dessus.
Nice! Donc je me demande quelle est la différence entre un appel $(document).prêt(...) contre $(document).bind("prêt",...). Dommage que le unbind documentation dit qu'elle n'affecte que ces rappels qui ont été fixés par l'intermédiaire d'un appel de bind ().
La différence est que .bind("ready", handler) gestionnaires ne sera pas appelée si l' ready événement a déjà tiré. Ils sont aussi appelés en dernier, après tous les gestionnaires lié de la façon la plus commune.
Du mieux que je peux dire en regardant la source, la $(document).bind("ready") gestionnaires seront appelés après les autres prêts gestionnaires et qu'ils sont les seuls qui peuvent être enlevés avec $(document).unbind(). Vous ne pouvez pas supprimer un $(document).ready() gestionnaire avec les séparer car ils sont stockés de manière différente.

OriginalL'auteur gilly3
0

$(document).prêt() dépend de l'événement onLoad qui est déclenché par le navigateur, ce qui signifie que vous ne pouvez pas l'empêcher de se produire. Si l'alert() est déterminé par un certain état alors je voudrais utiliser un if/else pour décider s'il est appelé.

Ce n'est pas le cas. $(document).prêt() est généré par jQuery et il existe des moyens pour arrêter de se produire.

OriginalL'auteur Justin Lucas
0

Super vieille question, mais il est venu à travers le besoin de le faire récemment pour prévenir document.code prêt à l'emploi je n'ai pas le contrôle dans certains cas. Ceci peut être réalisé par l'utilisation de proxy jQuery fonction ready, un peu comme un test de l'espion. Suivantes:
```
var ready = $.prototype.ready;

//proxy the ready function
$.prototype.ready = function ( fn, allowed ) {
    allowed = allowed || false;

    if ( allowed ) {
        ready.call( this, fn );
    }
};
```
Tous les appels à $( document ).ready va maintenant être ignoré. Vous pouvez remplacer ce comportement par un passage à la vrai que le deuxième argument: $( document ).ready( fn, true )

OriginalL'auteur baseten

Vous devez vous connecter pour publier un commentaire.