角度服务与角度工厂


1065

我已经看到angular.factory()angular.service()都用于声明服务;但是,我在官方文档中找不到 angular.service任何地方。

两种方法有什么区别?
应该使用哪个(假设他们做不同的事情)?



4
我搜索了“ [angularjs]服务工厂”,但我也想起已经有一个关于它的问题(因为我曾经考虑过自己写这个问题)。
Mark Rajcok

2
在搜索中,方括号是否表示标签?
2013年

11
@Jacob方括号正在缩小搜索范围。[angularjs]指令-将搜索“指令”以查找已经用angularjs标记的问题。
Mahbub 2013年

1
@Mahbub换句话说,“是” :)
Brian

Answers:


1268
  angular.service('myService', myServiceFunction);
  angular.factory('myFactory', myFactoryFunction);

直到我以这种方式将自己介绍给自己时,我还是难以解决这个问题:

服务:您编写的函数将是新的 -ed:

  myInjectedService  <----  new myServiceFunction()

Factory:将调用您编写的函数(构造函数):

  myInjectedFactory  <---  myFactoryFunction()

您可以根据自己的意愿进行操作,但是有一些有用的模式...

例如编写服务函数以公开公共API:

function myServiceFunction() {
  this.awesomeApi = function(optional) {
    // calculate some stuff
    return awesomeListOfValues;
  }
}
---------------------------------------------------------------------------------
// Injected in your controller
$scope.awesome = myInjectedService.awesomeApi();

或使用工厂函数公开公共API:

function myFactoryFunction() {
  var aPrivateVariable = "yay";

  function hello() {
    return "hello mars " + aPrivateVariable;
  }

  // expose a public API
  return {
    hello: hello
  };
}
---------------------------------------------------------------------------------
// Injected in your controller
$scope.hello = myInjectedFactory.hello();

或使用工厂函数返回构造函数:

function myFactoryFunction() {
    return function() {
        var a = 2;
        this.a2 = function() {
            return a*2;
        };
    };
}
---------------------------------------------------------------------------------
// Injected in your controller
var myShinyNewObject = new myInjectedFactory();
$scope.four = myShinyNewObject.a2();

使用哪一个?

两者都可以完成相同的事情。但是,在某些情况下,工厂为您提供了一些灵活性,可以使用更简单的语法创建可注射的对象。这是因为myInjectedService必须始终是对象,而myInjectedFactory可以是对象,函数引用或任何值。例如,如果您编写了一个用于创建构造函数的服务(如上面的上一个示例中所示),则必须将其实例化为:

var myShinyNewObject = new myInjectedService.myFunction()

可以说这是不那么理想的:

var myShinyNewObject = new myInjectedFactory();

(但是您首先应该警惕使用这种类型的模式,因为控制器中的对象会创建难以跟踪的依赖关系,而这些依赖关系很难模拟以进行测试。最好让服务来管理用于以下目的的对象集合你比new()狡猾地使用。)


还有一件事,他们都是辛格顿人...

还要记住,在两种情况下,角度都可以帮助您管理单例。无论您在何处或多少次注入服务或功能,都将获得对相同对象或功能的相同引用。(除了工厂何时仅返回数字或字符串之类的值。在这种情况下,您将始终获得相同的值,而不是引用。)


2
称它为对象构造函数比使用Newable更好吗?
markyzm 2014年

2
@Hugo,我演示的是您可以同时有效地完成相同的事情,只是语法会有所不同。
吉尔·伯曼

105
我不确定在确定服役和工厂之间的区别之前,我必须阅读多少次才能知道它们之间的区别
DMac the Destroyer 2014年

10
我们已经有一个动词说“ to new”,它是“ instantiate”。仅供参考。:)
sscarduzio

7
工厂是被调用的函数,因此它们可以返回任何内容。另一方面,服务是通过angular via实例化的new fn(),因此它们必须返回一个实例。
吉尔·伯曼 Gil Birman)2015年

