प्रोग्रामिंग भाषाओं में टाइप करने पर लाइकबेज़

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

पूर्ण संस्करण में सभी प्रकार की टाइपिंग, कोड उदाहरणों के साथ सुगंधित, लोकप्रिय प्रोग्रामिंग भाषाओं के लिंक और घातीय चित्रों का विस्तृत विवरण है।

मैं पहले लेख के लघु संस्करण को पढ़ने की सलाह देता हूं, और फिर, यदि आप चाहें, और पूर्ण एक।

लघु संस्करण

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

चूंकि "टाइपलेस टाइपिंग" एक कॉर्क के रूप में स्वाभाविक रूप से सरल है, इसलिए इसे किसी अन्य प्रकार में विभाजित नहीं किया गया है। लेकिन टाइप की गई भाषाओं को कई अतिव्यापी श्रेणियों में विभाजित किया गया है:

• स्थैतिक / गतिशील टाइपिंग। स्टेटिक इस तथ्य से निर्धारित होता है कि संकलन चरण में अंतिम प्रकार के चर और फ़ंक्शन निर्धारित किए गए हैं। यानी पहले से कंपाइलर 100% निश्चित है कि कौन सा प्रकार कहाँ है। डायनामिक टाइपिंग में, सभी प्रकार के प्रोग्राम निष्पादन के दौरान पहले से ही पाए जाते हैं।
  
  उदाहरण:
  स्टेटिक: सी, जावा, सी #;
  डायनामिक: पायथन, जावास्क्रिप्ट, रूबी।
  
  
• मजबूत / कमजोर टाइपिंग (कभी-कभी वे सख्त / गैर-सख्त कहते हैं)। मजबूत टाइपिंग को इस तथ्य से अलग किया जाता है कि भाषा विभिन्न प्रकार के भावों को मिलाने की अनुमति नहीं देती है और स्वचालित रूप से निहित रूपांतरण नहीं करती है, उदाहरण के लिए, आप स्ट्रिंग से बहुत अधिक नहीं घटा सकते हैं। कमजोर टाइप की हुई भाषाएं कई निहित रूपांतरणों को स्वचालित रूप से निष्पादित करती हैं, भले ही परिशुद्धता का नुकसान हो सकता है या रूपांतरण अस्पष्ट है।
  
  उदाहरण:
  मजबूत: जावा, पायथन, हास्केल, लिस्प;
  कमजोर: सी, जावास्क्रिप्ट, विजुअल बेसिक, पीएचपी।
  
  
• स्पष्ट / निहित टाइपिंग। स्पष्ट रूप से टाइप की गई भाषाएं इस बात से भिन्न होती हैं कि नए चर / कार्यों / उनके तर्कों के प्रकार को स्पष्ट रूप से निर्धारित किया जाना चाहिए। तदनुसार, निहित टाइपिंग वाली भाषाएं इस कार्य को संकलक / दुभाषिया को हस्तांतरित करती हैं।
  
  उदाहरण:
  स्पष्ट: C ++, D, C #
  लागू: PHP, Lua, जावास्क्रिप्ट
  

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

फिर भी, एक ही समय में स्थिर और गतिशील प्रकार के साथ कोई भाषा नहीं है। हालांकि आगे देख कर मैं कहूँगा कि मैं यहाँ झूठ बोल रहा हूँ - वे वास्तव में मौजूद हैं, लेकिन बाद में और भी बहुत कुछ।

और आगे चलते हैं।

विस्तृत संस्करण

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

टाइपिंग टाइपिंग

टाइपिंग प्रोग्रामिंग भाषाओं में, सभी संस्थाओं को केवल विभिन्न लंबाई के बिट्स के अनुक्रम माना जाता है।

आमतौर पर टाइपिंग टाइपिंग निम्न-स्तरीय (असेंबली लैंग्वेज, फोर्थ) और गूढ़ (ब्रेनफक, एचक्यू 9, पीट) भाषाओं में निहित है। हालांकि, वह, नुकसान के साथ, कुछ फायदे हैं।

लाभ

• आपको एक अत्यंत निम्न स्तर पर लिखने की अनुमति देता है, और संकलक / दुभाषिया किसी भी प्रकार की जांच में हस्तक्षेप नहीं करेगा। आप किसी भी तरह के डेटा पर कोई भी ऑपरेशन करने के लिए स्वतंत्र हैं।
• परिणामस्वरूप कोड आमतौर पर अधिक कुशल होता है।
• निर्देशों की पारदर्शिता। भाषा के ज्ञान के साथ, आमतौर पर इसमें कोई संदेह नहीं है कि एक विशेष कोड क्या है।

