सेवा बनाम कारखाने के बारे में भ्रमित

Question

जैसा कि मैं इसे समझता हूं, जब एक कारखाने के अंदर मैं एक वस्तु लौटाता हूं जिसे एक नियंत्रक में इंजेक्ट किया जाता है। जब किसी सेवा के अंदर मैं किसी वस्तु का उपयोग कर रहा होता हूं 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.firstमें ACtrlयह पता चला है कि user.firstमें BCtrlभी बदल गया है, उदाहरण के लिए Userएक सिंगलटन है?

मेरी धारणा यह थी कि एक नियंत्रक के साथ कारखाने में एक नया उदाहरण इंजेक्ट किया गया था?

Comments

"मॉड्यूल. सर्विस" और "मॉड्यूल.फैक्टिंग" के बगल में एंगुलरजेएस में सेवाएं बनाने के 2 और तरीके हैं। ब्लॉग पोस्ट द्वारा अधिक जानकारी के लिए जाँच करें : " कैसे (सिंगलटन) बनाने के लिए 4 अलग-अलग तरीकों से AngularJS सेवाएं "

— एमिल वैन गैलन

कोणीय.सर्विस बनाम कोणीय.फैक्टिंग

— कौशल

Answer 1

सभी कोणीय सेवाएं एकल हैं :

डॉक्स ( एकल के रूप में सेवाएँ देखें ): https://docs.angularjs.org/guide/services

अंत में, यह महसूस करना महत्वपूर्ण है कि सभी कोणीय सेवाएं अनुप्रयोग एकल हैं। इसका मतलब यह है कि प्रति इंजेक्टर दिए गए सेवा का केवल एक उदाहरण है।

मूल रूप से सेवा और कारखाने के बीच का अंतर इस प्रकार है:

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

$ प्रदान के बारे में इस प्रस्तुति को देखें : http://slides.wesalvaro.com/20121113/#

उन स्लाइडों को एक AngularJs meetups में इस्तेमाल किया गया था: http://blog.angularjs.org/2012/11/more-angularjs-meetup-videos.html

Comments

यह भी देखें stackoverflow.com/questions/15666048/… जो सेवा, कारखाने और प्रदान करने के बीच के अंतरों पर चर्चा करता है।

— मार्क राजकॉक

आधिकारिक तौर पर डॉक्टर साहब! पर्याप्त स्पष्ट नहीं है] इसका मतलब है कि भले ही आप कारखाने के साथ सेवा को परिभाषित करते हैं, केवल एक बार बनाया गया है। दूसरे शब्दों में इसका संदर्भ (इंजेक्शन बिंदु) के अनुसार फिर से नहीं बनाया गया-जो भी आप इसे कहते हैं। दोनों तरीकों से प्रति इंजेक्टर में एक सिंगलटन उदाहरण होता है।

— होनजजडे

आप कहते हैं "सेवा केवल एक रचनाकार कार्य है जिसे 'नया' कहा जाएगा" लेकिन मुझे लगता है कि यह भ्रामक है। मुझे नहीं लगता कि इसे पर्दे के पीछे से नया कहा जाता है, मुझे लगता है कि डेवलपर इस newपर कॉल करने के लिए जिम्मेदार है।

— टिम किंडबर्ग

@nfiniteloop, लाइन कोड 3574 के पास स्रोत कोड की जाँच करें। फैक्टर एक प्रदाता की $ प्राप्त करने की विधि है, और सेवाएँ एक विधि का उपयोग करके कारखाने उत्पन्न करती हैं जो प्रदान किए गए फ़ंक्शन पर $ injectionor.instantiate कहते हैं, जो तब नया कॉल करता है। ( डॉक्स देखें )

— citizenslave

मैं इस धारणा के तहत था कि एक सेवा सिंगलटन के रूप में थी जिसे आपने इसका संदर्भ देकर उपयोग किया था। और यह कि एक कारखाना एक सिंगलटन था जो हर बार एक नई वस्तु लौटाता था। यही है, एक सेवा आपको एक "कार" देगी और आपके प्रोजेक्ट की हर चीज इस कार का उपयोग करेगी। जबकि एक फैक्ट्री आपको हर बार एक नई कार देती थी, जब आप फ़ैक्टरी को लागू करते थे। एक एक सिंगलटन था जो एक सिंगलटन लौटा था और एक एक सिंगलटन था जो किसी ऑब्जेक्ट को लौटाता था। क्या कोई समझा सकता है? सब कुछ एक सिंगलटन को कॉल करना मदद नहीं करता है क्योंकि यह कई चीजों को संदर्भित कर सकता है।

— user2483724

Answer 2