318

简单的说 ..

// Service
service = (a, b) => {
  a.lastName = b;
  return a;
};

// Factory
factory = (a, b) => Object.assign({}, a, { lastName: b });

const fullName = { firstName: 'john' };

// Service
const lastNameService = (a, b) => {
  a.lastName = b;
  return a;
};
console.log(lastNameService(fullName, 'doe'));

// Factory
const lastNameFactory = (a, b) => 
  Object.assign({}, a, { lastName: b })
console.log(lastNameFactory(fullName, 'doe'));


169
杜德,谢谢。并非其他答案的详细信息无效,但有时您需要10秒版本。
R Claven 2014年

4
只是让服务函数什么都不返回。该this.name = ...就足以显示其暴露的API。
pixelbits 2014年

3
但是,如果您确实返回并反对,它将使用它代替它。jsfiddle.net/Ne5P8/1221
MrB 2014年

@MrB,这是正常的JavaScript功能,并非特定于Angular或此问题的上下文。
Om Shankar 2014年

@Om Shankar,上面的答案表明,区别在于此对象与返回对象的使用。我向我展示了“ THIS”是将与服务一起使用的默认值,但是,如果您返回一个值,它将几乎像工厂一样工作。但是,另一方面,工厂似乎要求返回值,否则会发生错误-(在此示例中显示-jsfiddle.net/hmoc0q3v/1)。
MrB 2014年

247

主要区别如下:

服务

句法: module.service( 'serviceName', function );

结果:将serviceName声明为可注入参数时,将为您提供传递给的函数实例module.service

用法:对于共享实用程序功能很有用( ),这些功能只需添加到注入的函数引用中即可调用。也可以与injectedArg.call( this )类似。

工厂工厂

句法: module.factory( 'factoryName', function );

结果:在将factoryName声明为可注入参数时,将为您提供通过调用传递给函数引用的函数返回module.factory

用法:对于返回“类”可能很有用函数然后可以对其进行新的创建实例。

这是使用services和factory的示例。阅读有关AngularJS Service vs Factory的更多信息

您也可以查看AngularJS文档以及关于stackoverflow的关于服务与工厂的困惑的类似问题。


27
我不同意您使用工厂的示例。服务和工厂(假设返回了一个函数。它可能只是一个值或一个对象)都可以被更新。实际上,由于为您提供了函数实例,因此服务是唯一可以保证是新的选项。我要说的是,在服务上使用FACTORY的好处是,它允许对属性的访问进行一些控制-私有和公共本身,而服务的所有属性本质上都是公开的。而且我将提供者视为工厂的工厂-只有它可以在配置时注入和配置。
Drew R

1
@DrewR感谢您的评论,我找到了使用工厂的公共和私有方法的一个很好的例子:stackoverflow.com/a/14904891/65025
edzillion 2013年

实际上,我必须在这一方面同意@DrewR。我以前曾经使用过工厂来返回对象,但是老实说,这时值得一直使用$providers
jedd.ahyoung 2014年

服务是自动实例化构造函数的,对吗?
Martian2049 '16

1
@DrewR-从我的理解来看,您的确可以通过服务获得与工厂一样的新效果,但这并不是它的目的。它的主要目的是当您只想返回一些实用程序对象并为此提供了更合适的语法时-您只需this.myFunc = function(){}在服务中编写代码即可(避免像编写工厂代码那样编写代码来创建对象) )。
BornToCode

137

TL; DR

1)使用工厂时,请创建一个对象,向其添加属性,然后返回该对象。当您将此工厂传递到控制器中时,对象上的那些属性现在将通过您的工厂在该控制器中可用。

app.controller('myFactoryCtrl', function($scope, myFactory){
  $scope.artist = myFactory.getArtist();
});

app.factory('myFactory', function(){
  var _artist = 'Shakira';
  var service = {};

  service.getArtist = function(){
    return _artist;
  }

  return service;
});


