anguleux.service vs angulaire.usine

j'ai vu les deux angulaires.usine() et angular.service () utilisé pour déclarer des services; cependant, I ne peut pas trouver angular.service n'importe où dans la documentation officielle.

Quelle est la différence entre les deux méthodes? Pour quoi faire (en présumant qu'ils font des choses différentes)?

1042
demandé sur Gil Birman 2013-01-14 22:36:41
la source

9 ответов

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

j'ai eu de la difficulté à me concentrer sur ce concept jusqu'à ce que je me le dise:

Service : la fonction que vous écrivez sera nouveau - ed:

  myInjectedService  <----  new myServiceFunction()

usine : la fonction (constructeur) que vous écrivez sera invoquée :

  myInjectedFactory  <---  myFactoryFunction()

ce que vous faites avec cela dépend de vous, mais il y a quelques modèles utiles...

tel que l'écriture d'un service fonction pour exposer une API publique:

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

Ou à l'aide d'un usine fonction d'exposer une API publique:

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

ou en utilisant une fonction usine pour retourner un constructeur:

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

Lequel utiliser?...

Vous pouvez accomplir la même chose avec les deux. Cependant, dans certains cas, le factory vous donne un peu plus de flexibilité pour créer un injectable avec une syntaxe plus simple. C'est parce que si myInjectedService doit toujours être un objet, myInjectedFactory peut être un objet, une référence de fonction, ou n'importe quelle valeur. Par exemple, si vous avez écrit un service de créer un constructeur (comme dans le dernier exemple ci-dessus), il devrait être instancié comme suit:

var myShinyNewObject = new myInjectedService.myFunction()

ce qui est sans doute moins souhaitable que ceci:

var myShinyNewObject = new myInjectedFactory();

(mais vous devriez vous méfier de l'utilisation de ce type de pattern en premier lieu parce que nouveau - ing objects dans vos controllers crée des dépendances difficiles à suivre qui sont difficiles à simuler pour les tests. Il est préférable d'avoir un service gérer une collection de objets pour vous que d'utiliser new() wily-nilly.)


une dernière chose, ce sont tous des Singleton...

gardez aussi à l'esprit que dans les deux cas, angular vous aide à gérer un singleton. Peu importe où et combien de fois vous injectez votre service ou votre fonction, vous obtiendrez la même référence au même objet ou à la même fonction. (À l'exception de quand une usine retourne simplement une valeur comme un nombre ou une chaîne. Dans ce des cas, vous obtiendrez toujours la même valeur, mais pas une référence.)

1252
répondu Gil Birman 2015-01-27 23:58:17
la source

simplement dit ..

// 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'));
316
répondu Kirk Strobeck 2016-12-05 23:07:27
la source

Voici les principales différences:

Services

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

résultat: lorsque vous déclarez serviceName comme argument injectable, vous recevrez l'instance d'une fonction passée à module.service .

Usage: pourrait être utile pour partage des fonctions d'utilité qui sont utiles à invoquer en ajoutant simplement ( ) à la référence de la fonction injectée. Peut également être exécuté avec injectedArg.call( this ) ou similaire.

usines

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

résultat: lorsque vous déclarez factoryName comme argument injectable, vous recevrez la valeur qui est retournée en invoquant la référence de fonction passée à module.factory .

Usage: pourrait être utile pour retourner un 'classe' fonction qui peut ensuite être new'ED pour créer des instances.

Voici exemple utilisant les services et l'usine . En savoir plus sur AngularJS Service vs Factory .

vous pouvez également consulter la AngularJS documentation et question similaire sur stackoverflow confused about service vs factory .

244
répondu Manish Chhabra 2017-05-23 15:10:47
la source

TL; DR



1) lorsque vous utilisez un Factory vous créez un objet, y ajoutez des propriétés, puis retournez ce même objet. Lorsque vous passez cette usine dans votre controller, ces propriétés sur l'objet seront maintenant disponibles dans ce controller via votre usine.

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) Lorsque vous êtes à l'aide de Service , Angulaire instancie derrière les scènes avec le "nouveau" mot-clé. Pour cette raison, vous ajouterez des propriétés à ‘ceci’ et le service retournera ‘ceci’. Lorsque vous passez le service dans votre controller, ces propriétés sur ‘this’ seront désormais disponibles sur ce controller via votre service.

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

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