मेरे लिए रहस्योद्घाटन तब हुआ जब मुझे एहसास हुआ कि वे सभी एक ही तरह से काम करते हैं: किसी चीज को एक बार चलाने से , वे जो मूल्य प्राप्त करते हैं, उसे संग्रहीत करते हैं, और फिर डिपेंडेंसी इंजेक्शन के माध्यम से संदर्भित होने पर उसी संग्रहीत मूल्य को खांसी करते हैं।

कहो हमारे पास:

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

तीन के बीच अंतर यह है कि:

1. aसंग्रहीत मूल्य fnदूसरे शब्दों में, चलने से आता है :fn()
2. bसंग्रहीत मूल्य newआईएनजी से आता है fn, दूसरे शब्दों में:new fn()
3. cसंग्रहीत मूल्य पहले newआईएनजी द्वारा आईएनजी द्वारा प्राप्त किया जाता है fn, और फिर $getइंस्टेंस का एक तरीका चल रहा है

जिसका अर्थ है, कोणीय वस्तु के अंदर कैश ऑब्जेक्ट जैसा कुछ है, जिसका प्रत्येक इंजेक्शन का मूल्य केवल एक बार असाइन किया गया है, जब उन्हें पहली बार इंजेक्ट किया गया है, और जहां:

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

यही कारण है कि हम उपयोग करते हैं this सेवाओं में करते हैं, और this.$getप्रदाताओं में परिभाषित करते हैं ।

उम्मीद है की यह मदद करेगा।

Comments

अंत में, एक समझदार व्याख्या। कोणीय पागल है और इतना बुरा है कि यह दर्द होता है।

— ओसिरिस

यह स्वीकृत उत्तर होना चाहिए क्योंकि यह वास्तव में WHY कारखानों, सेवाओं, और प्रदाताओं के सिंगलटन मानों के प्रश्न का उत्तर देता है। अन्य उत्तर फैक्ट्रियों, सेवाओं और प्रदाताओं के बीच के अंतर को स्पष्ट करते हैं लेकिन सिंगलटन पहलू पर कभी स्पर्श नहीं करते हैं।

— wmock

मुझे यह पसंद है ... जब मैं दूसरे ब्लॉगर से वाक्य की हजार पंक्तियां पढ़ता हूं .. तो मैं केवल फैक्टरी को समझने का प्रबंधन करता हूं। लेकिन मैंने इसे पढ़ा ... मैं सभी को समझता

— हूं

@osiris मैं सहमत हूँ। मुझे यह पसंद नहीं है। यह सिर्फ इतनी बारीकी से युग्मित महसूस करता है कि यह मेरे दांत पीसता है।

— थॉमस

इसलिए आपको प्रदाताओं का उपयोग करते समय $ प्राप्त करने का कार्यान्वयन प्रदान करना होगा?

— विक्टर

Answer 3

जीवंत उदाहरण

"हैलो वर्ल्ड" उदाहरण

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 4

वहाँ भी एक निर्माता समारोह लौटने के लिए तो तुम लौट सकते हैं एक तरीका है newable कारखानों में कक्षाएं, इस तरह:

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

और यहां Google समूह के पृष्ठ, जहां इस पर चर्चा की गई थी:
https://groups.google.com/forum/#/msg/angular/56sdORWEoqg/b8hdPskxZXsJ

Comments

आपके उदाहरण का उपयोग करते हुए मेरे पास समस्याएँ हैं। क्या आप जानते हैं कि मुझे इसकी व्याख्या कैसे करनी चाहिए?

— Pål

हां, वहां पर कोणीय के लिए एक छोटा अंकन मौजूद है। यह कुछ इस तरह होना चाहिए: App.factory('MyObjectWithParam', ['$injector', function ($injector) { return function(name) { return $injector.instantiate(MyObjectWithParam,{ name: name }); }; }]); इसके बारे में यहाँ और पढ़ें: docs.angularjs.org/tutorial/step_05

— JustGoscha

आप यह क्यों करना चाहते हैं, अगर आप .serviceइसके बजाय उपयोग कर सकते हैं ?

— ।

मेरे पास एक ही विचार था @flup। @justgoscha, वहाँ के रूप में उपयोग करने के लिए कुछ लाभ (हैरान ? ) .factoryहै .service?

— xandercoded

मुझे लगता है क्योंकि एक सेवा एक सिंगलटन है । मैंने यहां जो निर्माण किया वह मूल रूप से एक वर्ग है जो नया है। यदि आप एक कार सेवा कारखाने की तरह कुछ है और फिर कर सकते हैं तो बनाने new Car('BMW')और new Car('Ford')और वे एक ही चर और सब कुछ साझा नहीं करते।

— जस्टगोशा

Answer 5

यहाँ प्राथमिक अंतर हैं:

सेवाएं

वाक्य - विन्यास: module.service( 'serviceName', function );

परिणाम: जब एक इंजेक्शन तर्क के रूप में SERVICENAME की घोषणा आप के साथ उपलब्ध कराया जाएगा एक समारोह के कहने के लिए पारितmodule.service ।