2)当您使用Service时,Angular 使用'new'关键字在后台实例化它。因此,您将向'this'添加属性,服务将返回'this'。当您将服务传递到控制器中时,“ this”上的那些属性现在将通过您的服务在该控制器上可用。

app.controller('myServiceCtrl', function($scope, myService){
  $scope.artist = myService.getArtist();
});

app.service('myService', function(){
  var _artist = 'Nelly';
  this.getArtist = function(){
    return _artist;
  }
});



非TL; DR

1)工厂
工厂是创建和配置服务的最流行方法。实际上,TL; DR所说的不多。您只需创建一个对象,向其添加属性,然后返回该对象即可。然后,当您将工厂传递到控制器中时,对象上的那些属性现在将通过工厂在该控制器中可用。下面是一个更广泛的示例。

app.factory('myFactory', function(){
  var service = {};
  return service;
});

现在,当我们将“ myFactory”传递到控制器中时,我们附加到“服务”的任何属性都将可用。

现在,让我们在回调函数中添加一些“私有”变量。无法从控制器直接访问这些变量,但是我们最终将在“服务”上设置一些getter / setter方法,以便能够在需要时更改这些“私有”变量。

app.factory('myFactory', function($http, $q){
  var service = {};
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
   _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK';
    return _finalUrl
  }

  return service;
});

在这里,您会注意到我们没有将这些变量/功能附加到“服务”上。我们只是创建它们,以便以后使用或修改它们。

  • baseUrl是iTunes API所需的基本URL
  • _artist是我们要查找的艺术家
  • _finalUrl是我们将呼叫iTunes的最终且完全构建的URL,makeUrl是可创建并返回iTunes友好URL的函数。

现在我们的帮助器/私有变量和函数已经到位,让我们向“服务”对象添加一些属性。无论我们使用什么“服务”,我们都可以在传递“ myFactory”的任何控制器中直接使用。

我们将创建仅返回或设置艺术家的setArtist和getArtist方法。我们还将创建一个方法,该方法将使用创建的URL调用iTunes API。此方法将返回一个诺言,一旦数据从iTunes API返回,诺言就会实现。如果您在Angular中没有太多使用诺言的经验,我强烈建议您对它们进行深入研究。

setArtist下方,接受一位艺术家,并允许您设置该艺术家。getArtist返回艺术家callItunes首先调用makeUrl(),以构建我们将用于$ http请求的URL。然后,它设置一个Promise对象,使用最终的URL发出$ http请求,然后由于$ http返回Promise,我们可以在请求后调用.success或.error。然后,我们用iTunes数据解决诺言,或者通过显示“出现错误”的消息来拒绝诺言。

app.factory('myFactory', function($http, $q){
  var service = {};
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }

  service.setArtist = function(artist){
    _artist = artist;
  }

  service.getArtist = function(){
    return _artist;
  }

  service.callItunes = function(){
    makeUrl();
    var deferred = $q.defer();
    $http({
      method: 'JSONP',
      url: _finalUrl
    }).success(function(data){
      deferred.resolve(data);
    }).error(function(){
      deferred.reject('There was an error')
    })
    return deferred.promise;
  }

  return service;
});

现在我们的工厂完成了。现在,我们可以将“ myFactory”注入到任何控制器中,然后可以调用附加到服务对象(setArtist,getArtist和callItunes)的方法。

app.controller('myFactoryCtrl', function($scope, myFactory){
  $scope.data = {};
  $scope.updateArtist = function(){
    myFactory.setArtist($scope.data.artist);
  };

  $scope.submitArtist = function(){
    myFactory.callItunes()
      .then(function(data){
        $scope.data.artistData = data;
      }, function(data){
        alert(data);
      })
  }
});