Non TL; DR

1) usine

Les usines sont le moyen le plus populaire pour créer et configurer un service. Il n'y a pas grand-chose de plus que ce que le TL a dit. Il suffit de créer un objet, d'y ajouter des propriétés, puis de retourner le même objet. Ensuite, lorsque vous passez l'usine dans votre controller, ces propriétés sur l'objet seront maintenant disponibles dans ce controller via votre usine. Un plus de vastes exemple ci-dessous.

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

maintenant, quelles que soient les propriétés que nous attachons à ‘service’ nous serons disponibles lorsque nous passerons ‘myFactory’ dans notre contrôleur.

maintenant, ajoutons quelques variables "privées" à notre fonction de rappel. Ceux-ci ne seront pas directement accessibles depuis le contrôleur, mais nous finirons par mettre en place des méthodes getter/setter sur ‘service’ pour pouvoir modifier ces variables ‘privées’ en cas de besoin.

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

ici, vous remarquerez que nous n'attachons pas ces variables / fonctions au "service". Nous les créons simplement pour les utiliser ou les modifier plus tard.

  • baseUrl est L'URL de base que l'API iTunes nécessite
  • _artist est l'artiste nous souhaitons pour la recherche de
  • _finalUrl est L'URL finale et entièrement construite à laquelle nous ferons l'appel à iTunes makeUrl est une fonction qui va créer et retourner notre iTunes friendly URL.

maintenant que nos variables et notre fonction helper/private sont en place, ajoutons quelques propriétés à l'objet ‘service’. Quoi que nous mettions sur ‘service’ Nous serons en mesure d'utiliser directement dans n'importe quel contrôleur dans lequel nous passerons ‘myFactory’.

nous allons créer des méthodes setArtist et getArtist qui reviennent simplement ou mettent l'artiste. Nous allons aussi créer une méthode qui appellera L'API iTunes avec notre created URL. Cette méthode va retourner une promesse qui sera remplie une fois que les données seront revenues de l'API iTunes. Si vous n'avez pas beaucoup d'expérience de l'utilisation de promesses en angle, je recommande fortement de faire une plongée profonde sur eux.

ci-dessous setArtist accepte un artiste et vous permet de mettre l'artiste. getArtist renvoie l'artiste callItunes premier appel makeUrl () afin de construire l'URL que nous allons utiliser avec notre $http request. Puis il configure un objet promise, fait une requête $http avec notre url finale, puis parce que $http renvoie une promesse, nous sommes en mesure d'appeler .la réussite ou de l' .erreur après notre demande. Nous résolvons alors notre promesse avec les données iTunes, ou nous la rejetons avec un message disant "Il y avait une erreur".

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

Maintenant, notre usine est terminée. Nous sommes maintenant en mesure d'injecter ' myFactory’ dans n'importe quel contrôleur et nous serons alors en mesure d'appeler nos méthodes que nous avons attachées à notre objet de service (setArtist, getArtist, and 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);
      })
  }
});

dans le contrôleur ci-dessus, on s'injecte dans le service "myFactory". Nous définissons ensuite les propriétés de notre objet $ scope qui proviennent des données de ‘myFactory’. Le seul code délicat ci-dessus est si vous n'avez jamais traité avec des promesses avant. Parce que callItunes est de retour une promesse, nous sommes en mesure d'utiliser le .alors() la méthode et seulement $champ d'application.données.artistData une fois notre promesse tenue avec les données iTunes. Vous remarquerez notre contrôleur est très "minces". Toutes nos données logiques et persistantes sont localisées dans notre service, pas dans notre contrôleur.