उपयोग: उपयोगिता कार्यों को साझा करने के लिए उपयोगी हो सकता है जो इंजेक्शन फ़ंक्शन के संदर्भ में केवल () संलग्न करके उपयोगी हैं। के साथ injectedArg.call( this )या समान चलाया जा सकता है ।

कारखाना

वाक्य - विन्यास: module.factory( 'factoryName', function );

परिणाम: जब कारखानेनाम को एक इंजेक्शन तर्क के रूप में घोषित किया जाता है, तो आपको वह मान प्रदान किया जाएगा, जो पारित किए गए फ़ंक्शन को लागू करके लौटा दिया गया हैmodule.factory ।

उपयोग: एक 'वर्ग' लौटने के लिए उपयोगी हो सकता है फ़ंक्शन जो तब इंस्टेंस बनाने के लिए नया हो सकता है।

इसके अलावा AngularJS प्रलेखन और स्टैकओवरफ्लो पर समान प्रश्न सेवा बनाम कारखाने के बारे में उलझन की जाँच करें ।

यहां सेवाओं और कारखाने का उपयोग करके उदाहरण दिया गया है । AngularJS सेवा बनाम कारखाने के बारे में और पढ़ें ।

Comments

मुझे यह अर्थपूर्ण लग रहा है। वह कारखाना नई वस्तुओं के निर्माण का खाका लौटाता है।

Answer 6