在上面的控制器中,我们正在注入“ myFactory”服务。然后,在$ scope对象上设置来自“ myFactory”数据的属性。上面唯一棘手的代码是,如果您以前从未处理过诺言。由于callItunes正在返回承诺,因此我们可以使用.then()方法,并且仅在iTunes数据满足承诺后,才设置$ scope.data.artistData。您会注意到我们的控制器非常“薄”。我们所有的逻辑和持久数据都位于我们的服务中,而不是我们的控制器中。

2)服务
也许在创建服务时要知道的最大事情就是使用“ new”关键字实例化了它。对于您的JavaScript专家来说,这应该为您提供代码本质的一个重要提示。对于那些在JavaScript中具有有限背景的人或不太熟悉'new'关键字实际功能的人,让我们回顾一些JavaScript基础知识,这些基础知识最终将帮助我们理解服务的性质。

为了真正看到使用'new'关键字调用函数时发生的更改,让我们创建一个函数并使用'new'关键字调用它,然后让我们展示当解释器看到'new'关键字时所做的事情。最终结果将是相同的。

首先,让我们创建构造函数。

var Person = function(name, age){
  this.name = name;
  this.age = age;
}

这是典型的JavaScript构造函数。现在,每当我们使用“ new”关键字调用Person函数时,“ this”都将绑定到新创建的对象。

现在,让我们在Person的原型上添加一个方法,以便该方法在Person的“类”的每个实例上可用。

Person.prototype.sayName = function(){
  alert('My name is ' + this.name);
}

现在,因为我们将sayName函数放在原型上,所以Person的每个实例都将能够调用sayName函数,以警告该实例的名称。

现在,我们在其原型上具有Person构造函数和sayName函数,让我们实际创建Person的实例,然后调用sayName函数。

var tyler = new Person('Tyler', 23);
tyler.sayName(); //alerts 'My name is Tyler'

因此,所有用于创建Person构造函数,向其原型添加函数,创建Person实例,然后在其原型上调用该函数的代码看起来都像这样。

var Person = function(name, age){
  this.name = name;
  this.age = age;
}
Person.prototype.sayName = function(){
  alert('My name is ' + this.name);
}
var tyler = new Person('Tyler', 23);
tyler.sayName(); //alerts 'My name is Tyler'

现在,让我们看看在JavaScript中使用'new'关键字时实际发生的情况。您应该注意的第一件事是,在我们的示例中使用了“ new”之后,我们就可以像对待对象一样在“ tyler”上调用方法(sayName),这是因为。所以首先,我们知道我们的Person构造函数正在返回一个对象,无论是否可以在代码中看到它。第二,我们知道,因为我们的sayName函数位于原型上,而不是直接位于Person实例上,所以Person函数返回的对象必须在失败的查找时委派给其原型。用更简单的术语来说,当我们调用tyler.sayName()时,解释器会说“确定,我将查看刚刚创建的'tyler'对象,找到sayName函数,然后对其进行调用。请稍等,我在这里看不到-我只看到名字和年龄,让我检查一下原型。是的,看起来像是在原型上,让我称呼它。”

下面的代码说明了如何思考'new'关键字在JavaScript中的实际作用。这基本上是上一段的代码示例。我已经将“解释器视图”或解释器在便笺内看到代码的方式放入了。

var Person = function(name, age){
  //The line below this creates an obj object that will delegate to the person's prototype on failed lookups.
  //var obj = Object.create(Person.prototype);

  //The line directly below this sets 'this' to the newly created object
  //this = obj;

  this.name = name;
  this.age = age;

  //return this;
}

了解了“ new”关键字在JavaScript中的实际作用后,在Angular中创建Service应该更容易理解。

创建服务时要了解的最大事情是知道服务已使用'new'关键字实例化。将这些知识与上面的示例相结合,您现在应该认识到,您将把属性和方法直接附加到“ this”,然后将从服务本身返回该属性和方法。让我们看看实际情况。

与我们最初对Factory示例所做的不同,我们不需要创建对象然后返回该对象,因为就像之前多次提到的那样,我们使用了'new'关键字,因此解释器将创建该对象并将其委托给它是原型,然后无需我们进行工作即可将其退还给我们。

首先,让我们创建我们的“私有”和帮助函数。这应该看起来非常熟悉,因为我们对工厂进行了完全相同的操作。我不会在这里解释每一行的功能,因为我在工厂示例中做了此操作,如果您感到困惑,请重新阅读工厂示例。

app.service('myService', function($http, $q){
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }
});

现在,我们将在控制器中可用的所有方法附加到“ this”。

app.service('myService', function($http, $q){
  var baseUrl = 'https://itunes.apple.com/search?term=';
  var _artist = '';
  var _finalUrl = '';

  var makeUrl = function(){
    _artist = _artist.split(' ').join('+');
    _finalUrl = baseUrl + _artist + '&callback=JSON_CALLBACK'
    return _finalUrl;
  }

  this.setArtist = function(artist){
    _artist = artist;
  }

  this.getArtist = function(){
    return _artist;
  }

  this.callItunes = function(){
    makeUrl();
    var deferred = $q.defer();
    $http({
      method: 'JSONP',
      url: _finalUrl
    }).success(function(data){
      deferred.resolve(data);
    }).error(function(){
      deferred.reject('There was an error')
    })
    return deferred.promise;
  }

});

现在就像在我们的工厂中一样,无论我们将myService传递给哪个控制器,都可以使用setArtist,getArtist和callItunes。这是myService控制器(与我们的工厂控制器几乎完全相同)。

app.controller('myServiceCtrl', function($scope, myService){
  $scope.data = {};
  $scope.updateArtist = function(){
    myService.setArtist($scope.data.artist);
  };

  $scope.submitArtist = function(){
    myService.callItunes()
      .then(function(data){
        $scope.data.artistData = data;
      }, function(data){
        alert(data);
      })
  }
});

就像我之前提到的,一旦您真正了解了“新”功能,服务就几乎与Angular中的工厂相同。


12
您可能需要直接提供指向博客的链接。tylermcginnis.com/angularjs-factory-vs-service-vs-provider我发现它更容易阅读。
Tyler Collier 2014年

3
在这里重复您的博客没什么错,但是我同意那是一篇很烂的博客文章。
R Claven 2014年

5
对每个人在幕后所做的事情进行了详细的详细说明,但仍然不清楚为什么以及何时选择在工厂使用服务。换句话说,相对于工厂返回的对象,我什么时候更喜欢使用更新的对象。我认为这是最大的困惑。
demisx

2
基本上,如果您想创建到远程服务的持久连接,例如示例中提到的具有恒定连接(连接状态,调用历史记录,数据存储)的iTunes API,则可以使用Factory。如果将其实现为服务,那么每次您希望从API中获得某些东西时,您都将重新创建连接,并且实际上无法在其中存储任何内容。因为每次重新创建服务时,都会得到一个空白/默认对象。
Meki 2014年

4
我认为这是不对的,@ Aznim。就像其他人所说的,两者都提供单例。
加密病毒2015年

35

线索就是名字

服务和工厂彼此相似。两者都会产生一个单例对象,可以将其注入其他对象,因此经常互换使用。

它们旨在在语义上用于实现不同的设计模式。

服务是用于实现服务模式的

服务模式是一种将应用程序分解为逻辑上一致的功能单元的模式。一个示例可能是API访问器或一组业务逻辑。

这在Angular中尤其重要,因为Angular模型通常只是从服务器提取的JSON对象,因此我们需要放置业务逻辑的地方。

例如,这是一个Github服务。它知道如何与Github交谈。它知道URL和方法。我们可以将其注入到控制器中,它将生成并返回承诺。

(function() {
  var base = "https://api.github.com";

  angular.module('github', [])
    .service('githubService', function( $http ) {
      this.getEvents: function() {
        var url = [
          base,
          '/events',
          '?callback=JSON_CALLBACK'
        ].join('');
        return $http.jsonp(url);
      }
    });
  )();

工厂实施工厂模式

另一方面,工厂旨在实现工厂模式。一种工厂模式,其中我们使用工厂函数来生成对象。通常,我们可能会使用它来构建模型。这是一个返回Author构造函数的工厂:

angular.module('user', [])
  .factory('User', function($resource) {
    var url = 'http://simple-api.herokuapp.com/api/v1/authors/:id'
    return $resource(url);
  })

我们将这样使用:

angular.module('app', ['user'])
  .controller('authorController', function($scope, User) {
    $scope.user = new User();
  })

请注意,工厂也会返回单例。

工厂可以返回构造函数

因为工厂只是返回一个对象,所以它可以返回您喜欢的任何类型的对象,包括构造函数,如上所述。

工厂返回一个对象;服务是新的

另一个技术差异是服务和工厂的组成方式。服务功能将被更新以生成对象。工厂函数将被调用并返回对象。

  • 服务是可更新的构造函数。
  • 工厂被简单地调用并返回一个对象。

这意味着在服务中,我们将附加“ this”,在构造函数的上下文中,它将指向正在构造的对象。

为了说明这一点,下面是使用服务和工厂创建的相同简单对象:

angular.module('app', [])
  .service('helloService', function() {
    this.sayHello = function() {
      return "Hello!";
    }
  })
  .factory('helloFactory', function() {
    return {
      sayHello: function() {
        return "Hello!";
      }
    }
  });

2
很好的解释,谢谢!在工厂样本代码中也有一种类型,Author喷油器参数应该是Person
mikhail-t 2015年

谢谢@ mik-T,我修复了错字。
superluminary 2015年

1
您对服务模式的使用不正确-这应该是工厂。如果调用.factory()而不是.service(),则会看到它的工作原理完全相同。服务模式应提供给构造函数,而不是返回新对象的函数。Angular(有效地)在构造函数上调用“ new”。服务起作用的唯一原因是,如果在返回对象的构造函数上调用“ new”,则实际上是取回了返回的对象,而不是构造的对象。而且工厂可以用来创建您想要的任何东西,而不仅仅是模型。
丹·金

27

这里的所有答案似乎都与服务和工厂有关,这是有效的,因为这就是要问的问题。但请务必记住,还有其他一些内容provider(),包括value(),和constant()

要记住的关键是每个都是另一个的特例。链中的每个特例都使您可以用更少的代码来做相同的事情。每个人也有一些其他限制。

要决定何时使用哪种,您只需看一下哪一个就可以用更少的代码来完成所需的工作。这是一张图片,说明它们之间的相似程度:

在此处输入图片说明

有关逐步使用的详细信息和使用时间的快速参考,可以访问我从以下位置获得此图片的博客文章:

http://www.simplygoodcode.com/2015/11/the-difference-between-service-provider-and-factory-in-angularjs/


3
@jacob可能是这样,但我认为不仅要何时使用它们,而且它们本质上都是同一事物的变体的整体概念很重要。
路易斯·佩雷斯

1
@LuisPerez指向您博客的链接和解释其区别的视频非常棒。通过视频中的示例更容易理解:)
Alin Ciocan '16

24

app.factory('fn',fn)与app.service('fn',fn)

施工

对于工厂,Angular将调用该函数以获取结果。是缓存和注入的结果。

 //factory
 var obj = fn();
 return obj;

对于服务,Angular将通过调用new来调用构造函数。构造的函数被缓存并注入。

  //service
  var obj = new fn();
  return obj;

实作

工厂通常返回对象文字,因为返回值注入到控制器,运行块,指令等中的值

  app.factory('fn', function(){
         var foo = 0;
         var bar = 0;
         function setFoo(val) {
               foo = val;
         }
         function setBar (val){
               bar = val;
         }
         return {
                setFoo: setFoo,
                serBar: setBar
         }
  });

