Puis-je utiliser jquery getScript () sans rappel?

Faire "la première" n'est actuellement pas^* possible avec jQuery.getScript car il ne prend en charge les opérations asynchrones, et donc il revient tout de suite après avoir été appelé.

Puisqu'il revient avant que votre script a été téléchargé lorsque le script tente d'invoquer myHelperFunction()myHelperFunction est undefined et les causes de cette erreur.

^*Voir la mise à jour au bas de cette réponse pour une prometteuse nouvelle méthode qui permettra éventuellement de vous écrire du code qui fonctionne presque comme votre style désiré.

Vous pourriez le faire à l'aide de jQuery.ajax avec le async jeu de paramètre false avec un code qui est quelque chose comme ceci:

$.ajax({
  url: 'js/myHelperFile.js',
  async: false,
  dataType: "script",
});

myHelperFunction();

Mais comme le la documentation états:

des requêtes synchrones peuvent verrouiller temporairement le navigateur, la désactivation de toutes les actions, tandis que la demande est active.

C'est une très mauvaise chose. Si le serveur qui fournit myHelperFile.js est lente à réagir à tout moment (ce qui sera arriver à un certain point) la page ne répond plus jusqu'à ce que la demande de finitions ou timesout.

Ce serait une bien meilleure idée pour embrasser le rappel de style qui est largement utilisé tout au long de jQuery.

$.getScript('js/myHelperFile.js', function () {
   myHelperFunction();
});

Vous n'avez pas besoin d'utiliser une fonction anonyme, vous pouvez mettre votre code dans une fonction nommée:

function doStuffWithHelper() {
   myHelperFunction();
}

$.getScript('js/myHelperFile.js', doStuffWithHelper);

---

Si vous avez besoin de charger plus d'une dépendance avant d'appeler myHelperFunction cela ne marchera pas, sauf si vous mettez en place une sorte de système pour savoir si toutes les dépendances sont téléchargés avant d'exécuter votre code. Vous pouvez ensuite définir le gestionnaire de rappel sur toutes les .getScript appelle pour vérifier que toutes les dépendances sont chargés avant l'exécution de votre code.

var loadedScripts = {
    myHelperFile: false,
    anotherHelperFile: false
};

function doStuffWithHelper() {
    //check to see if all our scripts are loaded
    var prop;
    for (prop in loadedScripts) {
        if (loadedScripts.hasOwnProperty(prop)) {
            if (loadedScripts[prop] === false) {
                return; //not everything is loaded wait more
            }
        }
    }

    myHelperFunction();
}

$.getScript('js/myHelperFile.js', function () {
    loadedScripts.myHelperFile = true;
    doStuffWithHelper();
});
$.getScript('js/anotherHelperFile.js', function () {
    loadedScripts.anotherHelperFile = true;
    doStuffWithHelper();
});

Comme vous pouvez le voir, ce type d'approche devient compliqué et difficile à maintenir rapide.

Si vous avez besoin de charger de multiples dépendances, vous feriez probablement mieux à l'aide d'un scriptloader comme yepnope.js de le faire.

yepnope( {
        load : [ 'js/myHelperFile.js', 'js/anotherHelperFile.js' ],
        complete: function () {
            var foo;
            foo = myHelperFunction();
            foo = anotherHelperFunction(foo);
            //do something with foo
        }
} );

Yepnope utilise les rappels comme .getScript de sorte que vous ne pouvez pas utiliser la séquence de style vous voulais rester avec. C'est un bon compromis, mais parce que la réalisation de plusieurs synchrone jQuery.ajax à des appels à la ligne juste composé que des méthodes de problèmes.

---

Mise à jour 2013-12-08

La jQuery 1.5 releasefournit un autre pur jQuery façon de faire. Que de 1,5, toutes les requêtes AJAX retour d'un Différée Objet de sorte que vous pourriez faire ceci:

$.getScript('js/myHelperFile.js').done(function () {
   myHelperFunction();
});

Être une requête asynchrone, il a évidemment besoin d'un rappel. À l'aide de Deferreds cependant a un énorme avantage sur le traditionnel rappel du système, à l'aide de $.lorsque() vous pouvez facilement étendre ce pour le chargement de plusieurs préalable des scripts sans votre propre alambiqué système de suivi:

$.when($.getScript('js/myHelperFile.js'), $.getScript('js/anotherHelperFile.js')).done(function () {
  var foo;
  foo = myHelperFunction();
  foo = anotherHelperFunction(foo);
  //do something with foo
});

Cela permettrait de télécharger les deux scripts simultanément et exécuter uniquement la fonction de rappel après que les deux d'entre eux ont été téléchargés, à l'instar de la Yepnope exemple ci-dessus.

---

Mise à jour 2014-03-30

J'ai lu récemment un article qui m'a fait prendre conscience d'une nouvelle fonction JavaScript qui pourrait à l'avenir permettre à la nature de la procédure-la recherche-encore-async code que vous vouliez l'utiliser! Async Fonctions utilisera le await mot-clé pour interrompre l'exécution d'un async fonction jusqu'à ce que l'opération asynchrone se termine. La mauvaise nouvelle, c'est qu'il est actuellement prévu pour l'inclusion dans l'ES7, deux ECMAScript versions loin.

await s'appuie sur les fonctions asynchrones vous attendent au retour d'un Promesse. Je ne suis pas sûr de la façon dont le navigateur implémentations de se comporter, si ils auront besoin d'un vrai ES6 Promesse de l'objet ou si d'autres implémentations de promesses, comme celle de jQuery retours d'appels AJAX suffira. Si un ES6 Promesse est tenue, vous aurez besoin d'envelopper jQuery.getScript avec une fonction qui retourne une Promesse:

"use strict";
var getScript = function (url) {
  return new Promise(function(resolve, reject) {
    jQuery.getScript(url).done(function (script) {
      resolve(script);
    });
  });
};

Ensuite, vous pouvez l'utiliser pour télécharger et await avant de poursuivre:

(async function () {
  await getScript('js/myHelperFile.js');
  myHelperFunction();
}());

Si vous êtes vraiment déterminé à écrire dans ce style, aujourd'hui, vous pouvez utiliser asyc et await et ensuite utiliser Traceur à transpile votre code dans le code qui sera exécuté dans les navigateurs actuels. L'avantage de ce processus est que vous pouvez également utiliser de nombreux d'autres nouvelles caractéristiques ES6 trop.

$.getScript, et vraiment tous HTTP OP liées à des fonctions jQuery non-blocage des appels par défaut. C'est-à-dire que le code n'est pas de se bloquer lors de l'opération se termine. Ce que cela signifie, c'est que votre code ci-dessus va certainement échouer, car il n'y a aucun moyen de $.getScript va charger le script avant de la ligne de la tentative d'exécution de la méthode s'exécute. C'est pourquoi les fonctions de rappel sont acceptés en tant que paramètres.

Cependant, ce que vous essayez de faire est possible. Une fois que le script a été chargé, vous devriez être en mesure d'appeler à partir de n'importe où. Tout ce qui est nécessaire pour éviter la méthode appelée avant que le script ne soit téléchargé est nécessaire de drapeaux.

var HelperFileLoaded = false; 
$.getScript('js/myHelperFile.js', function() { HelperFileLoaded = true; });

//...

function btnSaveClick() {
    if(!HelperFileLoaded) return;
    myHelperFunction(); 
}

BenM la suggestion est possible, mais sauf si vous êtes seulement de faire un seul appel à myHelperFunction il ne fonctionne pas comme une solution parce qu'il n'y aura aucune garantie que le script ont téléchargé avant toute autre méthode d'appel myHelperFunction ont été déclenchées.