confus au sujet de service vs usine

Question

Si je comprends bien, lorsqu'à l'intérieur d'une usine-je retourner un objet injecté dans un contrôleur. Quand à l'intérieur d'un service que je fais affaire avec l'objet à l'aide d' this et ne pas rentrer quoi que ce soit.

J'étais sous l'hypothèse qu'un service a été toujours un singleton, et qu'une nouvelle usine de l'objet devient injectés dans chaque contrôleur. Cependant, comme il s'avère, d'une usine d'objet est un singleton?

Exemple de code pour illustrer:

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;
});

Lors de la modification de l'utilisateur.d'abord dans ACtrl il s'avère que l'utilisateur.d'abord dans BCtrl est également modifié, par exemple, l'Utilisateur est un singleton?

Mon hypothèse était qu'une nouvelle instance a été injecté dans un contrôleur avec une usine?

Answer 1

Tous angulaire de services sont des singletons:

Docs (voir Services comme des singletons): https://docs.angularjs.org/guide/services

Enfin, il est important de réaliser que tous Angulaire de services sont des singletons. Cela signifie qu'il n'existe qu'une seule instance d'un service donné par l'injecteur.

En gros la différence entre le service et l'usine est comme suit:

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 + "!";
    }
  }
});

Découvrez dans cette présentation de dollars fournir: http://slides.wesalvaro.com/20121113/#/

Ces diapositives ont été utilisés dans l'un des AngularJs rencontres: http://blog.angularjs.org/2012/11/more-angularjs-meetup-videos.html

Answer 2

live exemple

exemple "hello world"

avec 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()];
}​

Answer 3

Il est aussi un moyen de retourner une fonction constructeur de sorte que vous pouvez revenir newable classes dans les usines, comme ceci:

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 });
  };
}); 

De sorte que vous pouvez le faire dans un contrôleur, qui utilise MyObjectWithParam:

var obj = new MyObjectWithParam("hello"),

Voir ici l'exemple complet:
http://plnkr.co/edit/GKnhIN?p=preview

Et voici le groupe google pages, où il a été discuté:
https://groups.google.com/forum/#!msg/angulaire/56sdORWEoqg/b8hdPskxZXsJ

Answer 4

Voici les principales différences:

Services

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

Résultat: Lors de la déclaration de serviceName comme un produit injectable argument, vous sera fourni avec l' exemple d'une fonction passée de module.service.

Utilisation: Peut être utile pour le partage de l'utilitaire de fonctions qui sont utiles pour appeler simplement en ajoutant () pour l'injection de la fonction de référence. Pourrait également être exécuté avec injectedArg.call( this ) ou similaire.

Les usines

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

Résultat: Lors de la déclaration de factoryName comme un produit injectable argument qui vous sera fourni à la valeur qui est renvoyée par l'invocation de la fonction de référence transmis module.factory.

Utilisation: Peut être utile pour le retour d'une "classe" de la fonction que peut-être de nouveaux ed pour créer des instances.

Vérifiez également AngularJS la documentation et la même question sur stackoverflow confus au sujet de service vs usine.

Voici exemple l'utilisation des services et de l'usine. Lire plus sur AngularJS service vs usine.

Answer 5

En ajoutant à la première réponse, je pense .service() est pour les gens qui ont écrit leur code en plus de style orienté objet (à l'aide de cette/prototype/fonction Constructeur).

L'usine est aux développeurs d'écrire du code qui est plus naturel de javascript-style de codage et je préfère le style de l'Usine, aller de l'avant.

Regardez le code source de .service et .usine de méthode à l'intérieur d'angular.js - en interne, ils font tous appel fournisseur de méthode:

  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);
    }]);
  }