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

const handleSaveTextKeydown = (event: KeyboardEvent) => {
   if (event.key === 'Enter') {
    //... save text
   }
}

इस मामले में, इवेंट.की प्रकार की स्ट्रिंग है, और उदाहरण के लिए, गलती से 'एंटर' में एक स्थान शामिल करके बग पेश करना आसान है।

इस स्थिति को किसी फ़ंक्शन में समाहित क्यों नहीं किया जाता?

const handleSaveTextKeydown = (event: KeyboardEvent) => {
   if (checkIsEnterKey(event.key)) {
    //... save text
   }
}

यह सुनिश्चित करता है कि एंटर कुंजी के लिए सभी जांच सुसंगत और विश्वसनीय हैं।

अब, इस सत्यापन पर विचार करें:

type Value = null | object;

const value = {} as Value;

if (typeof value === 'object') {
  value; // value type is null | object
}

हालाँकि टाइपस्क्रिप्ट स्मार्ट है, लेकिन स्थिति के अंदर का मूल्य टाइप वैल्यू का ही रहता है। ऐसा इसलिए है क्योंकि typeof null 'ऑब्जेक्ट' लौटाता है।

तो, आपको लिखना होगा:

if (value !== null && typeof value === 'object') {
  value; // value type is object
}

कई डेवलपर इसे किसी फ़ंक्शन में इनकैप्सुलेट नहीं कर सकते हैं और इसके बजाय जब भी वे इस स्थिति का सामना करते हैं तो इसे बार-बार लिखते हैं।

आपने अपने जीवन में कितनी बार वही स्थिति लिखी है?

आपने कितनी बार एक ही गलती की है?

भविष्य में आप यही शर्त कितनी बार लिखेंगे?

अगर मैं होता, तो मैं यह करता:

if (checkIsObject(value)) {
  value; // value type is object
}

कार्यों में सामान्य स्थितियों को समाहित करने के कई लाभ हैं।

निम्नलिखित उदाहरण पर विचार करें:

const array = [0, 1, 2, 3, 4, 5, null, undefined];

आइए एक ऐसी सरणी बनाएं जिसमें केवल शून्य मान शामिल न हों।

आप संक्षिप्तता को प्राथमिकता दे सकते हैं और इसे इस तरह लिख सकते हैं:

const numbers = array.filter(Boolean);

दुर्भाग्य से, यह आदर्श नहीं है। 0 का मूल्यांकन भी असत्य के रूप में किया जाता है और उसे बाहर कर दिया जाता है। तो आपको लिखना होगा:

const numbers = array.filter(item => item !== null && item !== undefined);

क्या यह बदसूरत, पुन: प्रयोज्य कोड जैसा नहीं लगता?

मैं अधिक सुंदर कोड लिख सकता हूं:

const numbers = array.filter(checkIsNullish);

सामान्य शर्तों को बार-बार लिखना बंद करें। इससे केवल गलतियाँ होती हैं, और कोड कम पढ़ने योग्य हो जाता है।

मैं अपने द्वारा बनाई गई चेकर नामक लाइब्रेरी का परिचय देता हूं।

यह उपयोगिता फ़ंक्शन लाइब्रेरी सामान्य वेब विकास और निम्न-स्तरीय विकास में फ़ंक्शंस के रूप में आमतौर पर उपयोग की जाने वाली स्थितियों का प्रतिनिधित्व करती है। सभी फ़ंक्शन एक इनपुट लेते हैं और एक बूलियन मान लौटाते हैं।

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

आइए वास्तविक दुनिया के कुछ उदाहरण देखें।

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

यहां, हम एनपीएम के साथ एक उदाहरण के रूप में @चेकर/स्ट्रिंग पैकेज लेंगे।

1. पैकेज स्थापित करें

अपनी प्रोजेक्ट निर्देशिका में निम्नलिखित कमांड चलाएँ:

  npx jsr add @checker/string

1. फ़ंक्शंस का उपयोग करना

  import { checkIsNotEmptyString, checkIsIndexFound } from "@checker/string";

  const value = "Hello";

  const formatted = value.trim();

  if (checkIsNotEmptyString(formatted)) {
    // formatted !== ''
    // When formatted is not an empty string
  }

  const index = value.indexOf("el");

  if (checkIsIndexFound(index)) {
    // index !== -1
    // When "el" is found in value
  }

मैं बूलियन मान को उलटने के लिए !SOME_CONDITION जैसे तार्किक निषेध ऑपरेटरों का उपयोग करने का शौकीन नहीं हूं। ऐसा इसलिए है क्योंकि यह अंतर्निहित है, और इसे जोड़कर या हटाकर बूलियन मान को उलटने से कई खतरनाक स्थितियाँ पैदा हो सकती हैं।

इसलिए, सभी फ़ंक्शनों में संबंधित checkIsNot~ फ़ंक्शन परिभाषित होते हैं।

कार्यों में सामान्य स्थितियों को संपुटित करें। इस तरह, कोड अधिक पठनीय हो जाता है, और बग का पता लगाना आसान हो जाता है।

पढ़ने के लिए आपका शुक्रिया।