पहले उत्तर में जोड़ते हुए, मुझे लगता है कि .service () उन लोगों के लिए है जिन्होंने अपना कोड अधिक ऑब्जेक्ट ओरिएंटेड स्टाइल (C # / Java) में लिखा है (इस कीवर्ड का उपयोग करते हुए और प्रोटोटाइप / कंस्ट्रक्टर फ़ंक्शन के माध्यम से ऑब्जेक्ट को इंस्टेंट करते हुए)।

फैक्टरी उन डेवलपर्स के लिए है जो कोड लिखते हैं जो जावास्क्रिप्ट / कोडिंग की कार्यात्मक शैली के लिए अधिक स्वाभाविक है।

.Service और .factory विधि के स्रोत कोड पर एक नज़र डालें।

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

Answer 7

बहुत ही सरलता से:

.service - पंजीकृत फ़ंक्शन को एक निर्माता (उर्फ 'न्यूड') के रूप में आमंत्रित किया जाएगा।

.factory - पंजीकृत फ़ंक्शन को एक साधारण फ़ंक्शन के रूप में लागू किया जाएगा

दोनों को एक बार मिलाने के परिणामस्वरूप एक सिंगलटन ऑब्जेक्ट मिलता है जो आपके ऐप के अन्य घटकों में इंजेक्ट हो जाता है।

Comments

हाँ। चलो चीजों को और अधिक जटिल नहीं बनाते हैं क्योंकि वे वास्तव में हैं

— फ्लॉप

Answer 8

सभी प्रदाता समान तरीके से काम करते हैं। विभिन्न तरीकों service, factory, providerकेवल आपके कम कोड में इसी कार्य को पूरा करते हैं।

पुनश्च वहाँ भी है valueऔर constant।

चेन के साथ शुरू providerऔर समाप्त होने वाले प्रत्येक विशेष मामले valueमें एक अतिरिक्त सीमा होती है। तो उन दोनों के बीच फैसला करने के लिए आपको खुद से पूछना होगा कि आप कम कोड के साथ क्या चाहते हैं।

यहाँ एक तस्वीर है जो आपको दिखाती है कि मेरा क्या मतलब है:

आप जिस ब्लॉग पोस्ट से यह चित्र प्राप्त करते हैं, उस पर आप एक विराम और संदर्भ मार्गदर्शिका दे सकते हैं:

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

Comments

सेवाओं को सिंगलटन कहा जाता है, लेकिन हर बार जब मैं इसे इंजेक्ट करता हूं, तो नया उदाहरण कैसे बनाया जाता है?

— अंकुर मरवाहा

@AnkurMarwaha हर बार एक नया उदाहरण नहीं बनाया जाता है, यह केवल एक बार बनाया जाता है और AngularJS द्वारा कैश किया जाता है। यह सच है कि क्या आप एक प्रदाता, कारखाने, सेवा, आदि का उपयोग कर रहे हैं। आप console.log()कई नियंत्रकों में इसका उपयोग और इंजेक्शन लगाने की पुष्टि कर सकते हैं ।

— लुइस पेरेज़

लुइस, आपकी टिप्पणी स्वीकार किए गए उत्तर के साथ संघर्ष करती है क्योंकि यह कहती है - अंत में, यह महसूस करना महत्वपूर्ण है कि सभी कोणीय सेवाएं अनुप्रयोग मानदंड हैं। इसका मतलब यह है कि प्रति इंजेक्टर दिए गए सेवा का केवल एक उदाहरण है।

— अंकुर मरवाहा

@AnkurMarwaha शायद मुझे कुछ गलत लग रहा है। आपने उद्धृत किया "यह महसूस करना महत्वपूर्ण है कि सभी कोणीय सेवाएं अनुप्रयोग एकल हैं" - तथ्य यह है कि वे एकल हैं वे केवल एक बार बनाए गए हैं। जो मैंने कहा है " हर बार एक नया उदाहरण नहीं बनाया जाता है, यह केवल एक बार बनाया जाता है और कैश किया जाता है ..."। क्या आप अधिक विस्तार से इंगित कर सकते हैं जहां आप संघर्ष देखते हैं?

— लुइस पेरेस

आह, मैं भ्रम देखता हूं। "इंजेक्टर" कोणीय में एक वस्तु है। यह "इंजेक्शन" करने के प्रभारी हैं। उदाहरण, जब नियंत्रक को पहले "इंजेक्टर" चलाया जाता है, मापदंडों को देखता है और प्रत्येक को इंजेक्ट करता है। आपके पूरे ऐप के लिए केवल एक "इंजेक्टर" है। एक बार जब इंजेक्टर एक विशेष कारखाना या सेवा बनाता है तो यह उसके लिए एक उदाहरण रखता है और उसका पुन: उपयोग करता है - इसलिए सिंगलटन। इसलिए प्रति ऐप में केवल एक इंजेक्टर है और प्रति इंजेक्टर के लिए दिए गए सेवा का केवल एक उदाहरण है। अधिकांश कोणीय अनुप्रयोगों में केवल एक ऐप होता है, इसलिए एक इंजेक्टर, इसलिए किसी भी सेवा, नियंत्रक आदि का एक उदाहरण

— लुइस पेरेज़

Answer 9

यहाँ सेवाओं बनाम कारखानों के कुछ और उदाहरण हैं जो उनके बीच के अंतर को देखने में उपयोगी हो सकते हैं। मूल रूप से, एक सेवा के पास "नया ..." है, जिसे उस पर बुलाया गया है, यह पहले से ही तत्काल है। एक कारखाना स्वचालित रूप से त्वरित नहीं है।

मूल उदाहरण

एक क्लास ऑब्जेक्ट लौटाएं जिसमें एक एकल विधि है

यहाँ एक सेवा है जिसमें एक ही विधि है:

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

दोनों मामलों में आउटपुट समान है, संख्याओं की सूची।

उन्नत उदाहरण

कारखानों का उपयोग करके "वर्ग" चर

इस उदाहरण में हम एक काउंटरफैक्ट्री को परिभाषित करते हैं, यह एक काउंटर को बढ़ाता या घटाता है और आप वर्तमान गणना प्राप्त कर सकते हैं या प्राप्त कर सकते हैं कि कितने काउंटरफैक्टिव ऑब्जेक्ट बनाए गए हैं:

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

Comments

यह एक उपयोगी उदाहरण है, number_of_counter_factories काउंटरफैक्ट्री क्लास के मेटा एट्रिब्यूट की तरह है, ठीक है ?, मैं समझता हूं कि यह उदाहरण एक सेवा पर प्रतिकृति है (मुझे बताएं यदि मैं गलत हूं), तो इस मामले में अर्ध-अंतर क्या होगा?

— जियोम

उपयोगी उदाहरण! तो मूल रूप से इसका मतलब है कि एक कारखाने में आपके पास अमूर्त की अतिरिक्त परत हो सकती है जो एक सेवा में नहीं मिलेगी। हालांकि जो कुछ भी लौटाया जाता है, उसका नया उदाहरण जब भी is नया ’का उपयोग किया जाता है, वापस कर दिया जाएगा। कोई भी वैरिएबल जो रिटर्न ब्लॉक के अंदर घोषित नहीं होता है, वह सिंगलटन होगा। क्या मैने सही किया?

— स्वनिधि

@Swanidhi मूल रूप से हाँ, आप उन चरों को घोषित कर सकते हैं जो कारखाने में सिंगलटन हैं। इसलिए मैंने उन्हें "वर्ग" चर कहा।

Answer 10

"फैक्टरी" और "सेवा" कोणीय में DI (निर्भरता इंजेक्शन) करने के विभिन्न तरीके हैं।

इसलिए जब हम DI को "सेवा" का उपयोग करके परिभाषित करते हैं जैसा कि नीचे दिए गए कोड में दिखाया गया है। यह "लकड़हारा" वस्तु का एक नया वैश्विक उदाहरण बनाता है और इसे फ़ंक्शन में इंजेक्ट करता है।

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

जब आप DI को "फ़ैक्टरी" का उपयोग करके परिभाषित करते हैं तो यह एक उदाहरण नहीं बनाता है। यह सिर्फ विधि को पारित करता है और बाद में उपभोक्ता को आंतरिक रूप से ऑब्जेक्ट इंस्टेंस के लिए कारखाने में कॉल करना पड़ता है।

app.factory("Customerfactory", CreateCustomer);

नीचे एक सरल छवि है जो नेत्रहीन दिखाती है कि "सेवा" के लिए DI प्रक्रिया "फैक्टरी" से अलग कैसे है।

फैक्टरी का उपयोग तब किया जाना चाहिए जब हम परिदृश्यों के आधार पर विभिन्न प्रकार की वस्तुओं का निर्माण करना चाहते हैं। उदाहरण के लिए, परिदृश्य के आधार पर हम "फोन" ऑब्जेक्ट के साथ "पता" ऑब्जेक्ट या "ग्राहक" के साथ एक सरल "ग्राहक" ऑब्जेक्ट या "ग्राहक" बनाना चाहते हैं। इस पैराग्राफ की विस्तृत व्याख्या इस प्रकार है

सेवा का उपयोग तब किया जाना चाहिए जब हमारे पास उपयोगिता, लकड़हारा, त्रुटि हैंडलर आदि जैसे इंजेक्शन या साझा कार्य हों।

Comments

इस सवाल पर मैंने जो जवाब दिया है, और इसी तरह के अन्य जवाब मैकेनिक और सिंटैक्स में अंतर बता रहे हैं। यह उत्तर एक वास्तविक कारण देता है कि आप दूसरे पर एक का चयन क्यों करेंगे। यह शब्दार्थ की बात है और नाम, सेवा या कारखाने को देखकर, उनके उद्देश्य और वे कैसे उपयोग किए जाते हैं, का संचार करते हैं।

— जो मेयो

Answer 11

सेवा शैली: ( संभवत : सबसे सरल एक ) वास्तविक फ़ंक्शन देता है: उपयोगिता कार्यों को साझा करने के लिए उपयोगी है जो इंजेक्शन फ़ंक्शन के संदर्भ में केवल संलग्न () द्वारा लागू करने के लिए उपयोगी हैं।

AngularJS में एक सेवा एक सिंगलटन जावास्क्रिप्ट ऑब्जेक्ट है जिसमें फ़ंक्शन का एक सेट होता है

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

});

