क्या कोई मुझे सरल शब्दों में क्लोजर ट्रांसड्यूसर समझा सकता है?

100

मैंने इस पर पढ़ने की कोशिश की है, लेकिन मुझे अभी भी उनके मूल्य या वे क्या बदलते हैं, यह समझ में नहीं आता है। और क्या वे मेरे कोड को छोटा, अधिक समझने योग्य या क्या बनाते हैं?

अपडेट करें

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

clojure transducer

— appshare.co
स्रोत

75

ट्रांसड्यूसर ऐसी रेसिपी हैं जो बिना ज्ञान के डेटा के अनुक्रम के साथ क्या करती हैं, अंतर्निहित अनुक्रम क्या है (इसे कैसे करें)। यह किसी भी seq, async चैनल या शायद अवलोकन योग्य हो सकता है।

वे रचना योग्य और बहुरूपी हैं।

लाभ यह है, आपको हर बार नया डेटा स्रोत जोड़ने पर सभी मानक कॉम्बिनेटरों को लागू करने की आवश्यकता नहीं होती है। बार बार। परिणामस्वरूप प्रभाव के रूप में उपयोगकर्ता विभिन्न डेटा स्रोतों पर उन व्यंजनों का पुन: उपयोग करने में सक्षम हैं।

विज्ञापन अद्यतन

क्लोजर के पूर्व संस्करण 1.7 में आपके पास डेटाफ्लो क्वेश्चन लिखने के तीन तरीके थे:

नेस्टेड कॉल

    (reduce + (filter odd? (map #(+ 2 %) (range 0 10))))

कार्यात्मक रचना

    (def xform
      (comp
        (partial filter odd?)
        (partial map #(+ 2 %))))
    (reduce + (xform (range 0 10)))

थ्रेडिंग मैक्रो

    (defn xform [xs]
      (->> xs
           (map #(+ 2 %))
           (filter odd?)))
    (reduce + (xform (range 0 10)))

ट्रांसड्यूसर्स के साथ आप इसे लिखेंगे:

(def xform
  (comp
    (map #(+ 2 %))
    (filter odd?)))
(transduce xform + (range 0 10))

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

(chan 1 xform)

— अलेश रूबाइक
स्रोत

3

मैं एक उत्तर की तलाश में था जो एक उदाहरण के साथ आता है जो मुझे दिखाता है कि ट्रांसड्यूसर मुझे समय कैसे बचाते हैं।

— appshare.co

वे नहीं करते हैं तो आप क्लोजर या कुछ डेटाफ्लो काम नहीं कर रहे हैं।

— एलेक रौबिके

5

इसका तकनीकी निर्णय नहीं है। हम केवल व्यावसायिक मूल्य आधारित निर्णयों का उपयोग करते हैं। "बस उनका उपयोग करें" मुझे निकाल दिया जाएगा

— appshare.co

1

यदि आप क्लोजर 1.7 जारी होने तक ट्रांसड्यूसर का उपयोग करने की कोशिश में देरी करते हैं तो आपके पास अपनी नौकरी रखने का एक आसान समय हो सकता है।

— user100464

7

ट्रांसड्यूसर विभिन्न प्रकार के चलने योग्य वस्तुओं पर अमूर्त करने का एक उपयोगी तरीका लगता है। ये गैर-उपभोग्य हो सकते हैं, जैसे कि क्लोजर seq, या उपभोज्य (जैसे async चैनल)। इस संबंध में, मुझे लगता है कि आप ट्रांसड्यूसर का उपयोग करने से बहुत लाभान्वित होंगे यदि, उदाहरण के लिए, आप एक seq- आधारित कार्यान्वयन से कोर का उपयोग करके स्विच करते हैं। ट्रांसड्यूसर्स को आपको अपने तर्क के मूल को अपरिवर्तित रखने की अनुमति देनी चाहिए। पारंपरिक अनुक्रम-आधारित प्रसंस्करण का उपयोग करके आपको ट्रांसड्यूसर या कुछ कोर-एसिंक्स एनालॉग का उपयोग करने के लिए इसे परिवर्तित करना होगा। यही व्यवसाय का मामला है।

— नाथन डेविस

47

ट्रांसड्यूसर दक्षता में सुधार करते हैं, और आपको अधिक मॉड्यूलर तरीके से कुशल कोड लिखने की अनुमति देते हैं।

यह एक सभ्य माध्यम है ।

वर्ष के लिए कॉल रचना की तुलना में map, filter,reduce आदि आपको बेहतर प्रदर्शन मिलता है क्योंकि आपको प्रत्येक चरण के बीच मध्यवर्ती संग्रह बनाने की आवश्यकता नहीं होती है, और बार-बार उन संग्रह को चलना चाहिए।

तुलना में reducers, या मैन्युअल रूप से एक ही अभिव्यक्ति में अपने सभी आपरेशनों की तुलना में, आप अमूर्त उपयोग करने के लिए आसान हो, बेहतर modularity और प्रसंस्करण कार्यों का पुन: उपयोग।

— noisesmith
स्रोत

2

बस उत्सुक, आपने ऊपर कहा: "प्रत्येक चरण के बीच मध्यवर्ती संग्रह बनाने के लिए"। लेकिन एक विरोधी पैटर्न की तरह "मध्यवर्ती संग्रह" ध्वनि नहीं है? .NET, आलसी एनुमरबेल प्रदान करता है, जावा आलसी स्ट्रीम या अमरूद-संचालित पुनरावृत्तियाँ प्रदान करता है, आलसी हास्केल में कुछ आलसी भी होना चाहिए। इनमें से कोई नहीं की आवश्यकता है map/ reduceमध्यवर्ती संग्रह का उपयोग करने के लिए है, क्योंकि उन सभी को पुनरावर्तक श्रृंखला का निर्माण। मैं यहाँ गलत कहाँ हूँ?

— हुसोमिर शयदैरिव

3

नेस्टेड होने पर क्लोजर mapऔर filterमध्यवर्ती संग्रह बनाएं।

— 22

4

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

— दोपहर 12:59

एक उदाहरण बहुत अच्छा है।

— appshare.co

8

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

— एरिकप्रिस

22

ट्रांसड्यूसर कार्यों को कम करने के लिए संयोजन का एक साधन है।

उदाहरण: कार्य कम करना ऐसे कार्य हैं जो दो तर्क देते हैं: एक परिणाम अभी तक और एक इनपुट। वे एक नया परिणाम (अब तक) लौटाते हैं। उदाहरण के लिए+ : दो तर्कों के साथ, आप पहले परिणाम के बारे में सोच सकते हैं और दूसरा इनपुट के रूप में।

एक ट्रांसड्यूसर अब + फ़ंक्शन ले सकता है और इसे दो बार-प्लस फ़ंक्शन कर सकता है (इसे जोड़ने से पहले हर इनपुट को दोगुना करता है)। यह है कि ट्रांसड्यूसर कैसा लगेगा (सबसे बुनियादी शब्दों में):

(defn double
  [rfn]
  (fn [r i] 
    (rfn r (* 2 i))))

चित्रण विकल्प के rfnसाथ +यह देखने के लिए कि कैसे +दो बार-प्लस में बदल दिया गया है:

(def twice-plus ;; result of (double +)
  (fn [r i] 
    (+ r (* 2 i))))

(twice-plus 1 2)  ;-> 5
(= (twice-plus 1 2) ((double +) 1 2)) ;-> true

इसलिए

(reduce (double +) 0 [1 2 3])

अब 12 उपज होगी।

ट्रांसड्यूसर्स द्वारा लौटाए गए कार्यों को कम करना स्वतंत्र है कि परिणाम कैसे जमा होता है क्योंकि वे उनके पास पारित होने वाले कम करने वाले फ़ंक्शन के साथ जमा होते हैं, अनजाने में कैसे। यहां हम conjइसके बजाय उपयोग करते हैं +। Conjएक संग्रह और एक मूल्य लेता है और उस मूल्य के साथ एक नया संग्रह लौटाता है।

(reduce (double conj) [] [1 2 3])

उपज होगी [२ ४ ६]

वे इस बात से भी स्वतंत्र हैं कि इनपुट किस प्रकार का स्रोत है।

कई ट्रांसड्यूसर को कम करने वाले कार्यों को बदलने के लिए एक (चेनेबल) नुस्खा के रूप में जंजीर किया जा सकता है।

अपडेट: चूंकि अब इसके बारे में एक आधिकारिक पेज है, इसलिए मैं इसे पढ़ने की अत्यधिक सलाह देता हूं: http://clojure.org/transducers

— लियोन ग्रेपेंथिन
स्रोत

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

— appshare.co

1

आप सही हैं, उत्पन्न शब्द यहाँ अनुचित था।

— लियोन ग्रेपेंथिन

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

— appshare.co

1

वे कार्यों को कम करने के लिए संयोजन का एक साधन हैं। आपके पास और कहां है? यह एक अनुकूलन से कहीं अधिक है।

— लियोन ग्रेपेंटिन 10

मुझे यह उत्तर बहुत दिलचस्प लगता है, लेकिन यह मेरे लिए स्पष्ट नहीं है कि यह ट्रांसड्यूसर्स से कैसे जुड़ता है (आंशिक रूप से क्योंकि मैं अभी भी विषय को गोपनीय पाता हूं)। बीच क्या संबंध है doubleऔर transduce?

— मंगल

21

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

cat /etc/passwd | tr '[:lower:]' '[:upper:]' | cut -d: -f1| grep R| wc -l

(उपर्युक्त कमांड उन यूजर्स की संख्या को r या तो उनके यूजरनेम में ऊपरी या निचले अक्षर के साथ गिनता है)। इसे प्रक्रियाओं के एक सेट के रूप में लागू किया जाता है, जिनमें से प्रत्येक पिछली प्रक्रियाओं के आउटपुट से पढ़ता है, इसलिए चार मध्यवर्ती धाराएं हैं। आप एक अलग कार्यान्वयन की कल्पना कर सकते हैं जो पांच कमांड को एक एकल कमांड में बनाता है, जो इसके इनपुट से पढ़ेगा और इसके आउटपुट को एक बार में लिख देगा। यदि मध्यवर्ती धाराएं महंगी थीं, और संरचना सस्ती थी, तो यह एक अच्छा व्यापार हो सकता है।

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

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

यह ट्रांसड्यूसर्स का एक बहुत अच्छा अवलोकन है।

— user100464
स्रोत

1

आह, इसलिए ट्रांसड्यूसर ज्यादातर एक प्रदर्शन अनुकूलन हैं, यह है कि आप क्या कह रहे हैं?

— appshare.co

@ ज़ुबैर हाँ, यह सही है। ध्यान दें कि अनुकूलन मध्यवर्ती धाराओं को समाप्त करने से परे जाता है; आप समानांतर में संचालन करने में भी सक्षम हो सकते हैं।

— user100464

2

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

— मंगल

10

रिच हिकी ने स्ट्रेंज लूप 2014 सम्मेलन (45 मिनट) में 'ट्रांसड्यूसर्स' की वार्ता दी।

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

वीडियो: https://www.youtube.com/watch?v=6mTbuzafcII

— जॉर्डन बिसकोव
स्रोत

8

मैंने ट्रांसड्यूसर्स-जेएस से उदाहरण पढ़ते हुए पाया है कि मैं उन्हें ठोस शब्दों में समझने में मदद करता हूं कि मैं उन्हें दिन-प्रतिदिन के कोड में कैसे उपयोग कर सकता हूं।

उदाहरण के लिए, इस उदाहरण पर विचार करें (ऊपर दिए गए लिंक पर README से लिया गया):

var t = require("transducers-js");

var map    = t.map,
    filter = t.filter,
    comp   = t.comp,
    into   = t.into;

var inc    = function(n) { return n + 1; };
var isEven = function(n) { return n % 2 == 0; };
var xf     = comp(map(inc), filter(isEven));

console.log(into([], xf, [0,1,2,3,4])); // [2,4]

एक के लिए, xfअंडरस्कोर के साथ सामान्य विकल्प की तुलना में बहुत क्लीनर दिखता है।

_.filter(_.map([0, 1, 2, 3, 4], inc), isEven);

— enocom
स्रोत

कैसे आया ट्रांसड्यूसर का उदाहरण इतना लंबा है। अंडरस्कोर संस्करण बहुत अधिक संक्षिप्त लगता है

— appshare.co

1

@ ज़ुबैर वास्तव में नहींt.into([], t.comp(t.map(inc), t.filter(isEven)), [0,1,2,3,4])

— जुआन

7

ट्रांसड्यूसर (मेरी समझ में!) फ़ंक्शन हैं जो एक रिडक्शन फंक्शन लेते हैं और दूसरे को लौटाते हैं। एक कम करने का कार्य एक है

उदाहरण के लिए:

user> (def my-transducer (comp count filter))
#'user/my-transducer
user> (my-transducer even? [0 1 2 3 4 5 6])
4
user> (my-transducer #(< 3 %) [0 1 2 3 4 5 6])
3

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

यह एक ही बात है दूसरे उदाहरण में यह एक बार में एक मान की जाँच करता है और यदि वह मान 3 से कम है तो यह 1 को जोड़ने देता है।

— टोबियास
स्रोत

मुझे यह सरल स्पष्टीकरण पसंद आया

— इग्नासियो

7

एक ट्रांसड्यूसर स्पष्ट परिभाषा यहाँ है:

Transducers are a powerful and composable way to build algorithmic transformations that you can reuse in many contexts, and they’re coming to Clojure core and core.async.

इसे समझने के लिए, आइए निम्नलिखित सरल उदाहरण पर विचार करें:

;; The Families in the Village

(def village
  [{:home :north :family "smith" :name "sue" :age 37 :sex :f :role :parent}
   {:home :north :family "smith" :name "stan" :age 35 :sex :m :role :parent}
   {:home :north :family "smith" :name "simon" :age 7 :sex :m :role :child}
   {:home :north :family "smith" :name "sadie" :age 5 :sex :f :role :child}

   {:home :south :family "jones" :name "jill" :age 45 :sex :f :role :parent}
   {:home :south :family "jones" :name "jeff" :age 45 :sex :m :role :parent}
   {:home :south :family "jones" :name "jackie" :age 19 :sex :f :role :child}
   {:home :south :family "jones" :name "jason" :age 16 :sex :f :role :child}
   {:home :south :family "jones" :name "june" :age 14 :sex :f :role :child}

   {:home :west :family "brown" :name "billie" :age 55 :sex :f :role :parent}
   {:home :west :family "brown" :name "brian" :age 23 :sex :m :role :child}
   {:home :west :family "brown" :name "bettie" :age 29 :sex :f :role :child}

   {:home :east :family "williams" :name "walter" :age 23 :sex :m :role :parent}
   {:home :east :family "williams" :name "wanda" :age 3 :sex :f :role :child}])

इसके बारे में हम यह जानना चाहते हैं कि गाँव में कितने बच्चे हैं? हम निम्नलिखित reducer के साथ इसे आसानी से पता कर सकते हैं:

;; Example 1a - using a reducer to add up all the mapped values

(def ex1a-map-children-to-value-1 (r/map #(if (= :child (:role %)) 1 0)))

(r/reduce + 0 (ex1a-map-children-to-value-1 village))
;;=>
8

यहाँ यह करने का एक और तरीका है:

;; Example 1b - using a transducer to add up all the mapped values

;; create the transducers using the new arity for map that
;; takes just the function, no collection

(def ex1b-map-children-to-value-1 (map #(if (= :child (:role %)) 1 0)))

;; now use transduce (c.f r/reduce) with the transducer to get the answer 
(transduce ex1b-map-children-to-value-1 + 0 village)
;;=>
8

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

;; Example 2a - using a reducer to count the children in the Brown family

;; create the reducer to select members of the Brown family
(def ex2a-select-brown-family (r/filter #(= "brown" (string/lower-case (:family %)))))

;; compose a composite function to select the Brown family and map children to 1
(def ex2a-count-brown-family-children (comp ex1a-map-children-to-value-1 ex2a-select-brown-family))

;; reduce to add up all the Brown children
(r/reduce + 0 (ex2a-count-brown-family-children village))
;;=>
2

मुझे आशा है कि आप इन उदाहरणों में मददगार हो सकते हैं। आप अधिक पा सकते हैं यहाँ

आशा करता हूँ की ये काम करेगा।

क्लेमेंसियो मोरालेस लुकास।

— क्लेमेंसियो मोरालेस लुकास
स्रोत

3

"ट्रांसड्यूसर एल्गोरिदमिक परिवर्तनों का निर्माण करने के लिए एक शक्तिशाली और प्रभावी तरीका है जिसे आप कई संदर्भों में पुन: उपयोग कर सकते हैं, और वे क्लूजुर कोर और कोर.संकट में आ रहे हैं।" परिभाषा लगभग कुछ भी लागू हो सकती है?

— appshare.co

1

लगभग किसी भी क्लोजर ट्रांसड्यूसर के लिए, मैं कहूंगा।

— क्लेमेंसियो मोरालेस लुकास

6

यह एक परिभाषा की तुलना में एक मिशन स्टेटमेंट से अधिक है।

— मंगल

4

मैंने इस बारे में एक क्लोजरस्क्रिप्ट उदाहरण के साथ ब्लॉग किया, जो बताता है कि कैसे कम करने वाले फ़ंक्शन को बदलने में सक्षम होने से अनुक्रम फ़ंक्शन अब एक्स्टेंसिबल हैं।

यह ट्रांसड्यूसर्स का बिंदु है क्योंकि मैंने इसे पढ़ा है। आप के बारे में सोचते हैं consया conjआपरेशन कि मुश्किल की तरह परिचालन में कोडित है map, filterआदि, को कम करने के समारोह नहीं पहुंचा जा सकता था।

ट्रांसड्यूसर्स के साथ, कम करने वाले फ़ंक्शन को डिकॉउड किया जाता है और मैं इसे बदल सकता हूं जैसे मैंने pushट्रांसड्यूसर्स के लिए देशी जावास्क्रिप्ट सरणी धन्यवाद के साथ किया था ।

(transduce (filter #(not (.hasOwnProperty prevChildMapping %))) (.-push #js[]) #js [] nextKeys)

filter और दोस्तों के पास एक नया 1 एरिटी ऑपरेशन है जो एक ट्रांसड्यूसिंग फ़ंक्शन लौटाएगा जिसका उपयोग आप अपने स्वयं के कम करने वाले फ़ंक्शन को आपूर्ति करने के लिए कर सकते हैं।

— dagda1
स्रोत

4

यहाँ मेरा (ज्यादातर) शब्दजाल और कोड मुक्त उत्तर है।

दो तरह से डेटा के बारे में सोचें, एक स्ट्रीम (मान जो कि घटनाओं के रूप में समय के साथ होती है) या एक संरचना (एक सूची में एक समय पर मौजूद डेटा जैसे सूची, एक वेक्टर, एक सरणी आदि)।

कुछ निश्चित ऑपरेशन हैं जो आप धाराओं या संरचनाओं पर करना चाहते हैं। ऐसा ही एक ऑपरेशन मैपिंग है। एक मैपिंग फ़ंक्शन प्रत्येक डेटा आइटम को बढ़ा सकता है (यह मानते हुए कि यह एक नंबर है) और आप उम्मीद कर सकते हैं कि यह कैसे स्ट्रीम या संरचना पर लागू हो सकता है।

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

ट्रांसड्यूसर आपको एक या एक से अधिक कम करने वाले कार्यों का एक "रैप" करने देते हैं और एक "पैकेज" (जो स्वयं एक फ़ंक्शन है) का उत्पादन करते हैं जो दोनों धाराओं या संरचनाओं पर काम करता है। उदाहरण के लिए, आप कार्यों को कम करने का एक क्रम "पैकेज" कर सकते हैं (उदाहरण के लिए संख्याओं को फ़िल्टर करें, फिर परिणामी संख्याओं को 1 से बढ़ाएँ) को मैप करें और फिर मानों की एक धारा या संरचना (या दोनों) पर उस ट्रांसड्यूसर "पैकेज" का उपयोग करें। ।

तो इसमें खास क्या है? आमतौर पर, कार्य को कम करने और धाराओं और संरचनाओं दोनों पर काम करने के लिए कुशलतापूर्वक रचना करने में सक्षम नहीं है।

तो आपके लिए लाभ यह है कि आप इन कार्यों के आसपास अपने ज्ञान का लाभ उठा सकते हैं और उन्हें अधिक उपयोग के मामलों में लागू कर सकते हैं। आपके लिए लागत यह है कि आपको यह अतिरिक्त शक्ति देने के लिए कुछ अतिरिक्त मशीनरी (यानी ट्रांसड्यूसर) सीखना होगा।

— optevo
स्रोत

2

जहां तक मैं समझता हूं, वे बिल्डिंग ब्लॉक्स की तरह हैं , इनपुट और आउटपुट कार्यान्वयन से डिकोड किया गया है। आप बस ऑपरेशन को परिभाषित करें।

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

मैं ट्रांसड्यूसर्स के लिए भी नया हूं, संभवतः-अस्पष्ट उत्तर के लिए क्षमा करें।

— कादिर मलक
स्रोत

1

मुझे लगता है कि यह पोस्ट आपको ट्रांसड्यूसर के बारे में अधिक विहंगम दृश्य प्रदान करती है।

https://medium.com/@roman01la/understanding-transducers-in-javascript-3500d3bd9624

— का यू लाई
स्रोत

3

केवल बाहरी लिंक पर भरोसा करने वाले उत्तर SO पर हतोत्साहित होते हैं क्योंकि भविष्य में किसी भी समय लिंक टूट सकते हैं। इसके बजाय अपने उत्तर में सामग्री को उद्धृत करें।

— विंसेंट कैंटिन

@VincentCantin वास्तव में, मध्यम पोस्ट हटा दिया गया था।

— दिमित्री ज़ैतसेव

लगभग web.archive.org/web/20190316032907/https://medium.com/…

— दिमित्री जैतसेव