Javascript 同步使用requirejs

我有一个requirejs项目，它已经优化为一个文件，我正在同步加载该文件。代码按预期加载，但模块仍在异步加载（直到加载过程的后期才可用），这给一些我希望可以使用的遗留代码带来了问题

给定下面的代码，在加载

legacy_code.js

之前，是否有任何方法可以在加载后立即使用

main build

的方法

<script type="text/javascript" src="/scripts/vendor/require.js"></script>
<script type="text/javascript" src="/scripts/main-build.js"></script>

<!-- At this point, the code is set up and it will be invoked later -->
<!-- ...but the next file requires to access methods in the modules.-->

<script type="text/javascript" src="/script/legacy_code.js"></script>

---

如果出现最坏的情况，我可以编写自己版本的

define（）

和

require（）

（这也会释放大量带宽，因为它需要做的只是编目和调用模块），但我希望有一种内置的方法来做到这一点。

这是最简单的方法，而不必重写

define（）

和

require（）

，肯定只是将您的

main build.js

模块定义指定为依赖项

---

我知道从技术上讲它不是“同步的”，但它应该可以实现您想要的功能-只有在加载require模块后才能调用遗留代码。

这是最简单的方法，无需覆盖

define（）

和

require（）

，当然，只需将您的

main build.js

模块定义指定为依赖项即可

---

我知道从技术上讲它不是“同步”的，但它应该可以实现您想要的功能-只有在加载了require模块之后才能调用遗留代码。

这里回答了我自己的问题。环顾四周很长一段时间后，我看不到任何同步加载Requirejs代码或在加载后立即调用模块的方法。因此，我最终编写了一些代码来临时覆盖

require

和

declare

方法。它适用于我的用例，但如果其他人需要它，可能需要更改。我相信它可以比现在更优化，但它是有效的

您可以找到代码，我将尝试维护它

此时的代码如下所示：

(function () {
    var self = {},
        originalDefine = window.define,
        originalRequire = window.require,
        modules = [];

    var define = function (id, deps, fn) {
        if (id !== 'requireLib' && id !== 'text') {
            modules.push({"id": id, "deps": deps, "fn": fn});
        }
    };



    var require = function (deps, fn) {
        var sortedModules = [],
            unsortedModules = [],
            resolvedDeps = {},
            maxAttempts = 1000,
            module,
            dep,
            depList,
            canAdd,
            i,
            j;

        unsortedModules = ([]).concat(modules);
        while (unsortedModules.length > 0 && --maxAttempts > 0) {

            for (i = unsortedModules.length - 1; i >= 0; i--) {
                canAdd = true;
                module = unsortedModules[i];

                for (j = 0; j < module.deps.length; j++) {
                    dep = module.deps[j];
                    if (resolvedDeps[dep] === undefined) {
                        canAdd = false;
                        break;
                    }
                }
                if (canAdd) {
                    resolvedDeps[module.id] = module;
                    sortedModules.push(unsortedModules.splice(i,1)[0]);
                }
            }
        }

        for (i = 0; i < sortedModules.length; i++) {
            module = sortedModules[i];
            depList = [];
            for (j = 0; j < module.deps.length; j++) {
                depList.push(resolvedDeps[module.deps[j]]);
            }
            resolvedDeps[module.id] = module.fn.apply(this, depList);
        }

        depList = [];
        for (i = 0; i < deps.length; i++) {
            depList.push(resolvedDeps[deps[i]]);
        }

        fn.apply(this, depList);

        window.define = originalDefine || function () {};
        window.require = originalRequire || function () {};
    };

    window.define = define;
    window.require = require;
    window.require.config = function() {};

    return self;
} ());

（函数（）{
var self={}，
originalDefine=window.define，
originalRequire=window.require，
模块=[]；
变量定义=函数（id、deps、fn）{
if（id！=“requireLib”&&id！=“text”）{
push（{“id”：id，“deps”：deps，“fn”：fn}）；
}
};
var require=功能（deps，fn）{
变量sortedModules=[]，
未排序的模块=[]，
resolvedDeps={}，
最大尝试次数=1000次，
模块，
副署长，
部门名单，
卡纳德，
我
J
未排序的模块=（[]）.concat（模块）；
while（unsortedModules.length>0&--maxtures>0）{
对于（i=unsortedModules.length-1；i>=0；i--）{
canAdd=正确；
模块=未排序的模块[i]；
对于（j=0；j

在这里回答我自己的问题。环顾四周很长一段时间后，我看不到任何同步加载Requirejs代码或在加载后立即调用模块的方法。因此，我最终编写了一些代码来临时覆盖

require

和

declare

方法。它适用于我的用例，但如果其他人需要它，可能需要更改。我相信它可以比现在更优化，但它是有效的

您可以找到代码，我将尝试维护它

此时的代码如下所示：

(function () {
    var self = {},
        originalDefine = window.define,
        originalRequire = window.require,
        modules = [];

    var define = function (id, deps, fn) {
        if (id !== 'requireLib' && id !== 'text') {
            modules.push({"id": id, "deps": deps, "fn": fn});
        }
    };



    var require = function (deps, fn) {
        var sortedModules = [],
            unsortedModules = [],
            resolvedDeps = {},
            maxAttempts = 1000,
            module,
            dep,
            depList,
            canAdd,
            i,
            j;

        unsortedModules = ([]).concat(modules);
        while (unsortedModules.length > 0 && --maxAttempts > 0) {

            for (i = unsortedModules.length - 1; i >= 0; i--) {
                canAdd = true;
                module = unsortedModules[i];

                for (j = 0; j < module.deps.length; j++) {
                    dep = module.deps[j];
                    if (resolvedDeps[dep] === undefined) {
                        canAdd = false;
                        break;
                    }
                }
                if (canAdd) {
                    resolvedDeps[module.id] = module;
                    sortedModules.push(unsortedModules.splice(i,1)[0]);
                }
            }
        }

        for (i = 0; i < sortedModules.length; i++) {
            module = sortedModules[i];
            depList = [];
            for (j = 0; j < module.deps.length; j++) {
                depList.push(resolvedDeps[module.deps[j]]);
            }
            resolvedDeps[module.id] = module.fn.apply(this, depList);
        }

        depList = [];
        for (i = 0; i < deps.length; i++) {
            depList.push(resolvedDeps[deps[i]]);
        }

        fn.apply(this, depList);

        window.define = originalDefine || function () {};
        window.require = originalRequire || function () {};
    };

    window.define = define;
    window.require = require;
    window.require.config = function() {};

    return self;
} ());

（函数（）{
var self={}，
originalDefine=window.define，
originalRequire=window.require，
模块=[]；
变量定义=函数（id、deps、fn）{
if（id！=“requireLib”&&id！=“text”）{
push（{“id”：id，“deps”：deps，“fn”：fn}）；
}
};
var require=功能（deps，fn）{
变量sortedModules=[]，
未排序的模块=[]，
resolvedDeps={}，
最大尝试次数=1000次，
模块，
副署长，
部门名单，
卡纳德，
我
J
未排序的模块=（[]）.concat（模块）；
while（unsortedModules.length>0&--maxtures>0）{
对于（i=unsortedModules.length-1；i>=0；i--）{
canAdd=正确；
模块=未排序的模块[i]；
对于（j=0；j