फैक्टरी शैली: ( अधिक शामिल लेकिन अधिक परिष्कृत ) फ़ंक्शन का रिटर्न मान लौटाता है: जावा में नई वस्तु () जैसी किसी वस्तु को तत्काल।

फैक्टरी एक फ़ंक्शन है जो मान बनाता है। जब किसी सेवा, नियंत्रक आदि को किसी कारखाने से इंजेक्ट किए गए मूल्य की आवश्यकता होती है, तो कारखाना मांग पर मूल्य बनाता है। एक बार बनाए जाने के बाद, मूल्य को सभी सेवाओं, नियंत्रकों आदि के लिए पुन: उपयोग किया जाता है, जिन्हें इसकी आवश्यकता होती है।

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

});

प्रदाता शैली: ( पूर्ण विकसित, विन्यास योग्य संस्करण ) फ़ंक्शन के $ प्राप्त फ़ंक्शन का आउटपुट देता है: कॉन्फ़िगर करने योग्य।

AngularJS में प्रदाता आपके द्वारा बनाए गए कारखाने का सबसे लचीला रूप है। आप एक प्रदाता को मॉड्यूल के साथ पंजीकृत करते हैं जैसे आप किसी सेवा या कारखाने के साथ करते हैं, इसके अलावा आप प्रदाता () फ़ंक्शन का उपयोग करते हैं।

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

Answer 12

मूल अंतर यह है कि प्रदाता फैक्ट्री घोषित चर में आदिम (गैर-वस्तुएं), सरणी, या कॉलबैक फ़ंक्शन मान सेट करने की अनुमति देता है, और इस प्रकार यदि किसी वस्तु को लौटाता है तो उसे स्पष्ट रूप से घोषित किया जाता है और वापस लौटा दिया जाता है।

दूसरी ओर एक सेवा का उपयोग केवल एक वस्तु के लिए घोषित सेवा को सेट करने के लिए किया जा सकता है, इस प्रकार हम स्पष्ट निर्माण और वस्तुओं की वापसी से बच सकते हैं, जबकि दूसरी ओर यह इस कीवर्ड के उपयोग की अनुमति देता है ।

या कम शब्दों में " प्रदाता एक अधिक सामान्य रूप है जबकि सेवा केवल वस्तुओं तक सीमित है"।

Answer 13

इस तरह से मैंने डिज़ाइन पैटर्न के संदर्भ में उनके बीच के अंतर को समझा:

सेवा : एक प्रकार लौटाएं, उस प्रकार की एक वस्तु बनाने के लिए नया किया जाएगा। यदि जावा एनालॉग का उपयोग किया जाता है, तो सेवा जावा क्लास की परिभाषा देती है ।

फैक्टरी : एक ठोस वस्तु लौटाता है जिसे तुरंत इस्तेमाल किया जा सकता है। जावा एनालॉग में एक फैक्ट्री जावा ऑब्जेक्ट देता है ।

वह हिस्सा जो अक्सर लोगों को भ्रमित करता है (अपने आप सहित) वह यह है कि जब आप अपने कोड में किसी सेवा या कारखाने को इंजेक्ट करते हैं तो उनका उसी तरह उपयोग किया जा सकता है, जो आपको अपने कोड में दोनों मामलों में मिलता है। यह एक ठोस वस्तु है जिसे आप तुरंत लागू कर सकते हैं। जिसका अर्थ है कि सेवा के मामले में, कोणीय आपकी ओर से सेवा घोषणा पर "नया" कहता है। मुझे लगता है कि यह एक जटिल अवधारणा है।

Answer 14

यह सेवा बनाम कारखाना बनाम प्रदाता को समझने के लिए सबसे अच्छा और छोटा उत्तर होगा

स्रोत : https://groups.google.com/forum/# .msg / angular/ 56sdORWEoqg / HuZsOsMvKv4J

यहाँ एक डेमो http://jsbin.com/ohamub/1/edit?html,output के साथ बेन क्या कहता है

"प्राथमिक अंतरों को दर्शाने वाले कोड में टिप्पणियां हैं लेकिन मैं यहां उन पर थोड़ा विस्तार करूंगा। एक नोट के रूप में, मैं बस इसके चारों ओर अपना सिर प्राप्त कर रहा हूं इसलिए अगर मैं कुछ भी कहूं जो गलत है तो कृपया मुझे बताएं।

सेवाएं

सिंटैक्स : मॉड्यूल. सर्विस ('सेवानाम', फ़ंक्शन);

परिणाम : जब सेवानाम को एक इंजेक्शन योग्य तर्क के रूप में घोषित किया जाता है, तो आपको मॉड्यूल.service को दिया गया वास्तविक फ़ंक्शन संदर्भ प्रदान किया जाएगा।

प्रयोग : उपयोगिता कार्यों को साझा करने के लिए उपयोगी हो सकता है जो केवल इंजेक्शन फ़ंक्शन के संदर्भ में संलग्न () करने के लिए उपयोगी हैं। यह भी इंजेक्शन के साथ चलाया जा सकता है।

कारखाना

वाक्य - विन्यास : मॉड्यूल.फैक्टिंग ('factoryName', फ़ंक्शन);

परिणाम : जब फैक्ट्रीनाम को एक इंजेक्टेबल तर्क के रूप में घोषित किया जाता है तो आपको वह मान प्रदान किया जाएगा जो मॉड्यूल.फैक्टिंग को दिए गए फ़ंक्शन संदर्भ को लागू करके लौटाया जाता है।

प्रयोग : एक 'क्लास' फ़ंक्शन को लौटाने के लिए उपयोगी हो सकता है जो तब इंस्टेंसेस बनाने के लिए new'ed हो सकता है।

प्रदाताओं