2) Service

Peut-être la plus grande chose à savoir quand il s'agit de créer un Service est qu'il est instancié avec le mot-clé "new". Pour vous gourous JavaScript ceci devrait vous donner un grand indice sur la nature du code. Pour ceux d'entre vous avec un limitées contexte dans JavaScript ou pour ceux qui ne sont pas trop familiers avec ce que le "nouveau" mot-clé fait réellement, revoyons quelques principes de base de JavaScript qui nous aideront éventuellement à comprendre la nature d'un Service.

pour vraiment voir les changements qui se produisent lorsque vous invoquez une fonction avec le mot-clé ‘new’, créons une fonction et invoquons-la avec le mot-clé ‘new’, puis montrons ce que l'interprète fait quand il voit le mot-clé ‘new’. Les résultats finaux seront à la fois être le même.

créons D'abord notre constructeur.

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

il s'agit d'une fonction de constructeur JavaScript typique. Maintenant, chaque fois que nous invoquons la fonction personne en utilisant le mot-clé ‘new’, ‘this’ sera lié à l'objet nouvellement créé.

maintenant, ajoutons une méthode sur le prototype de notre personne pour qu'elle soit disponible sur chaque instance de notre "classe" de personne.

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

maintenant, parce que nous mettez la fonction sayName sur le prototype, chaque instance de la personne sera en mesure d'appeler la fonction sayName dans l'ordre alerter le nom de l'instance.

maintenant que nous avons notre fonction de constructeur de personne et notre fonction sayName sur son prototype, créons en fait une instance de personne puis appelons la fonction sayName.

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

donc tous ensemble le code pour créer un constructeur de personne, ajoutant une fonction à son prototype, créant un L'instance de la personne, et ensuite appeler la fonction sur son prototype ressemble à ceci.

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'

voyons maintenant ce qui se passe réellement lorsque vous utilisez le mot-clé " new " en JavaScript. La première chose que vous devriez remarquer est qu'après avoir utilisé ‘new’ dans notre exemple, nous sommes en mesure d'appeler une méthode (sayName) sur ‘tyler’ comme si c'était un objet - c'est parce que c'est le cas. Donc d'abord, nous savons que notre constructeur de personne renvoie un objet, que nous puissions voir cela dans le code ou pas. Deuxièmement, nous savons que parce que notre fonction sayName est située sur le prototype et non directement sur L'instance de la personne, l'objet que la fonction de la personne renvoie doit être délégué à son prototype sur les recherches ratées. En termes plus simples, quand on appelle tyler.sayName() l'interpréteur dit "OK, je vais regarder sur l'objet’ tyler' que nous venons de créer, localiser la fonction sayName, puis l'appeler. Attendez une minute, je ne vois pas ici - je ne vois que le nom et l'âge, laissez-moi vérifier le prototype. On dirait qu'il est sur le prototype, laissez-moi l'appeler.".

ci-dessous est le code pour la façon dont vous pouvez penser à ce que le "nouveau" mot clé fait réellement en JavaScript. C'est un exemple de code du paragraphe ci-dessus. J'ai mis la ‘vue de l'interprète’ ou la façon dont l'interprète voit le code dans les notes.

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

ayant maintenant cette connaissance de ce que le mot-clé "nouveau" fait réellement en JavaScript, la création d'un Service en angle devrait être plus facile à comprendre.

la plus grande chose à comprendre lors de la création d'un Service est de savoir que les Services sont instanciés avec le mot-clé "new". En combinant cette connaissance avec nos exemples ci-dessus, vous devriez maintenant reconnaître que vous attacherez vos propriétés et méthodes directement à ‘ceci’ qui sera alors retourné du Service lui-même. Jetons un coup d'oeil à cette action.

