627

据我了解,在工厂内部时,我返回一个注入控制器的对象。在服务内部时,我正在使用this而不返回任何东西来处理对象。

我假设一个服务总是一个单例,并且一个新的工厂对象被注入到每个控制器中。然而,事实证明,工厂对象也是单例吗?

示例代码来演示:

var factories = angular.module('app.factories', []);
var app = angular.module('app',  ['ngResource', 'app.factories']);

factories.factory('User', function () {
  return {
    first: 'John',
    last: 'Doe'
  };
});

app.controller('ACtrl', function($scope, User) {
  $scope.user = User;
});

app.controller('BCtrl', function($scope, User) {
  $scope.user = User;
});

当改变user.firstinACtrl时,结果user.firstinBCtrl也改变了,例如User是一个单例?

我的假设是在带有工厂的控制器中注入了一个新实例?

4

20 回答 20

607

所有角度服务都是单例

文档(参见单例服务):https ://docs.angularjs.org/guide/services

最后,重要的是要认识到所有 Angular 服务都是应用程序单例。这意味着每个注入器只有一个给定服务的实例。

基本上服务和工厂的区别如下:

app.service('myService', function() {

  // service is just a constructor function
  // that will be called with 'new'

  this.sayHello = function(name) {
     return "Hi " + name + "!";
  };
});

app.factory('myFactory', function() {

  // factory returns an object
  // you can run some code before

  return {
    sayHello : function(name) {
      return "Hi " + name + "!";
    }
  }
});

查看有关 $provide 的演示文稿:http: //slides.wesalvaro.com/20121113/#/

这些幻灯片用于 AngularJs 聚会之一:http: //blog.angularjs.org/2012/11/more-angularjs-meetup-videos.html

于 2012-12-07T13:17:36.387 回答
385

对我来说,当我意识到它们都以相同的方式工作时,我得到了启示:运行一次,存储它们获得的值,然后在通过依赖注入引用时咳出相同的存储值。

假设我们有:

app.factory('a', fn);
app.service('b', fn);
app.provider('c', fn);

三者的区别在于:

  1. a的存储值来自 running fn,换句话说:fn()
  2. b的存储值来自newing fn,换句话说:new fn()
  3. c的存储值来自首先通过newing获取一个实例fn,然后运行$get该实例的一个方法

这意味着,在 angular 内部有一个类似于缓存对象的东西,每次注入的值只分配一次,当它们第一次被注入时,并且在哪里:

cache.a = fn()
cache.b = new fn()
cache.c = (new fn()).$get()

这就是我们this在服务中使用并在提供者中定义 a的原因this.$get

希望这可以帮助。

于 2014-11-14T06:32:17.777 回答
95

活生生的例子

“你好世界”的例子

factory/ service/ provider

var myApp = angular.module('myApp', []);
 
//service style, probably the simplest one
myApp.service('helloWorldFromService', function() {
    this.sayHello = function() {
        return "Hello, World!"
    };
});
 
//factory style, more involved but more sophisticated
myApp.factory('helloWorldFromFactory', function() {
    return {
        sayHello: function() {
            return "Hello, World!"
        }
    };
});
    
//provider style, full blown, configurable version     
myApp.provider('helloWorld', function() {
    // In the provider function, you cannot inject any
    // service or factory. This can only be done at the
    // "$get" method.
 
    this.name = 'Default';
 
    this.$get = function() {
        var name = this.name;
        return {
            sayHello: function() {
                return "Hello, " + name + "!"
            }
        }
    };
 
    this.setName = function(name) {
        this.name = name;
    };
});
 
//hey, we can configure a provider!            
myApp.config(function(helloWorldProvider){
    helloWorldProvider.setName('World');
});
        
 
function MyCtrl($scope, helloWorld, helloWorldFromFactory, helloWorldFromService) {
    
    $scope.hellos = [
        helloWorld.sayHello(),
        helloWorldFromFactory.sayHello(),
        helloWorldFromService.sayHello()];
}​
于 2013-10-28T13:50:19.593 回答
57

还有一种方法可以返回构造函数,这样您就可以在工厂中返回可更新的类,如下所示:

function MyObjectWithParam($rootScope, name) {
  this.$rootScope = $rootScope;
  this.name = name;
}
MyObjectWithParam.prototype.getText = function () {
  return this.name;
};

App.factory('MyObjectWithParam', function ($injector) {
  return function(name) { 
    return $injector.instantiate(MyObjectWithParam,{ name: name });
  };
}); 

