आप इस लेख को मीडियम पर भी पढ़ सकते हैं।

यह हमेशा हास्यास्पद होता है जब हम देखते हैं कि प्रोग्रामिंग भाषाएं समय के साथ कैसे विकसित होती हैं।

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

हालांकि, जैसे-जैसे ये कमजोर टाइप की भाषाएं विकसित होती हैं, उनमें दृढ़ता से टाइप की जाने वाली भाषाओं की विशेषताएं शामिल हो जाती हैं, जिससे वे सी और जावा के समान हो जाती हैं:

• पायथन: टाइप संकेत क्षमताओं को 2015 में संस्करण 3.5 से पेश किया गया, और 2022 में संस्करण 3.12 में बढ़ाया गया।
• PHP: घोषित प्रकार 2015 में संस्करण 7 में पेश किए गए।
• जावास्क्रिप्ट: 2012 में टाइपस्क्रिप्ट के जारी होने से इसे "प्रकारों के लिए सिंटैक्स के साथ जावास्क्रिप्ट" के रूप में परिभाषित किया गया।

यह बदलाव क्यों?

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

// C   example: 'y' will be an integer
float x = 3.14;
int y = x;  //  y = 3 (ignored the decimal part of the number)

दूसरी ओर, पायथन, पीएचपी और जावास्क्रिप्ट जैसी गतिशील रूप से टाइप की गई भाषाएं हमें वेरिएबल बनाने की अनुमति देती हैं और दुभाषिया को रनटाइम के दौरान उनके प्रकार का संकेत देने देती हैं:

# In python and PHP: 'y' will take the same type as 'x'
x = 3.14
y = x  // y = 3.14 (float)

गतिशील भाषाओं में सुस्पष्ट टाइपिंग कैसे शुरू की जाती है?

निम्नलिखित उदाहरण में, हम गतिशील और स्थिर टाइपिंग का उपयोग करके समान फ़ंक्शन घोषित करते हैं।

पायथन:

# using the classic syntax:
def add(x, y):
    return x   y
# using explicit typing:
def add(x: int, y:int) -> int:
    return x   y

जावास्क्रिप्ट / टाइपस्क्रिप्ट:

// using the classic syntax
function add(x, y) {
    return x   y;
}
// using explicit typing
function add(x: number, y: number): number {
    return x   y;
}

PHP:

// using the classic syntax:
function add($x, $y) {
    return $x   $y;
}
// using explicit typing:
function add(int $x, int $y): int {
    return $x   $y;
}

PHP 8.2 (दिसंबर 2022 में जारी) स्टैंड-अलोन प्रकारों के रूप में अशक्त, सत्य और असत्य के लिए समर्थन पेश करके इसे और आगे बढ़ाता है:

public null $nil = null;
public false $false = false;`

विडम्बना कहाँ है?

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

x: int = 0
x = "John" 
print(type(x))   # 

PHP के लिए भी, यह केवल कंसोल पर एक अस्वीकृत चेतावनी प्रिंट करेगा।

कोई पूछ सकता है कि दुभाषिया हमें इस कोड को निष्पादित करने की अनुमति क्यों देता है?
ऐसा इसलिए है क्योंकि ये भाषाएँ इस तरह से बनाई गई हैं: वे परिभाषा के अनुसार गतिशील रूप से टाइप की जाती हैं। यदि हम इस विशेषता को हटा देते हैं, तो वे अब गतिशील नहीं रहेंगी; वे C जैसी कड़ाई से टाइप की जाने वाली भाषाएँ बन जाएँगी, लेकिन धीमी।

उम्मीद है, आप अपनी PHP फ़ाइल में strict_types को true पर सेट करके अपने दुभाषिया को अधिक कठोर होने के लिए कह सकते हैं:

declare(strict_types=1);

पायथन में रहते हुए, आप अपने कोड का विश्लेषण करने और बग पकड़ने के लिए 'mypy' पैकेज का उपयोग कर सकते हैं:

$ mypy program.py
error: Incompatible types in assignment (expression has type "str", variable has type "int")  [assignment]

आप 'mypy' को एक सलाहकार के रूप में देख सकते हैं जो आपको बताता है कि आपने क्या गलत किया है, लेकिन यह आपको अपने जोखिम पर अपना कोड निष्पादित करने से नहीं रोकता है।

भले ही आप अपने वेरिएबल के प्रकार के बारे में निश्चित नहीं हैं, फिर भी आप स्वीकृत प्रकारों की सूची को कम करने के लिए यूनियन ऑपरेटर का उपयोग कर सकते हैं:

PHP और Python के निम्नलिखित उदाहरण बताते हैं कि यह कैसे करना है:

y: int | float = f(x)   # introduced in Python 3.10
int | float $y = f($x)  // introduced in PHP 8.0
let y: number | string  // typescript

क्या हम कोड पठनीयता का त्याग कर रहे हैं?

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

अब, मैं खुद को कुछ अजीब पीईपी पढ़ रहा हूं और खुद से सवाल कर रहा हूं कि क्या इन नई सुविधाओं को शामिल करके मेरे कोडबेस को जटिल बनाना वास्तव में इसके लायक है।

आइए एक उदाहरण फ़ंक्शन देखें जो शब्दकोश के आइटम प्रिंट करता है। यहाँ प्रारंभिक संस्करण है:

def print_attributes(**kwargs):
    for key, value in kwargs.items():
        print(key, value)

person = {"name": "John", "height": 1.84}
print_attributes(**person)

पायथन 3.12 में प्रस्तुत पीईपी 692 की सिफारिशों का उपयोग करके, कोड बन जाता है:

from typing import TypedDict, Unpack

class Person(TypedDict):   # create a class inheriting from TypedDict
    name: str                  
    height: float           

def print_attributes(**kwargs: Unpack[Person]) -> None:  # use the Unpack operator
    for key, value in kwargs.items():
        print(key, value)

person: Person = {"name": "John", "height": 1.84}  # create an instance of the class
print_attributes(**person)

संक्षेप में: हमने एक वर्ग बनाया जो टाइप्डडिक्ट से विरासत में मिला है, प्रत्येक आइटम का नाम और प्रकार निर्दिष्ट किया है, और "mypy" को यह बताने के लिए अनपैक ऑपरेटर का उपयोग किया है कि प्राप्त ऑब्जेक्ट एक टाइप्डडिक्ट है।

परिणामस्वरूप, हमारा कोड आकार में दोगुना हो गया। यदि हमारी वस्तु में अधिक वस्तुएँ होतीं तो यह और भी लंबी हो जाती।

सौभाग्य से, हम अपने कोड के कुछ हिस्सों के लिए स्थिर टाइपिंग का उपयोग कर सकते हैं और बाकी को डायनामिक छोड़ सकते हैं। या अगर हम चाहें तो हम इसका बिल्कुल भी उपयोग न करने का विकल्प चुन सकते हैं।

हमें इसका उपयोग कब करना चाहिए?

केवल इसलिए कि आपने एक नई, चमकदार सुविधा सीखी है, अपने संपूर्ण कोडबेस को फिर से लिखने के लिए दबाव महसूस न करें।

ये नई सुविधाएं टूल की तरह हैं। मेरी सलाह है कि इनका बुद्धिमानी से उपयोग करें:

निम्नलिखित परिदृश्यों में स्थिर टाइपिंग का उपयोग करें:

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

जब आप हों तो स्थिर टाइपिंग का उपयोग करने से बचें:

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

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