प्रोग्रामिंग पुस्तकों की शुरुआत में आमतौर पर यह चेतावनी शामिल होती है: "शून्य से विभाजित न करें! आपको एक रनटाइम त्रुटि मिलेगी! "
में चीजें बदल गई हैं VB.NET. हालांकि और भी हैं प्रोग्रामिंग विकल्प और गणना अधिक सटीक है, यह देखना हमेशा आसान नहीं होता है कि चीजें किस तरह से होती हैं।
यहां, हम सीखते हैं कि VB.NET की संरचित त्रुटि हैंडलिंग का उपयोग करके विभाजन को शून्य से कैसे संभालना है। और रास्ते में, हम नए VB.NET स्थिरांक भी कवर करते हैं: NaN, Infinity, और Epsilon।
क्या होता है अगर आप VB.NET में 'डिवाइड बाय जीरो' चलाते हैं
यदि आप VB.NET में 'डिवाइड बाय जीरो' परिदृश्य चलाते हैं, तो आपको यह परिणाम मिलता है:
डिम ए, बी, सी अस डबल
a = 1: b = 0
सी = ए / बी
कंसोल। पंक्ति लिखो( _
"गणित के नियम हैं" _
& vbCrLf & _
"निरस्त कर दिया गया?" _
& vbCrLf & _
"शून्य से विभाजन " _
& vbCrLf & _
"संभव होना चाहिए!")
तो यहां क्या हो रहा है? इसका उत्तर यह है कि VB.NET वास्तव में आपको गणितीय रूप से सही उत्तर देता है। गणितीय, आप कर सकते हैं शून्य से विभाजित करें, लेकिन आपको जो मिलता है वह "अनंत" है।
डिम ए, बी, सी अस डबल
a = 1: b = 0
सी = ए / बी
कंसोल। पंक्ति लिखो( _
"उत्तर है: " _
& सी)
'प्रदर्शित करता है:
'उत्तर है: अनंत
मूल्य "अनन्तता" अधिकांश व्यावसायिक अनुप्रयोगों के लिए बहुत उपयोगी नहीं है। (जब तक कि सीईओ यह नहीं सोच रहा हो कि उसके स्टॉक बोनस की ऊपरी सीमा क्या है।) लेकिन यह आपके अनुप्रयोगों को एक रनटाइम अपवाद पर दुर्घटनाग्रस्त होने से बचाता है, जैसे कम शक्तिशाली भाषाएं।
VB.NET आपको गणना करने की अनुमति देकर और भी अधिक लचीलापन देता है। इसकी जांच करें:
डिम ए, बी, सी अस डबल
a = 1: b = 0
सी = ए / बी
c = c + 1
'इनफिनिटी प्लस 1 है
'फिर भी अनंत
गणितीय रूप से सही रहने के लिए, VB.NET आपको कुछ गणनाओं जैसे 0/0 के लिए NaN (नंबर नहीं) का उत्तर देता है।
डिम ए, बी, सी अस डबल
a = 0: b = 0
सी = ए / बी
कंसोल। पंक्ति लिखो( _
"उत्तर है: " _
& सी)
'प्रदर्शित करता है:
'जवाब है: NaN
VB.NET भी सकारात्मक अनंत और नकारात्मक अनंत के बीच अंतर बता सकता है:
डिम ए 1, ए, बी, सी अस डबल
ए 1 = 1: ए 2 = -1: बी = 0
यदि (a / b)> (a2 / b) तब _
कंसोल। पंक्ति लिखो( _
"पोस्टिव इन्फिनिटी है" _
& vbCrLf & _
"से अधिक" _
& vbCrLf & _
"नकारात्मक अनंत।")
पॉजिटिव इनफिनिटी और नेगेटिव इनफिनिटी के अलावा, VB.NET एप्सिलॉन भी प्रदान करता है, जो शून्य से अधिक छोटा सकारात्मक डबल मूल्य है।
ध्यान रखें कि VB.NET की ये सभी नई क्षमताएं केवल फ्लोटिंग पॉइंट (डबल या सिंगल) डेटा प्रकारों के साथ उपलब्ध हैं। और यह लचीलापन कुछ Try-Catch-आखिर (संरचित त्रुटि हैंडलिंग) भ्रम पैदा कर सकता है। उदाहरण के लिए, किसी भी तरह के अपवाद को फेंकने के बिना .NET कोड ऊपर चलता है, इसलिए इसे Try-Catch-आखिर ब्लॉक के अंदर कोड करने से मदद नहीं मिलेगी। शून्य से भाग के लिए परीक्षण करने के लिए, आपको कुछ इस तरह से एक परीक्षण कोड करना होगा:
यदि सी। ToString = "इन्फिनिटी" फिर...
यहां तक कि अगर आप प्रोग्राम को कोड करते हैं (एकल या दोहरे प्रकारों के बजाय पूर्णांक का उपयोग करके), तो भी आपको "ओवरफ्लो" अपवाद मिलता है, न कि "जीरो द्वारा विभाजित" अपवाद। यदि आप अन्य तकनीकी मदद के लिए वेब पर खोज करते हैं, तो आप देखेंगे कि उदाहरण सभी ओवरफ़्लो अपवाद के लिए परीक्षण करते हैं।
.NET में वास्तव में DivideByZeroException एक वैध प्रकार के रूप में है। लेकिन अगर कोड कभी अपवाद को ट्रिगर नहीं करता है, तो आप इस मायावी त्रुटि को कब देखेंगे?
जब आप DivideByZeroException देखेंगे
जैसा कि बाद में पता चला, माइक्रोसॉफ्टट्राइ-कैच-आखिर ब्लॉक के बारे में MSDN पृष्ठ वास्तव में उन्हें कोडित करने के तरीके को स्पष्ट करने के लिए शून्य उदाहरणों से विभाजित का उपयोग करता है। लेकिन एक सूक्ष्म "कैच" है जो वे स्पष्ट नहीं करते हैं। उनका कोड इस तरह दिखता है:
डिम ए ऐज एँगर = ०
डिम बी अस इंटेगर = ०
डिगर c As Integer = 0
प्रयत्न
a = b \ c
एक्सेप्शन के रूप में कैच करें
कंसोल। राइटलाइन ("एक रन-टाइम त्रुटि हुई")
आखिरकार
कंसोल। पढ़ने के लिए लाइन()
समाप्ति का प्रयास करें
यह कोड कर देता है शून्य अपवाद द्वारा वास्तविक विभाजन को ट्रिगर करें।
लेकिन यह कोड अपवाद को क्यों ट्रिगर करता है और कुछ भी नहीं है जिसे हमने पहले कोडित किया है? और Microsoft क्या समझा रहा है?
ध्यान दें कि वे जिस ऑपरेशन का उपयोग करते हैं वह है नहीं विभाजित ("/"), यह पूर्णांक विभाजित है ("\")! (अन्य Microsoft उदाहरण वास्तव में चरों को पूर्णांक घोषित करते हैं।) जैसा कि यह पता चला है, पूर्णांक गणना है केवल मामला जो वास्तव में उस अपवाद को फेंकता है। यह अच्छा होता अगर Microsoft (और अन्य पेज जो उनके कोड को कॉपी करते हैं) ने उस छोटे विवरण को समझाया।