contrairement à ce que nous avons fait à l'origine avec l'exemple de L'usine, nous n'avons pas besoin de créer un objet puis de retourner cet objet parce que, comme mentionné plusieurs fois auparavant, nous avons utilisé le mot-clé " new " pour que l'interpréteur crée cet objet, le fasse déléguer à son prototype, puis le renvoie pour nous sans que nous ayons à faire le travail.

tout d'abord, créons notre fonction ‘private’ et helper. Ce devrait être très familier puisque nous avons fait exactement la même chose avec notre usine. Je ne vais pas expliquer ce que chaque ligne fait ici parce que je l'ai fait que dans l'exemple d'usine, si vous êtes confus, relisez l'exemple d'usine.

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

maintenant, nous allons attacher toutes nos méthodes qui seront disponibles dans notre contrôleur à ‘ceci’.

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

});

maintenant comme dans notre usine, setArtist, getArtist, et callItunes seront disponibles dans n'importe quel contrôleur dans lequel nous passerons myService. Voici le contrôleur myService (qui est presque exactement le même que notre contrôleur d'usine).

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

comme je l'ai déjà mentionné, une fois que vous comprenez vraiment ce que "nouveau" fait, les Services sont presque identiques aux usines en angle.

134
répondu Tyler McGinnis 2015-06-05 21:56:56
la source

L'indice est dans le nom

les services et les usines sont similaires. Les deux donnent un objet unique qui peut être injecté dans d'autres objets, et sont donc souvent utilisés de façon interchangeable.

ils sont destinés à être utilisés sémantiquement pour mettre en œuvre différents modèles de conception.

les Services sont pour la mise en œuvre d'un modèle de service

un modèle de service est un dans lequel votre application est divisé en unités de fonctionnalité cohérentes. Un exemple pourrait être un accesseur D'API, ou un ensemble de logique d'affaires.

C'est particulièrement important dans Angular parce que les modèles angulaires sont typiquement juste des objets JSON tirés d'un serveur, et donc nous avons besoin d'un endroit pour mettre notre logique d'affaires.

voici un service Github par exemple. Il sait comment parler à Github. Il connaît les URL et les méthodes. On peut l'injecter dans un contrôleur, et il sera générer et retourner une promesse.

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

les usines mettent en œuvre un modèle d'usine

usines, d'autre part sont destinés à mettre en œuvre un modèle d'usine. Un modèle d'usine dans lequel nous utilisons une fonction d'usine pour générer un objet. Généralement, nous pourrions l'utiliser pour construire des modèles. Voici une usine qui renvoie un constructeur auteur:

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

Nous avons fait usage de cette sorte:

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

notez que les usines renvoient aussi des singletons.

les usines peuvent retourner un constructeur

parce qu'une usine retourne simplement un objet, elle peut retourner n'importe quel type d'objet que vous aimez, y compris une fonction de constructeur, comme nous le voyons ci-dessus.

"1519100920 des" Usines " de retour d'un objet; les services sont newable

une autre différence technique réside dans la composition des services et des usines. Service fonction sera newed pour générer l'objet. Une fonction d'usine sera appelée et retournera l'objet.

  • les Services sont des nouveaux constructeurs.
  • les usines sont simplement appelées et renvoient un objet.

cela signifie que dans un service, nous ajoutons "ceci" qui, dans le contexte d'un constructeur, indiquera l'objet en construction.

pour illustrer ceci, voici le même objet simple créé en utilisant un service et une usine:

angular.module('app', [])
  .service('helloService', function() {
    this.sayHello = function() {
      return "Hello!";
    }
  })
  .factory('helloFactory', function() {
    return {
      sayHello: function() {
        return "Hello!";
      }
    }
  });
33
répondu superluminary 2015-12-09 16:10:20
la source

toutes les réponses ici semblent être autour du service et de l'usine, et c'est valable puisque c'était ce qui était demandé. Mais il est également important de garder à l'esprit qu'il ya plusieurs autres dont provider() , value() , et constant() .