कमियों

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

मजबूत टाइपिंग टाइपिंग?

, . ( 86/86-64, ) , cx (16 ) rax (64 ).

mov cx, eax ;

, - ? , . , , .

, (static) (dynamic) , , .

, ( , ). , — , ? ? , , ?

.

• — . , , ( , ).
• . , .
• , .
• IDE ( , ).

• — ( , ).
• ( , , ).
• — , .

, — . — ( ) — , .

? 3- : .

— . , ( ) , , — (-1).

(Python):

def find( required_element, list ):
    for (index, element) in enumerate(list):
        if element == required_element:
            return index

    return (-1)

, , , , . . — - !

():

unsigned int find_int( int required_element, int array[], unsigned int size ) {
    for (unsigned int i = 0; i < size; ++i )
        if (required_element == array[i])
            return i;

    return (-1);
}

unsigned int find_float( float required_element, float array[], unsigned int size ) {
    for (unsigned int i = 0; i < size; ++i )
        if (required_element == array[i])
            return i;

    return (-1);
}

unsigned int find_char( char required_element, char array[], unsigned int size ) {
    for (unsigned int i = 0; i < size; ++i )
        if (required_element == array[i])
            return i;

    return (-1);
}

, Python, ? ?

, . , . C++ . :

( , C++):

template <class T>
unsigned int find( T required_element, std::vector<T> array ) {
    for (unsigned int i = 0; i < array.size(); ++i )
        if (required_element == array[i])
            return i;

    return (-1);
}

! Python . , 3-, !

, — .

, , . - ( Haskell). - ( ), () .

, , :

• C# - dynamic.
• F# ?, .
• Haskell — Data.Dynamic.
• Delphi — Variant.

, :

• Common Lisp — .
• Perl — 5.6, .

, ?

. « ». — strong typing.

, , , . « ». — weak typing.

, . .

, . , , . !

. , , , , , «» ? — , ! (, )

- ? , , , , .

?

• — , .
• — , , , , .
• — -, , , , - -.
• — , . , .

• ( ).
• .
• .

, , ! ?

.

,

… . « » ?

, . — . — ( , , , -, , ).

. 3.5 — ( — ? ? ? ?).

— , . .

, PL/I . ! !

, . ? , Pascal , . C#, Groovy Common Lisp.

, , . , .

Haskell.

, .

pi + 1, pi + 1.0 pi + float(1). pi + 1!

Haskell, , 1 . , , . !

sum x y, x y ( 1), — sum , sum , sum , sum sum .

, .

, , . , ( Haskell, Java, C#, Python), ( C, JavaScript, Lua, PHP).

, ?

, , . — explicit typing.

, , . — implicit typing.

- , , — , , .

, , ?

• ( int add(int, int)) , .
• , , .

• — def add(x, y) , int add( int x, int y).
• . - , , .

, , ( - ?), !

-

, - . . — Haskell, , :

--    
add (x, y) = x + y

--   
add :: (Integer, Integer) -> Integer
add (x, y) = x + y

: , add :: (Num a) => a -> a -> a*, .. , Haskell'.

* int_index .

. , . 18 , !

, Haskell, . ( )

- -?
.

-

C++, C++11 ( C++0x), auto, , :

 :
//   
unsigned int a = 5;
unsigned int b = a + 3;

//   
unsigned int a = 5;
auto b = a + 3;

. . ( , , , ):

//   
std::vector<int> vec = randomVector( 30 );
for ( std::vector::const_iterator it = vec.cbegin(); ... ) { 
    ...
}

//   
auto vec = randomVector<int>( 30 );
for ( auto it = vec.cbegin(); ... ) { 
    ...
}

! . , - Haskell, ?

, decltype auto:

//   
int divide( int x, int y ) {
    ...
}

//   
auto divide( int x, int y ) -> decltype(x / y) {
    ...
}

, , (templates / generics) .



“”.

JavaScript  -  |       | 
Ruby        -  |      | 
Python      -  |      | 
Java        -   |      | 
PHP         -  |       | 
C           -   |       | 
C++         -   |       | 
Perl        -  |       | 
Objective-C -   |       | 
C#          -   |      | 
Haskell     -   |      | 
Common Lisp -  |      | 
D           -   |      | 
Delphi      -   |      | 

( C# qxfusion):

• C# — , - dynamic 4.0. dynamic var.
• ++ — C++11 auto decltype. , Boost (boost::any, boost::variant). .
• Common Lisp — , .
• D — .
• Delphi — Variant.

- , CL, PHP Obj-C, - — .

. , . ? ? ? , .

!

:
: