कार्यात्मक प्रोग्रामिंग - त्वरित गाइड

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

कार्यात्मक प्रोग्रामिंग भाषाओं को दो समूहों में वर्गीकृत किया जाता है, अर्थात -

  • Pure Functional Languages- इस प्रकार की कार्यात्मक भाषाएं केवल कार्यात्मक प्रतिमानों का समर्थन करती हैं। उदाहरण के लिए - हास्केल।

  • Impure Functional Languages- इस प्रकार की कार्यात्मक भाषाएं कार्यात्मक प्रतिमान और अनिवार्य शैली प्रोग्रामिंग का समर्थन करती हैं। उदाहरण के लिए - LISP।

कार्यात्मक प्रोग्रामिंग - लक्षण

कार्यात्मक प्रोग्रामिंग की सबसे प्रमुख विशेषताएं इस प्रकार हैं -

  • कार्यात्मक प्रोग्रामिंग भाषाओं को गणितीय कार्यों की अवधारणा पर डिज़ाइन किया गया है जो संगणना प्रदर्शन करने के लिए सशर्त अभिव्यक्ति और पुनरावृत्ति का उपयोग करते हैं।

  • कार्यात्मक प्रोग्रामिंग का समर्थन करता है higher-order functions तथा lazy evaluation विशेषताएं।

  • फ़ंक्शनल प्रोग्रामिंग लैंग्वेज प्रवाह नियंत्रणों का समर्थन नहीं करती हैं जैसे कि लूप स्टेटमेंट और सशर्त स्टेटमेंट जैसे इफ़-एल्स और स्विच स्टेटमेंट। वे सीधे फ़ंक्शन और कार्यात्मक कॉल का उपयोग करते हैं।

  • OOP की तरह, फंक्शनल प्रोग्रामिंग लैंग्वेजेज एब्सट्रैक्शन, इनकैप्सुलेशन, इनहेरिटेंस और पॉलीमोर्फिज्म जैसी लोकप्रिय अवधारणाओं का समर्थन करती हैं।

कार्यात्मक प्रोग्रामिंग - लाभ

कार्यात्मक प्रोग्रामिंग निम्नलिखित लाभ प्रदान करता है -

  • Bugs-Free Code - कार्यात्मक प्रोग्रामिंग का समर्थन नहीं करता है state, इसलिए कोई साइड-इफेक्ट परिणाम नहीं हैं और हम त्रुटि-मुक्त कोड लिख सकते हैं।

  • Efficient Parallel Programming- फंक्शनल प्रोग्रामिंग लैंग्वेज में NO Mutable स्टेट होता है, इसलिए स्टेट-चेंज मुद्दे नहीं होते हैं। एक "निर्देश" के रूप में समानांतर काम करने के लिए "कार्य" कर सकता है। इस तरह के कोड आसान पुन: प्रयोज्य और परीक्षणशीलता का समर्थन करते हैं।

  • Efficiency- कार्यात्मक कार्यक्रमों में स्वतंत्र इकाइयाँ होती हैं जो समवर्ती रूप से चल सकती हैं। नतीजतन, ऐसे कार्यक्रम अधिक कुशल हैं।

  • Supports Nested Functions - फंक्शनल प्रोग्रामिंग नेस्टेड फंक्शंस को सपोर्ट करता है।

  • Lazy Evaluation - फंक्शनल प्रोग्रामिंग आलसी फंक्शनल कंस्ट्रक्शंस जैसे लेजी लिस्ट, लेजी मैप्स आदि को सपोर्ट करता है।

एक नकारात्मक पहलू के रूप में, कार्यात्मक प्रोग्रामिंग के लिए एक बड़ी मेमोरी स्पेस की आवश्यकता होती है। जैसा कि इसमें राज्य नहीं है, आपको हर बार कार्रवाई करने के लिए नई ऑब्जेक्ट बनाने की आवश्यकता होती है।

कार्यात्मक प्रोग्रामिंग का उपयोग उन स्थितियों में किया जाता है जहां हमें डेटा के एक ही सेट पर कई अलग-अलग ऑपरेशन करने पड़ते हैं।

  • लिस्प का उपयोग आर्टिफिशियल इंटेलिजेंस एप्लिकेशन जैसे मशीन लर्निंग, लैंग्वेज प्रोसेसिंग, मॉडलिंग ऑफ स्पीच और विजन आदि के लिए किया जाता है।

  • एंबेडेड लिस्प व्याख्याकार Emacs जैसी कुछ प्रणालियों के लिए प्रोग्रामबिलिटी जोड़ते हैं।

कार्यात्मक प्रोग्रामिंग बनाम वस्तु-उन्मुख प्रोग्रामिंग

निम्न तालिका कार्यात्मक प्रोग्रामिंग और ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के बीच प्रमुख अंतर पर प्रकाश डालती है -

कार्यात्मक प्रोग्रामिंग OOP
अपरिवर्तनीय डेटा का उपयोग करता है। उपयोग करने योग्य डेटा।
घोषित प्रोग्रामिंग मॉडल का अनुसरण करता है। इंपीरियल प्रोग्रामिंग मॉडल का अनुसरण करता है।
फोकस इस पर है: "आप क्या कर रहे हैं" फोकस "आप कैसे कर रहे हैं" पर है
समानांतर प्रोग्रामिंग का समर्थन करता है समानांतर प्रोग्रामिंग के लिए उपयुक्त नहीं है
इसके कार्यों का कोई साइड-इफेक्ट नहीं है इसके तरीके गंभीर दुष्प्रभाव पैदा कर सकते हैं।
पुनरावर्तन के साथ फ़ंक्शन कॉल और फ़ंक्शन कॉल का उपयोग करके फ्लो कंट्रोल किया जाता है प्रवाह नियंत्रण छोरों और सशर्त बयानों का उपयोग करके किया जाता है।
यह संग्रह डेटा को पुनरावृत्त करने के लिए "पुनरावर्तन" अवधारणा का उपयोग करता है। यह संग्रह डेटा को पुनरावृत्त करने के लिए "लूप" अवधारणा का उपयोग करता है। उदाहरण के लिए: जावा में प्रत्येक लूप के लिए
बयानों का निष्पादन क्रम इतना महत्वपूर्ण नहीं है। बयानों का निष्पादन क्रम बहुत महत्वपूर्ण है।
"डेटा पर अमूर्तता" और "व्यवहार पर संयम" दोनों का समर्थन करता है। केवल "डेटा पर अमूर्तता" का समर्थन करता है।

एक प्रोग्राम कोड की क्षमता

एक प्रोग्रामिंग कोड की दक्षता एल्गोरिदमिक दक्षता और निष्पादन की गति के सीधे आनुपातिक है। अच्छी दक्षता उच्च प्रदर्शन सुनिश्चित करती है।

प्रोग्राम की दक्षता को प्रभावित करने वाले कारकों में शामिल हैं -

  • मशीन की गति
  • संकलक की गति
  • ऑपरेटिंग सिस्टम
  • सही प्रोग्रामिंग भाषा चुनना
  • एक कार्यक्रम में डेटा का तरीका आयोजित किया जाता है
  • एल्गोरिदम का उपयोग समस्या को हल करने के लिए किया जाता है

एक प्रोग्रामिंग भाषा की दक्षता में निम्नलिखित कार्य करके सुधार किया जा सकता है -

  • अनावश्यक कोड या उस कोड को हटाकर जो अनावश्यक प्रसंस्करण पर जाता है।

  • इष्टतम मेमोरी और गैर-वाष्पशील भंडारण का उपयोग करके

  • जहां भी लागू हो, पुन: प्रयोज्य घटकों का उपयोग करके।

  • कार्यक्रम की सभी परतों में त्रुटि और अपवाद हैंडलिंग का उपयोग करके।

  • प्रोग्रामिंग कोड बनाकर जो डेटा अखंडता और स्थिरता सुनिश्चित करता है।

  • डिज़ाइन लॉजिक और प्रवाह के अनुरूप प्रोग्राम कोड विकसित करके।

एक कुशल प्रोग्रामिंग कोड, ऑपरेटिंग वातावरण में न्यूनतम जोखिम के साथ संसाधन खपत और पूर्णता के समय को कम कर सकता है।

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

विभिन्न कार्यात्मक भाषाएं फ़ंक्शन लिखने के लिए विभिन्न सिंटैक्स का उपयोग करती हैं।

एक समारोह लिखने के लिए आवश्यक शर्तें

एक फ़ंक्शन लिखने से पहले, एक प्रोग्रामर को निम्नलिखित बिंदुओं को जानना चाहिए -

  • फ़ंक्शन का उद्देश्य प्रोग्रामर को पता होना चाहिए।

  • फ़ंक्शन का एल्गोरिदम प्रोग्रामर को पता होना चाहिए।

  • कार्य डेटा चर और उनके लक्ष्य प्रोग्रामर को पता होना चाहिए।

  • फ़ंक्शन का डेटा प्रोग्रामर को पता होना चाहिए जिसे उपयोगकर्ता द्वारा कहा जाता है।

एक फंक्शन का फ्लो कंट्रोल

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

  • कार्यक्रम "फ़ंक्शन कॉल" वाले बयान तक पहुंचता है।

  • फ़ंक्शन के अंदर पहली पंक्ति निष्पादित होती है।

  • फ़ंक्शन के अंदर सभी बयान ऊपर से नीचे तक निष्पादित किए जाते हैं।

  • जब फ़ंक्शन को सफलतापूर्वक निष्पादित किया जाता है, तो नियंत्रण उस कथन पर वापस जाता है जहां से शुरू हुआ था।

  • फ़ंक्शन द्वारा गणना और लौटाए गए किसी भी डेटा को कोड की मूल पंक्ति में फ़ंक्शन के स्थान पर उपयोग किया जाता है।

किसी कार्य का पर्याय

किसी फ़ंक्शन का सामान्य सिंटैक्स निम्नानुसार दिखता है -

returnType functionName(type1 argument1, type2 argument2, . . . ) {     
   // function body 
}

C ++ में फ़ंक्शन को परिभाषित करना

आइए एक उदाहरण लेते हैं कि यह समझने के लिए कि फ़ंक्शन को C ++ में कैसे परिभाषित किया जा सकता है, जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है। निम्न कोड में एक फ़ंक्शन होता है जो दो नंबर जोड़ता है और आउटपुट के रूप में इसका परिणाम प्रदान करता है।

#include <stdio.h> 

int addNum(int a, int b);     // function prototype  

int main() {    
   int sum; 
   sum = addNum(5,6);         // function call 
   printf("sum = %d",sum); 
   return 0; 
}  
int addNum (int a,int b) {    // function definition      
   int result; 
   result = a + b; 
   return result;             // return statement 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Sum = 11

एर्लांग में एक कार्य को परिभाषित करना

आइए देखें कि एर्लैंग में उसी फ़ंक्शन को कैसे परिभाषित किया जा सकता है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

-module(helloworld).  
-export([add/2,start/0]).   

add(A,B) ->
   C = A + B,  
   io:fwrite("~w~n",[C]).  
start() ->  
   add(5,6).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

11

समारोह प्रोटोटाइप

फ़ंक्शन प्रोटोटाइप फ़ंक्शन की एक घोषणा है जिसमें रिटर्न-प्रकार, फ़ंक्शन-नाम और तर्क-सूची शामिल है। यह फ़ंक्शन-बॉडी के बिना फ़ंक्शन की परिभाषा के समान है।

For Example - कुछ प्रोग्रामिंग भाषाएँ फंक्शन प्रोटोटाइप का समर्थन करती हैं और कुछ नहीं हैं।

C ++ में, हम फंक्शन प्रोटोटाइप को फंक्शन 'योग' की तरह बना सकते हैं -

int sum(int a, int b)

Note - प्रोग्रामिंग भाषाएं जैसे पायथन, एरलंग, आदि फंक्शन प्रोटोटाइप का समर्थन नहीं करती हैं, हमें पूरा फ़ंक्शन घोषित करने की आवश्यकता है।

फ़ंक्शन प्रोटोटाइप का उपयोग क्या है?

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

समारोह हस्ताक्षर

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

void Sum(int a, int b, int c);         // function 1  
void Sum(float a, float b, float c);   // function 2  
void Sum(float a, float b, float c);   // function 3

फंक्शन 1 और फंक्शन 2 के अलग-अलग हस्ताक्षर हैं। फंक्शन 2 और फंक्शन 3 में एक ही हस्ताक्षर हैं।

Note - फ़ंक्शन ओवरलोडिंग और फ़ंक्शन ओवरराइडिंग, जिसके बारे में हम बाद के अध्यायों में चर्चा करेंगे, फ़ंक्शन हस्ताक्षर की अवधारणा पर आधारित हैं।

  • फंक्शन ओवरलोडिंग तब संभव है जब एक वर्ग में एक ही नाम के साथ कई कार्य हों लेकिन विभिन्न हस्ताक्षर।

  • जब एक व्युत्पन्न वर्ग फ़ंक्शन का आधार वर्ग के समान नाम और हस्ताक्षर होता है, तो फ़ंक्शन ओवरराइडिंग संभव है।

कार्य दो प्रकार के होते हैं -

  • पूर्वनिर्धारित कार्य
  • उपयोगकर्ता-परिभाषित कार्य

इस अध्याय में, हम कार्यों के बारे में विस्तार से चर्चा करेंगे।

पूर्वनिर्धारित कार्य

ये वे कार्य हैं जो संचालन करने के लिए भाषा में निर्मित किए जाते हैं और मानक फ़ंक्शन लाइब्रेरी में संग्रहीत किए जाते हैं।

For Example - C ++ में 'Strcat' और हास्केल में 'concat' का उपयोग दो तारों को जोड़ने के लिए किया जाता है, C ++ में 'strlen' और Python में 'len' का उपयोग स्ट्रिंग की लंबाई की गणना के लिए किया जाता है।

C ++ में स्ट्रिंग की लंबाई प्रिंट करने का कार्यक्रम

निम्नलिखित कार्यक्रम दिखाता है कि आप C ++ का उपयोग करके स्ट्रिंग की लंबाई कैसे प्रिंट कर सकते हैं -

#include <iostream> 
#include <string.h> 
#include <stdio.h> 
using namespace std;  

int main() {     
   char str[20] = "Hello World"; 
   int len; 
   len = strlen(str); 
   cout<<"String length is: "<<len; 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

String length is: 11

पायथन में स्ट्रिंग की लंबाई को मुद्रित करने का कार्यक्रम

निम्नलिखित कार्यक्रम दिखाता है कि पायथन का उपयोग करके स्ट्रिंग की लंबाई कैसे प्रिंट की जाए, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

str = "Hello World"; 
print("String length is: ", len(str))

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

('String length is: ', 11)

उपयोगकर्ता-परिभाषित कार्य

उपयोगकर्ता द्वारा परिभाषित कार्य विशिष्ट कार्यों को करने के लिए उपयोगकर्ता द्वारा परिभाषित किए जाते हैं। एक फ़ंक्शन को परिभाषित करने के लिए चार अलग-अलग पैटर्न हैं -

  • कोई तर्क और कोई वापसी मूल्य के साथ कार्य
  • कोई तर्क नहीं बल्कि एक वापसी मूल्य के साथ कार्य
  • तर्क के साथ कार्य लेकिन कोई वापसी मूल्य नहीं
  • तर्क और एक वापसी मूल्य के साथ कार्य

कोई तर्क और कोई वापसी मूल्य के साथ कार्य

निम्न कार्यक्रम दिखाता है कि कैसे एक फ़ंक्शन को बिना किसी तर्क और बिना रिटर्न मान के परिभाषित किया जाए C++ -

#include <iostream> 
using namespace std; 

void function1() { 
   cout <<"Hello World"; 
}  
int main() { 
   function1(); 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Hello World

निम्न कार्यक्रम दिखाता है कि आप एक समान फ़ंक्शन (कोई तर्क और कोई वापसी मान) को कैसे परिभाषित कर सकते हैं Python -

def function1():    
   print ("Hello World") 
    
function1()

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Hello World

कोई तर्क नहीं बल्कि एक वापसी मूल्य के साथ कार्य

निम्न कार्यक्रम दिखाता है कि फ़ंक्शन को बिना तर्क के कैसे परिभाषित किया जाए, लेकिन इसमें रिटर्न वैल्यू नहीं है C++ -

#include <iostream> 
using namespace std; 
string function1() { 
   return("Hello World"); 
}  

int main() { 
   cout<<function1(); 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Hello World

निम्न कार्यक्रम दिखाता है कि आप एक समान फ़ंक्शन (बिना तर्क के लेकिन रिटर्न वैल्यू के साथ) को कैसे परिभाषित कर सकते हैं Python -

def function1(): 
   return "Hello World" 
res = function1() 
print(res)

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Hello World

तर्क के साथ कार्य लेकिन कोई वापसी मूल्य नहीं

निम्न कार्यक्रम दिखाता है कि कैसे एक फ़ंक्शन को तर्क के साथ परिभाषित किया जाए लेकिन इसमें कोई वापसी मूल्य नहीं है C++ -

#include <iostream> 
using namespace std; 
void function1(int x, int y) {    
   int c; 
   c = x+y;  
   cout<<"Sum is: "<<c; 
}  

int main() { 
   function1(4,5); 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Sum is: 9

निम्न प्रोग्राम दिखाता है कि आप एक समान फ़ंक्शन को कैसे परिभाषित कर सकते हैं Python -

def function1(x,y): 
   c = x + y 
   print("Sum is:",c) 
function1(4,5)

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

('Sum is:', 9)

तर्क और एक वापसी मूल्य के साथ कार्य

निम्नलिखित कार्यक्रम से पता चलता है कि C ++ में फ़ंक्शन को बिना किसी तर्क के कैसे परिभाषित किया जाता है, लेकिन रिटर्न वैल्यू -

#include <iostream> 
using namespace std; 
int function1(int x, int y) {    
   int c; 
   c = x + y;  
   return c;    
} 

int main() {  
   int res; 
   res = function1(4,5); 
   cout<<"Sum is: "<<res; 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Sum is: 9

निम्न कार्यक्रम दिखाता है कि एक समान फ़ंक्शन (तर्क और वापसी मान के साथ) को कैसे परिभाषित किया जाए Python -

def function1(x,y): 
   c = x + y 
   return c  

res = function1(4,5) 
print("Sum is ",res)

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

('Sum is ', 9)

एक फ़ंक्शन को परिभाषित करने के बाद, हमें वांछित आउटपुट प्राप्त करने के लिए इसमें पास तर्क की आवश्यकता होती है। ज्यादातर प्रोग्रामिंग लैंग्वेज सपोर्ट करती हैंcall by value तथा call by reference कार्यों में तर्कों को पारित करने के लिए तरीके।

इस अध्याय में, हम C ++ जैसी ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग लैंग्वेज और पायथन जैसी कार्यात्मक प्रोग्रामिंग लैंग्वेज में "कॉल बाई वैल्यू" सीखेंगे।

मूल्य विधि द्वारा कॉल में, original value cannot be changed। जब हम किसी फ़ंक्शन के लिए एक तर्क पास करते हैं, तो इसे स्टैक मेमोरी में फ़ंक्शन पैरामीटर द्वारा स्थानीय रूप से संग्रहीत किया जाता है। इसलिए, मान केवल फ़ंक्शन के अंदर बदले जाते हैं और फ़ंक्शन के बाहर इसका प्रभाव नहीं होगा।

C ++ में वैल्यू बाय कॉल

निम्न प्रोग्राम दिखाता है कि C ++ में वैल्यू बाय कॉल कैसे काम करता है -

#include <iostream> 
using namespace std; 

void swap(int a, int b) {    
   int temp; 
   temp = a; 
   a = b; 
   b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<a; 
   cout<<"\n"<<"value of b inside the function: "<<b; 
}  
int main() {     
   int a = 50, b = 70;   
   cout<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(a, b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

value of a before sending to function:  50 
value of b before sending to function:  70 
value of a inside the function:  70 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  70

पायथन में मूल्य से कॉल करें

निम्नलिखित कार्यक्रम दिखाता है कि पायथन में वैल्यू बाय कॉल कैसे काम करता है -

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 

# Now we can call the swap function 
a = 50 
b = 75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
swap(a,b) 
print "value of a after sending to function: ", a 
print "value of b after sending to function: ",b

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function: : 75 
value of b inside the function:  50 
value of a after sending to function:  50 
value of b after sending to function:  75

कॉल बाय रेफरेंस, द original value is changedक्योंकि हम तर्कों का संदर्भ पता पास करते हैं। वास्तविक और औपचारिक तर्क एक ही पते की जगह साझा करते हैं, इसलिए फ़ंक्शन के अंदर मूल्य का कोई भी परिवर्तन अंदर और साथ ही फ़ंक्शन के बाहर परिलक्षित होता है।

C ++ में संदर्भ द्वारा कॉल करें

निम्न प्रोग्राम दिखाता है कि C ++ में वैल्यू बाय कॉल कैसे काम करता है -

#include <iostream> 
using namespace std; 

void swap(int *a, int *b) {    
   int temp; 
   temp = *a; 
   *a = *b; 
   *b = temp; 
   cout<<"\n"<<"value of a inside the function: "<<*a; 
   cout<<"\n"<<"value of b inside the function: "<<*b; 
}  
int main() {     
   int a = 50, b = 75;   
   cout<<"\n"<<"value of a before sending to function: "<<a; 
   cout<<"\n"<<"value of b before sending to function: "<<b; 
   swap(&a, &b);  // passing value to function 
   cout<<"\n"<<"value of a after sending to function: "<<a; 
   cout<<"\n"<<"value of b after sending to function: "<<b; 
   return 0;   
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function: 50 
value of a after sending to function:  75 
value of b after sending to function:  50

पायथन में संदर्भ द्वारा कॉल करें

निम्नलिखित कार्यक्रम दिखाता है कि पायथन में वैल्यू बाय कॉल कैसे काम करता है -

def swap(a,b): 
   t = a; 
   a = b; 
   b = t; 
   print "value of a inside the function: :",a 
   print "value of b inside the function: ",b 
   return(a,b) 
    
# Now we can call swap function 
a = 50 
b =75 
print "value of a before sending to function: ",a 
print "value of b before sending to function: ",b 
x = swap(a,b) 
print "value of a after sending to function: ", x[0] 
print "value of b after sending to function: ",x[1]

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

value of a before sending to function:  50 
value of b before sending to function:  75 
value of a inside the function:  75 
value of b inside the function:  50 
value of a after sending to function:  75 
value of b after sending to function:  50

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

किसी कार्य को ओवरलोड करने के दो तरीके हैं, -

  • विभिन्न तर्कों के बाद
  • विभिन्न प्रकार के तर्क

फंक्शन ओवरलोडिंग आम तौर पर तब की जाती है जब हमें अलग-अलग संख्या या प्रकार के तर्कों के साथ एक ही ऑपरेशन करना होता है।

C ++ में फ़ंक्शन ओवरलोडिंग

निम्न उदाहरण दिखाता है कि C ++ में फ़ंक्शन ओवरलोडिंग कैसे की जाती है, जो एक वस्तु उन्मुख प्रोग्रामिंग भाषा है -

#include <iostream> 
using namespace std;  
void addnum(int,int); 
void addnum(int,int,int); 

int main() {     
   addnum (5,5); 
   addnum (5,2,8); 
   return 0; 
} 

void addnum (int x, int y) {     
   cout<<"Integer number: "<<x+y<<endl; 
} 

void addnum (int x, int y, int z) {     
   cout<<"Float number: "<<x+y+z<<endl; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Integer number: 10 
Float number: 15

एरलांग में फंक्शन ओवरलोडिंग

निम्न उदाहरण दिखाता है कि एरलांग में फ़ंक्शन ओवरलोडिंग कैसे करें, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

-module(helloworld).  
-export([addnum/2,addnum/3,start/0]).   

addnum(X,Y) ->  
   Z = X+Y,  
   io:fwrite("~w~n",[Z]).  
    
addnum(X,Y,Z) ->  
   A = X+Y+Z,  
   io:fwrite("~w~n",[A]).  
  
start() ->
   addnum(5,5),     addnum(5,2,8).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

10 
15

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

C ++ का उपयोग करके ओवरराइडिंग

निम्न उदाहरण दिखाता है कि C ++ में फ़ंक्शन ओवरराइडिंग कैसे की जाती है, जो एक आपत्तिजनक प्रोग्रामिंग भाषा है -

#include <iostream> 
using namespace std;  

class A {  
   public: 
   void display() {   
      cout<<"Base class"; 
   } 
}; 

class B:public A {  
   public: 
   void display() {   
      cout<<"Derived Class"; 
   } 
}; 

int main() {  
   B obj; 
   obj.display(); 
   return 0;  
}

यह निम्न आउटपुट का उत्पादन करेगा

Derived Class

पायथन का उपयोग करके ओवरराइडिंग

निम्न उदाहरण दिखाता है कि पायथन में फ़ंक्शन ओवरराइडिंग कैसे करें, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

class A(object): 
   def disp(self): 
      print "Base Class"  
class B(A): 
   def disp(self): 
      print "Derived Class"  
x = A() 
y = B()  
x.disp() 
y.disp()

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Base Class 
Derived Class

एक फ़ंक्शन जो स्वयं को कॉल करता है, उसे एक पुनरावर्ती फ़ंक्शन के रूप में जाना जाता है और इस तकनीक को पुनरावर्ती के रूप में जाना जाता है। एक पुनरावृत्ति निर्देश तब तक जारी रहता है जब तक कि कोई अन्य निर्देश इसे रोकता नहीं है।

C ++ में पुनरावृत्ति

निम्न उदाहरण से पता चलता है कि C ++ में रिकर्सन कैसे काम करता है, जो एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है -

#include <stdio.h> 
long int fact(int n);  

int main() { 
   int n; 
   printf("Enter a positive integer: "); 
   scanf("%d", &n); 
   printf("Factorial of %d = %ld", n, fact(n)); 
   return 0; 
} 
long int fact(int n) { 
   if (n >= 1) 
      return n*fact(n-1); 
   else 
      return 1; 
}

यह निम्न आउटपुट का उत्पादन करेगा

Enter a positive integer: 5 
Factorial of 5 = 120

पायथन में पुनरावृत्ति

निम्नलिखित उदाहरण से पता चलता है कि पायथन में कैसे काम करता है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

def fact(n): 
   if n == 1: 
      return n 
   else: 
      return n* fact (n-1)  

# accepts input from user 
num = int(input("Enter a number: "))  
# check whether number is positive or not 

if num < 0: 
   print("Sorry, factorial does not exist for negative numbers") 
else: 
   print("The factorial of " + str(num) +  " is " + str(fact(num)))

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Enter a number: 6
The factorial of 6 is 720

एक उच्च क्रम फ़ंक्शन (HOF) एक फ़ंक्शन है जो निम्न स्थितियों में से कम से कम एक का अनुसरण करता है -

  • तर्क के रूप में या अधिक कार्य करता है
  • एक परिणाम के रूप में एक समारोह देता है

PHP में HOF

निम्नलिखित उदाहरण से पता चलता है कि PHP में एक उच्च क्रम फ़ंक्शन कैसे लिखना है, जो एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है -

<?php  
$twice = function($f, $v) { return $f($f($v)); 
};  

$f = function($v) { 
   return $v + 3; }; echo($twice($f, 7));

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

13

अजगर में HOF

निम्न उदाहरण से पता चलता है कि पायथन में एक उच्च क्रम फ़ंक्शन कैसे लिखना है, जो एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है -

def twice(function): 
   return lambda x: function(function(x))  
def f(x): 
   return x + 3 
g = twice(f)
print g(7)

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

13

एक डेटा-प्रकार एक मूल्य के प्रकार को परिभाषित करता है जो एक वस्तु हो सकती है और उस पर कौन से संचालन किए जा सकते हैं। उपयोग किए जाने से पहले एक डेटा प्रकार पहले घोषित किया जाना चाहिए। विभिन्न प्रोग्रामिंग भाषाएं विभिन्न डेटा-प्रकारों का समर्थन करती हैं। उदाहरण के लिए,

  • C चार, इंट, फ्लोट, लॉन्ग आदि का समर्थन करता है।
  • पायथन स्ट्रिंग, सूची, टपल आदि का समर्थन करता है।

एक व्यापक अर्थ में, तीन प्रकार के डेटा प्रकार हैं -

  • Fundamental data types- ये पूर्वनिर्धारित डेटा प्रकार हैं जो प्रोग्रामर द्वारा सीधे आवश्यकता के अनुसार केवल एक मान को स्टोर करने के लिए उपयोग किए जाते हैं, जैसे, पूर्णांक प्रकार, वर्ण प्रकार, या फ्लोटिंग प्रकार। उदाहरण के लिए - इंट, चार, फ्लोट, आदि।

  • Derived data types- ये डेटा प्रकार अंतर्निहित डेटा प्रकार का उपयोग करके प्राप्त किए जाते हैं जो प्रोग्रामर द्वारा अपनी आवश्यकता के अनुसार एक ही प्रकार के कई मूल्यों को संग्रहीत करने के लिए डिज़ाइन किए जाते हैं। उदाहरण के लिए - ऐरे, पॉइंटर, फंक्शन, लिस्ट आदि।

  • User-defined data types- ये डेटा प्रकार बिल्ट-इन डेटा प्रकारों का उपयोग करके प्राप्त किए जाते हैं जो कि एक ही प्रकार के विभिन्न मूल्यों या आवश्यकता के अनुसार दोनों के स्टोर करने के लिए एक एकल डेटा प्रकार में लिपटे होते हैं। उदाहरण के लिए - कक्षा, संरचना, आदि।

C ++ द्वारा समर्थित डेटा प्रकार

निम्न तालिका C ++ द्वारा समर्थित डेटा प्रकारों को सूचीबद्ध करती है -

डाटा प्रकार आकार रेंज
चार 1 बाइट -128 से 127 या 0 से 255
अचिन्हित वर्ण 1 बाइट 0 से 255 रु
हस्ताक्षरित चार 1 बाइट -128 से 127
पूर्णांक 4 निवाले -2147483648 से 2147483647
अहस्ताक्षरित int 4 निवाले 0 से 4294967295 पर
हस्ताक्षरित int 4 निवाले -2147483648 से 2147483647
संक्षिप्त इंट 2 बाइट्स -32768 से 32767
अहस्ताक्षरित लघु int 2 बाइट्स 0 से 65,535 रु
लघु int पर हस्ताक्षर किए 2 बाइट्स -32768 से 32767
लंबे समय से int 4 निवाले -2,147,483,648 से 2,147,483,647
लंबे इंट पर हस्ताक्षर किए 4 निवाले -2,147,483,648 से 2,147,483,647
अहस्ताक्षरित लंबे int 4 निवाले 0 से 4,294,967,295 रु
नाव 4 निवाले +/- 3.4e +/- 38 (~ 7 अंक)
दोहरा 8 बाइट्स +/- 1.7e +/- 308 (~ 15 अंक)
लंबा दोहरा 8 बाइट्स +/- 1.7e +/- 308 (~ 15 अंक)

जावा द्वारा समर्थित डेटा प्रकार

निम्नलिखित डेटा प्रकार जावा द्वारा समर्थित हैं -

डाटा प्रकार आकार रेंज
बाइट 1 बाइट -128 से 127
चार २ बाइट 0 से 65,536 तक
कम २ बाइट -32,7688 से 32,767 तक
पूर्णांक 4 बाइट -2,147,483,648 से 2,147,483,647
लंबा 8 बाइट -9,223,372,036,854,775,808 से 9,223,372,036,854,775,807
नाव 4 बाइट -2147483648 से 2147483647
दोहरा 8 बाइट + 9,223 * 1018
बूलियन 1 बिट सही या गलत

Erlang द्वारा समर्थित डेटा प्रकार

इस खंड में, हम एरलंग द्वारा समर्थित डेटा प्रकारों पर चर्चा करेंगे, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

संख्या

Erlang दो प्रकार के संख्यात्मक शाब्दिक का समर्थन करता है, अर्थात integer तथा float। निम्नलिखित उदाहरण पर एक नज़र डालें जो दिखाता है कि दो पूर्णांक मान कैसे जोड़े जाएं -

-module(helloworld).
-export([start/0]). 
start() -> 
   io:fwrite("~w",[5+4]).

यह निम्नलिखित उत्पादन करेगा -

9

परमाणु

एक atomएक स्ट्रिंग है जिसका मूल्य नहीं बदला जा सकता है। यह एक लोअरकेस अक्षर से शुरू होना चाहिए और इसमें अल्फ़ान्यूमेरिक वर्ण और विशेष वर्ण हो सकते हैं। जब एक परमाणु में विशेष वर्ण होते हैं, तो इसे एकल उद्धरण (') के अंदर संलग्न किया जाना चाहिए। बेहतर समझने के लिए निम्नलिखित उदाहरण पर एक नज़र डालें।

-module(helloworld). 
-export([start/0]). 

start()-> 
   io:fwrite(monday).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

monday

Note- राजधानी "एम" के साथ परमाणु को "सोमवार" में बदलने की कोशिश करें। कार्यक्रम एक त्रुटि पैदा करेगा।

बूलियन

इस डेटा प्रकार का उपयोग परिणाम को प्रदर्शित करने के लिए किया जाता है true या false। निम्नलिखित उदाहरण पर एक नज़र डालें। यह दिखाता है कि दो पूर्णांक की तुलना कैसे करें।

-module(helloworld). 
-export([start/0]). 

start() -> 
   io:fwrite(5 =< 9).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

true

बिट स्ट्रिंग

बिट स्ट्रिंग का उपयोग अन-टाइप की गई मेमोरी के एक क्षेत्र को संग्रहीत करने के लिए किया जाता है। निम्नलिखित उदाहरण पर एक नज़र डालें। यह दिखाता है कि बिट स्ट्रिंग के 2 बिट्स को एक सूची में कैसे परिवर्तित किया जाए।

-module(helloworld). 
-export([start/0]). 

start() -> 
   Bin2 = <<15,25>>, 
   P = binary_to_list(Bin2), 
   io:fwrite("~w",[P]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[15,25]

टपल

एक ट्यूपल एक मिश्रित डेटा प्रकार है जिसमें निश्चित संख्याएँ होती हैं। टपल के प्रत्येक शब्द को एक के रूप में जाना जाता हैelement। तत्वों की संख्या टपल का आकार है। निम्नलिखित उदाहरण से पता चलता है कि 5 शब्दों के टपल को कैसे परिभाषित किया जाए और इसके आकार को प्रिंट किया जाए।

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5

नक्शा

एक नक्शा एक यौगिक डेटा प्रकार है जिसमें कुंजी-मूल्य संघों की एक चर संख्या होती है। मानचित्र में प्रत्येक कुंजी-मूल्य संघ को एक के रूप में जाना जाता हैassociation-pair। key तथा value जोड़ी के हिस्सों को कहा जाता है elements। एसोसिएशन-जोड़े की संख्या को नक्शे का आकार कहा जाता है। निम्न उदाहरण दिखाता है कि 3 मैपिंग के मानचित्र को कैसे परिभाषित किया जाए और इसके आकार को कैसे प्रिंट किया जाए।

-module(helloworld).  
-export([start/0]).  
 
start() ->  
   Map1 = #{name => 'abc',age => 40, gender => 'M'},  
   io:fwrite("~w",[map_size(Map1)]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

3

सूची

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

-module(helloworld).  
-export([start/0]).  

start() ->  
   List1 = [10,15,20,25,30] ,  
   io:fwrite("~w",[length(List1)]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5

Note - Er स्ट्रिंग ’डेटा-प्रकार को एर्लैंग में परिभाषित नहीं किया गया है।

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

बहुरूपता दो प्रकार का होता है -

  • Compile-time Polymorphism - इस तरह के बहुरूपता को ओवरलोडिंग विधि का उपयोग करके प्राप्त किया जा सकता है।

  • Run-time Polymorphism - इस प्रकार के बहुरूपता को ओवरराइडिंग और वर्चुअल फ़ंक्शंस का उपयोग करके प्राप्त किया जा सकता है।

बहुरूपता के लाभ

बहुरूपता निम्नलिखित लाभ प्रदान करता है -

  • यह प्रोग्रामर को कोड्स का पुन: उपयोग करने में मदद करता है, अर्थात, एक बार लिखित, परीक्षण और कार्यान्वित की गई कक्षाओं को आवश्यकतानुसार पुन: उपयोग किया जा सकता है। बहुत समय बचता है।

  • एकल चर का उपयोग कई डेटा प्रकारों को संग्रहीत करने के लिए किया जा सकता है।

  • कोड डीबग करना आसान है।

बहुरूपी डेटा प्रकार

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

function1(void *p, void *q)

कहाँ पे p तथा q जेनेरिक पॉइंटर्स हैं जो पकड़ सकते हैं int, float (या कोई अन्य) एक तर्क के रूप में मूल्य।

C ++ में बहुरूपी फ़ंक्शन

निम्न प्रोग्राम दिखाता है कि C ++ में बहुरूपी कार्यों का उपयोग कैसे किया जाता है, जो एक वस्तु उन्मुख प्रोग्रामिंग भाषा है।

#include <iostream> 
Using namespace std: 

class A {  
   public: 
   void show() {    
      cout << "A class method is called/n"; 
   } 
}; 

class B:public A { 
   public: 
   void show() {   
      cout << "B class method is called/n"; 
   } 
};  

int main() {   
   A x;        // Base class object 
   B y;        // Derived class object 
   x.show();   // A class method is called 
   y.show();   // B class method is called 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

A class method is called 
B class method is called

पाइथन में बहुरूपी कार्य

निम्नलिखित कार्यक्रम से पता चलता है कि पायथन में बहुरंगी कार्यों का उपयोग कैसे किया जाता है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

class A(object): 
   def show(self): 
      print "A class method is called" 
  
class B(A): 
   def show(self): 
      print "B class method is called" 
  
def checkmethod(clasmethod): 
   clasmethod.show()  

AObj = A() 
BObj = B() 
  
checkmethod(AObj) 
checkmethod(BObj)

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

A class method is called 
B class method is called

ए stringरिक्त स्थान सहित वर्णों का एक समूह है। हम कह सकते हैं कि यह एक आयामी चरित्र है, जिसे एक पूर्ण चरित्र ('0') द्वारा समाप्त किया जाता है। एक स्ट्रिंग को एक पूर्वनिर्धारित वर्ग के रूप में भी माना जा सकता है जो अधिकांश प्रोग्रामिंग भाषाओं जैसे कि C, C ++, Java, PHP, Erlang, Haskell, Lisp, आदि द्वारा समर्थित है।

निम्न छवि दिखाती है कि मेमोरी में स्ट्रिंग "ट्यूटोरियल" कैसे दिखाई देगा।

C ++ में एक स्ट्रिंग बनाएं

निम्न कार्यक्रम एक उदाहरण है जो दिखाता है कि C ++ में स्ट्रिंग कैसे बनाई जाए, जो कि ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है।

#include <iostream> 
using namespace std; 

int main () {    
   char greeting[20] = {'H', 'o', 'l', 'i', 'd', 'a', 'y', '\0'}; 
   cout << "Today is: "; 
   cout << greeting << endl; 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Today is: Holiday

एरलांग में स्ट्रिंग

निम्नलिखित कार्यक्रम एक उदाहरण है जो दिखाता है कि इरलांग में एक स्ट्रिंग कैसे बनाई जाए, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

-module(helloworld).  
-export([start/0]).   
start() -> 
   Str = "Today is: Holiday",  
   io:fwrite("~p~n",[Str]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

"Today is: Holiday"

स्ट्रिंग संचालन C ++ में

विभिन्न प्रोग्रामिंग लैंग्वेज स्ट्रिंग्स पर विभिन्न तरीकों का समर्थन करती हैं। निम्न तालिका C ++ द्वारा समर्थित कुछ पूर्वनिर्धारित स्ट्रिंग विधियों को दिखाती है।

क्र.सं. विधि और विवरण
1

Strcpy(s1,s2)

यह स्ट्रिंग s2 को स्ट्रिंग s1 में कॉपी करता है
2

Strcat(s1,s2)

यह s1 के अंत में स्ट्रिंग s2 जोड़ता है
3

Strlen(s1)

यह स्ट्रिंग s1 की लंबाई प्रदान करता है
4

Strcmp(s1,s2)

यह 0 देता है जब स्ट्रिंग s1 & s2 समान होते हैं
5

Strchr(s1,ch)

यह स्ट्रिंग s1 में वर्ण ch की पहली घटना के लिए एक पॉइंटर लौटाता है
6

Strstr(s1,s2)

यह स्ट्रिंग s2 में स्ट्रिंग s2 की पहली घटना के लिए एक पॉइंटर लौटाता है

निम्नलिखित कार्यक्रम दिखाता है कि उपरोक्त विधियों का उपयोग C ++ में कैसे किया जा सकता है -

#include <iostream> 
#include <cstring> 
using namespace std; 

int main () {   
   char str1[20] = "Today is "; 
   char str2[20] = "Monday"; 
   char str3[20]; 
   int  len ;  
   strcpy( str3, str1); // copy str1 into str3 
   cout << "strcpy( str3, str1) : " << str3 << endl;  

   strcat( str1, str2); // concatenates str1 and str2 
   cout << "strcat( str1, str2): " << str1 << endl;  

   len = strlen(str1);  // String length after concatenation 
   cout << "strlen(str1) : " << len << endl; 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

strcpy(str3, str1)   :  Today is 
strcat(str1, str2)   :  Today is Monday 
strlen(str1)         :  15

एरलांग में स्ट्रिंग संचालन

निम्न तालिका Erlang द्वारा समर्थित पूर्वनिर्धारित स्ट्रिंग विधियों की एक सूची दिखाती है।

क्र.सं. विधि और विवरण
1

len(s1)

दिए गए स्ट्रिंग में वर्णों की संख्या लौटाता है।
2

equal(s1,s2)

यह तब सही होता है जब स्ट्रिंग s1 & s2 समान होते हैं और झूठे वापस आते हैं
3

concat(s1,s2)

यह स्ट्रिंग s1 के अंत में string s2 जोड़ता है
4

str(s1,ch)

यह स्ट्रिंग s1 में वर्ण ch की अनुक्रमणिका स्थिति देता है
5

str (s1,s2)

यह स्ट्रिंग s1 में s2 की अनुक्रमणिका स्थिति देता है
6

substr(s1,s2,num)

यह विधि स्ट्रिंग s1 से स्ट्रिंग s1 लौटाती है जो शुरुआती स्थिति और वर्णों की संख्या के आधार पर शुरू होती है
7

to_lower(s1)

यह विधि निम्न स्थिति में स्ट्रिंग लौटाती है

निम्नलिखित कार्यक्रम दिखाता है कि एरलंग में उपरोक्त तरीकों का उपयोग कैसे किया जा सकता है।

-module(helloworld).  
-import(string,[concat/2]).  
-export([start/0]).  
   start() ->  
   S1 = "Today is ",  
   S2 = "Monday",  
   S3 = concat(S1,S2),  
   io:fwrite("~p~n",[S3]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

"Today is Monday"

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

जावा में संख्याओं की सूची बनाने का कार्यक्रम

सूची जावा / सी / सी ++ में डेटा प्रकार नहीं है, लेकिन हमारे पास जावा में एक सूची बनाने के वैकल्पिक तरीके हैं, अर्थात, उपयोग करके ArrayList तथा LinkedList।

निम्न उदाहरण दिखाता है कि जावा में एक सूची कैसे बनाई जाए। यहां हम संख्याओं की सूची बनाने के लिए लिंक्ड सूची विधि का उपयोग कर रहे हैं।

import java.util.*; 
import java.lang.*; 
import java.io.*;  

/* Name of the class has to be "Main" only if the class is public. */ 

public class HelloWorld { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> listStrings = new LinkedList<String>(); 
      listStrings.add("1"); 
      listStrings.add("2"); 
      listStrings.add("3"); 
      listStrings.add("4"); 
      listStrings.add("5"); 
  
      System.out.println(listStrings); 
   } 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[1, 2, 3, 4, 5]

Erlang में संख्याओं की सूची बनाने का कार्यक्रम

-module(helloworld).  
-export([start/0]).   

start() ->  
   Lst = [1,2,3,4,5],  
   io:fwrite("~w~n",[Lst]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[1 2 3 4 5]

जावा में सूची संचालन

इस खंड में, हम कुछ कार्यों पर चर्चा करेंगे जो जावा में सूचियों पर किए जा सकते हैं।

तत्वों को सूची में जोड़ना

तत्वों (सूची), ऐड (इंडेक्स, ऑब्जेक्ट), ऐडऑल () का उपयोग सूची में तत्वों को जोड़ने के लिए किया जाता है। उदाहरण के लिए,

ListStrings.add(3, “three”)

तत्वों को एक सूची से हटाना

सूची से तत्वों को हटाने के लिए (इंडेक्स) या रिमूवजेक्ट () का उपयोग किया जाता है। उदाहरण के लिए,

ListStrings.remove(3,”three”)

Note - सूची से सभी तत्वों को हटाने के लिए स्पष्ट () विधि का उपयोग किया जाता है।

तत्वों को एक सूची से पुनर्प्राप्त करना

एक निर्दिष्ट स्थान पर सूची से तत्वों को प्राप्त करने के लिए () विधि का उपयोग किया जाता है। LinkedList वर्ग में getfirst () और getlast () विधियों का उपयोग किया जा सकता है। उदाहरण के लिए,

String str = ListStrings.get(2)

एक सूची में अद्यतन तत्वों

सेट (इंडेक्स, एलीमेंट) विधि का उपयोग किसी निर्दिष्ट इंडेक्स के साथ निर्दिष्ट इंडेक्स पर किसी तत्व को अपडेट करने के लिए किया जाता है। उदाहरण के लिए,

listStrings.set(2,”to”)

तत्वों को एक सूची में क्रमबद्ध करना

तरीके collection.sort () और collection.reverse () का उपयोग आरोही या अवरोही क्रम में एक सूची को सॉर्ट करने के लिए किया जाता है। उदाहरण के लिए,

Collection.sort(listStrings)

एक सूची में तत्वों की खोज

आवश्यकता के अनुसार निम्नलिखित तीन विधियों का उपयोग किया जाता है -

Boolean contains(Object) विधि रिटर्न true यदि सूची में निर्दिष्ट तत्व है, तो यह वापस आ जाता है false।

int indexOf(Object) विधि किसी सूची में किसी निर्दिष्ट तत्व की पहली घटना का सूचकांक लौटाती है, अन्यथा यह तत्व नहीं मिलने पर -1 लौट आती है।

int lastIndexOf(Object) किसी सूची में एक निर्दिष्ट तत्व की अंतिम घटना का सूचकांक देता है, अन्यथा यह तत्व नहीं मिलने पर -1 लौटता है।

एर्लांग में सूची संचालन

इस खंड में, हम कुछ ऑपरेशनों के बारे में चर्चा करेंगे, जो एर्लांग में सूचियों पर किए जा सकते हैं।

दो सूचियों को जोड़ना

दो सूचियों को जोड़कर एक नई सूची बनाने के लिए एपेंड (सूचीपत्र, लिस्टसेकंड) विधि का उपयोग किया जाता है। उदाहरण के लिए,

append(list1,list2)

किसी तत्व को हटाना

सूची से निर्दिष्ट तत्व को हटाने के लिए डिलीट (एलिमेंट, लिस्टनाम) मेथड का उपयोग किया जाता है और यह नई सूची देता है। उदाहरण के लिए,

delete(5,list1)

सूची से अंतिम तत्व हटाना

किसी सूची से अंतिम तत्व को हटाने और एक नई सूची वापस करने के लिए ड्रॉपप्लास्ट (सूचीनाम) विधि का उपयोग किया जाता है। उदाहरण के लिए,

droplast(list1)

किसी तत्व की खोज करना

सदस्य (तत्व, सूचीनाम) विधि का उपयोग सूची में तत्व को खोजने के लिए किया जाता है, यदि यह पाया जाता है कि यह सही है तो यह गलत है। उदाहरण के लिए,

member(5,list1)

अधिकतम और न्यूनतम मूल्य प्राप्त करना

किसी सूची में अधिकतम और न्यूनतम मान ज्ञात करने के लिए अधिकतम (सूचीनाम) और न्यूनतम (सूचीनाम) विधियों का उपयोग किया जाता है। उदाहरण के लिए,

max(list1)

सूची तत्वों को क्रमबद्ध करना

सूची प्रकार (सूचीनाम) और रिवर्स (सूचीनाम) का उपयोग आरोही या अवरोही क्रम में सूची को क्रमबद्ध करने के लिए किया जाता है। उदाहरण के लिए,

sort(list1)

सूची तत्वों को जोड़ना

किसी सूची के सभी तत्वों को जोड़ने और उनकी राशि को वापस करने के लिए योग (listname) विधि का उपयोग किया जाता है। उदाहरण के लिए,

sum(list1)

जावा का उपयोग करके आरोही और अवरोही क्रम में एक सूची को क्रमबद्ध करें

निम्न प्रोग्राम दिखाता है कि जावा का उपयोग करके आरोही और अवरोही क्रम में एक सूची को कैसे सॉर्ट करना है -

import java.util.*; 
import java.lang.*; 
import java.io.*;  

public class SortList { 
   public static void main (String[] args) throws java.lang.Exception { 
      List<String> list1 = new ArrayList<String>(); 
      list1.add("5"); 
      list1.add("3"); 
      list1.add("1"); 
      list1.add("4"); 
      list1.add("2"); 
  
      System.out.println("list before sorting: " + list1); 
  
      Collections.sort(list1); 
  
      System.out.println("list in ascending order: " + list1); 
      Collections.reverse(list1); 
  
      System.out.println("list in dsending order: " + list1); 
   } 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

list before sorting     : [5, 3, 1, 4, 2] 
list in ascending order : [1, 2, 3, 4, 5] 
list in dsending order  : [5, 4, 3, 2, 1]

Erlang का उपयोग करके आरोही क्रम में एक सूची को क्रमबद्ध करें

निम्नलिखित कार्यक्रम से पता चलता है कि एर्लांग का उपयोग करके आरोही और अवरोही क्रम में एक सूची को कैसे सॉर्ट करना है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

-module(helloworld).  
-import(lists,[sort/1]).  
-export([start/0]).   

start() ->  
   List1 = [5,3,4,2,1],  
   io:fwrite("~p~n",[sort(List1)]),

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[1,2,3,4,5]

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

C # में एक टपल को परिभाषित करने का कार्यक्रम

निम्नलिखित कार्यक्रम से पता चलता है कि कैसे चार शब्दों के टपल को परिभाषित किया जाए और उन्हें C # का उपयोग करके प्रिंट किया जाए, जो एक ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग भाषा है।

using System; 
public class Test { 
   public static void Main() { 
      var t1 = Tuple.Create(1, 2, 3, new Tuple<int, int>(4, 5));   
      Console.WriteLine("Tuple:" + t1);    
   } 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Tuple :(1, 2, 3, (4, 5))

एर्लांग में एक टपल को परिभाषित करने का कार्यक्रम

निम्नलिखित कार्यक्रम से पता चलता है कि चार शब्दों के एक टपल को कैसे परिभाषित करें और एर्लांग का उपयोग करके उन्हें प्रिंट करें, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

-module(helloworld).  
-export([start/0]).   

start() -> 
   P = {1,2,3,{4,5}} ,  
   io:fwrite("~w",[P]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

{1, 2, 3, {4, 5}}

टपल का लाभ

Tuples निम्नलिखित लाभ प्रदान करते हैं -

  • Tuples का आकार प्रकृति में होता है अर्थात हम tuple से तत्वों को जोड़ / हटा नहीं सकते हैं।

  • हम किसी भी तत्व को टूपल में खोज सकते हैं।

  • ट्यूपल्स सूचियों की तुलना में तेज़ हैं, क्योंकि उनके पास मूल्यों का एक निरंतर सेट है।

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

ट्यूपल्स बनाम सूची

टपल सूची
टुपल्स हैं immutable, यानी, हम इसके डेटा को अपडेट नहीं कर सकते। सूची हैं mutable, यानी, हम इसके डेटा को अपडेट कर सकते हैं।
एक टपल में तत्व विभिन्न प्रकार के हो सकते हैं। किसी सूची में सभी तत्व एक ही प्रकार के हैं।
तत्वों के चारों ओर गोल कोष्ठक द्वारा ट्यूपल्स को निरूपित किया जाता है। तत्वों के चारों ओर वर्गाकार कोष्ठकों द्वारा सूचियाँ अंकित की जाती हैं।

टुपल्स पर संचालन

इस खंड में, हम कुछ कार्यों के बारे में चर्चा करेंगे जो एक टुप पर किए जा सकते हैं।

जांचें कि एक सम्मिलित मूल्य एक टपल है या नहीं

प्रक्रिया is_tuple(tuplevalues)यह निर्धारित करने के लिए उपयोग किया जाता है कि सम्मिलित मूल्य टपल है या नहीं। यह लौट आता हैtrue जब एक सम्मिलित मूल्य टपल होता है, तो यह वापस आ जाता है false। उदाहरण के लिए,

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} , io:fwrite("~w",[is_tuple(K)]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

True

एक सूची को एक टुपल में परिवर्तित करना

प्रक्रिया list_to_tuple(listvalues)एक सूची को टुपल में परिवर्तित करता है। उदाहरण के लिए,

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[list_to_tuple([1,2,3,4,5])]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

{1, 2, 3, 4, 5}

एक सूची में ट्यूपल परिवर्तित करना

प्रक्रिया tuple_to_list(tuplevalues)एक निर्दिष्ट टपल को सूची प्रारूप में परिवर्तित करता है। उदाहरण के लिए,

-module(helloworld).  
-export([start/0]).  

start() ->  
   io:fwrite("~w",[tuple_to_list({1,2,3,4,5})]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[1, 2, 3, 4, 5]

टपल का आकार जांचें

प्रक्रिया tuple_size(tuplename)टपल का आकार देता है। उदाहरण के लिए,

-module(helloworld).  
-export([start/0]).  

start() ->  
   K = {abc,50,pqr,60,{xyz,75}} ,  
   io:fwrite("~w",[tuple_size(K)]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5

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

रिकॉर्ड कैसे बनाये?

कीवर्ड 'रिकॉर्ड' का उपयोग रिकॉर्ड नाम और उसके क्षेत्रों के साथ निर्दिष्ट रिकॉर्ड बनाने के लिए किया जाता है। इसका सिंटैक्स इस प्रकार है -

record(recodname, {field1, field2, . . fieldn})

रिकॉर्ड में मान सम्मिलित करने का सिंटैक्स है -

#recordname {fieldName1 = value1, fieldName2 = value2 .. fieldNamen = valuen}

एर्लांग का उपयोग करके रिकॉर्ड बनाने का कार्यक्रम

निम्नलिखित उदाहरण में, हमने नाम का रिकॉर्ड बनाया है student दो क्षेत्रों, अर्थात्, sname तथा sid।

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5}.

C ++ का उपयोग करके रिकॉर्ड बनाने का कार्यक्रम

निम्न उदाहरण दिखाता है कि C ++ का उपयोग करके रिकॉर्ड कैसे बनाया जाए, जो एक वस्तु-उन्मुख प्रोग्रामिंग भाषा है -

#include<iostream> 
#include<string>
using namespace std; 

class student {
   public: 
   string sname; 
   int sid; 
   15 
}; 

int main() {    
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   return 0;  
}

Erlang का उपयोग करके रिकॉर्ड मूल्यों तक पहुंचने का कार्यक्रम

निम्न कार्यक्रम दिखाता है कि एर्लैंग का उपयोग करके रिकॉर्ड मूल्यों का उपयोग कैसे किया जाता है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है -

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   io:fwrite("~p~n",[S#student.sid]),  
   io:fwrite("~p~n",[S#student.sname]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5 
"Sachin"

C ++ का उपयोग करके रिकॉर्ड मान तक पहुंचने का कार्यक्रम

निम्न प्रोग्राम दिखाता है कि C ++ का उपयोग करके रिकॉर्ड मानों तक कैसे पहुंचा जाए -

#include<iostream> 
#include<string> 
using namespace std; 

class student {     
   public: 
   string sname; 
   int sid; 
}; 

int main() {     
   student S;  
   S.sname = "Sachin"; 
   S.sid = 5; 
   cout<<S.sid<<"\n"<<S.sname;  
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5 
Sachin

रिकॉर्ड मानों को किसी विशेष फ़ील्ड में मान बदलकर और फिर उस रिकॉर्ड को एक नए चर नाम पर असाइन किया जा सकता है। ऑब्जेक्ट-ओरिएंटेड और कार्यात्मक प्रोग्रामिंग भाषाओं का उपयोग करके यह समझने के लिए निम्नलिखित दो उदाहरणों पर एक नज़र डालें।

Erlang का उपयोग करके रिकॉर्ड मूल्यों को अपडेट करने का कार्यक्रम

निम्नलिखित कार्यक्रम दिखाता है कि एर्लैंग का उपयोग करके रिकॉर्ड मूल्यों को कैसे अपडेट किया जाए -

-module(helloworld).  
-export([start/0]).  
-record(student, {sname = "", sid}).   

start() ->  
   S = #student{sname = "Sachin",sid = 5},  
   S1 = S#student{sname = "Jonny"},  
   io:fwrite("~p~n",[S1#student.sid]),  
   io:fwrite("~p~n",[S1#student.sname]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

5
"Jonny"

C ++ का उपयोग करके रिकॉर्ड मानों को अपडेट करने का कार्यक्रम

निम्न प्रोग्राम दिखाता है कि C ++ का उपयोग करके रिकॉर्ड मानों को कैसे अपडेट किया जाए -

#include<iostream> 
#include<string> 
using namespace std;  

class student {    
   public: 
   string sname; 
   int sid; 
};  

int main() {     
   student S;  
   S.sname = "Jonny"; 
   S.sid = 5; 
   cout<<S.sname<<"\n"<<S.sid; 
   cout<<"\n"<< "value after updating"<<"\n"; 
   S.sid = 10; 
   cout<<S.sname<<"\n"<<S.sid; 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Jonny 
5 
value after updating 
Jonny 
10

लैम्ब्डा कैलकुलस एक फ्रेमवर्क है जिसे अलोंजो चर्च द्वारा 1930 के दशक में विकसित किया गया था ताकि कार्यों के साथ संगणना का अध्ययन किया जा सके।

  • Function creation - चर्च ने नोटेशन की शुरुआत की λx.Eएक फ़ंक्शन को निरूपित करने के लिए जिसमें 'x' एक औपचारिक तर्क है और 'E' कार्यात्मक निकाय है। ये कार्य बिना नाम और एकल तर्क के हो सकते हैं।

  • Function application - चर्च ने नोटेशन का इस्तेमाल किया E1.E2 फ़ंक्शन के अनुप्रयोग को निरूपित करने के लिए E1 वास्तविक तर्क के लिए E2। और सभी कार्य एकल तर्क पर हैं।

लैम्ब्डा कैलकुलस का सिंटैक्स

लैम्ब्डा कैलकुलस में तीन अलग-अलग प्रकार के भाव शामिल हैं, अर्थात,

E :: = x (चर)

| ई 1 ई 2 (फ़ंक्शन अनुप्रयोग)

| λx.E (फंक्शन क्रिएशन)

कहाँ पे λx.E लैंबडा एब्स्ट्रैक्शन कहलाता है और E को λ-अभिव्यक्तियों के रूप में जाना जाता है।

लैम्ब्डा कैलकुलस का मूल्यांकन

शुद्ध लैम्ब्डा कैलकुलस का कोई अंतर्निहित कार्य नहीं है। आइए हम निम्नलिखित अभिव्यक्ति का मूल्यांकन करें -

(+ (* 5 6) (* 8 3))

यहाँ, हम '+' से शुरू नहीं कर सकते क्योंकि यह केवल संख्याओं पर काम करता है। दो निरर्थक भाव हैं: (* ५ ६) और (*। ३)।

हम या तो पहले कम कर सकते हैं। उदाहरण के लिए -

(+ (* 5 6) (* 8 3)) 
(+ 30 (* 8 3)) 
(+ 30 24) 
= 54

ule-कटौती नियम

हमें λ को संभालने के लिए एक कमी नियम की आवश्यकता है

(λx . * 2 x) 4 
(* 2 4) 
= 8

इसे β-कमी कहा जाता है।

औपचारिक पैरामीटर का उपयोग कई बार किया जा सकता है -

(λx . + x x) 4 
(+ 4 4) 
= 8

जब कई शर्तें होती हैं, तो हम उन्हें निम्नानुसार संभाल सकते हैं -

(λx . (λx . + (− x 1)) x 3) 9

भीतरी x भीतर का है λ और बाहरी एक्स बाहरी एक से संबंधित है।

(λx . + (− x 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
= 11

मुफ्त और बाध्य चर

एक अभिव्यक्ति में, एक चर की प्रत्येक उपस्थिति या तो "मुक्त" (λ के लिए) या "बाध्य" (एक λ के लिए) है।

of-कमी (λx . E) y हर की जगह x कि में मुक्त होता है E साथ में y। उदाहरण के लिए -

अल्फा रिडक्शन

अल्फा की कमी बहुत सरल है और यह लंबोदर अभिव्यक्ति के अर्थ को बदलने के बिना किया जा सकता है।

λx . (λx . x) (+ 1 x) ↔ α λx . (λy . y) (+ 1 x)

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

(λx . (λx . + (− x 1)) x 3) 9 
(λx . (λy . + (− y 1)) x 3) 9 
(λy . + (− y 1)) 9 3 
+ (− 9 1) 3 
+ 8 3 
11

चर्च-रोसेर प्रमेय

चर्च-रोसेर प्रमेय निम्नलिखित बताता है -

  • यदि E1 E E2 है, तो एक E मौजूद है जैसे कि E1 → E और E2 → E. "किसी भी तरह से कटौती अंततः एक ही परिणाम उत्पन्न कर सकती है।"

  • यदि E1 → E2, और E2 सामान्य रूप है, तो E1 से E2 तक सामान्य क्रम में कमी है। "सामान्य-क्रम में कमी हमेशा एक सामान्य रूप का उत्पादन करेगी, यदि कोई मौजूद है।"

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

आलसी मूल्यांकन का उपयोग यूनिक्स मानचित्र कार्यों में डिस्क से केवल आवश्यक पृष्ठों को लोड करके उनके प्रदर्शन को बेहतर बनाने के लिए किया जाता है। शेष पृष्ठों के लिए कोई मेमोरी आवंटित नहीं की जाएगी।

आलसी मूल्यांकन - लाभ

  • यह भाषा रनटाइम को उप-अभिव्यक्तियों को छोड़ने की अनुमति देता है जो सीधे अभिव्यक्ति के अंतिम परिणाम से जुड़े नहीं हैं।

  • यह अस्थायी संगणना और सशर्त को त्यागकर एक एल्गोरिथ्म की समय जटिलता को कम करता है।

  • यह प्रोग्रामर को डेटा संरचनाओं के घटकों को एक्सेस करने के बाद उन्हें शुरू करने की अनुमति देता है, जब तक कि वे किसी भी परिपत्र निर्भरता से मुक्त नहीं हो जाते।

  • यह डेटा लोड करने के लिए सबसे उपयुक्त है जिसे बार-बार एक्सेस किया जाएगा।

आलसी मूल्यांकन - कमियां

  • यह भाषा रनटाइम को उप-अभिव्यक्तियों के मूल्यांकन के लिए बाध्य करता है जब तक कि इसे अंतिम परिणाम बनाने की आवश्यकता न हो thunks (विलंबित वस्तुएं)।

  • कभी-कभी यह एक एल्गोरिथ्म के अंतरिक्ष जटिलता को बढ़ाता है।

  • इसके प्रदर्शन का पता लगाना बहुत मुश्किल है क्योंकि इसमें उनके निष्पादन से पहले भावों के अंश शामिल हैं।

पायथन का उपयोग करके आलसी मूल्यांकन

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

r = range(10) 
print(r) 
range(0, 10) 
print(r[3])

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
3

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

यहाँ कुछ कार्यों की एक सूची दी गई है, जिन्हें किसी फ़ाइल पर किया जा सकता है -

  • एक नई फ़ाइल बनाना
  • किसी मौजूदा फ़ाइल को खोलना
  • फ़ाइल सामग्री पढ़ना
  • फ़ाइल पर डेटा खोजना
  • एक नई फ़ाइल में लिखना
  • किसी मौजूदा फ़ाइल में सामग्री अपडेट करना
  • फ़ाइल हटाना
  • एक फ़ाइल बंद करना

फ़ाइल में लिखना

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

आइए देखें कि C ++ का उपयोग करके किसी फ़ाइल में सामग्री कैसे लिखें।

उदाहरण

#include <iostream> 
#include <fstream> 
using namespace std;  

int main () {   
   ofstream myfile; 
   myfile.open ("Tempfile.txt", ios::out); 
   myfile << "Writing Contents to file.\n"; 
   cout << "Data inserted into file"; 
   myfile.close(); 
   return 0; 
}

Note -

  • fstream फ़ाइल पढ़ने / लिखने के संचालन को नियंत्रित करने के लिए प्रयुक्त स्ट्रीम क्लास है।

  • ofstream फ़ाइल में सामग्री लिखने के लिए उपयोग किया जाने वाला स्ट्रीम क्लास है।

आइए देखें कि एरलांग का उपयोग करके किसी फ़ाइल में सामग्री कैसे लिखनी है, जो एक कार्यात्मक प्रोग्रामिंग भाषा है।

-module(helloworld).  
-export([start/0]).   

start() ->
   {ok, File1} = file:open("Tempfile.txt", [write]),  
   file:write(File1,"Writting contents to file"), 
   io:fwrite("Data inserted into file\n").

Note -

  • एक फ़ाइल खोलने के लिए हमें उपयोग करना होगा, open(filename,mode)।

  • फ़ाइल में सामग्री लिखने के लिए सिंटैक्स: write(filemode,file_content)।

Output - जब हम इस कोड को "फाइल करने के लिए लेखन सामग्री" चलाते हैं, तो फ़ाइल में लिखा जाएगा Tempfile.txt। यदि फ़ाइल में कोई मौजूदा सामग्री है, तो इसे ओवरराइट कर दिया जाएगा।

एक फ़ाइल से पढ़ना

किसी फ़ाइल से पढ़ने के लिए, पहले हमें निर्दिष्ट फ़ाइल को खोलना होगा reading mode। यदि फ़ाइल मौजूद नहीं है, तो उसका संबंधित तरीका NULL देता है।

निम्न प्रोग्राम दिखाता है कि किसी फ़ाइल की सामग्री को कैसे पढ़ा जाए C++ -

#include <iostream> 
#include <fstream> 
#include <string> 
using namespace std;  

int main () {
   string readfile; 
   ifstream myfile ("Tempfile.txt",ios::in); 
   
   if (myfile.is_open()) {     
      while ( getline (myfile,readfile) ) {       
         cout << readfile << '\n'; 
      } 
      myfile.close(); 
   } else  
      cout << "file doesn't exist";  
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

Writing contents to file

Note- इस कार्यक्रम में, हमने "ios ::" का उपयोग करके रीड मोड में एक टेक्स्ट फ़ाइल खोली और फिर स्क्रीन पर इसकी सामग्री प्रिंट की। हमने इस्तेमाल किया हैwhile "गेटलाइन" विधि का उपयोग करके फ़ाइल सामग्री लाइन को पढ़ने के लिए लूप।

निम्न प्रोग्राम दिखाता है कि कैसे एक ही ऑपरेशन का उपयोग करना है Erlang। यहाँ, हम उपयोग करेंगेread_file(filename) निर्दिष्ट फ़ाइल से सभी सामग्री को पढ़ने की विधि।

-module(helloworld).  
-export([start/0]).   

start() ->  
   rdfile = file:read_file("Tempfile.txt"),  
   io:fwrite("~p~n",[rdfile]).

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

ok, Writing contents to file

मौजूदा फ़ाइल हटाएं

हम फ़ाइल संचालन का उपयोग करके मौजूदा फ़ाइल को हटा सकते हैं। निम्न प्रोग्राम दिखाता है कि मौजूदा फ़ाइल को कैसे हटाया जाएusing C++ -

#include <stdio.h> 

int main () {   
   if(remove( "Tempfile.txt" ) != 0 ) 
      perror( "File doesn’t exist, can’t delete" ); 
   else 
      puts( "file deleted successfully " ); 
   return 0; 
}

यह निम्नलिखित उत्पादन का उत्पादन करेगा -

file deleted successfully

निम्नलिखित कार्यक्रम दिखाता है कि आप उसी ऑपरेशन को कैसे कर सकते हैं Erlang। यहां, हम विधि का उपयोग करेंगेdelete(filename) मौजूदा फ़ाइल को हटाने के लिए।

-module(helloworld).  
-export([start/0]).   

start() ->  
   file:delete("Tempfile.txt").

Output - यदि फ़ाइल "Tempfile.txt" मौजूद है, तो इसे हटा दिया जाएगा।

किसी फ़ाइल का आकार निर्धारित करना

निम्न प्रोग्राम दिखाता है कि आप C ++ का उपयोग करके किसी फ़ाइल का आकार कैसे निर्धारित कर सकते हैं। यहाँ, समारोहfseek धारा से जुड़े स्थिति सूचक को एक नई स्थिति में सेट करता है, जबकि ftell धारा में वर्तमान स्थिति लौटाता है।

#include <stdio.h> 

int main () {  
   FILE * checkfile; 
   long size; 
   checkfile = fopen ("Tempfile.txt","rb"); 
   
   if (checkfile == NULL)  
      perror ("file can’t open"); 
   else {   
      fseek (checkfile, 0, SEEK_END);    // non-portable 
      size = ftell (checkfile); 
      fclose (checkfile); 
      printf ("Size of Tempfile.txt: %ld bytes.\n",size); 
   } 
   return 0; 
}

Output - यदि फ़ाइल "Tempfile.txt" मौजूद है, तो यह बाइट्स में अपना आकार दिखाएगा।

निम्नलिखित कार्यक्रम दिखाता है कि आप एर्लैंग में एक ही ऑपरेशन कैसे कर सकते हैं। यहां, हम विधि का उपयोग करेंगेfile_size(filename) फ़ाइल का आकार निर्धारित करने के लिए।

-module(helloworld).  
-export([start/0]).   

start() ->  
   io:fwrite("~w~n",[filelib:file_size("Tempfile.txt")]).

Output- यदि फ़ाइल "Tempfile.txt" मौजूद है, तो यह बाइट्स में अपना आकार दिखाएगा। और, यह "0" प्रदर्शित करेगा।

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2025 | All Rights Reserved