क्या Http विधियों द्वारा बनाई गई वेधशालाओं से सदस्यता समाप्त करना आवश्यक है?

Question

क्या आपको स्मृति रिसाव को रोकने के लिए कोणीय 2 http कॉल से सदस्यता समाप्त करने की आवश्यकता है?

 fetchFilm(index) {
        var sub = this._http.get(`http://example.com`)
            .map(result => result.json())
            .map(json => {
                dispatch(this.receiveFilm(json));
            })
            .subscribe(e=>sub.unsubscribe());
            ...

Comments

कोणीय 2 में स्मृति रिसाव

— एरिक मार्टिनेज

देखें stackoverflow.com/questions/34461842/… (और साथ ही टिप्पणियां)

— एरिक मार्टिनेज

Answer 1

तो जवाब है नहीं, आप नहीं। Ng2इसे खुद साफ करेंगे।

Http सेवा स्रोत, कोणीय के Http XHR बैकएंड स्रोत से:

ध्यान दें कि complete()परिणाम प्राप्त करने के बाद यह कैसे चलता है । इसका मतलब यह वास्तव में पूरा होने पर सदस्यता समाप्त कर देता है। इसलिए आपको इसे स्वयं करने की आवश्यकता नहीं है।

यहाँ मान्य करने के लिए एक परीक्षा है:

  fetchFilms() {
    return (dispatch) => {
        dispatch(this.requestFilms());

        let observer = this._http.get(`${BASE_URL}`)
            .map(result => result.json())
            .map(json => {
                dispatch(this.receiveFilms(json.results));
                dispatch(this.receiveNumberOfFilms(json.count));
                console.log("2 isUnsubscribed",observer.isUnsubscribed);
                window.setTimeout(() => {
                  console.log("3 isUnsubscribed",observer.isUnsubscribed);
                },10);
            })
            .subscribe();
        console.log("1 isUnsubscribed",observer.isUnsubscribed);
    };
}

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

और नतीजा

इसलिए, कोई भी रिसाव Ng2ऑटो अनसब्सक्राइबर्स के रूप में मौजूद नहीं होगा !

उल्लेख करना अच्छा है: Observableइसे वर्गीकृत किया गया है finite, इसके विपरीत infinite Observableजो डेटा की एक अनंत धारा है उसे DOM की तरह उत्सर्जित किया जा सकता हैclick उदाहरण के लिए श्रोता की ।

इस पर मदद के लिए धन्यवाद, @rubyboy।

Comments

उन मामलों में क्या होता है जहां उपयोगकर्ता प्रतिक्रिया आने से पहले पृष्ठ छोड़ देता है, या यदि उपयोगकर्ता को देखने से पहले प्रतिक्रिया कभी नहीं आती है? क्या इससे रिसाव नहीं होगा?

— थिबस

मैं ऊपर भी जानना चाहूंगा।

— 1984

@ 1984 का जवाब हमेशा की तरह है। यह उत्तर इस टिप्पणी में दिए गए कारण के लिए पूरी तरह से गलत है। दूर नेविगेट करने वाला उपयोगकर्ता एक मेमोरी लिंक है। इसके अलावा, अगर उस सदस्यता का कोड उपयोगकर्ता द्वारा नेविगेट किए जाने के बाद चलता है तो यह त्रुटियों का कारण हो सकता है / अप्रत्याशित दुष्प्रभाव हो सकता है। मैं सभी वेधशालाओं पर takeWhile (() => this.componentActive) का उपयोग करता हूं और बस एक घटक में सभी वेधशालाओं को साफ करने के लिए ng.comDestroy में this.componentActive = false सेट करता हूं।

— लेनी

यहां प्रदर्शित उदाहरण एक गहरी कोणीय निजी एपि को कवर करता है। किसी भी अन्य निजी एपीआई के साथ, यह बिना किसी नोटिस के अपग्रेड के साथ बदल सकता है। अंगूठे का नियम है: यदि यह आधिकारिक रूप से प्रलेखित नहीं है, तो कोई धारणा न बनाएं। उदाहरण के लिए, AsynPipe के पास स्पष्ट दस्तावेज हैं कि वह आपके लिए स्वतः सदस्यता / सदस्यता छोड़ दे। HttpClient डॉक्स उसके बारे में कुछ भी उल्लेख नहीं करते हैं।

— यूसुफफगलाबी

@YoussefTaghlabi, FYI, आधिकारिक कोणीय दस्तावेज ( angular.io/guide/http ) यह उल्लेख करता है कि: "AsyncPipe ग्राहक (और unsubscribes) आपके लिए स्वचालित रूप से।" तो, यह वास्तव में आधिकारिक तौर पर प्रलेखित है।

— हुडी

Answer 2

आप लोग क्या बात कर रहे हैं !!!

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

1) संसाधनों को साफ करें। जैसा कि दूसरों ने कहा है कि यह HTTP वेधशालाओं के लिए एक नगण्य समस्या है। यह सिर्फ खुद को साफ कर देगा।

