1

我有一个已优化为单个文件的 requirejs 项目，我正在同步加载该文件。代码按预期加载，但模块仍在异步加载（它们直到加载过程的后期才可用）并且它导致一些我希望它可以使用的遗留代码出现问题。

鉴于下面的代码，有没有办法让main-build' 方法在加载后立即可用，在加载之前legacy_code.js？

<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()and版本require()（这也将释放大量带宽，因为它需要做的就是编目和调用模块），但我希望有一个内置的方法去做这个。

4

2 回答 2

1

在这里回答我自己的问题。看了很久，我看不到任何同步加载Requirejs代码或加载后立即调用模块的方法。所以我最终写了一些代码来临时覆盖require和declare方法。它适用于我的用例，但如果其他人需要它可能需要更改。我确信它可以比现在进行更多优化，但它确实有效。

你可以在 GitHub 上找到代码，我会尽力维护。

此时的代码如下所示：

(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;
} ());
于 2012-08-29T16:13:26.580 回答
0

做到这一点的最简单方法，无需重写define()and require()，肯定只是将您的旧代码包装在 AMD 中，并将您的main-build.js模块定义指定为依赖项。

我知道这在技术上不是“同步的”，但它应该可以实现您正在寻找的东西 - 遗留代码仅在加载了 require 模块后才被调用。

于 2012-08-25T11:33:01.133 回答