AngularJS: कारखाने के बजाय सेवा का उपयोग कब करें




angularjs-service angularjs-factory (7)

कारखाने और सेवा दोनों में सिंगलटन ऑब्जेक्ट्स होते हैं जो प्रदाताओं द्वारा कॉन्फ़िगर किए जाते हैं और नियंत्रकों में इंजेक्शन और ब्लॉक चलाते हैं। इंजेक्शन के दृष्टिकोण से, वस्तु में फैक्ट्री या सेवा से कोई फर्क नहीं पड़ता है।

तो, कारखाने का उपयोग कब करें, और कब सेवा का उपयोग करें? यह आपके कोडिंग वरीयता के लिए उबाल जाता है, और कुछ और नहीं। यदि आप मॉड्यूलर जेएस पैटर्न पसंद करते हैं तो कारखाने के लिए जाएं। यदि आपको कन्स्ट्रक्टर फ़ंक्शन ("क्लास") शैली पसंद है तो सेवा के लिए जाएं। ध्यान दें कि दोनों शैलियों निजी सदस्यों का समर्थन करते हैं।

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

कृपया मेरे साथ यहाँ भालू। मुझे पता है कि अन्य उत्तर भी हैं जैसे: AngularJS: सेवा बनाम प्रदाता बनाम फैक्ट्री

हालांकि जब भी आप फैक्ट्री पर सेवा का उपयोग करेंगे तो मैं अभी भी पता नहीं लगा सकता।

जो मैं कारखाने को बता सकता हूं उससे आम तौर पर "सामान्य" फ़ंक्शंस बनाने के लिए उपयोग किया जाता है जिसे एकाधिक नियंत्रकों द्वारा बुलाया जा सकता है: सामान्य नियंत्रक फ़ंक्शन बनाना

कोणीय दस्तावेज़ सेवा पर फैक्ट्री पसंद करते हैं। वे कारखाने का उपयोग करते समय भी "सेवा" का उल्लेख करते हैं जो और भी भ्रमित है! http://docs.angularjs.org/guide/dev_guide.services.creating_services

तो जब कोई सेवा का उपयोग करेगा?

क्या ऐसा कुछ है जो सेवा के साथ केवल संभव या बहुत आसान है?

दृश्यों के पीछे क्या कुछ अलग है? प्रदर्शन / स्मृति मतभेद?

यहां एक उदाहरण दिया गया है। घोषणा की विधि के अलावा, वे समान दिखते हैं और मैं यह नहीं समझ सकता कि मैं एक बनाम एक क्यों करूँगा। http://jsfiddle.net/uEpkE/

अद्यतन: थॉमस के उत्तर से ऐसा लगता है कि सेवा निजी तरीकों के साथ अधिक जटिल तर्क के लिए सरल तर्क और कारखाने के लिए है, इसलिए मैंने नीचे दिए गए पहेली कोड को अपडेट किया और ऐसा लगता है कि दोनों निजी कार्यों का समर्थन करने में सक्षम हैं?

myApp.factory('fooFactory', function() {
    var fooVar;
    var addHi = function(foo){ fooVar = 'Hi '+foo; }

    return {
        setFoobar: function(foo){
            addHi(foo);
        },
        getFoobar:function(){
            return fooVar;
        }
    };
});
myApp.service('fooService', function() {
    var fooVar;
    var addHi = function(foo){ fooVar = 'Hi '+foo;}

    this.setFoobar = function(foo){
        addHi(foo);
    }
    this.getFoobar = function(){
        return fooVar;
    }
});

function MyCtrl($scope, fooService, fooFactory) {
    fooFactory.setFoobar("fooFactory");
    fooService.setFoobar("fooService");
    //foobars = "Hi fooFactory, Hi fooService"
    $scope.foobars = [
        fooFactory.getFoobar(),
        fooService.getFoobar()
    ];
}

व्याख्या

आपको यहां विभिन्न चीज़ें मिल गईं:

प्रथम:

  • यदि आप किसी सेवा का उपयोग करते हैं तो आपको एक फ़ंक्शन का उदाहरण मिलेगा (" this " कीवर्ड)।
  • यदि आप किसी कारखाने का उपयोग करते हैं तो आपको फ़ंक्शन संदर्भ (फ़ैक्टरी में वापसी विवरण) का आविष्कार करके वापस किया जाएगा

ref: angular.service बनाम angular.factory

दूसरा:

ध्यान रखें AngularJS (मूल्य, निरंतर, सेवाओं, कारखानों) में सभी प्रदाताओं सिंगलेट हैं!

तीसरा:

एक या दूसरे (सेवा या फैक्ट्री) का उपयोग कोड शैली के बारे में है। लेकिन, AngularJS में आम तरीका फैक्ट्री का उपयोग करना है।

क्यूं कर ?

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

( रेफरी : http://www.amazon.com/Mastering-Web-Application-Development-AngularJS/dp/1782161821 वेब- एप्लीकेशन- विकास- अंगुलर जेएस http://www.amazon.com/Mastering-Web-Application-Development-AngularJS/dp/1782161821 डीपी / http://www.amazon.com/Mastering-Web-Application-Development-AngularJS/dp/1782161821 )।

प्रयोग

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

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

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

अन्य मामलों में यदि आप किसी सेवा का उदाहरण वापस करना चाहते हैं तो बस सेवा का उपयोग करें

लेकिन आप समय के साथ देखेंगे कि आप 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

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

अद्यतन करें :

AngularJS टीम अपना काम करती है और स्पष्टीकरण देती है: http://docs.angularjs.org/guide/providers

और इस पृष्ठ से:

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


एक सेवा के मुकाबले कोई फैक्ट्री नहीं कर सकती है या बेहतर नहीं करती है। और उपाध्यक्ष। फैक्टरी बस अधिक लोकप्रिय प्रतीत होता है। इसका कारण निजी / सार्वजनिक सदस्यों को संभालने में इसकी सुविधा है। इस संबंध में सेवा अधिक बेकार होगी। किसी सेवा को कोड करते समय आप अपने ऑब्जेक्ट सदस्यों को "इस" कीवर्ड के माध्यम से सार्वजनिक करते हैं और अचानक पता लगा सकते हैं कि वे सार्वजनिक सदस्य निजी तरीकों (यानी आंतरिक कार्यों) के लिए दृश्यमान नहीं हैं।

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'

कोणीय आपके लिए एक सेवा बनाने के लिए "नया" कीवर्ड का उपयोग करता है, इसलिए उदाहरण के लिए कोणीय पास नियंत्रक को समान कमी होगी। बेशक आप इस / इसका उपयोग करके समस्या से उबर सकते हैं:

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'  

लेकिन एक बड़ी सेवा स्थिरता के साथ यह \ N-ing कोड को खराब पठनीय बना देगा। इसके अलावा, सेवा प्रोटोटाइप निजी सदस्यों को नहीं देख पाएंगे - केवल सार्वजनिक ही उनके लिए उपलब्ध होगा:

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'

फैक्टरी का उपयोग करके इसे सारांशित करना अधिक सुविधाजनक है। चूंकि फैक्ट्री में इन कमीएं नहीं हैं। मैं डिफ़ॉल्ट रूप से इसका उपयोग करने की सिफारिश करता हूं।


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

यह दिखाता है कि कैसे कार सेवा हमेशा 4 सिलेंडर वाली कार का उत्पादन करेगी, आप इसे अलग-अलग कारों के लिए नहीं बदल सकते हैं। जबकि कारफैक्टरी एक फ़ंक्शन देता है ताकि आप उस कार के लिए विशिष्ट सिलेंडरों में गुजरने के दौरान अपने नियंत्रक में new CarFactory कर सकें। आप new 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;
});

देखें कि यह वास्तव में एक कार का उत्पादन करने वाला कारखाना है।

उनके ब्लॉग से निष्कर्ष बहुत अच्छा है:

निष्कर्ष के तौर पर,

---------------------------------------------------  
| Provider| Singleton| Instantiable | Configurable|
---------------------------------------------------  
| Factory | Yes      | Yes          | No          |
---------------------------------------------------  
| Service | Yes      | No           | No          |
---------------------------------------------------  
| Provider| Yes      | Yes          | Yes         |       
---------------------------------------------------  
  1. सेवा का उपयोग करें जब आपको केवल एक साधारण वस्तु की आवश्यकता होती है जैसे हैश, उदाहरण के लिए {foo; 1, bar: 2} यह कोड करना आसान है, लेकिन आप इसे तुरंत चालू नहीं कर सकते हैं।

  2. फैक्ट्री का प्रयोग करें जब आपको किसी ऑब्जेक्ट को चालू करने की आवश्यकता होती है, यानी नया ग्राहक (), नई टिप्पणी () इत्यादि।

  3. जब आप इसे कॉन्फ़िगर करने की आवश्यकता हो तो प्रदाता का उपयोग करें। यानी परीक्षण यूआरएल, क्यूए यूआरएल, उत्पादन यूआरएल।

यदि आप पाते हैं कि आप कारखाने में ऑब्जेक्ट लौट रहे हैं तो आपको शायद सेवा का उपयोग करना चाहिए।

ऐसा मत करो:

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

इसके बजाय सेवा का उपयोग करें:

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

आप जिस तरह से चाहते हैं उसका उपयोग कर सकते हैं : चाहे ऑब्जेक्ट या just दोनों को फ़ंक्शंस एक्सेस करने के लिए बनाएं

आप सेवा से नई वस्तु बना सकते हैं

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

ध्यान दें :

  • डिफ़ॉल्ट रिटर्न कन्स्ट्रक्टर फ़ंक्शन द्वारा फैक्ट्री और ऑब्जेक्ट नहीं।
  • इसलिए यही कारण है कि कन्स्ट्रक्टर फ़ंक्शन के साथ नई ऑब्जेक्ट बनाई जा सकती है।

सरल कार्यों तक पहुंचने के लिए सेवा बनाएं

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

निष्कर्ष:

  • आप जिस तरह से चाहते हैं कि आप नई वस्तुएं बनाना चाहते हैं या बस सरल कार्यों तक पहुंचने के लिए उपयोग कर सकते हैं
  • दूसरे पर एक का उपयोग करके कोई प्रदर्शन हिट नहीं होगी
  • दोनों सिंगलटन ऑब्जेक्ट्स हैं और प्रति ऐप केवल एक उदाहरण बनाया गया है।
  • केवल एक उदाहरण होने के नाते जहां उनका संदर्भ पारित किया जाता है।
  • कोणीय दस्तावेज कारखाने में सेवा कहा जाता है और सेवा को सेवा भी कहा जाता है

यहां तक ​​कि जब वे कहते हैं कि सभी सेवाएं और कारखानियां सिंगलटन हैं, तो मैं इसके साथ 100 प्रतिशत सहमत नहीं हूं। मैं कहूंगा कि कारखाने सिंगलेट नहीं हैं और यह मेरे जवाब का मुद्दा है। मैं वास्तव में उस नाम के बारे में सोचूंगा जो हर घटक (सेवा / फैक्टरी) को परिभाषित करता है, मेरा मतलब है:

एक कारखाना क्योंकि सिंगलटन नहीं है, आप इंजेक्ट करते समय जितना चाहें उतना बना सकते हैं, इसलिए यह वस्तुओं के कारखाने की तरह काम करता है। आप अपने डोमेन की एक इकाई का कारखाना बना सकते हैं और इस ऑब्जेक्ट के साथ अधिक आराम से काम कर सकते हैं जो आपके मॉडल की ऑब्जेक्ट की तरह हो सकता है। जब आप कई ऑब्जेक्ट्स पुनर्प्राप्त करते हैं तो आप उन्हें इन ऑब्जेक्ट्स में मैप कर सकते हैं और यह डीडीबीबी और एंगुलरजेएस मॉडल के बीच एक और परत की तरह काम कर सकता है। आप ऑब्जेक्ट्स में विधियों को जोड़ सकते हैं ताकि आप ऑब्जेक्टजेस ऐप को थोड़ी अधिक ऑब्जेक्ट्स के लिए उन्मुख कर सकें।

इस बीच एक सेवा एक सिंगलटन है, इसलिए हम केवल एक प्रकार का बना सकते हैं, शायद नहीं बना सकते हैं, लेकिन जब हम नियंत्रक में इंजेक्ट करते हैं तो हमारे पास केवल 1 उदाहरण होता है, इसलिए एक सेवा एक सामान्य सेवा (बाकी कॉल, कार्यक्षमता ..) जैसी अधिक प्रदान करती है। नियंत्रकों के लिए।

संकल्पनात्मक रूप से आप सोच सकते हैं कि सेवाएं एक सेवा प्रदान करती हैं, कारखानियां कक्षा के कई उदाहरण (ऑब्जेक्ट्स) बना सकती हैं


सेवाएं

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

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

कारखाना

सिंटेक्स : module.factory ('factoryName', फ़ंक्शन);

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

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

प्रदाताओं

सिंटेक्स : module.provider ('प्रदाता नाम', फ़ंक्शन);

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

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





angularjs-factory