2) subscribeहैंडलर को चलाने से रोकें ।

(HTTP के लिए यह वास्तव में ब्राउज़र में अनुरोध को भी रद्द कर देगा - इसलिए यह प्रतिक्रिया पढ़ने में समय बर्बाद नहीं करेगा। लेकिन यह वास्तव में नीचे मेरे मुख्य बिंदु पर एक तरफ है।)

नंबर 2 की प्रासंगिकता आपके सब्सक्राइबर हैंडलर पर निर्भर करती है:

यदि आपके subscribe()हैंडलर फंक्शन में किसी भी तरह का साइड इफेक्ट होता है जो कि अवांछित है यदि इसे कॉल या बंद किया जाता है तो इसे निष्पादित करने से रोकने के लिए आपको सदस्यता समाप्त करनी चाहिए (या सशर्त तर्क जोड़ना होगा)।

कुछ मामलों पर विचार करें:

1) एक लॉगिन फ़ॉर्म। आप उपयोगकर्ता नाम और पासवर्ड दर्ज करें और 'लॉगिन' पर क्लिक करें। क्या होगा यदि सर्वर धीमा है और आप डायलॉग को बंद करने के लिए एस्केप हिट करने का निर्णय लेते हैं? आप शायद यह मान लेंगे कि आप लॉग इन नहीं थे, लेकिन यदि आपके भागने के बाद http अनुरोध वापस आया, तो फिर भी आपके पास जो भी तर्क होगा, आप उसे अंजाम देंगे। इसके परिणामस्वरूप एक खाता पृष्ठ, एक अवांछित लॉगिन कुकी या टोकन चर सेट किया जा सकता है। यह शायद वह नहीं है जो आपके उपयोगकर्ता को उम्मीद थी।

2) एक 'ईमेल भेजें' फ़ॉर्म।

यदि subscribe'सेंडइमेल' के लिए हैंडलर ऐसा कुछ करता है, जैसे 'आपका ईमेल भेजा जाता है' एनीमेशन, आपको एक अलग पृष्ठ पर स्थानांतरित करता है या किसी भी चीज़ का उपयोग करने की कोशिश करता है जिसे आप का अपवाद या अवांछित व्यवहार मिल सकता है।

यह भी ध्यान रखें unsubscribe()कि 'रद्द' का अर्थ न हो । एक बार जब HTTP संदेश उड़ान में है, unsubscribe()तो यह HTTP अनुरोध को रद्द नहीं करेगा यदि यह आपके सर्वर पर पहले ही पहुंच चुका है। यह केवल आपके पास वापस आने वाली प्रतिक्रिया को रद्द कर देगा। और ईमेल शायद भेजा जाएगा।

यदि आप एक यूआई घटक के अंदर सीधे ईमेल भेजने के लिए सदस्यता बनाते हैं, तो आप शायद निपटान पर सदस्यता समाप्त करना चाहेंगे, लेकिन यदि ईमेल गैर-यूआई केंद्रीकृत सेवा द्वारा भेजा जा रहा है, तो आपको शायद इसकी आवश्यकता नहीं होगी।

3) एक कोणीय घटक जो नष्ट / बंद होता है। कोई भी http वेधशाला जो अभी भी समय पर चल रही है, पूरी हो जाएगी और अपने तर्क को तब तक चलाएगी जब तक कि आप अनसब्सक्राइब नहीं करतेonDestroy() । परिणाम तुच्छ हैं या नहीं यह इस बात पर निर्भर करेगा कि आप सब्सक्राइबर हैंडलर में क्या करते हैं। यदि आप किसी ऐसी चीज़ को अपडेट करने की कोशिश करते हैं जो अब मौजूद नहीं है तो आपको एक त्रुटि मिल सकती है।

कभी-कभी आपके पास कुछ क्रियाएं हो सकती हैं जो आप चाहते हैं कि घटक का निपटान हो, और कुछ आप नहीं करेंगे। उदाहरण के लिए हो सकता है कि आपके पास भेजे गए ईमेल के लिए 'स्वोश' ध्वनि हो। आप शायद इसे तब भी खेलना चाहेंगे जब घटक बंद हो गया था, लेकिन यदि आप घटक पर एक एनीमेशन चलाने की कोशिश करते हैं तो यह विफल हो जाएगा। उस स्थिति में सदस्यता के अंदर कुछ अतिरिक्त सशर्त तर्क समाधान होंगे - और आप http के अवलोकन योग्य को अनसब्सक्राइब नहीं करना चाहेंगे।

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

युक्ति: Subscriptionएक closedबूलियन संपत्ति होती है जो उन्नत मामलों में उपयोगी हो सकती है। HTTP के लिए यह पूरा होने पर सेट हो जाएगा। कोणीय में यह कुछ स्थितियों में उपयोगी हो सकता है एक _isDestroyedसंपत्ति सेट करें ngDestroyजिसमें आपके subscribeहैंडलर द्वारा जांच की जा सकती है ।

टिप 2: यदि आप कई सब्स्क्रिप्शन को हैंडल कर रहे हैं तो आप एक एड-हॉक new Subscription()ऑब्जेक्ट और उसके लिए add(...)कोई अन्य सब्सक्रिप्शन बना सकते हैं - इसलिए जब आप मुख्य से अनसब्सक्राइब करते हैं तो यह सभी जोड़े गए सब्सक्रिप्शन को भी अनसब्सक्राइब कर देगा।

Comments

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

— सिमोन_विवर

हालांकि ब्राउज़र को अनसब्सक्राइब करना रद्द कर देता है, फिर भी सर्वर अनुरोध पर काम करता है। क्या ऑपरेशन को निरस्त करने के लिए सर्वर को अंतरंग करने का एक तरीका है? मैं त्वरित उत्तराधिकार में http अनुरोध भेज रहा हूं, जिनमें से अधिकांश को सदस्यता समाप्त करके रद्द कर दिया गया है। लेकिन, सर्वर अभी भी क्लाइंट द्वारा रद्द किए गए अनुरोधों पर काम करता है, जिससे वैध अनुरोध की प्रतीक्षा होती है।

— बाला

@bala आपको इसके लिए अपने स्वयं के तंत्र के साथ आना होगा - जिसका RxJS से कोई लेना-देना नहीं होगा। उदाहरण के लिए, आप अनुरोधों को केवल एक तालिका में रख सकते हैं और उन्हें पृष्ठभूमि में 5 सेकंड के बाद चला सकते हैं, तो यदि कुछ रद्द करने की आवश्यकता है तो आप पुरानी पंक्तियों पर एक झंडा हटा देंगे या एक झंडा स्थापित करेंगे जो उन्हें निष्पादित करना बंद कर देगा। पूरी तरह से इस बात पर निर्भर करेगा कि आपका आवेदन क्या है। हालाँकि, जब आप उल्लेख करते हैं कि सर्वर अवरुद्ध हो रहा है, तो इसे एक समय में केवल एक अनुरोध की अनुमति देने के लिए कॉन्फ़िगर किया जा सकता है - लेकिन यह फिर से उस पर निर्भर करेगा जो आप उपयोग कर रहे थे।

— सिमोन_विवर

🔥🔥🔥Tip 2 - एक PRO-TIP है, wants किसी के लिए भी जो केवल एक फ़ंक्शन को कॉल करके कई सदस्यता से सदस्यता समाप्त करना चाहता है। NgDestroy में .add () विधि और से .unsubscribe () का उपयोग करके जोड़ें।

— अभय त्रिपाठी

Answer 3

इस unsubscribeपद्धति को कॉल करना बल्कि इन-प्रोग्रेस HTTP रिक्वेस्ट को रद्द करना है क्योंकि यह विधि abortअंतर्निहित XHR ऑब्जेक्ट पर एक को कॉल करती है और लोड और त्रुटि घटनाओं पर श्रोताओं को हटा देती है:

// From the XHRConnection class
return () => {
  _xhr.removeEventListener('load', onLoad);
  _xhr.removeEventListener('error', onError);
  _xhr.abort();
};

उस ने कहा, unsubscribeश्रोताओं को हटा देता है ... तो यह एक अच्छा विचार हो सकता है लेकिन मुझे नहीं लगता कि यह एक अनुरोध के लिए आवश्यक है;;

आशा है कि यह आपकी मदद करता है, थियरी

Comments

: | वह बेतुका है: | मैं रुकने का रास्ता खोज रहा था ... लेकिन मैं आश्चर्यचकित था, और अगर यह मुझे कोडिंग था, किसी न किसी परिदृश्य में: मैं इसे इस तरह से करूंगा: y = x.subscribe((x)=>data = x); फिर इनपुट में एक उपयोगकर्ता परिवर्तन और x.subscribe((x)=>cachlist[n] = x); y.unsubscribe()अरे आप हमारे सर्वर संसाधनों का उपयोग करते हैं, मैं जीता। 'टी थ्रो y.stop()

— यू

Answer 4

सदस्यता समाप्ति एक है MUST यदि आप एक चाहते नियतात्मक सभी नेटवर्क गति पर व्यवहार।

कल्पना कीजिए कि घटक A को टैब में प्रस्तुत किया गया है - आप 'GET' अनुरोध भेजने के लिए एक बटन क्लिक करते हैं। प्रतिक्रिया आने में 200 एमएस लगते हैं। इसलिए, आप किसी भी क्षण टैब को बंद करने के लिए सुरक्षित हैं, यह जानकर कि मशीन आपसे तेज होगी और http प्रतिक्रिया संसाधित होती है और टैब बंद होने से पहले पूरा हो जाता है और घटक ए नष्ट हो जाता है।

कैसे के बारे में एक बहुत धीमी नेटवर्क पर? आप एक बटन पर क्लिक करते हैं, 'GET' अनुरोध को अपनी प्रतिक्रिया प्राप्त करने में 10 सेकंड लगते हैं, लेकिन 5 सेकंड प्रतीक्षा में आप टैब को बंद करने का निर्णय लेते हैं। यह बाद में एक समय में कचरा एकत्र करने के लिए घटक ए को नष्ट कर देगा। एक मिनट रुकिए! , हमने सदस्यता समाप्त नहीं की - अब 5 सेकंड बाद, एक प्रतिक्रिया वापस आती है और नष्ट हुए घटक में तर्क निष्पादित किया जाएगा। यह निष्पादन अब माना जाता है out-of-contextऔर बहुत कम प्रदर्शन सहित कई चीजों का परिणाम हो सकता है।

इसलिए, takeUntil()घटक नष्ट होने पर http कॉल से उपयोग और सदस्यता समाप्त करना सबसे अच्छा अभ्यास है ।

import { Component, OnInit, OnDestroy } from '@angular/core';
import { HttpClient } from '@angular/common/http';

import { Subject } from 'rxjs';
import { takeUntil } from 'rxjs/operators';

interface User {
  id: string;
  name: string;
  age: number;
}

@Component({
  selector: 'app-foobar',
  templateUrl: './foobar.component.html',
  styleUrls: ['./foobar.component.scss'],
})
export class FoobarComponent implements OnInit, OnDestroy {
  private user: User = null;
  private destroy$ = new Subject();

  constructor(private http: HttpClient) {}

  ngOnInit() {
    this.http
      .get<User>('api/user/id')
      .pipe(takeUntil(this.destroy$))
      .subscribe(user => {
        this.user = user;
      });
  }

  ngOnDestroy(): void {
    this.destroy$.next();  // trigger the unsubscribe
    this.destroy$.complete(); // finalize & clean up the subject stream
  }
}

Comments

क्या इसके BehaviorSubject()बजाय उपयोग करना और सिर्फ कॉल करना ठीक complete()है ngOnDestroy()?

— साक्षाम

आपको अभी भी सदस्यता समाप्त करने की आवश्यकता होगी ... BehaviourSubjectअलग क्यों होगा ?

— बेन टालियाडोरोस

HttpClient वेधशालाओं से सदस्यता समाप्त करने की कोई आवश्यकता नहीं है क्योंकि वे परिमित पर्यवेक्षक हैं, अर्थात वे एक मान उत्सर्जित करने के बाद पूरा करते हैं।

— यथार्थ वार्ष्णेय

आपको वैसे भी सदस्यता समाप्त करनी चाहिए, मान लीजिए कि टोस्ट त्रुटियों के लिए एक इंटरसेप्टर है, लेकिन आपने पहले ही पृष्ठ छोड़ दिया है जो त्रुटि को ट्रिगर करता है .. आपको एक अन्य पृष्ठ में एक त्रुटि संदेश दिखाई देगा .... साथ ही एक स्वास्थ्य-जांच पृष्ठ के बारे में भी सोचें जो सभी microservices ... और इतने पर कॉल

— वाशिंगटन Guedes

Answer 5

नए HttpClient मॉड्यूल के साथ भी, समान व्यवहार रहता है

Comments

उपरोक्त कोड एक यूनिट टेस्ट से प्रतीत होता है, जिसका अर्थ है कि HttpClient के साथ, आपको अपने स्वयं के .complete () पर कॉल करने की आवश्यकता है ( github.com/angular/angular/blob/… )

— CleverPatus

हां, आप सही हैं, लेकिन यदि आप निरीक्षण करते हैं ( github.com/angular/angular/blob/… ) तो आपको वही दिखाई देगा। मुख्य प्रश्न के संबंध में, यदि स्पष्ट रूप से सदस्यता समाप्त करने के लिए आवश्यक है? अधिकांश मामले नहीं, क्योंकि एंगुलर ने खुद को संभाला है। एक ऐसा मामला हो सकता है जिसमें एक लंबी प्रतिक्रिया हो सकती है और आप किसी अन्य मार्ग पर चले गए हैं या शायद एक घटक को नष्ट कर दिया है, इस स्थिति में आपके पास कुछ ऐसा उपयोग करने की कोशिश करने की संभावना है जो अब अपवाद को छोड़कर मौजूद नहीं है।

— रिकार्डो मार्टिनेज

Answer 6

आपको उन पर्यवेक्षकों से सदस्यता समाप्त नहीं करनी चाहिए जो स्वचालित रूप से पूर्ण हो जाते हैं (जैसे Http, कॉल)। लेकिन जैसे कि अनंत वेधशालाओं से सदस्यता समाप्त करना आवश्यक है Observable.timer()।

Answer 7

परीक्षण, पढ़ने के प्रलेखन और HttpClient के सोर्सकोड के कुछ समय बाद।

HttpClient: https://github.com/angular/angular/blob/master/packages/common/http/src/client.ts

HttpXhrBackend : https://github.com/angular/angular/blob/master/packages/common/http/src/xhr.ts

HttpClientModule: https://indepth.dev/exploring-the-httpclientmodule-in-angular/

कोणीय एकजुटता: https://blog.angular-university.io/angular-http/

यह विशेष प्रकार की वेधशालाएँ एकल-मूल्य धाराएँ हैं: यदि HTTP अनुरोध सफल होता है, तो ये वेधशालाएँ केवल एक मान का उत्सर्जन करेंगी और फिर पूर्ण होंगी

और सदस्यता समाप्त करने के लिए "क्या मुझे जरूरत है" के पूरे मुद्दे का जवाब?

निर्भर करता है। Http कॉल Memoryleaks कोई समस्या नहीं है। आपके कॉलबैक फ़ंक्शन में समस्याएँ तर्क हैं।

उदाहरण के लिए: रूटिंग या लॉगिन।

यदि आपका कॉल एक लॉगिन कॉल है, तो आपको "सदस्यता समाप्त" करने की ज़रूरत नहीं है, लेकिन यदि उपयोगकर्ता पृष्ठ छोड़ देता है, तो आपको यह सुनिश्चित करने की आवश्यकता है कि आप उपयोगकर्ता की अनुपस्थिति में प्रतिक्रिया को ठीक से संभालते हैं।

this.authorisationService
      .authorize(data.username, data.password)
      .subscribe((res: HttpResponse<object>) => {
          this.handleLoginResponse(res);
        },
        (error: HttpErrorResponse) => {
          this.messageService.error('Authentication failed');
        },
        () => {
          this.messageService.info('Login has completed');
        })

कष्टप्रद से खतरनाक तक

अब बस कल्पना करें, नेटवर्क सामान्य से धीमा है, कॉल में 5 सेकंड का समय लगता है, और उपयोगकर्ता लॉगिन दृश्य छोड़ देता है और "समर्थन दृश्य" पर जाता है।

घटक सक्रिय नहीं हो सकता है लेकिन सदस्यता है। एक प्रतिक्रिया के मामले में, उपयोगकर्ता को अचानक पुन: आउट किया जाएगा (आपके हैंडल पर निर्भर करता है) (कार्यान्वयन)।

यह अच्छा नहीं है।

इसके अलावा बस कल्पना करें कि उपयोगकर्ता पीसी को छोड़ देता है, विश्वास है कि वह अभी तक लॉग इन नहीं हुआ है। लेकिन आप तर्क उपयोगकर्ता को लॉग इन करते हैं, अब आपके पास एक सुरक्षा मुद्दा है।

आप सदस्यता समाप्त किए बिना क्या कर सकते हैं?

क्या आप कॉल को वर्तमान स्थिति पर निर्भर करते हैं:

  public isActive = false;
  public ngOnInit(): void {
    this.isActive = true;
  }

  public ngOnDestroy(): void {
    this.isActive = false;
  }

.pipe(takeWhile(value => this.isActive))यह सुनिश्चित करने के लिए कि प्रतिक्रिया सक्रिय होने पर उपयोगकर्ता को केवल हैंडल किया जाता है।

this.authorisationService
      .authorize(data.username, data.password).pipe(takeWhile(value => this.isActive))
      .subscribe((res: HttpResponse<object>) => {
          this.handleLoginResponse(res);
        },
        (error: HttpErrorResponse) => {
          this.messageService.error('Authentication failed');
        },
        () => {
          this.messageService.info('Login has completed');
        })

लेकिन आप यह कैसे सुनिश्चित कर सकते हैं कि सदस्यता मेमोरीली का कारण नहीं बन रही है?

यदि आप "taddownLogic" लागू होते हैं तो लॉग इन कर सकते हैं।

जब सबक्रिप्शन खाली या सदस्यता समाप्त हो जाती है, तो एक सदस्यता की अशांति को कहा जाएगा।

this.authorisationService
      .authorize(data.username, data.password).pipe(takeWhile(value => this.isActive))
      .subscribe((res: HttpResponse<object>) => {
          this.handleLoginResponse(res);
        },
        (error: HttpErrorResponse) => {
          this.messageService.error('Authentication failed');
        },
        () => {
          this.messageService.info('Login has completed');
    }).add(() => {
        // this is the teardown function
        // will be called in the end
      this.messageService.info('Teardown');
    });

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

हमेशा अनबन क्यों नहीं होती?

कल्पना कीजिए कि आप एक पुट या पोस्ट अनुरोध करते हैं। सर्वर संदेश को किसी भी तरह से पढ़ता है, बस प्रतिक्रिया में कुछ समय लगता है। सदस्यता समाप्त करना, पोस्ट को पूर्ववत नहीं करेगा या डाला नहीं जाएगा। लेकिन जब आप सदस्यता समाप्त कर लेते हैं, तो आपके पास प्रतिक्रिया को संभालने या उपयोगकर्ता को सूचित करने का मौका नहीं होगा, उदाहरण के लिए डायलॉग या टॉयलेट पेपर आदि के माध्यम से।

Wich उपयोगकर्ता को विश्वास करने का कारण बनता है, कि पुट / पोस्ट अनुरोध नहीं किया गया था।

तो यह निर्भर करता है। ऐसे मुद्दों से कैसे निपटना है, यह आपका डिजाइन निर्णय है।

Answer 8

आपको यह लेख जरूर पढ़ना चाहिए । यह आपको दिखाता है कि आपको हमेशा http से भी सदस्यता समाप्त क्यों करनी चाहिए ।

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

अपडेट करें

उपरोक्त पुष्टि सही प्रतीत होती है, लेकिन फिर भी, जब जवाब वापस आता है तो http सदस्यता वैसे भी नष्ट हो जाती है

Comments

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

— साइमन_वेवर

Answer 9

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

वे पहरेदारों के एक ही अंदाज़ में काम करते हैं लेकिन काफी अलग क्रम में। जब घटक नष्ट हो रहा हो तो उन्हें अनसब्सक्राइब करने का बेहतर अभ्यास। हम बाद में ऐसा कर सकते हैं । इस। $ manageSubscription.unsubscibe ()

अगर हमने नीचे दिए गए वाक्यविन्यास जैसे अवलोकन को बनाया है जैसे कि

** नए प्रेक्षण योग्य ((पर्यवेक्षक) => {** // वापस लौटें) यह ठंडी अवस्था में अवलोकनीय बनाता है ।