解释

这里有不同的东西:

第一:

如果你使用一个服务，你将得到一个函数的实例("this") 关键字)。 如果您使用工厂，您将获得返回的值 调用函数引用(工厂中的return语句)。

裁判:角。Service vs angular.factory

第二:

记住，AngularJS中的所有提供者(value, constant, services, factories)都是单例的!

第三:

使用一种或另一种(服务或工厂)取决于代码风格。 但是，AngularJS中常用的方法是使用工厂。

为什么?

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

(参考:http://www.amazon.com/Mastering-Web-Application-Development-AngularJS/dp/1782161821)。

---

使用

Service:可以通过将()附加到注入的函数引用来共享有用的实用程序函数。也可以使用injectedArg.call(this)或类似的方法运行。

Factory:可能用于返回一个' class '函数，然后可以重新创建实例。

因此，当您的服务中有复杂的逻辑而又不想暴露这种复杂性时，请使用工厂。

在其他情况下，如果你想返回一个服务的实例，只需使用service。

但是随着时间的推移你会发现80%的情况下你会用到工厂。

详情请访问:http://blog.manishchhabra.com/2013/09/angularjs-service-vs-factory-with-example/

---

更新:

这里有很棒的帖子: http://iffycan.blogspot.com.ar/2013/05/angular-service-or-factory.html

如果你想让你的函数像普通函数一样被调用，请使用 工厂。如果你想要你的函数用new 接线员，使用服务。如果你不知道其中的区别，就用factory。”

---

更新:

AngularJS团队做了他的工作并给出了解释: http://docs.angularjs.org/guide/providers

从这一页开始:

“工厂和服务是最常用的食谱。它们之间唯一的区别是Service recipe更好地用于自定义类型的对象，而Factory可以生成JavaScript原语和函数。”

工厂和服务都产生了单例对象，这些对象可以由提供者配置，并注入到控制器和运行块中。从被注入者的角度来看，对象来自工厂还是来自服务绝对没有区别。

那么，什么时候使用工厂，什么时候使用服务?这可以归结为您的编码偏好，而不是其他。如果你喜欢模块化JS模式，那就选择工厂模式。如果你喜欢构造函数(“类”)风格，那么就选择服务。注意，这两种样式都支持私有成员。

从面向对象的角度来看，该服务的优势可能是它更直观:创建一个“类”，并与提供者一起跨模块重用相同的代码，并通过在配置块中向构造函数提供不同的参数来改变实例化对象的行为。

Allernhwkim最初发布了这个问题的答案，链接到他的博客上，但被版主删除了。这是我发现的唯一一篇文章，它不仅告诉你如何用服务、提供者和工厂做同样的事情，而且还告诉你用提供者可以做什么而用工厂不能做什么，用工厂不能做什么。

直接来自他的博客:

app.service('CarService', function() {
   this.dealer="Bad";
    this.numCylinder = 4;
});

app.factory('CarFactory', function() {
    return function(numCylinder) {
      this.dealer="Bad";
        this.numCylinder = numCylinder
    };
});

app.provider('CarProvider', function() {
    this.dealerName = 'Bad';
    this.$get = function() {
        return function(numCylinder) {
            this.numCylinder = numCylinder;
            this.dealer = this.dealerName;
        }
    };
    this.setDealerName = function(str) {
      this.dealerName = str;
    }      
});

这表明CarService总是生产4汽缸的汽车，你不能为单个汽车更改它。而CarFactory返回一个函数，所以你可以在你的控制器中做新的CarFactory，传递一些特定于那辆车的圆柱体。你不能创建新的CarService因为CarService是一个对象而不是一个函数。

工厂不这样运作的原因是:

app.factory('CarFactory', function(numCylinder) {
      this.dealer="Bad";
      this.numCylinder = numCylinder
});

并自动返回一个函数让你实例化，是因为你不能这样做(添加东西到原型/等):

app.factory('CarFactory', function() {
    function Car(numCylinder) {
        this.dealer="Bad";
        this.numCylinder = numCylinder
    };
    Car.prototype.breakCylinder = function() {
        this.numCylinder -= 1;
    };
    return Car;
});

看看它是如何字面上生产汽车的工厂。

他博客的结论很好:

In conclusion, --------------------------------------------------- | Provider| Singleton| Instantiable | Configurable| --------------------------------------------------- | Factory | Yes | Yes | No | --------------------------------------------------- | Service | Yes | No | No | --------------------------------------------------- | Provider| Yes | Yes | Yes | --------------------------------------------------- Use Service when you need just a simple object such as a Hash, for example {foo;1, bar:2} It’s easy to code, but you cannot instantiate it. Use Factory when you need to instantiate an object, i.e new Customer(), new Comment(), etc. Use Provider when you need to configure it. i.e. test url, QA url, production url.

如果你发现你只是在工厂中返回一个对象，你可能应该使用service。

不要这样做:

app.factory('CarFactory', function() {
    return {
        numCylinder: 4
    };
});

改用service:

app.service('CarService', function() {
    this.numCylinder = 4;
});

服务

语法:模块。service('serviceName'，函数); 结果:当将serviceName声明为可注入参数时，你将得到传递给module.service的实际函数引用。

使用方法:可以通过简单地将()附加到注入的函数引用来共享有用的实用程序函数。也可以用injectedArg运行。调用(这个)或类似的方法。

工厂

语法:模块。factory('factoryName'，函数);

结果:当将factoryName声明为一个可注入参数时，你将得到通过调用传递给module.factory的函数引用返回的值。

用法:可能用于返回一个'class'函数，然后可以重新创建实例。

供应商

语法:模块。provider('providerName'，函数);

结果:当将providerName声明为一个可注入参数时，您将获得通过调用传递给module.provider的函数引用的$get方法返回的值。

用途:可能用于返回一个'类'函数，然后可以重新创建实例，但在注入之前需要某种配置。也许对跨项目可重用的类有用?我还是不太清楚。

与服务相比，没有什么是工厂做不到或做得更好的。反之亦然。工厂似乎更受欢迎。这样做的原因是方便处理私人/公共成员。在这方面，服务将更加笨拙。 在编码Service时，你倾向于通过“this”关键字将对象成员设为public，然后可能突然发现那些public成员对于私有方法(即内部函数)是不可见的。

var Service = function(){

  //public
  this.age = 13;

  //private
  function getAge(){

    return this.age; //private does not see public

  }

  console.log("age: " + getAge());

};

var s = new Service(); //prints 'age: undefined'

Angular使用" new "关键字为你创建一个服务，所以Angular传递给控制器的实例也会有同样的缺点。 当然你可以用this/that来解决这个问题:

var Service = function(){

  var that = this;

  //public
  this.age = 13;

  //private
  function getAge(){

    return that.age;

  }

  console.log("age: " + getAge());

};

var s = new Service();// prints 'age: 13'  

但是对于一个大的服务常量this\that-ing会使代码可读性很差。 此外，服务原型不会有private成员，只有public成员可以使用:

var Service = function(){

  var name = "George";

};

Service.prototype.getName = function(){

  return this.name; //will not see a private member

};

var s = new Service();
console.log("name: " + s.getName());//prints 'name: undefined'

综上所述，使用Factory更加方便。As Factory没有这些缺点。我建议在默认情况下使用它。

即使他们说所有的服务和工厂都是单例的，我也不完全同意。我想说的是，工厂不是单身的，这就是我回答的重点。我真的会考虑定义每个组件的名称(服务/工厂)，我的意思是:

A factory because is not a singleton, you can create as many as you want when you inject, so it works like a factory of objects. You can create a factory of an entity of your domain and work more comfortably with this objects which could be like an object of your model. When you retrieve several objects you can map them in this objects and it can act kind of another layer between the DDBB and the AngularJs model.You can add methods to the objects so you oriented to objects a little bit more your AngularJs App.

与此同时，服务是单例的，所以我们只能创建一个，也许不能创建，但当我们注入一个控制器时，我们只有一个实例，所以服务提供更像一个公共服务(休息调用，功能..)到控制器。

从概念上讲，可以像服务提供服务一样，工厂可以创建一个类的多个实例(对象)

所有这些提供者的概念都比最初看起来要简单得多。如果你仔细分析一个提供程序，把它的不同部分拿出来，就会非常清楚。

简单地说，这些提供者中的每一个都是另一个的专门版本，顺序是:提供者>工厂>值/常量/服务。

只要提供程序做了你能做的，你就可以在链的更下方使用它，这将导致编写更少的代码。如果它不能完成你想要的，你可以继续往上走，你只需要写更多的代码。

这张图说明了我的意思，在这张图中，你将看到一个提供者的代码，突出显示的部分显示了提供者的哪些部分可以用来创建工厂、值等。

(来源:simplygoodcode.com)

要了解更多细节和例子，请访问:http://www.simplygoodcode.com/2015/11/the-difference-between-service-provider-and-factory-in-angularjs/

可以使用你想要的方式:是否创建对象或只是从两者访问函数

---

您可以从服务中创建新对象

app.service('carservice', function() {
    this.model = function(){
        this.name = Math.random(22222);
        this.price = 1000;
        this.colour = 'green';
        this.manufacturer = 'bmw';
    }
});

.controller('carcontroller', function ($scope,carservice) { 
    $scope = new carservice.model();
})

注意:

服务默认返回对象而不是构造函数。 这就是构造函数函数被设为这个的原因。模型属性。 由于此服务将返回对象，但是但是对象内部将是用于创建新对象的构造函数;

您可以从工厂创建新对象

app.factory('carfactory', function() {
    var model = function(){
        this.name = Math.random(22222);
        this.price = 1000;
        this.colour = 'green';
        this.manufacturer = 'bmw';
    }
    return model;
});

.controller('carcontroller', function ($scope,carfactory) { 
    $scope = new carfactory();
})

注意:

Factory默认返回构造函数函数而不是对象。 这就是为什么new object可以用构造函数function创建。

创建只访问简单功能的服务

app.service('carservice', function () {
   this.createCar = function () {
       console.log('createCar');
   };
   this.deleteCar = function () {
       console.log('deleteCar');
   };
});

.controller('MyService', function ($scope,carservice) { 
    carservice.createCar()
})

创建用于访问简单函数的工厂

app.factory('carfactory', function () {
    var obj = {} 
        obj.createCar = function () {
            console.log('createCar');
        };
       obj.deleteCar = function () {
       console.log('deleteCar');
    };
});

.controller('MyService', function ($scope,carfactory) { 
    carfactory.createCar()
})

结论:

您可以使用您想要的方式，无论是创建新对象或 只是为了访问简单的函数 使用其中一种而不是另一种，不会对性能造成任何影响 两者都是单例对象，每个应用程序只创建一个实例。 在每个传递引用的地方都只有一个实例。 在angular文档中，工厂被称为服务，服务也被称为服务。

工厂和服务是最常用的方法。它们之间唯一的区别是，Service方法更好地用于需要继承层次结构的对象，而Factory可以生成JavaScript原语和函数。

Provider函数是核心方法，其他的都是语法糖。只有在构建需要全局配置的可重用代码段时才需要它。

创建服务有五种方法:Value、Factory、Service、Provider和Constant。你可以在这里了解更多关于angular service的信息，这篇文章用实际的演示例子解释了所有这些方法。

.