javascript - javascript函数可以是一个类和另一个对象的实例吗？

Question

如果你看这段代码:

    function supportAggregate(Meanio) {

      Meanio.prototype.aggregated = function(ext, group, callback) {
        // Aggregated Data already exists and is ready
        if (Meanio.Singleton.config.clean.aggregate === false){
          return callback('');
        }
        if (aggregated[group][ext].data) return callback(aggregated[group][ext].data);

        // No aggregated data exists so we will build it
        sortAggregateAssetsByWeight();

        // Returning rebuild data. All from memory so no callback required
        callback(aggregated[group][ext].data);
      };

      Meanio.prototype.aggregatedsrc = function(ext, group, callback) {
        // Aggregated Data already exists and is ready
        if (Meanio.Singleton.config.clean.aggregate !== false){
          if(ext==='js'){
            if(group==='header'){
              return callback(['/modules/aggregated.js?group=header']);
            }else{
              return callback(['/modules/aggregated.js']);
            }
          }else if(ext==='css' && group==='header'){
            return callback(['/modules/aggregated.css']);
          }
          return callback([]);
        }
        if (aggregated[group][ext].src) return callback(aggregated[group][ext].src);

        // No aggregated data exists so we will build it
        sortAggregateAssetsByWeight();

        // Returning rebuild data. All from memory so no callback required
        callback(aggregated[group][ext].src);
      };

      // Allows rebuilding aggregated data
      Meanio.prototype.rebuildAggregated = function() {
        sortAggregateAssetsByWeight();
      };

      Meanio.prototype.Module.prototype.aggregateAsset = function(type, asset, options) {
        options = options || {};
        if (!options.inline && !options.absolute && !options.url) {
          asset = path.join(Meanio.modules[this.name].source, this.name, 'public/assets', type, asset);
        }
        Meanio.aggregate(type, asset, options, Meanio.Singleton.config.clean);
      };

      Meanio.onModulesFoundAggregate = function(ext, options) {
        var config = Meanio.Singleton.config.clean;
        var aggregator = new Aggregator(options, false, config);
        for (var name in Meanio.modules) {
          aggregator.readFiles(ext, path.join(process.cwd(), Meanio.modules[name].source, name.toLowerCase(), 'public'));
        }
      };

      Meanio.aggregate = function(ext, asset, options, config) {
        var aggregator;
        options = options || {};
        if (!asset) {
          return;
        }
        aggregator = new Aggregator(options, true, config);
        if (options.inline) return aggregator.addInlineCode(ext, asset);
        else if (options.url) return aggregator.getRemoteCode(ext, asset);
        else if (options.singlefile) return aggregator.processDirOfFile(ext, asset);
        else return aggregator.readFile(ext, path.join(process.cwd(), asset));
      };

      Meanio.prototype.aggregate = Meanio.aggregate;
    }

    module.exports = supportAggregate;

( https://github.com/linnovate/meanio/blob/master/lib/aggregation.js#L213 )

您可以看到为 Meanio 创建了两种类型的函数。另外，顺便说一句，您可以在此处查看它的实例化位置:https://github.com/linnovate/meanio/blob/master/lib/mean.js#L114

但我只是感到困惑。有时，Meanio 函数定义如下:

Meanio.prototype.myfunction = function() {}

有时它们是这样定义的:

Meanio.myfunction = function() {}

我只是不明白；尽管我有一种感觉，在某种程度上涉及依赖注入(inject)。

这怎么可能？对象如何既是类又是其自身的实例？

这段代码让我很困惑，如果有人能帮我解释一下，我将不胜感激。我不是要你深入研究代码，但如果你能给我一个大概的理解，那就太好了。

提前致谢!

Answer 1

How can an object be both a class and an instance of itself?

这不是这里发生的事情。传递给函数的对象是一个实例。

然而，该函数确实会修改您传递给它的实例以及该实例的类。

如果您创建同一个类的两个实例，并将其中一个传递给函数，则另一个实例不会被修改，但它们共有的类会被修改。示例:

function MyClass() {}

var a = new MyClass();
var b = new MyClass();

supportAggregate(a);

现在 a.rebuildAggregated 和 b.rebuildAggregated 都存在，因为它们已添加到类中。 a.onModulesFoundAggregate 存在是因为它已添加到实例中，但 b.onModulesFoundAggregate 不存在。

(注意:这个例子实际上不会工作，因为还有更多的事情要做。这个类必须有更多的属性来使用那个函数，这个例子只是为了展示添加到原型(prototype)的属性和到实例。)