वाक्य - विन्यास : मॉड्यूल.प्रोवाइडर ('प्रोवाइडरनाम, फंक्शन);

परिणाम : जब प्रदातानाम को एक इंजेक्टेबल तर्क के रूप में घोषित करते हैं तो आपको वह मूल्य प्रदान किया जाएगा जो मॉड्यूल.प्रोवाइडर को पारित फ़ंक्शन संदर्भ की $ प्राप्त विधि को लागू करके लौटाया जाता है।

उपयोग : एक 'क्लास' फ़ंक्शन को लौटाने के लिए उपयोगी हो सकता है जो तब इंस्टेंस बनाने के लिए नया हो सकता है, लेकिन इंजेक्शन लगाने से पहले कुछ प्रकार के कॉन्फ़िगरेशन की आवश्यकता होती है। शायद उन वर्गों के लिए उपयोगी जो परियोजनाओं में पुन: प्रयोज्य हैं? अभी भी इस पर एक तरह का हाज़िर है। ”बेन

Answer 15

मुझे थोड़ी देर के लिए यह भ्रम था और मैं यहां एक सरल विवरण प्रदान करने की पूरी कोशिश कर रहा हूं। आशा है कि यह मदद करेगा!

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

इस सेवा को इंजेक्ट करते समय (जैसे आपके कंट्रोलर को):

• कोणीय वस्तु को वापस करने के लिए आपके दिए गए फ़ंक्शन (as ) को कॉल करेगाmyService()
• सिंगलटन - केवल एक बार कहा जाता है, संग्रहीत किया जाता है, और एक ही वस्तु को पारित करता है।

---

सर्विस

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

यदि आप अपनी सेवा को एक कंस्ट्रक्टर फ़ंक्शन ( thisकीवर्ड का उपयोग करके ) से प्रारंभ करना चाहते हैं , तो आपको इस serviceविधि का उपयोग करना होगा ।

जैसे

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

app.service('myService', myService);

इस सेवा को इंजेक्ट करते समय (जैसे आपके कंट्रोलर को):

• कोणीय वस्तु को वापस करने के लिए newआपके दिए गए फ़ंक्शन (एस new myService()) को निगलेगा
• सिंगलटन - केवल एक बार कहा जाता है, संग्रहीत किया जाता है, और एक ही वस्तु को पारित करता है।

---

नोट: यदि आप के factoryसाथ <constructor function>या इसके serviceसाथ उपयोग करते हैं <function with a return value>, तो यह काम नहीं करेगा।

---

उदाहरण - DEMO

• कोणीय सेवा बनाम कारखाना
• कोणीय सेवा बनाम कारखाना (मार्ग के साथ)

Answer 16

यह वही है जिसने मुझे अंतर को समझने में मदद की, पास्कल प्रीचट के एक ब्लॉग पोस्ट के लिए धन्यवाद।

एक सेवा एक मॉड्यूल पर एक विधि है जो एक नाम और एक फ़ंक्शन लेता है जो सेवा को परिभाषित करता है। आप उस विशेष सेवा को अन्य घटकों जैसे नियंत्रक, निर्देश और फ़िल्टर में इंजेक्ट और उपयोग कर सकते हैं। एक कारखाने मॉड्यूल पर एक विधि है और यह एक नाम और एक फ़ंक्शन भी लेता है, जो कारखाने को परिभाषित करता है। हम इसे उसी तरह से इंजेक्ट और उपयोग कर सकते हैं जैसे हमने सेवा के साथ किया था।

नई के साथ बनाई गई वस्तुएँ उनके निर्माता फ़ंक्शन के प्रोटोटाइप संपत्ति के मूल्य को उनके प्रोटोटाइप के रूप में उपयोग करती हैं, इसलिए मुझे एंगुलर कोड मिला जो Object.create () कहता है, मेरा मानना ​​है कि यह सेवा निर्माता फ़ंक्शन है जब यह त्वरित हो जाता है। हालांकि, एक फैक्ट्री फ़ंक्शन वास्तव में केवल एक फ़ंक्शन है जिसे कॉल किया जाता है, यही वजह है कि हमें फैक्ट्री के लिए एक वस्तु शाब्दिक लौटना पड़ता है।

यहाँ कोणीय 1.5 कोड है जो मुझे कारखाने के लिए मिला है:

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

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

कारखाने के लिए कोणीय स्रोत कोड स्निपेट () फ़ंक्शन:

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

यह नाम और फैक्ट्री फ़ंक्शन लेता है जो पारित हो जाता है और एक प्रदाता को उसी नाम से लौटाता है, जिसमें $ प्राप्त करने की विधि होती है जो हमारे कारखाने का कार्य है। जब भी आप इंजेक्टर को एक विशिष्ट निर्भरता के लिए पूछते हैं, तो यह मूल रूप से उस प्रदाता की उस सेवा के लिए $ get () पद्धति को कॉल करके पूछता है। इसलिए प्रदाता बनाते समय $ प्राप्त () की आवश्यकता होती है।

यहां सेवा के लिए कोणीय 1.5 कोड है।

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

यह पता चला है कि जब हम सेवा () कहते हैं, तो यह वास्तव में कारखाना () कहता है! हालाँकि, यह कारखाने के लिए हमारे सेवा निर्माण कार्य को पास नहीं करता है। यह एक फ़ंक्शन भी पास करता है जो इंजेक्टर को दिए गए कंस्ट्रक्टर द्वारा किसी वस्तु को तुरंत हटाने के लिए कहता है।

दूसरे शब्दों में, यदि हम MyService को कहीं इंजेक्ट करते हैं, तो कोड में क्या होता है:

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

इसे फिर से स्थापित करने के लिए, एक सेवा एक कारखाने को बुलाती है, जो संबंधित प्रदाता पर एक $ प्राप्त () विधि है। इसके अलावा, $ injector.instantiate () वह विधि है जो अंततः कंस्ट्रक्टर फ़ंक्शन के साथ Object.create () को कॉल करती है। इसलिए हम सेवाओं में "इस" का उपयोग करते हैं।

ES5 के लिए यह कोई फर्क नहीं पड़ता कि हम किसका उपयोग करते हैं: सेवा () या कारखाना (), यह हमेशा एक कारखाना है जिसे कहा जाता है जो हमारी सेवा के लिए एक प्रदाता बनाता है।

आप सेवाओं के साथ भी ठीक यही काम कर सकते हैं। एक सेवा एक निर्माण कार्य है, हालांकि, यह हमें वस्तु शाब्दिक रिटर्न से नहीं रोकता है। इसलिए हम अपना सेवा कोड ले सकते हैं और इसे इस तरह से लिख सकते हैं कि यह मूल रूप से हमारे कारखाने या दूसरे शब्दों में ठीक वैसा ही काम करता है, आप किसी वस्तु को वापस करने के लिए एक कारखाने के रूप में सेवा लिख ​​सकते हैं।

ज्यादातर लोग सेवाओं पर कारखानों का उपयोग करने की सलाह क्यों देते हैं? यह सबसे अच्छा उत्तर है जो मैंने देखा है जो पावेल कोज़लोस्की की पुस्तक: मास्टेरिंग वेब एप्लीकेशन डेवलपमेंट विथ एंगुलरजेएस।

फैक्ट्री विधि एंगुलरजेएस निर्भरता इंजेक्शन प्रणाली में वस्तुओं को प्राप्त करने का सबसे आम तरीका है। यह बहुत लचीला है और इसमें परिष्कृत सृजन तर्क हो सकते हैं। चूंकि कारखाने नियमित कार्य हैं, इसलिए हम "निजी" चर का अनुकरण करने के लिए एक नए शाब्दिक दायरे का लाभ भी उठा सकते हैं। यह बहुत उपयोगी है क्योंकि हम किसी दिए गए सेवा के कार्यान्वयन विवरण छिपा सकते हैं। ”

Answer 17

• साथ कारखाने आप वास्तव में एक बनाने वस्तु के अंदर कारखाना और इसे वापस।
• सेवा के साथ आपके पास एक मानक फ़ंक्शन है जो फ़ंक्शन this को परिभाषित करने के लिए कीवर्ड का उपयोग करता है।
• साथ प्रदाता वहाँ एक है $getआप को परिभाषित करने और इसे इस्तेमाल किया जा सकता प्राप्त करने के लिए उद्देश्य यह है कि डेटा देता है।

Answer 18

AngularJS में व्यावसायिक तर्क को संभालने के तीन तरीके हैं: ( Yaakov's Coursera AngularJS पाठ्यक्रम से प्रेरित ) जो हैं:

1. सर्विस
2. फ़ैक्टरी
3. प्रदाता

यहां हम केवल सेवा बनाम कारखाने के बारे में बात करने जा रहे हैं

सेवा :

वाक्य - विन्यास:

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

index.html

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

सेवा की मुख्य विशेषताएं:

1. आलसी त्वरित : यदि सेवा को इंजेक्ट नहीं किया जाता है तो यह कभी भी त्वरित नहीं होगा। तो इसका उपयोग करने के लिए आपको इसे एक मॉड्यूल में इंजेक्ट करना होगा।

2. सिंगलटन : यदि इसे कई मॉड्यूल में इंजेक्ट किया जाता है, तो सभी की पहुंच केवल एक विशेष उदाहरण तक होगी। इसीलिए, विभिन्न नियंत्रकों में डेटा साझा करना बहुत सुविधाजनक है।

फैक्टरी

अब बात करते हैं AngularJS में फैक्ट्री की

पहले सिंटैक्स पर एक नजर डालते हैं :

app.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()पद्धति का उपयोग आमतौर पर किसी चीज़ के लिए एक शॉर्टकट के रूप में किया जाता है जिसे किसी भी कॉन्फ़िगरेशन की आवश्यकता नहीं होती है।

Answer 19

संक्षिप्त और सरल स्पष्टीकरण के लिए https://stackoverflow.com/a/26924234/5811973 देखें ।

विस्तृत विवरण के लिए https://stackoverflow.com/a/15666049/5811973 देखें ।

इसके अलावा angularJs प्रलेखन से:

Answer 20

आप इस सादृश्य के साथ अंतर को समझ सकते हैं - एक सामान्य फ़ंक्शन के बीच के अंतर पर विचार करें जो कुछ मूल्य और निर्माता फ़ंक्शन को लौटाएगा जो नए कीवर्ड का उपयोग करके त्वरित हो जाएगा। कारखाने का निर्माण सामान्य फ़ंक्शन बनाने के लिए समान है जो कुछ मान लौटाएगा (आदिम या ऑब्जेक्ट) सेवा बनाते समय निर्माण फ़ंक्शन (OO वर्ग) बनाना जैसा होता है, जिसमें हम नए कीवर्ड का उपयोग करके उदाहरण बना सकते हैं। ध्यान देने वाली बात केवल यह है कि जब हम सेवाओं को बनाने के लिए सेवा पद्धति का उपयोग करते हैं तो यह स्वतः ही इसका उदाहरण बना देगा, जो कि AngularJS द्वारा समर्थित निर्भरता इंजेक्शन तंत्र का उपयोग कर