La clé à se rappeler est que chacun est un cas particulier de l'autre. Chaque cas particulier en bas de la chaîne, vous permettant de faire la même chose avec moins de code. Chacun également avoir un obstacle supplémentaire.

pour décider quand utiliser lequel vous venez de voir lequel vous permet de faire ce que vous voulez en moins de code. Voici une image illustrant à quel point ils sont similaires:

enter image description here

pour une ventilation pas-à-pas complète et une référence rapide du moment d'utiliser chacun, vous pouvez visiter l'article de blog où j'ai obtenu cette image de:

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

24
répondu Luis Perez 2017-04-19 16:36:51
la source

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

Construction

avec les usines, angulaire invoquera la fonction pour obtenir le résultat. C'est le résultat qui est mis en cache et injecté.

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

avec services, Angular invoquera la fonction constructeur en appelant nouveau . La fonction construite est mise en cache et injectée.

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

mise en Œuvre

les usines renvoient généralement un objet littéral parce que la valeur de retour est ce qui est injecté dans les contrôleurs, exécuter des blocs, directives, etc

  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
         }
  });
Les fonctions de Service

ne renvoient généralement rien. Au lieu de cela, ils effectuent l'initialisation et exposent des fonctions. Les fonctions peuvent également faire référence à "ceci" puisqu'il a été construit en utilisant "Nouveau".

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

Conclusion

Lorsqu'il s'agit d'utiliser des usines ou des services, ils sont tous les deux très similaires. Ils sont injectés dans des controllers, des directives, des run block, etc, et utilisés dans le code client à peu près de la même manière. Ce sont aussi des singletons, c'est - à-dire que la même instance est partagée entre tous les lieux où le service/l'usine est injecté.

alors qu'est-ce que vous préférez? Soit - ils sont tellement similaires que l' les différences sont insignifiantes. Si vous choisissez l'un par rapport à l'autre, il suffit de savoir comment ils sont construits, de sorte que vous pouvez les mettre en œuvre correctement.

23
répondu pixelbits 2014-06-27 04:49:15
la source

j'ai passé du temps à essayer de comprendre la différence.

et je pense que la fonction d'usine utilise le modèle de module et la fonction de service utilise le modèle de constructeur de script java standard.

5
répondu ps. 2015-03-10 18:04:24
la source

le modèle d'usine est plus flexible car il peut retourner des fonctions et des valeurs aussi bien que des objets.

il n'y a pas beaucoup de point dans le modèle de service IMHO, comme tout ce qu'il fait, vous pouvez tout aussi facilement faire avec une usine. Les exceptions pourraient être:

  • si vous vous souciez du type déclaré de votre service instancié pour une raison quelconque - si vous utilisez le modèle de service, votre constructeur sera le type du nouveau service.
  • si vous avez déjà une fonction de constructeur que vous utilisez ailleurs que vous voulez aussi utiliser comme un service (bien que probablement pas beaucoup d'utilisation si vous voulez y injecter quoi que ce soit!).

on peut soutenir que le modèle de service est une légèrement meilleure façon de créer un nouvel objet du point de vue de la syntaxe, mais il est également plus coûteux d'instancier. D'autres ont indiqué que angulaires utilise "nouveau" pour créer le service, mais ce n'est pas tout à fait vrai - il n'est pas en mesure de le faire parce que chaque constructeur de service a un nombre différent de paramètres. Ce que l'angular fait réellement est d'utiliser le modèle d'usine à l'interne pour envelopper votre fonction de constructeur. Ensuite, il fait quelques astucieux jiggery pokery à simuler l'opérateur" nouveau " de javascript, invoquant votre constructeur avec un nombre variable d'arguments injectables - mais vous pouvez laisser cette étape si vous utilisez juste le modèle d'usine directement, donc très légèrement augmenter l'efficacité de votre code.

2
répondu Dan King 2015-08-06 18:11:37
la source

Autres questions sur angularjs angular-services