您可以创建一个承诺并在请求成功时解决它; 并在 promise 的错误处理程序中优雅地失败：

require(["dojo/Deferred"], function(Deferred){
    var d = new Deferred();
    require(['twitter-api'], function(twitterApi){
        d.resolve(twitterApi);
    });
    d.then(function(api){
        // use api
    }, function(err){
        // fail gracefully
    });
    return d.promise;
});

Stafamus的回答是解决手头问题的一个非常接近的解决方案。 实际上，由于您无法确定require是否会完成，因此您不能尝试解决或拒绝其中的承诺。 我最终将dojo/Deferred与dojo.io.script结合使用，以便异步加载 Twitter API，然后在加载 Twitter API 时调用的回调中解析承诺。

还要记住，我使用的是 Dojo 1.7.2。 从 Dojo 1.8 开始，dojo.io.script 被弃用，取而代之的是 dojo/request/script 。 我没有研究两者之间的区别。

这段代码可能会优化得更好一点，例如，我认为你不需要使用declare或者如果你这样做，你可以创建一个基 API 类，我不确定如果你尝试在页面上多次使用或加载 Twitter API，它是否运行得非常好。 但是，它符合我的需求，我已经调整了此解决方案，以类似的方式加载Youtube，Google和Facebook API。

推特.js

基本上，代码归结为使用dojo.io.script让Dojo在页面上放置带有Twitter src的<script>标签，这使我们获得了Twitter使用的全局，twttr并试图确保它不需要的话不会这样做。 Twitter 有一个"就绪"回调，通过t.ready()定义，我们通过引用全局twttr来解决我们的 API 承诺。 实际上，这是Twitter告诉你的Dojo包装方式，已经加载JavaScript API。

define([
    "dojo/_base/declare",
    "dojo/_base/Deferred",
    "dojo/io/script"
], function (
        declare,
        Deferred,
        ioScript
        ) {
    /**
     * @class api/Twitter
     * @classdesc Wrapper for the Twitter API which isn't inherently AMD
     */
    var Twitter = declare("api.Twitter", [], {
        /**
         * The deferred that we use to get a handle to API
         * @member {dojo/Deferred} api/Twitter#apiDeferred
         */
        apiDeferred: null,
        /**
         * The constructor which loads the API and starts the player creation
         * @method api/Twitter#constructor
         * @param {HTMLElement} container The id of the element to hold the player
         */
        constructor: function (container) {
            // Create a deferred that will resolve when we have a player
            this.apiDeferred = this.loadAPI();
        },
        /**
         * Function that loads the API from Twitter asynchronously
         * @method api/Twitter#loadAPI
         * @return {dojo/Deferred} The deferred that will resolve when the API is loaded
         */
        loadAPI: function () {
            // Create an API deferred to resolve when the API is loaded
            var apiDeferred = new Deferred();
            // Make sure that we haven't already loaded the Twitter API
            if (typeof twttr === "undefined") {
                /*
                 * This is where we wrap up the normally "synchronous" loading
                 * of whatever API we're using.  Twitter is slightly asynchronous
                 * in that it loads itself through creating a script tag and setting 
                 * the src which we can do with dojo.io.script already.  However,
                 * twitter expects there to exist a "twttr" variable whenever it loads
                 * much like dojo expects a dojoConfig.  In the twttr, there is an array
                 * of callbacks _e that will be called once the API is loaded.  This is
                 * where we create the boilerplate for Twitter. 
                 */
                // Create the twttr object from an immediately executed functor
                window.twttr = (function () {
                    // Make sure we don't already have a twttr object
                    var t = window.twttr || {};
                    // Create a ready callback array
                    t._e = [];
                    // Create a wrapper to allow pushing to the ready array
                    t.ready = function (f) {
                        t._e.push(f);
                    };
                    // Add our on callback that will let us know twitter loaded
                    t.ready(function (e) {
                        // Deliver the API through the deferred
                        apiDeferred.resolve(e.widgets);
                    });
                    // Return the twitter object
                    return t;
                }());
                // Ask dojo to load a new script tag with the Twitter API as the src
                ioScript.get({
                    url: "https://platform.twitter.com/widgets.js",
                    error: function (e) {
                        apiDeferred.reject("Twitter API seems incorrectly loaded.");
                    }
                });
            }
            // If we already have the Twitter API, we can resolve right now
            else {
                if (typeof twttr.widgets !== "undefined") {
                    apiDeferred.resolve(twttr.widgets);
                }
                else {
                    apiDeferred.reject("Twitter API seems incorrectly loaded.");
                }
            }
            // Return the API Deferred
            return apiDeferred;
        },
        /**
         * Function to get a handle to the deferred that should resolve to the twitter API
         * @member api/Twitter#getAPIDeferred
         * @returns {dojo/Deferred} The Twitter API
         */
        getAPIDeferred: function () {
            return this.apiDeferred;
        }
    });
    // Return our class
    return Twitter;
});

共享吧.js

在我的小部件中，我有开关让我禁用社交 API，如果我想使用一个，我只需要上面的包装 API。 然后我创建一个新Twitter，请求 API 延迟，如果它解析，我创建 Twitter 按钮。 此文件被严重截断，不包括所有小部件代码，仅包含 API 代码的实际使用。

define([
    "dojo/_base/declare",
    "Twitter"
], function (
        declare,
        Twitter
        ) {
    /**
     * @class ShareBar
     * @classdesc Widget used to display social media functionality on a page.
     */
    var ShareBar = declare({
        /**
         * By requiring the Twitter API, we have the twttr JS 
         * object which we can use to do Twitter stuff like 
         * parsing tweet buttons
         * @method ShareBar#_loadTwitter
         */
        _loadTwitter: function () {
            var
                    // Create a twitter module
                    twitter = new Twitter(),
                    // Get a closure safe handle to our twitter button
                    twitterButton = this.TwitterButton,
                    // Create a callback for when the twitter API loads
                    twitterSuccess = function (twitterAPI) {
                        // Run the twitter parser on our twitter button
                        twitterAPI.load(twitterButton);
                        // Allow the twitter button to be seen
                        domClass.remove(twitterButton, "hiddenSocialButton");
                    },
                    // Create an errback for if the twitter API fails
                    twitterFail = function (err) {
                        // Note the error
                        console.log(err);
                    };
            // Wait for the API to resolve and use the callbacks
            twitter.getAPIDeferred().then(twitterSuccess, twitterFail);
        }
    });
    // Return widget
    return ShareBar;
});