Javascript 在Durandal viewmodel中返回函数和返回对象之间有什么区别？

我正在研究在我的应用程序中实现一个向导类型的系统，并研究GitHub上DFIDLE-2.0项目的第一个向导示例。step VIEWMODEL都是函数，我试图理解为什么

以下是DFIDLE用于向导的index.js的内容：

define(['durandal/activator', './step1', './step2', './step3', 'knockout'], function( activator, Step1, Step2, Step3, ko ) {

    var steps = [new Step1(), new Step2(), new Step3()];
    var step = ko.observable(0);
    var activeStep = activator.create();
    var stepsLength = steps.length;

    var hasPrevious = ko.computed(function() {
        return step() > 0;
    });

    var hasNext = ko.computed(function() {
        return (step() < stepsLength - 1);
    });

    // Start with first step
    activeStep(steps[step()]);

    return {
        showCodeUrl: true,
        steps: steps,
        step: step,
        activeStep: activeStep,
        next: next,
        previous: previous,
        hasPrevious: hasPrevious,
        hasNext: hasNext
    };

    function next () {
        if ( step() < stepsLength ) {
            step(step() + 1);
            activeStep(steps[step()]);
        }
    }

    function previous () {
        if ( step() > 0 ) {
            step(step() - 1);
            activeStep(steps[step()]);
        }
    }

});

下面是我目前用于index.js的内容

define(['knockout'],
    function (ko) {
        var rootPath = "viewmodels/wizards/steps/";
        var steps = ["step1", "step2", "step3"];
        var step = ko.observable(0);
        var activeStep = ko.observable(); 
        var stepLength = steps.length;

        var hasPrevious = ko.computed(function () { return step() > 0 });
        var hasNext = ko.computed(function () { return step() < stepLength - 1 });

        var activate = function () {
            return activeStep(rootPath + steps[step()]);
        };

        return {
            steps: steps,
            step: step,
            activeStep: activeStep,
            next: next,
            previous: previous,
            hasPrevious: hasPrevious,
            hasNext: hasNext,
            activate: activate
        }

        function next() {
            if (hasNext()) {
                step(step() + 1);
                activeStep(rootPath + steps[step()]);
            }
        }

        function previous() {
            if (hasPrevious()) {
                step(step() - 1);
                activeStep(rootPath + steps[step()]);
            }
        }
    });

---

绑定是相同的，那么这两种方法有何不同呢？如果只返回一个对象而不使用函数，我会损失什么？

差别很微妙，但很重要。返回对象的模块是单例的。同一对象将在依赖它的所有其他模块之间共享。返回函数的模块称为构造函数。从属模块将使用

new

关键字实例化此构造函数。因此，每个实例都是唯一的

以下是从以下网站收集的更多信息：

模块的

define

仅在第一次需要模块时执行一次。因此，如果您返回一个对象实例，那么您已经创建了一个单例，它将在应用程序的生命周期中一直保留在内存中。如果不希望这样做，则返回构造函数，允许使用者根据需要创建/释放对象，从而更好地控制对象的生命周期

在你的例子中，你没有失去任何东西。这两种方法都有效。哪个更正确取决于很多事情。如果您不需要每次都需要模块的唯一实例，那么单例是最佳选择。但是，如果您需要同一对话框模块的多个实例，但每个实例都有自己的数据，则可以使用构造函数

---

我希望这能有所帮助。

区别很微妙，但很重要。返回对象的模块是单例的。同一对象将在依赖它的所有其他模块之间共享。返回函数的模块称为构造函数。从属模块将使用

new

关键字实例化此构造函数。因此，每个实例都是唯一的

以下是从以下网站收集的更多信息：

模块的

define

仅在第一次需要模块时执行一次。因此，如果您返回一个对象实例，那么您已经创建了一个单例，它将在应用程序的生命周期中一直保留在内存中。如果不希望这样做，则返回构造函数，允许使用者根据需要创建/释放对象，从而更好地控制对象的生命周期

在你的例子中，你没有失去任何东西。这两种方法都有效。哪个更正确取决于很多事情。如果您不需要每次都需要模块的唯一实例，那么单例是最佳选择。但是，如果您需要同一对话框模块的多个实例，但每个实例都有自己的数据，则可以使用构造函数

我希望这有帮助

define(['knockout'],
    function (ko) {
        var rootPath = "viewmodels/wizards/steps/";
        var steps = ["step1", "step2", "step3"];
        var step = ko.observable(0);
        var activeStep = ko.observable(); 
        var stepLength = steps.length;

        var hasPrevious = ko.computed(function () { return step() > 0 });
        var hasNext = ko.computed(function () { return step() < stepLength - 1 });

        var activate = function () {
            return activeStep(rootPath + steps[step()]);
        };

        return {
            steps: steps,
            step: step,
            activeStep: activeStep,
            next: next,
            previous: previous,
            hasPrevious: hasPrevious,
            hasNext: hasNext,
            activate: activate
        }

        function next() {
            if (hasNext()) {
                step(step() + 1);
                activeStep(rootPath + steps[step()]);
            }
        }

        function previous() {
            if (hasPrevious()) {
                step(step() - 1);
                activeStep(rootPath + steps[step()]);
            }
        }
    });

define(function () {
    var name = ko.observable("Step 1");
    var s1one = ko.observable("Unique to " + name());
    var s1two = ko.observable("Another property unique to " + name());
    var returnVm = {
        name: name,
        s1one: s1one,
        s1two: s1two
    };

    return returnVm;
});