因此,您可以在使用 MyObjectWithParam 的控制器中执行此操作:

var obj = new MyObjectWithParam("hello"),

请参阅此处的完整示例:
http ://plnkr.co/edit/GKnhIN?p=preview

这里是讨论它的谷歌组页面:
https ://groups.google.com/forum/#!msg/angular/56sdORWEoqg/b8hdPskxZXsJ

于 2013-04-09T14:39:47.723 回答
51

以下是主要区别:

服务

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

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

用法:对于共享实用函数很有用,只需将 () 附加到注入的函数引用即可调用。也可以运行injectedArg.call( this )或类似。

工厂

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

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

用法:对于返回一个“类”函数可能很有用,然后可以新建该函数以创建实例。

还要检查AngularJS 文档和关于 stackoverflow 的类似问题,对 service vs factory 感到困惑

这是使用 services 和 factory 的示例。阅读有关AngularJS 服务与工厂的更多信息。

于 2013-12-23T00:01:26.110 回答
27

除了第一个答案之外,我认为 .service() 适用于以更面向对象的风格(C#/Java)编写代码的人(使用 this 关键字并通过原型/构造函数实例化对象)。

Factory 适用于编写更自然的 javascript/函数式编码的代码的开发人员。

看一下 angular.js 中 .service 和 .factory 方法的源代码——在内部它们都调用了 provider 方法:

  function provider(name, provider_) {
    if (isFunction(provider_)) {
      provider_ = providerInjector.instantiate(provider_);
    }
    if (!provider_.$get) {
      throw Error('Provider ' + name + ' must define $get factory method.');
    }
    return providerCache[name + providerSuffix] = provider_;
  }

  function factory(name, factoryFn) { \
    return provider(name, { $get: factoryFn }); 
  }

  function service(name, constructor) {
    return factory(name, ['$injector', function($injector) {
      return $injector.instantiate(constructor);
    }]);
  }
于 2013-06-20T11:35:21.317 回答
25

很简单:

.service - 注册函数将作为构造函数调用(又名“newed”)

.factory - 注册函数将作为简单函数调用

两者都被调用一次,导致一个单例对象被注入到应用程序的其他组件中。

于 2014-11-25T14:17:41.737 回答
20

所有提供商的工作方式都相同。不同的方法service,,只是让你用更少的代码完成同样的事情。factoryprovider

PS 还有valueconstant

从开头到provider结尾的每个特殊情况value都有一个额外的限制。所以要在它们之间做出决定,你必须问自己,哪一个可以让你用更少的代码完成你想要的。

这是一张图片,向您展示了我的意思:

在此处输入图像描述

您可以在我从以下位置获得这张图片的博客文章中获得细分和参考指南:

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

于 2015-12-10T13:02:03.863 回答
13

“Factory” and “Service” are different ways of doing DI (Dependency injection) in angular.

So when we define DI using “service” as shown in the code below. This creates a new GLOBAL instance of the “Logger” object and injects it in to the function.

app.service("Logger", Logger); // Injects a global object

When you define DI using a “factory” it does not create a instance. It just passes the method and later the consumer internally has to make calls to the factory for object instances.

app.factory("Customerfactory", CreateCustomer);

Below is a simple image which shows visually how DI process for “Service” is different than “Factory”.

enter image description here

Factory should be used When we want to create different types of objects depending on scenarios. For example depending on scenario we want to create a simple “Customer” object , or “Customer” with “Address” object or “Customer” with “Phone” object. Here is a detailed explanation of this paragraph

Service should be used When we have utility or shared functions to be injected like Utility , Logger , Error handler etc.

于 2015-04-02T01:39:04.460 回答
13

这里有更多关于服务与工厂的示例,它们可能有助于了解它们之间的区别。基本上,一个服务调用了“new ...”,它已经被实例化了。工厂不会自动实例化。

基本示例

返回具有单个方法的类对象

这是一个具有单一方法的服务:

angular.service('Hello', function () {
  this.sayHello = function () { /* ... */ };
});

这是一个返回带有方法的对象的工厂:

angular.factory('ClassFactory', function () {
  return {
    sayHello: function () { /* ... */ }
  };
});

返回一个值

返回数字列表的工厂:

angular.factory('NumberListFactory', function () {
  return [1, 2, 3, 4, 5];
});

console.log(NumberListFactory);

返回数字列表的服务:

angular.service('NumberLister', function () {
  this.numbers = [1, 2, 3, 4, 5];
});

console.log(NumberLister.numbers);

两种情况下的输出都是相同的,即数字列表。

高级示例

使用工厂的“类”变量

在这个例子中,我们定义了一个 CounterFactory,它增加或减少一个计数器,您可以获取当前计数或获取已创建的 CounterFactory 对象的数量:

angular.factory('CounterFactory', function () {
  var number_of_counter_factories = 0; // class variable

  return function () {
    var count = 0; // instance variable
    number_of_counter_factories += 1; // increment the class variable

    // this method accesses the class variable
    this.getNumberOfCounterFactories = function () {
      return number_of_counter_factories;
    };

    this.inc = function () {
      count += 1;
    };
    this.dec = function () {
      count -= 1;
    };
    this.getCount = function () {
      return count;
    };
  }

})

我们使用CounterFactory来创建多个计数器。我们可以访问类变量来查看创建了多少计数器:

var people_counter;
var places_counter;

people_counter = new CounterFactory();
console.log('people', people_counter.getCount());
people_counter.inc();
console.log('people', people_counter.getCount());

console.log('counters', people_counter.getNumberOfCounterFactories());

places_counter = new CounterFactory();
console.log('places', places_counter.getCount());

console.log('counters', people_counter.getNumberOfCounterFactories());
console.log('counters', places_counter.getNumberOfCounterFactories());

这段代码的输出是:

people 0
people 1
counters 1
places 0
counters 2
counters 2
于 2014-07-29T07:56:13.240 回答
8

服务风格:(可能是最简单的一种)返回实际函数:对于共享实用函数很有用,这些实用函数只需将 () 附加到注入的函数引用即可调用。

AngularJS 中的服务是一个包含一组函数的单例 JavaScript 对象

var myModule = angular.module("myModule", []);

myModule.value  ("myValue"  , "12345");

function MyService(myValue) {
    this.doIt = function() {
        console.log("done: " + myValue;
    }
}

myModule.service("myService", MyService);
myModule.controller("MyController", function($scope, myService) {

    myService.doIt();

});

工厂风格:(更复杂但更复杂)返回函数的返回值:在 java 中实例化一个像 new Object() 这样的对象。

工厂是一个创造价值的功能。当服务、控制器等需要从工厂注入的值时,工厂会按需创建该值。一旦创建,该值就会被所有需要注入的服务、控制器等重用。

var myModule = angular.module("myModule", []);

myModule.value("numberValue", 999);

myModule.factory("myFactory", function(numberValue) {
    return "a value: " + numberValue;
})  
myModule.controller("MyController", function($scope, myFactory) {

    console.log(myFactory);

});

提供者风格:(完整的、可配置的版本)返回函数的 $get 函数的输出:可配置。

AngularJS 中的提供者是您可以创建的最灵活的工厂形式。您可以像使用服务或工厂一样向模块注册提供程序,但您使用 provider() 函数代替。

var myModule = angular.module("myModule", []);

myModule.provider("mySecondService", function() {
    var provider = {};
    var config   = { configParam : "default" };

    provider.doConfig = function(configParam) {
        config.configParam = configParam;
    }

    provider.$get = function() {
        var service = {};

        service.doService = function() {
            console.log("mySecondService: " + config.configParam);
        }

        return service;
    }

    return provider;
});

myModule.config( function( mySecondServiceProvider ) {
    mySecondServiceProvider.doConfig("new config param");
});

myModule.controller("MyController", function($scope, mySecondService) {

    $scope.whenButtonClicked = function() {
        mySecondService.doIt();
    }

});

src詹科夫

<!DOCTYPE html>
    <html ng-app="app">
    <head>
    	<script src="http://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.min.js"></script>
    	<meta charset=utf-8 />
    	<title>JS Bin</title>
    </head>
    <body ng-controller="MyCtrl">
    	{{serviceOutput}}
    	<br/><br/>
    	{{factoryOutput}}
    	<br/><br/>
    	{{providerOutput}}
    
    	<script>
    
    		var app = angular.module( 'app', [] );
    
    		var MyFunc = function() {
    
    			this.name = "default name";
    
    			this.$get = function() {
    				this.name = "new name"
    				return "Hello from MyFunc.$get(). this.name = " + this.name;
    			};
    
    			return "Hello from MyFunc(). this.name = " + this.name;
    		};
    
    		// returns the actual function
    		app.service( 'myService', MyFunc );
    
    		// returns the function's return value
    		app.factory( 'myFactory', MyFunc );
    
    		// returns the output of the function's $get function
    		app.provider( 'myProv', MyFunc );
    
    		function MyCtrl( $scope, myService, myFactory, myProv ) {
    
    			$scope.serviceOutput = "myService = " + myService;
    			$scope.factoryOutput = "myFactory = " + myFactory;
    			$scope.providerOutput = "myProvider = " + myProv;
    
    		}
    
    	</script>
    
    </body>
    </html>

jsbin

<!DOCTYPE html>
<html ng-app="myApp">
<head>
	<script src="http://cdnjs.cloudflare.com/ajax/libs/angular.js/1.0.1/angular.min.js"></script>
	<meta charset=utf-8 />
	<title>JS Bin</title>
</head>
<body>
<div ng-controller="MyCtrl">
    {{hellos}}
</div>
	<script>

	var myApp = angular.module('myApp', []);

//service style, probably the simplest one
myApp.service('helloWorldFromService', function() {
    this.sayHello = function() {
        return "Hello, World!"
    };
});

//factory style, more involved but more sophisticated
myApp.factory('helloWorldFromFactory', function() {
    return {
        sayHello: function() {
            return "Hello, World!"
        }
    };
});
    
//provider style, full blown, configurable version     
myApp.provider('helloWorld', function() {

    this.name = 'Default';

    this.$get = function() {
        var name = this.name;
        return {
            sayHello: function() {
                return "Hello, " + name + "!"
            }
        }
    };

    this.setName = function(name) {
        this.name = name;
    };
});

//hey, we can configure a provider!            
myApp.config(function(helloWorldProvider){
    helloWorldProvider.setName('World');
});
        

function MyCtrl($scope, helloWorld, helloWorldFromFactory, helloWorldFromService) {
    
    $scope.hellos = [
        helloWorld.sayHello(),
        helloWorldFromFactory.sayHello(),
        helloWorldFromService.sayHello()];
}
	</script>

</body>
</html>

jsfiddle

于 2015-12-17T00:06:25.133 回答
2

基本区别在于,提供者允许将原始(非对象)、数组或回调函数值设置到工厂声明的变量中,因此如果返回一个对象,则必须显式声明并返回它。

另一方面,服务只能用于将服务声明的变量设置为对象,因此我们可以避免对象的显式创建和返回,而另一方面它允许使用this关键字。

或者简而言之,“提供者是一种更通用的形式,而服务仅限于对象”。

于 2014-11-21T01:09:55.897 回答
2

这就是我在设计模式方面理解它们之间的区别的方式:

服务:返回一个类型,它将被更新以创建该类型的对象。如果使用 Java 类比,Service 返回一个Java 类定义

Factory:返回一个可以立即使用的具体对象。在 Java 类比中,工厂返回一个Java 对象

经常让人们(包括我自己)感到困惑的部分是,当您在代码中注入 Service 或 Factory 时,它们可以以相同的方式使用,在这两种情况下,您在代码中得到的是一个可以立即调用的具体对象。这意味着在服务的情况下,角度代表您在服务声明中调用“新”。我认为这是一个复杂的概念。

于 2016-01-22T22:59:00.780 回答
1

有关简短说明,请参阅https://stackoverflow.com/a/26924234/5811973

有关详细说明,请参阅https://stackoverflow.com/a/15666049/5811973

同样来自 angularJs 文档: 在此处输入图像描述

于 2017-06-30T11:50:55.803 回答
1

在 AngularJS 中有三种处理业务逻辑的方法:(受 Yaakov 的 Coursera AngularJS 课程启发)它们是:

  1. 服务
  2. 工厂
  3. 提供者

这里我们只讨论Service vs Factory

服务

句法:

应用程序.js

 var app = angular.module('ServiceExample',[]);
 var serviceExampleController =
              app.controller('ServiceExampleController', ServiceExampleController);
 var serviceExample = app.service('NameOfTheService', NameOfTheService);

 ServiceExampleController.$inject = ['NameOfTheService'] //very important as this protects from minification of js files

function ServiceExampleController(NameOfTheService){
     serviceExampleController = this;
     serviceExampleController.data = NameOfTheService.getSomeData();
 }

function NameOfTheService(){
     nameOfTheService = this;
     nameOfTheService.data = "Some Data";
     nameOfTheService.getSomeData = function(){
           return nameOfTheService.data;
     }     
}

索引.html

<div ng-controller = "ServiceExampleController as serviceExample">
   {{serviceExample.data}}
</div>

服务的主要特点:

  1. 惰性实例化:如果服务没有被注入,它将永远不会被实例化。因此,要使用它,您必须将其注入到模块中。

  2. Singleton:如果它被注入到多个模块中,那么所有模块都只能访问一个特定的实例。这就是为什么在不同的控制器之间共享数据非常方便。

工厂

现在让我们谈谈AngularJS中的工厂

首先让我们看一下语法

应用程序.js

var app = angular.module('FactoryExample',[]);
var factoryController = app.controller('FactoryController', FactoryController);
var factoryExampleOne = app.factory('NameOfTheFactoryOne', NameOfTheFactoryOne);
var factoryExampleTwo = app.factory('NameOfTheFactoryTwo', NameOfTheFactoryTwo);

//first implementation where it returns a function
function NameOfTheFactoryOne(){
   var factory = function(){
      return new SomeService();
    }
   return factory;
}

//second implementation where an object literal would be returned
function NameOfTheFactoryTwo(){
   var factory = {
      getSomeService : function(){
          return new SomeService();
       }
    };
   return factory;
}

现在在控制器中使用上述两个:

 var factoryOne = NameOfTheFactoryOne() //since it returns a function
 factoryOne.someMethod();

 var factoryTwo = NameOfTheFactoryTwo.getSomeService(); //accessing the object
 factoryTwo.someMethod();

工厂特点:

  1. 这种类型的服务遵循工厂设计模式。工厂可以被认为是创建新对象或方法的中心位置。

  2. 这不仅会产生单例,还会产生可定制的服务。

  3. .service()方法是一个始终生产相同类型服务的工厂,即单例。没有简单的方法来配置它的行为。该.service()方法通常用作不需要任何配置的快捷方式。

于 2017-02-27T19:23:04.320 回答
1

多亏了 Pascal Precht 的一篇博文,这帮助我理解了其中的区别。

服务是模块上的一种方法,它采用名称和定义服务的函数。您可以在其他组件(如控制器、指令和过滤器)中注入和使用该特定服务。工厂是模块上的一种方法,它还带有一个名称和一个函数,用于定义工厂。我们也可以像处理服务一样注入和使用它。

使用 new 创建的对象使用其构造函数的原型属性的值作为原型,因此我找到了调用 Object.create() 的 Angular 代码,我相信它是实例化时的服务构造函数。然而,工厂函数实际上只是一个被调用的函数,这就是为什么我们必须为工厂返回一个对象字面量。

这是我为工厂找到的 Angular 1.5 代码:

var needsRecurse = false;
    var destination = copyType(source);

    if (destination === undefined) {
      destination = isArray(source) ? [] : Object.create(getPrototypeOf(source));
      needsRecurse = true;
    }

factory() 函数的 Angular 源代码片段:

 function factory(name, factoryFn, enforce) {
    return provider(name, {
      $get: enforce !== false ? enforceReturnValue(name, factoryFn) : factoryFn
    });
  }

它接受名称和传递的工厂函数,并返回一个具有相同名称的提供者,它有一个 $get 方法,这是我们的工厂函数。每当您向注入器询问特定依赖项时,它基本上都会通过调用 $get() 方法向相应的提供者询问该服务的实例。这就是创建提供程序时需要 $get() 的原因。

这是用于服务的 Angular 1.5 代码。

function service(name, constructor) {
    return factory(name, ['$injector', function($injector) {
      return $injector.instantiate(constructor);
    }]);
  }

原来我们调用service()的时候,其实调用的是factory()!但是,它不只是将我们的服务构造函数按原样传递给工厂。它还传递了一个函数,该函数要求注入器通过给定的构造函数实例化一个对象。

换句话说,如果我们在某处注入 MyService,代码中会发生什么:

MyServiceProvider.$get(); // return the instance of the service

再次重申它,服务调用工厂,这是相应提供程序上的 $get() 方法。此外,$injector.instantiate() 是最终使用构造函数调用 Object.create() 的方法。这就是我们在服务中使用“this”的原因。

对于 ES5,我们使用哪个无关紧要:service() 或 factory(),它始终是一个被调用的工厂,它为我们的服务创建一个提供者。

你也可以对服务做同样的事情。服务是一个构造函数,但是,它不会阻止我们返回对象字面量。所以我们可以把我们的服务代码写成它基本上和我们的工厂做同样的事情,或者换句话说,你可以把服务写成工厂来返回一个对象。

为什么大多数人建议使用工厂而不是服务?这是我从 Pawel Kozlowski 的书:Mastering Web Application Development with AngularJS 中看到的最佳答案。

工厂方法是将对象放入 AngularJS 依赖注入系统的最常用方法。它非常灵活,可以包含复杂的创建逻辑。由于工厂是常规函数,我们还可以利用新的词法作用域来模拟“私有”变量。这非常有用,因为我们可以隐藏给定服务的实现细节。”

于 2016-07-01T18:01:53.830 回答
1
  • 使用工厂,您实际上在工厂内部创建了一个对象并将其返回。
  • 使用该服务,您只需一个使用关键字定义功能的标准功能。 this
  • 使用提供程序$get您可以定义一个,它可用于获取返回数据的对象。
于 2016-10-29T15:24:55.557 回答
1

我有一段时间感到困惑,我正在尽力在这里提供一个简单的解释。希望这会有所帮助!

angular .factory两者angular .service都用于初始化服务并以相同的方式工作。

唯一的区别是,您希望如何初始化您的服务。

两者都是单身人士


var app = angular.module('app', []);


工厂

app.factory( <service name>, <function with a return value>)

如果您想从您拥有的具有返回值的函数初始化您的服务,则必须使用此factory方法。

例如

function myService() {
  //return what you want
  var service = {
    myfunc: function (param) { /* do stuff */ }
  }
  return service;
}

app.factory('myService', myService);

注入此服务时(例如,注入您的控制器):

  • Angular 会调用你给定的函数(as myService())来返回对象
  • Singleton - 只调用一次,存储和传递同一个对象。


服务

app.service( <service name>, <constructor function>)

如果你想从构造函数初始化你的服务(使用this关键字),你必须使用这个service方法。

例如

function myService() {
  this.myfunc: function (param) { /* do stuff */ }
}

app.service('myService', myService);

注入此服务时(例如,注入您的控制器):

  • Angular 将new使用您给定的函数(as new myService())返回对象
  • Singleton - 只调用一次,存储和传递同一个对象。


注意:如果您使用factorywith<constructor function>servicewith <function with a return value>,它将不起作用。


示例 - 演示

于 2016-06-26T08:19:21.193 回答
1

This would be the best and short answer for understanding Service Vs Factory Vs Provider

Source: https://groups.google.com/forum/#!msg/angular/56sdORWEoqg/HuZsOsMvKv4J

Here what ben says with a demo http://jsbin.com/ohamub/1/edit?html,output

"There are comments in the code illustrating the primary differences but I will expand on them a bit here. As a note, I am just getting my head around this so if I say anything that is wrong please let me know.

Services

Syntax: module.service( 'serviceName', function );

Result: When declaring serviceName as an injectable argument you will be provided the actual function reference passed to module.service.

Usage: Could be useful for sharing utility functions that are useful to invoke by simply appending () to the injected function reference. Could also be run with injectedArg.call( this ) or similar.

Factories

Syntax: module.factory( 'factoryName', function );

Result: When declaring factoryName as an injectable argument you will be provided the value that is returned by invoking the function reference passed to module.factory.

Usage: Could be useful for returning a 'class' function that can then be new'ed to create instances.

Providers

Syntax: module.provider( 'providerName', function );

Result: When declaring providerName as an injectable argument you will be provided the value that is returned by invoking the $get method of the function reference passed to module.provider.

Usage: Could be useful for returning a 'class' function that can then be new'ed to create instances but that requires some sort of configuration before being injected. Perhaps useful for classes that are reusable across projects? Still kind of hazy on this one." Ben

于 2016-05-01T20:21:58.807 回答
0

您可以通过这个类比来理解差异 - 考虑将返回一些值的普通函数和将使用 new 关键字实例化的构造函数之间的区别。因此创建工厂类似于创建将返回一些值的普通函数(原始或一个对象),而创建服务就像创建构造函数(OO 类),我们可以使用 new 关键字创建实例。唯一需要注意的是,当我们使用 Service 方法创建服务时,它会使用 AngularJS 支持的依赖注入机制自动创建它的实例

于 2017-09-02T19:31:41.577 回答