服务功能通常不返回任何内容。相反,它们执行初始化并公开功能。函数也可以引用“ this”,因为它是使用“ new”构造的。

app.service('fn', function () {
         var foo = 0;
         var bar = 0;
         this.setFoo = function (val) {
               foo = val;
         }
         this.setBar = function (val){
               bar = val;
         }
});

结论

在使用工厂或服务时,两者都非常相似。它们被注入到控制器,指令,运行块等中,并以几乎相同的方式用于客户端代码。它们也是单例-意味着在注入服务/工厂的所有位置之间共享同一实例。

那么,您应该选择哪个呢?任一种-它们是如此相似,以致差异微不足道。如果您确实选择了一个,请注意它们是如何构造的,以便可以正确实现它们。


服务函数不会“不返回任何内容”,而是在您未指定自己的return语句的情况下隐式返回构造的对象(在后一种情况下,返回的对象将被创建并缓存,类似于工厂)。
加密病毒2015年

我认为您会误解它...当我说return时,我的意思是从服务功能实现的角度来看
pixelbits 2015年

您确定工厂也是单一城镇吗?
Martian2049 '16

5

我花了一些时间试图找出区别。

我认为工厂函数使用模块模式,服务函数使用标准的Java脚本构造函数模式。


2

工厂模式更灵活,因为它可以返回函数,值以及对象。

服务模式恕我直言没有太多意义,因为它所做的一切都可以像在工厂一样轻松地完成。例外可能是:

  • 如果您出于某种原因关心实例化服务的声明类型-如果使用服务模式,则构造函数将是新服务的类型。
  • 如果您已经拥有要在其他地方使用的构造函数,那么您也希望将其用作服务(尽管如果您想向其中注入任何东西,可能用处不大!)。

可以说,服务模式是一个稍微创建从一个语法点的新对象更好的方式,但它也更昂贵实例化。其他人已经指出,angular使用“ new”来创建服务,但这并不是真的-它无法做到这一点,因为每个服务构造函数都有不同数量的参数。angular的实际作用是在内部使用工厂模式来包装构造函数。然后,它会执行一些巧妙的操作来模拟 javascript的“新”运算符,并使用可变数量的可注入参数来调用构造函数-但是,如果您直接使用工厂模式,则可以省去此步骤,从而大大提高了效率码。


服务比工厂更有效地构建,因为工厂使用相对昂贵的闭包,并且服务(类)可以利用原型。
jacob 2015年

@jacob不确定您对闭包的含义吗?工厂只是一个返回对象的函数。仅当返回的对象需要“私有”状态时,才需要使用闭包。如果使用构造函数(服务),您仍然必须做同样的事情。我把你约的原型,虽然点-尽管你可能还在这在工厂,如果你想。
丹·金

function MyFactory(dep1) { var $$foo = 'bar', factory = {}; Object.defineProperties(factory.prototype, { foo: { value: $$foo } }); return factory; } function MyService(dep1) { var $$foo = 'bar'; Object.defineProperties(MyService.prototype, { foo: { value: $$foo } }); } 虽然MyFactory和MyService都使用原型,但MyFactory仍然对构造返回的对象造成性能损失。在两个示例中,它们都具有私有属性,但是在MyService中,性能相对没有差异。
jacob

1
对我来说,区别在于我是否想直接使用工厂而不使用方法:MyFactory(someArgument)(ex $http())。对于服务,这是不可能的,因为您要引用构造函数:MyService(someArgument)
jacob

关于对象构造时间,我真的看不到factory = {}对性能有何影响,不止是JavaScript在调用构造函数时为您初始化“ this”?而且我认为,将构造函数包装在工厂中然后为了模拟“新”而不得不跳过箍圈时,更大的性能损失是在角度方面,这可以注入您的依赖项。
丹·金
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.