javascript लॉडश फ्लो और टाइपस्क्रिप्ट




typescript functional-programming (3)

मैं लोडश के बारे में एक लेख का अनुसरण कर रहा हूं, क्यों _.chain का उपयोग करना एक गलती है , और यह हाइलाइट करता है कि आप Flow का उपयोग करके श्रृंखला की आवश्यकता को हटा सकते हैं।

दिया गया उदाहरण निम्नलिखित श्रृंखला का उपयोग कर रहा है

import _ from "lodash";

_.chain([1, 2, 3])
    .map(x => [x, x*2])
    .flatten()
    .sort()
    .value();

निम्न प्रवाह में परिवर्तित किया जा सकता है

import map from "lodash/fp/map";
import flatten from "lodash/fp/flatten";
import sortBy from "lodash/fp/sortBy";
import flow from "lodash/fp/flow";

flow(
    map(x => [x, x*2]),
    flatten,
    sortBy(x => x) 
)([1,2,3]);

हालाँकि, जब मैं टाइपस्क्रिप्ट का उपयोग करके इसे लागू करता हूं, तो मुझे निम्न त्रुटि मिलती है

ऑब्जेक्ट प्रकार 'अज्ञात' (2571) है

क्या इसे ठीक करने का कोई तरीका है ताकि टाइपस्क्रिप्ट को पता चल सके कि वह किस प्रकार का व्यवहार कर रहा है?


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

जैसा कि आप टाइपस्क्रिप्ट के साथ लॉश का उपयोग कर रहे हैं, आप जिन कार्यों का उपयोग कर रहे हैं उन्हें निर्दिष्ट करने के लिए आप समर्थन जेनरिक का उपयोग कर रहे हैं।

इसलिए आप बता सकते हैं कि दर्ज किए गए कार्यों से इनपुट / आउटपुट किस प्रकार किया जा रहा है:

flow(
    map<number, [number, number]>(x => [x, x * 2]),
    flatten,
    sortBy(x => x)
)([1, 2, 3]);

या जैसा कि dareka सुझाव देता है:

flow(
    map((x: number) => [x, x * 2]),
    flatten,
    sortBy(x => x)
)([1, 2, 3])

लेकिन फिर से यह केवल इसलिए काम करता है क्योंकि हम संकलक को संकेत दे रहे हैं कि वह कौन सा प्रकार है जिस पर कार्य किया जाने वाला है।

इन कोड स्निपेट्स पर काम करने का एक उदाहरण here पाया जा सकता here

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


_.flow() विधि एक pointfree फ़ंक्शन उत्पन्न pointfree है। यह टाइपस्क्रिप्ट को इनपुट के प्रकार को रोकने से रोकता है।

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

फ़ंक्शन को एक चर में निर्दिष्ट करने के बाद, आप इसे ( sandobx ) कह सकते हैं:

const fn: (numbers: number[]) => number[] = flow(
    map(x => [x, x*2]),
    flatten,
    sortBy(x => x) 
);

const result = fn([1,2,3]);

या यदि आप फंक्शन को तुरंत लागू करना चाहते हैं (टाइप करें)

type Fn = (numbers: number[]) => number[];

const result = (flow(
  map(x => [x, x * 2]),
  flatten,
  sortBy(x => x)
) as Fn)([1, 2, 3]);

मुझे बेन स्मिथ का जवाब पसंद है क्योंकि यह मेरे लिए काफी शैक्षिक था। लेकिन मैं यह सुझाव देने जा रहा था

map((x: number) => [x, x*2])

या और भी

map((x: any) => [x, x*2])

अधिक सामान्य मामलों के लिए। यह काम कर रहा है और यदि आप बहुत सख्त नहीं होना चाहते हैं तो जितना संभव हो उतना निष्कर्ष निकालेंगे।





lodash