ಪ್ರಯತ್ನಿಸಿ...ಕ್ಯಾಚ್ ರಚನೆಯು ದೋಷಗಳಿಗಾಗಿ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ - ಕ್ಯಾಚಿಂಗ್ ದೋಷ

ಇಂಟರ್ನೆಟ್ ಬ್ರೌಸ್ ಮಾಡುವಾಗ, ರನ್ಟೈಮ್ ದೋಷ ಸಂಭವಿಸಿದೆ ಮತ್ತು "ನೀವು ಡೀಬಗ್ ಮಾಡಲು ಬಯಸುವಿರಾ?" ಎಂದು ಕೇಳುವ JavaScript ಎಚ್ಚರಿಕೆ ವಿಂಡೋವನ್ನು ನಾವೆಲ್ಲರೂ ಎದುರಿಸಿದ್ದೇವೆ. ಈ ರೀತಿಯ ದೋಷ ಸಂದೇಶವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಬಹುದು, ಆದರೆ ಬಳಕೆದಾರರಿಗೆ ಅಲ್ಲ. ಬಳಕೆದಾರರು ದೋಷಗಳನ್ನು ನೋಡಿದಾಗ, ಅವರು ವೆಬ್ ಪುಟವನ್ನು ತೊರೆಯುತ್ತಾರೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷ ಸಂದೇಶಗಳನ್ನು ಹೇಗೆ ತಡೆಯುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ನಿಮಗೆ ಕಲಿಸುತ್ತದೆ ಆದ್ದರಿಂದ ನೀವು ನಿಮ್ಮ ವೀಕ್ಷಕರನ್ನು ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.

ಪ್ರಯತ್ನಿಸಿ ... ಕ್ಯಾಚ್ ನಿರ್ಮಾಣ

ಪ್ರಯತ್ನಿಸಿ ... ಕ್ಯಾಚ್ ರಚನೆಯು ದೋಷಗಳಿಗಾಗಿ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಪ್ರಯತ್ನಿಸಿ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವ ಮತ್ತು ಪರಿಶೀಲಿಸುವ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ದೋಷಗಳು ಸಂಭವಿಸಿದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕೋಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಸಿಂಟ್ಯಾಕ್ಸ್

ಪ್ರಯತ್ನಿಸಿ { //ಕೆಲವು ಕೋಡ್ ಅನ್ನು ಇಲ್ಲಿ ರನ್ ಮಾಡಿ } ಹಿಡಿಯಿರಿ (ತಪ್ಪು) { //ಇಲ್ಲಿ ನಿಭಾಯಿಸುವಲ್ಲಿ ದೋಷ }

ಪ್ರಯತ್ನಿಸಿ ... ಕ್ಯಾಚ್ ಅನ್ನು ಲೋವರ್ ಕೇಸ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ (ಸಣ್ಣ ಅಕ್ಷರಗಳು). ದೊಡ್ಡ ಅಕ್ಷರಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷ ಉಂಟಾಗುತ್ತದೆ!

ಉದಾಹರಣೆಗಳು

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು "ಸ್ವಾಗತ ಅತಿಥಿ!" ಅನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಮೌಸ್ ಗುಂಡಿಯನ್ನು ಒತ್ತಿದಾಗ. ಆದಾಗ್ಯೂ, ಸಂದೇಶ() ಕಾರ್ಯದಲ್ಲಿ ಮುದ್ರಣದೋಷವಿದೆ. ಎಚ್ಚರಿಕೆ() ಅನ್ನು addlert() ಎಂದು ಮುದ್ರಿಸಲಾಗಿದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ. ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚುವರಿ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಏನಾಯಿತು ಎಂಬುದನ್ನು ಬಳಕೆದಾರರಿಗೆ ತಿಳಿಸುವ ಕಸ್ಟಮ್ ದೋಷ ಸಂದೇಶವನ್ನು ಕೋಡ್ ಪ್ರದರ್ಶಿಸುತ್ತದೆ:

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಬಳಕೆದಾರರಿಗೆ ಕಸ್ಟಮ್ ಸಂದೇಶವನ್ನು ತೋರಿಸಲು ದೃಢೀಕರಣ ಪೆಟ್ಟಿಗೆಯನ್ನು ಬಳಸುತ್ತದೆ, ಅವರು ಮುಂದುವರಿಸಲು ಸರಿ ಕ್ಲಿಕ್ ಮಾಡಬಹುದು ಅಥವಾ ಮುಖ್ಯ ಪುಟಕ್ಕೆ ಹೋಗಲು ರದ್ದು ಕ್ಲಿಕ್ ಮಾಡಿ. ವಿಧಾನವು ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸಿದರೆ, ಬಳಕೆದಾರರು ರದ್ದುಮಾಡು ಕ್ಲಿಕ್ ಮಾಡಿದ್ದಾರೆ ಮತ್ತು ಕೋಡ್ ಬಳಕೆದಾರರನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ. ವಿಧಾನವು ನಿಜವೆಂದು ಹಿಂತಿರುಗಿಸಿದರೆ, ಕೋಡ್ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ:

ಉದಾಹರಣೆ var txt=""; ಕಾರ್ಯ ಸಂದೇಶ() { ಪ್ರಯತ್ನಿಸಿ { } ಹಿಡಿಯಿರಿ (ತಪ್ಪು) { ಒಂದು ವೇಳೆ(!ದೃಢೀಕರಿಸಿ(txt)) { document.location.href="http://site/"; } } }

ಕೊನೆಯ ನವೀಕರಣ: 10/23/2018

ಕೆಲವೊಮ್ಮೆ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ, ದೋಷಗಳು ಸಂಭವಿಸುತ್ತವೆ, ಅದು ಊಹಿಸಲು ಅಥವಾ ನಿರೀಕ್ಷಿಸಲು ಕಷ್ಟವಾಗುತ್ತದೆ ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಅಸಾಧ್ಯ. ಉದಾಹರಣೆಗೆ, ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ವರ್ಗಾಯಿಸುವಾಗ, ನೆಟ್ವರ್ಕ್ ಸಂಪರ್ಕವು ಅನಿರೀಕ್ಷಿತವಾಗಿ ಕುಸಿಯಬಹುದು. ಅಂತಹ ಸಂದರ್ಭಗಳನ್ನು ವಿನಾಯಿತಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. C# ಭಾಷೆಯು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅಂತಹ ಸಂದರ್ಭಗಳನ್ನು ನಿಭಾಯಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. C# ನಲ್ಲಿ ಟ್ರೈ...ಕ್ಯಾಚ್...ಅಂತಿಮವಾಗಿ ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅನ್ನು ಇದಕ್ಕಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.

ಪ್ರಯತ್ನಿಸಿ () ಹಿಡಿಯಲು () ಅಂತಿಮವಾಗಿ ()

ಪ್ರಯತ್ನಿಸಿ... ಹಿಡಿಯಿರಿ.. ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಬಳಸುವಾಗ, ಪ್ರಯತ್ನಿಸಿ ಬ್ಲಾಕ್‌ನಲ್ಲಿರುವ ಎಲ್ಲಾ ಹೇಳಿಕೆಗಳನ್ನು ಮೊದಲು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಈ ಬ್ಲಾಕ್ನಲ್ಲಿ ಯಾವುದೇ ವಿನಾಯಿತಿಗಳು ಸಂಭವಿಸದಿದ್ದರೆ, ಅದರ ಮರಣದಂಡನೆಯ ನಂತರ ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ತದನಂತರ ಪ್ರಯತ್ನಿಸಿ..ಹಿಡಿಯಿರಿ..ಕೊನೆಗೆ ತನ್ನ ಕೆಲಸವನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

ಯತ್ನದ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಒಂದು ಅಪವಾದವು ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಸಂಭವಿಸಿದಲ್ಲಿ, ಸಾಮಾನ್ಯ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಆರ್ಡರ್ ನಿಲ್ಲುತ್ತದೆ ಮತ್ತು CLR ಅಪವಾದವನ್ನು ನಿಭಾಯಿಸಬಲ್ಲ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಹುಡುಕಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಸರಿಯಾದ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಕಂಡುಬಂದರೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದು ಪೂರ್ಣಗೊಂಡ ನಂತರ, ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಅಗತ್ಯವಿರುವ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಕಂಡುಬಂದಿಲ್ಲವಾದರೆ, ವಿನಾಯಿತಿ ಸಂಭವಿಸಿದಾಗ, ಪ್ರೋಗ್ರಾಂ ಅಸಹಜವಾಗಿ ಅದರ ಮರಣದಂಡನೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಪರಿಗಣಿಸಿ:

ವರ್ಗ ಪ್ರೋಗ್ರಾಂ ( ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ (ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( int x = 5; int y = x / 0; Console.WriteLine ($"ಫಲಿತಾಂಶ: (y)"); Console.WriteLine ("ಪ್ರೋಗ್ರಾಂ ಅಂತ್ಯ"); ಕನ್ಸೋಲ್.ಓದಿ ();

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸಂಖ್ಯೆಯನ್ನು 0 ರಿಂದ ಭಾಗಿಸಲಾಗಿದೆ, ಇದು ವಿನಾಯಿತಿಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಮತ್ತು ನಾವು ಡೀಬಗ್ ಮೋಡ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ವಿಷುಯಲ್ ಸ್ಟುಡಿಯೋದಲ್ಲಿ ನಾವು ವಿನಾಯಿತಿಯ ಬಗ್ಗೆ ನಮಗೆ ತಿಳಿಸುವ ವಿಂಡೋವನ್ನು ನೋಡುತ್ತೇವೆ:

ಈ ವಿಂಡೋದಲ್ಲಿ ನಾವು ಒಂದು ವಿನಾಯಿತಿ ಸಂಭವಿಸಿದೆ ಎಂದು ನೋಡುತ್ತೇವೆ, ಅದು ಸಿಸ್ಟಮ್.ಡಿವೈಡ್ಬೈಝೆರೋಎಕ್ಸೆಪ್ಶನ್ ಪ್ರಕಾರವಾಗಿದೆ, ಅಂದರೆ, ಸೊನ್ನೆಯಿಂದ ಭಾಗಿಸುವ ಪ್ರಯತ್ನ. ವೀಕ್ಷಣೆ ವಿವರಗಳ ಐಟಂ ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ವಿನಾಯಿತಿಯ ಬಗ್ಗೆ ಹೆಚ್ಚು ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು ವೀಕ್ಷಿಸಬಹುದು.

ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸುವುದು ನಮಗೆ ಮಾತ್ರ ಉಳಿದಿದೆ.

ಅಂತಹ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಅನ್ನು ತಪ್ಪಿಸಲು, ನೀವು ವಿನಾಯಿತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಪ್ರಯತ್ನಿಸಿ...ಕ್ಯಾಚ್...ಅಂತಿಮವಾಗಿ ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅನ್ನು ಬಳಸಬೇಕು. ಆದ್ದರಿಂದ, ಈ ಕೆಳಗಿನಂತೆ ಉದಾಹರಣೆಯನ್ನು ಪುನಃ ಬರೆಯೋಣ:

ವರ್ಗ ಪ್ರೋಗ್ರಾಂ ( ಸ್ಥಾಯೀ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) (ಪ್ರಯತ್ನಿಸಿ ( int x = 5; int y = x / 0; Console.WriteLine($"ಫಲಿತಾಂಶ: (y)"); ) ಕ್ಯಾಚ್ ( Console.WriteLine("ಒಂದು ವಿನಾಯಿತಿ ಸಂಭವಿಸಿದೆ ! "); ) ಅಂತಿಮವಾಗಿ ( Console.WriteLine("ಅಂತಿಮವಾಗಿ ನಿರ್ಬಂಧಿಸಿ"); ) ಕನ್ಸೋಲ್

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮತ್ತೊಮ್ಮೆ ಪ್ರಯತ್ನಿಸಿ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ವಿನಾಯಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತೇವೆ, ಏಕೆಂದರೆ ನಾವು ಶೂನ್ಯದಿಂದ ಭಾಗಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದೇವೆ. ಮತ್ತು ರೇಖೆಯನ್ನು ತಲುಪುತ್ತದೆ

ಇಂಟ್ y = x / 0;

ಕಾರ್ಯಕ್ರಮದ ಅನುಷ್ಠಾನವು ನಿಲ್ಲುತ್ತದೆ. CLR ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಿಯಂತ್ರಣವನ್ನು ಆ ಬ್ಲಾಕ್‌ಗೆ ವರ್ಗಾಯಿಸುತ್ತದೆ.

ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ನಂತರ, ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಒಂದು ವಿನಾಯಿತಿ ಸಂಭವಿಸಿದೆ! ಅಂತಿಮವಾಗಿ ಕಾರ್ಯಕ್ರಮದ ಅಂತ್ಯವನ್ನು ನಿರ್ಬಂಧಿಸಿ

ಹೀಗಾಗಿ, ಪ್ರೋಗ್ರಾಂ ಇನ್ನೂ ಶೂನ್ಯದಿಂದ ವಿಭಜನೆಯನ್ನು ನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಮತ್ತು ಆದ್ದರಿಂದ ಈ ವಿಭಾಗದ ಫಲಿತಾಂಶವನ್ನು ಮುದ್ರಿಸುವುದಿಲ್ಲ, ಆದರೆ ಈಗ ಅದು ಕ್ರ್ಯಾಶ್ ಆಗುವುದಿಲ್ಲ, ಮತ್ತು ವಿನಾಯಿತಿಯನ್ನು ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ನಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ಈ ರಚನೆಗೆ ಪ್ರಯತ್ನದ ಬ್ಲಾಕ್ ಅಗತ್ಯವಿದೆ ಎಂದು ಗಮನಿಸಬೇಕು. ನಾವು ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಹೊಂದಿದ್ದರೆ, ನಾವು ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು:

ಪ್ರಯತ್ನಿಸಿ ( int x = 5; int y = x / 0; Console.WriteLine($"ಫಲಿತಾಂಶ: (y)"); ) ಕ್ಯಾಚ್ ( Console.WriteLine("ಒಂದು ವಿನಾಯಿತಿ ಸಂಭವಿಸಿದೆ!"); )

ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ನಾವು ಅಂತಿಮವಾಗಿ ಬ್ಲಾಕ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ನಾವು ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು ಮತ್ತು ವಿನಾಯಿತಿಯನ್ನು ನಿಭಾಯಿಸುವುದಿಲ್ಲ:

ಪ್ರಯತ್ನಿಸಿ ( int x = 5; int y = x / 0; Console.WriteLine($"ಫಲಿತಾಂಶ: (y)"); ) ಅಂತಿಮವಾಗಿ ( Console.WriteLine("Finally Block"); )

ಆದಾಗ್ಯೂ, ಅಂತಹ ನಿರ್ಮಾಣವು C# ಸಿಂಟ್ಯಾಕ್ಸ್ ದೃಷ್ಟಿಕೋನದಿಂದ ಸಾಕಷ್ಟು ಸರಿಯಾಗಿದ್ದರೂ, CLR ಗೆ ಅಗತ್ಯವಿರುವ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗದ ಕಾರಣ, ವಿನಾಯಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲಾಗುವುದಿಲ್ಲ ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ.

ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಮತ್ತು ಷರತ್ತುಗಳು

ಡೆವಲಪರ್‌ನಿಂದ ಹಲವಾರು ಅಸಾಧಾರಣ ಸಂದರ್ಭಗಳನ್ನು ನಿರೀಕ್ಷಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಪ್ರೋಗ್ರಾಂ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸುವುದನ್ನು ಮತ್ತು ಅದರ ವರ್ಗವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ:

ಸ್ಥಾಯೀ ನಿರರ್ಥಕ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( ಕನ್ಸೋಲ್. ರೈಟ್‌ಲೈನ್ ("ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ"); int x = Int32.Parse(Console.ReadLine()); x *= x; Console.WriteLine("ಸ್ಕ್ವೇರ್ ಸಂಖ್ಯೆ: " + x) ಕನ್ಸೋಲ್.ಓದಿ();

ಬಳಕೆದಾರರು ಸಂಖ್ಯೆ ಅಲ್ಲ, ಆದರೆ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಇತರ ಕೆಲವು ಅಕ್ಷರಗಳನ್ನು ನಮೂದಿಸಿದರೆ, ಪ್ರೋಗ್ರಾಂ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಒಂದೆಡೆ, ಸಂಭವನೀಯ ದೋಷವನ್ನು ನಿಭಾಯಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿ..ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಬಳಸುವಾಗ ಇದು ನಿಖರವಾಗಿ ಪರಿಸ್ಥಿತಿಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಪರಿವರ್ತನೆಯ ಸಿಂಧುತ್ವವನ್ನು ಪರಿಶೀಲಿಸಲು ಇದು ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ:

ಸ್ಥಿರ ಶೂನ್ಯ ಮುಖ್ಯ(ಸ್ಟ್ರಿಂಗ್ ಆರ್ಗ್ಸ್) ( ಕನ್ಸೋಲ್ . ರೈಟ್‌ಲೈನ್ ("ಸ್ಕ್ವೇರ್ ಸಂಖ್ಯೆ: " + x); ಕನ್ಸೋಲ್

Int32.TryParse() ವಿಧಾನವು ಪರಿವರ್ತನೆಯನ್ನು ನಿರ್ವಹಿಸಬಹುದಾದರೆ ಸರಿ ಮತ್ತು ಅದು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ ತಪ್ಪು ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಪರಿವರ್ತನೆಯು ಮಾನ್ಯವಾಗಿದ್ದರೆ, ವೇರಿಯಬಲ್ x ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಆದ್ದರಿಂದ, ಪ್ರಯತ್ನಿಸಿ ... ಕ್ಯಾಚ್ ಅನ್ನು ಬಳಸದೆಯೇ, ನೀವು ಸಂಭವನೀಯ ವಿನಾಯಿತಿಯನ್ನು ನಿಭಾಯಿಸಬಹುದು.

ಕಾರ್ಯಕ್ಷಮತೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ಷರತ್ತುಗಳನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಪ್ರಯತ್ನಿಸಿ..ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ದುಬಾರಿಯಾಗಿದೆ. ಆದ್ದರಿಂದ, ಸಾಧ್ಯವಾದರೆ, ಪ್ರಯತ್ನಿಸಿ..ಹಿಡಿಯುವ ಬದಲು, ಅಸಾಧಾರಣ ಸಂದರ್ಭಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಷರತ್ತುಬದ್ಧ ರಚನೆಗಳನ್ನು ಬಳಸುವುದು ಉತ್ತಮ.

T-SQL ಭಾಷೆಯಲ್ಲಿ, ಅನೇಕ ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ, ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಪ್ರತಿಬಂಧಿಸಲು ಸಾಧ್ಯವಿದೆ, ಇಂದು ನಾವು TRY CATCH ನಿರ್ಮಾಣವನ್ನು ನೋಡುತ್ತೇವೆ, ಅದರ ಸಹಾಯದಿಂದ ನಾವು ಅಸಾಧಾರಣ ಸಂದರ್ಭಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು, ಅಂದರೆ. ಅನಿರೀಕ್ಷಿತ ದೋಷಗಳು.

ನೀವು ಈಗಾಗಲೇ ಅರ್ಥಮಾಡಿಕೊಂಡಂತೆ, ನಾವು ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುವುದಿಲ್ಲ, SQL ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೊದಲು SQL ಸರ್ವರ್ ನಮಗೆ ತಿಳಿಸುತ್ತದೆ, ಆದರೆ ಕೆಲವು ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಕೋಡ್‌ನ ನಿರ್ದಿಷ್ಟ ವಿಭಾಗದಲ್ಲಿ ಸಂಭವಿಸಬಹುದಾದ ದೋಷಗಳ ಬಗ್ಗೆ.

ನಿಮಗೆ ತಿಳಿದಿರುವಂತೆ ಶೂನ್ಯದಿಂದ ಭಾಗಿಸುವುದು ಸರಳವಾದ ಉದಾಹರಣೆಯಾಗಿದೆ, ಆದರೆ ಈ ಅಂಕಿ ಅಂಶವು ಇನ್ನೂ ವಿಭಜನೆಯ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳಬಹುದು. ಪ್ರಮಾಣಿತವಲ್ಲದ, ತಪ್ಪಾದ ಡೇಟಾದ ಕಾರ್ಯಾಚರಣೆಗಳಲ್ಲಿ ಸಂಭವಿಸಬಹುದಾದ ಇತರ ದೋಷಗಳು ಸಹ ಇವೆ, ಆದಾಗ್ಯೂ ಸಾಮಾನ್ಯ ಡೇಟಾದಲ್ಲಿ ಅದೇ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಯಾವುದೇ ದೋಷಗಳಿಲ್ಲದೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಟ್ರಾನ್ಸಾಕ್ಟ್-SQL ಭಾಷೆಯಲ್ಲಿ ವಿಶೇಷ ನಿರ್ಮಾಣ TRY...CATCH ಇದೆ, ಇದು SQL ಸರ್ವರ್‌ನ 2005 ಆವೃತ್ತಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಂಡಿತು ಮತ್ತು ಇದನ್ನು ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಯಾರಾದರೂ ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳೊಂದಿಗೆ ಪರಿಚಿತರಾಗಿದ್ದರೆ, ಈ ನಿರ್ಮಾಣವು ನಿಮಗೆ ಹೆಚ್ಚು ಪರಿಚಿತವಾಗಿದೆ, ಏಕೆಂದರೆ ಇದನ್ನು ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಸೂಚನೆ! T-SQL ಭಾಷೆಯ ಹೆಚ್ಚು ವಿವರವಾದ ಅಧ್ಯಯನಕ್ಕಾಗಿ, ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್‌ಗಳು T-SQL ಪ್ರೋಗ್ರಾಮರ್‌ನ ಹಾದಿ ಪುಸ್ತಕವನ್ನು ಓದಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ವಹಿವಾಟು-SQL ಭಾಷಾ ಟ್ಯುಟೋರಿಯಲ್.

T-SQL ನಲ್ಲಿ ಕ್ಯಾಚ್ ನಿರ್ಮಾಣವನ್ನು ಪ್ರಯತ್ನಿಸಿ

ಪ್ರಯತ್ನಿಸಿ ಕ್ಯಾಚ್ ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ ಟ್ರಾನ್ಸಾಕ್ಟ್-SQL ರಚನೆಯಾಗಿದೆ. ದೋಷಗಳಿಗಾಗಿ ನೀವು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ಎಲ್ಲವೂ, ಅಂದರೆ. TRY ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷಗಳು ಸಂಭವಿಸಬಹುದಾದ ಕೋಡ್ ಅನ್ನು ನೀವು ಇರಿಸುತ್ತೀರಿ. ಈ ಬ್ಲಾಕ್‌ನ ಪ್ರಾರಂಭವನ್ನು BEGIN TRY ಸೂಚನೆಯಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಬ್ಲಾಕ್‌ನ ಅಂತ್ಯವನ್ನು ಅದರ ಪ್ರಕಾರ, END TRY ಮೂಲಕ ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ನೀವು ಏನು ಮಾಡಲು ಬಯಸುತ್ತೀರಿ, ಅಂದರೆ. TRY ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಆ ಸೂಚನೆಗಳನ್ನು ನೀವು CATCH ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಇರಿಸಿ, ಅದರ ಪ್ರಾರಂಭವನ್ನು BEGIN CATCH ನಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಅಂತ್ಯವು END CATCH ಆಗಿದೆ. TRY ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಯಾವುದೇ ದೋಷಗಳು ಸಂಭವಿಸದಿದ್ದರೆ, ನಂತರ CATCH ಬ್ಲಾಕ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಅನುಸರಿಸುವ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ದೋಷಗಳು ಸಂಭವಿಸಿದಲ್ಲಿ, ನಂತರ CATCH ಬ್ಲಾಕ್‌ನಲ್ಲಿನ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಈ ಬ್ಲಾಕ್ ಅನ್ನು ಅನುಸರಿಸುವ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, CATCH ಬ್ಲಾಕ್ ಅನ್ನು ಅನುಸರಿಸುವ ಎಲ್ಲಾ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಹೊರತು, ನಾವು ಬಲವಂತವಾಗಿ ಮರಣದಂಡನೆಯನ್ನು ಕೊನೆಗೊಳಿಸದಿದ್ದರೆ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಪ್ಯಾಕೇಜ್.

ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಸ್ವತಃ ಕರೆ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪತ್ತೆಯಾದ ದೋಷಗಳ ಬಗ್ಗೆ ಯಾವುದೇ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸುವುದಿಲ್ಲ, ಉದಾಹರಣೆಗೆ, ದೋಷದ ಸಂಖ್ಯೆ ಅಥವಾ ವಿವರಣೆಯನ್ನು ಕಂಡುಹಿಡಿಯಲು, ಇದಕ್ಕಾಗಿ ನೀವು SELECT, RAISERROR ಅಥವಾ PRINT ಹೇಳಿಕೆಗಳನ್ನು ಬಳಸಬಹುದು; ಕ್ಯಾಚ್ ಬ್ಲಾಕ್.

T-SQL ನಲ್ಲಿ TRY CATCH ರಚನೆಯ ಕುರಿತು ಪ್ರಮುಖ ಅಂಶಗಳು

• ಈ ಬ್ಲಾಕ್‌ಗಳ ನಡುವೆ ಸೂಚನೆಗಳನ್ನು ಇರಿಸಲು ಅನುಮತಿಸದ TRY ಬ್ಲಾಕ್‌ನ ನಂತರ ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಬರಬೇಕು;
• ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ಮುಚ್ಚದ 10 ಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ತೀವ್ರತೆಯ ಕೋಡ್‌ನೊಂದಿಗೆ ಎಲ್ಲಾ ದೋಷಗಳನ್ನು ಕ್ಯಾಚ್ ಪ್ರಯತ್ನಿಸಿ;
• TRY...CATCH ಕನ್ಸ್ಟ್ರಕ್ಟ್‌ನಲ್ಲಿ, ನೀವು ಒಂದು ಪ್ಯಾಕೆಟ್ ಮತ್ತು SQL ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ಗಳ ಒಂದು ಬ್ಲಾಕ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು;
• TRY...CATCH ರಚನೆಯನ್ನು ನೆಸ್ಟೆಡ್ ಮಾಡಬಹುದು, ಉದಾಹರಣೆಗೆ, TRY ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಮತ್ತೊಂದು TRY...CATCH ಸ್ಟ್ರಕ್ಟ್ ಇರಬಹುದು, ಅಥವಾ CATCH ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷಗಳು ಸಂಭವಿಸಿದಲ್ಲಿ CATCH ಬ್ಲಾಕ್‌ನಲ್ಲಿ ನೀವು ದೋಷ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಬರೆಯಬಹುದು;
• GOTO ಹೇಳಿಕೆಯನ್ನು TRY ಅಥವಾ CATCH ಬ್ಲಾಕ್‌ಗಳನ್ನು ನಮೂದಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ, TRY ಅಥವಾ CATCH ಬ್ಲಾಕ್‌ಗಳಲ್ಲಿ ಲೇಬಲ್‌ಗಳಿಗೆ ನೆಗೆಯುವುದನ್ನು ಮಾತ್ರ ಬಳಸಬಹುದು;
• ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿ...ಕ್ಯಾಚ್ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು ಬೆಂಬಲಿತವಾಗಿಲ್ಲ;
• TRY...CATCH ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಈ ಕೆಳಗಿನ ದೋಷಗಳನ್ನು ನಿಭಾಯಿಸುವುದಿಲ್ಲ: ಎಚ್ಚರಿಕೆ ಮತ್ತು ಮಾಹಿತಿ ಸಂದೇಶಗಳು 10 ಅಥವಾ ಅದಕ್ಕಿಂತ ಕಡಿಮೆ ಮಟ್ಟದ ತೀವ್ರತೆಯೊಂದಿಗೆ, ಕ್ಲೈಂಟ್-ಉಂಟುಮಾಡುವ ಸಂಪರ್ಕದ ಮುಕ್ತಾಯ, ಮತ್ತು KILL ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನಿರ್ವಾಹಕರ ಮುಕ್ತಾಯ.

ದೋಷ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯುವ ಕಾರ್ಯಗಳು

ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾದ ದೋಷಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪಡೆಯಲು, ನೀವು ಈ ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಬಹುದು:

• ERROR_NUMBER() - ದೋಷ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
• ERROR_MESSAGE() - ದೋಷದ ವಿವರಣೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
• ERROR_STATE() - ದೋಷ ಸ್ಥಿತಿ ಕೋಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ;
• ERROR_SEVERITY() - ದೋಷದ ತೀವ್ರತೆಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ;
• ERROR_PROCEDURE() - ಸಂಗ್ರಹಿಸಿದ ಕಾರ್ಯವಿಧಾನದ ಹೆಸರನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಅಥವಾ ದೋಷ ಸಂಭವಿಸಿದ ಪ್ರಚೋದಕ;
• ERROR_LINE() - ದೋಷಕ್ಕೆ ಕಾರಣವಾದ ಸೂಚನೆಯ ಸಾಲಿನ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.

ಈ ಕಾರ್ಯಗಳನ್ನು ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ನ ಹೊರಗೆ ಕರೆದರೆ ಅವು NULL ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ.

ದೋಷ ನಿರ್ವಹಣೆಗಾಗಿ TRY...CATCH ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆ

TRY...CATCH ಕನ್ಸ್ಟ್ರಕ್ಟ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಪ್ರದರ್ಶಿಸಲು, ನಾವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ದೋಷವನ್ನು ಮಾಡುವ ಸರಳ SQL ಹೇಳಿಕೆಯನ್ನು ಬರೆಯೋಣ, ಉದಾಹರಣೆಗೆ ಶೂನ್ಯದಿಂದ ಭಾಗಿಸಲು ಪ್ರಯತ್ನಿಸುವುದು.

ದೋಷ ನಿರ್ವಹಣಾ ಬ್ಲಾಕ್‌ನ ಆರಂಭ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಪ್ರಯತ್ನಿಸಿ --ದೋಷಗಳು ಸಂಭವಿಸಬಹುದಾದ ಸೂಚನೆಗಳನ್ನು ಘೋಷಿಸಿ @TestVar1 INT = 10, @TestVar2 INT = 0, @Rez INT SET @Rez = @TestVar1 / @TestVar2 END TRY ಪ್ರಾರಂಭಿಸಿ --ಕ್ಯಾಚ್ ಬ್ಲಾಕ್‌ನ ಪ್ರಾರಂಭ - -ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುವ ಕ್ರಿಯೆಗಳು ERROR_NUMBER() AS [ದೋಷ ಸಂಖ್ಯೆ], ERROR_MESSAGE() ನಂತೆ [ದೋಷ ವಿವರಣೆ] ಹೊಂದಿಸಿ @Rez = 0 END ಕ್ಯಾಚ್ ಆಯ್ಕೆ @Rez AS [ಫಲಿತಾಂಶ]

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ERROR_NUMBER() ಮತ್ತು ERROR_MESSAGE() ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ದೋಷ ಸಂಖ್ಯೆ ಮತ್ತು ವಿವರಣೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ ಮತ್ತು ಅಂತಿಮ ಫಲಿತಾಂಶದ ವೇರಿಯಬಲ್‌ಗೆ ಮೌಲ್ಯ 0 ಅನ್ನು ಸಹ ನಿಯೋಜಿಸುತ್ತೇವೆ, ನಾವು ನೋಡುವಂತೆ, CATCH ಬ್ಲಾಕ್‌ನ ನಂತರದ ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ.

ನನಗೆ ಅಷ್ಟೆ, ವಸ್ತುವು ನಿಮಗೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಬೈ!

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಕೋಡ್‌ನಲ್ಲಿ ಮುದ್ರಣದೋಷವನ್ನು ಮಾಡಿದ್ದೇವೆ (ಪ್ರಯತ್ನ ಬ್ಲಾಕ್‌ನಲ್ಲಿ).

ಉದಾಹರಣೆಯು "ಸ್ವಾಗತ ಅತಿಥಿ!" ಅನ್ನು ಎಚ್ಚರಿಸುತ್ತದೆ, ಆದರೆ ಎಚ್ಚರಿಕೆಯನ್ನು ತಪ್ಪಾಗಿ ಬರೆಯಲಾಗಿದೆ.

ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ ದೋಷವನ್ನು ಹಿಡಿಯುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ನಿರ್ವಹಿಸಲು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ:

ಪ್ರಯತ್ನಿಸಿ (
addlert("ಅತಿಥಿ ಸ್ವಾಗತ!");
}
ಹಿಡಿಯಿರಿ (ತಪ್ಪು) (
document.getElementById("ಡೆಮೊ").innerHTML = err.message;
}

ಕೆಳಗಿನ ಇನ್ನಷ್ಟು "ನಿಮ್ಮನ್ನು ಪ್ರಯತ್ನಿಸಿ" ಉದಾಹರಣೆಗಳು.

ವ್ಯಾಖ್ಯಾನ ಮತ್ತು ಬಳಕೆ

ಪ್ರಯತ್ನಿಸಿ/ಕ್ಯಾಚ್/ಅಂತಿಮವಾಗಿ ಹೇಳಿಕೆಯು ಕೋಡ್‌ನ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಸಂಭವಿಸಬಹುದಾದ ಕೆಲವು ಅಥವಾ ಎಲ್ಲಾ ದೋಷಗಳನ್ನು ಇನ್ನೂ ಕೋಡ್ ಅನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ನಿಭಾಯಿಸುತ್ತದೆ.

ದೋಷಗಳು ಪ್ರೋಗ್ರಾಮರ್ ಮಾಡಿದ ಕೋಡಿಂಗ್ ದೋಷಗಳು, ತಪ್ಪು ಇನ್‌ಪುಟ್‌ನಿಂದ ಉಂಟಾಗುವ ದೋಷಗಳು ಮತ್ತು ಇತರ ಅನಿರೀಕ್ಷಿತ ವಿಷಯಗಳಾಗಿರಬಹುದು.

ಪ್ರಯತ್ನದ ಹೇಳಿಕೆಯು ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವಾಗ ದೋಷಗಳಿಗಾಗಿ ಪರೀಕ್ಷಿಸಬೇಕಾದ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಟ್ರೈ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ, ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಕ್ಯಾಚ್ ಹೇಳಿಕೆಯು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ ಹೇಳಿಕೆಯು ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಹಿಡಿದ ನಂತರ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

ಗಮನಿಸಿ: ಕ್ಯಾಚ್ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಹೇಳಿಕೆಗಳು ಎರಡೂ ಐಚ್ಛಿಕವಾಗಿರುತ್ತವೆ, ಆದರೆ ಪ್ರಯತ್ನದ ಹೇಳಿಕೆಯನ್ನು ಬಳಸುವಾಗ ನೀವು ಅವುಗಳಲ್ಲಿ ಒಂದನ್ನು (ಎರಡೂ ಇಲ್ಲದಿದ್ದರೆ) ಬಳಸಬೇಕಾಗುತ್ತದೆ.

ಸಲಹೆ: ದೋಷ ಸಂಭವಿಸಿದಾಗ, JavaScript ಸಾಮಾನ್ಯವಾಗಿ ನಿಲ್ಲುತ್ತದೆ ಮತ್ತು ದೋಷ ಸಂದೇಶವನ್ನು ರಚಿಸುತ್ತದೆ. ಕಸ್ಟಮ್ ದೋಷವನ್ನು ರಚಿಸಲು ಥ್ರೋ ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿ (ವಿನಾಯಿತಿಯನ್ನು ಎಸೆಯಿರಿ). ನೀವು ಥ್ರೋ ಟುಗೆದರ್ ಟ್ರೈ ಅಂಡ್ ಕ್ಯಾಚ್ ಅನ್ನು ಬಳಸಿದರೆ, ನೀವು ಪ್ರೋಗ್ರಾಂ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸಬಹುದು ಮತ್ತು ಕಸ್ಟಮ್ ದೋಷ ಸಂದೇಶಗಳನ್ನು ರಚಿಸಬಹುದು.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳ ಕುರಿತು ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಓದಿ.

ಬ್ರೌಸರ್ ಬೆಂಬಲ ಹೇಳಿಕೆ

ಪ್ರಯತ್ನಿಸಿ / ಹಿಡಿಯಿರಿ / ಅಂತಿಮವಾಗಿ	ಹೌದು	ಹೌದು	ಹೌದು	ಹೌದು	ಹೌದು

ಸಿಂಟ್ಯಾಕ್ಸ್

ಪ್ರಯತ್ನಿಸಿ (
tryCode - ಪ್ರಯತ್ನಿಸಲು ಕೋಡ್ ಬ್ಲಾಕ್
}
ಹಿಡಿಯಿರಿ ( ತಪ್ಪು) {
ಕ್ಯಾಚ್‌ಕೋಡ್ - ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಕೋಡ್‌ನ ಬ್ಲಾಕ್
}
ಅಂತಿಮವಾಗಿ (
ಅಂತಿಮವಾಗಿ ಕೋಡ್ - ಪ್ರಯತ್ನಿಸಿ / ಕ್ಯಾಚ್ ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಕೋಡ್‌ನ ಬ್ಲಾಕ್
}

ಪ್ಯಾರಾಮೀಟರ್ ಮೌಲ್ಯಗಳು ಪ್ಯಾರಾಮೀಟರ್ ವಿವರಣೆ

ಪ್ರಯತ್ನಿಸಿ ಕೋಡ್	ಅಗತ್ಯವಿದೆ. ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವಾಗ ದೋಷಗಳಿಗಾಗಿ ಪರೀಕ್ಷಿಸಬೇಕಾದ ಬ್ಲಾಕ್
ತಪ್ಪು	ಕ್ಯಾಚ್ನೊಂದಿಗೆ ಬಳಸಿದರೆ ಅಗತ್ಯವಿದೆ. ದೋಷವನ್ನು ಸೂಚಿಸುವ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ವೇರಿಯೇಬಲ್ ದೋಷ ವಸ್ತುವನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು ("ಆಡ್ಲರ್ಟ್" ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿಲ್ಲ" ಎಂಬ ಸಂದೇಶದಂತಹ ದೋಷ ಸಂಭವಿಸಿದ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ). ಥ್ರೋ ಹೇಳಿಕೆಯಿಂದ ವಿನಾಯಿತಿಯನ್ನು ರಚಿಸಿದ್ದರೆ, ವೇರಿಯೇಬಲ್ ಥ್ರೋ ಹೇಳಿಕೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಸ್ತುವನ್ನು ಸೂಚಿಸುತ್ತದೆ ("ಹೆಚ್ಚಿನ ಉದಾಹರಣೆಗಳು" ನೋಡಿ)
ಕ್ಯಾಚ್ಕೋಡ್	ಐಚ್ಛಿಕ. ಪ್ರಯತ್ನಿಸಿ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ, ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು. ಯಾವುದೇ ದೋಷ ಸಂಭವಿಸದಿದ್ದರೆ, ಈ ಕೋಡ್ ಬ್ಲಾಕ್ ಅನ್ನು ಎಂದಿಗೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ
ಅಂತಿಮವಾಗಿ ಕೋಡ್	ಐಚ್ಛಿಕ. ಪ್ರಯತ್ನಿಸಿ / ಕ್ಯಾಚ್ ಫಲಿತಾಂಶವನ್ನು ಲೆಕ್ಕಿಸದೆಯೇ ಕೋಡ್‌ನ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು

ತಾಂತ್ರಿಕ ವಿವರಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಆವೃತ್ತಿ:

ECMAScript 3

ಇನ್ನಷ್ಟು ಉದಾಹರಣೆಗಳು

ಈ ಉದಾಹರಣೆಯು ಇನ್ಪುಟ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಮೌಲ್ಯವು ತಪ್ಪಾಗಿದ್ದರೆ, ವಿನಾಯಿತಿ (ತಪ್ಪು) ಎಸೆಯಲಾಗುತ್ತದೆ.

ಎಕ್ಸೆಪ್ಶನ್ (ದೋಷ) ಕ್ಯಾಚ್ ಸ್ಟೇಟ್‌ಮೆಂಟ್‌ನಿಂದ ಹಿಡಿಯಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ಕಸ್ಟಮ್ ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ:

ದಯವಿಟ್ಟು 5 ಮತ್ತು 10 ರ ನಡುವಿನ ಸಂಖ್ಯೆಯನ್ನು ನಮೂದಿಸಿ:

ಪರೀಕ್ಷಾ ಇನ್ಪುಟ್

ಕಾರ್ಯ myFunction() (
var ಸಂದೇಶ, x;
ಸಂದೇಶ = document.getElementById("ಸಂದೇಶ");
message.innerHTML = "";
x = document.getElementById("ಡೆಮೊ").ಮೌಲ್ಯ;
ಪ್ರಯತ್ನಿಸಿ (
if(x == "") "ಈಸ್ ಖಾಲಿ" ಎಸೆಯಿರಿ;
ವೇಳೆ(isNaN(x)) "ಸಂಖ್ಯೆಯಲ್ಲ" ಎಸೆದು;
if(x > 10) "ತುಂಬಾ ಹೆಚ್ಚು" ಎಸೆಯಿರಿ;
ವೇಳೆ(x< 5) throw "too low";
}
ಹಿಡಿಯಿರಿ (ತಪ್ಪು) (
message.innerHTML = "ಇನ್‌ಪುಟ್" + ದೋಷ;
}
}

ನಮಸ್ಕಾರ! ಈ ಪಾಠದಲ್ಲಿ ನಾನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ದೋಷಗಳ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಅವುಗಳನ್ನು ನಿಜವಾಗಿ ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು. ಎಲ್ಲಾ ನಂತರ, ಕಾಲಕಾಲಕ್ಕೆ ದೋಷಗಳು ಸಂಭವಿಸುತ್ತವೆ ಎಂದು ಆಗಾಗ್ಗೆ ಸಂಭವಿಸುತ್ತದೆ, ಮತ್ತು ಇದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನುಭವವನ್ನು ಹೊಂದಿರುವುದು ಅಥವಾ ಅದರ ಸಂಪೂರ್ಣ ಕೊರತೆ ಕೂಡ ಅಲ್ಲ. ಎಲ್ಲಾ ನಂತರ, ಅನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಸಹ ತಪ್ಪುಗಳನ್ನು ಮಾಡುತ್ತಾರೆ;

ದೋಷಗಳು ಮುಖ್ಯವಾಗಿ 2 ವಿಧಗಳಾಗಿವೆ - ವಾಕ್ಯರಚನೆ ಮತ್ತು ತಾರ್ಕಿಕ. ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ದೋಷಗಳು ವೇರಿಯಬಲ್‌ಗಳ ಹೆಸರುಗಳಲ್ಲಿನ ದೋಷಗಳು, ಕಾರ್ಯಗಳು ಮತ್ತು ಕೋಡ್ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಲ್ಲಿನ ದೋಷಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ತಾತ್ವಿಕವಾಗಿ, ಅಂತಹ ದೋಷಗಳನ್ನು ಬ್ರೌಸರ್ ಕನ್ಸೋಲ್ ಮೂಲಕ ಹಿಡಿಯುವುದು ಸುಲಭ.

ಆದರೆ ತಾರ್ಕಿಕ ದೋಷಗಳು ಅವರೊಂದಿಗೆ ತುಂಬಾ ಸರಳವಾಗಿಲ್ಲ ಏಕೆಂದರೆ ಅವು ಪ್ರೋಗ್ರಾಂ ಕೋಡ್ನ ತಪ್ಪಾದ ಮರಣದಂಡನೆಗೆ ಕಾರಣವಾಗುತ್ತವೆ. ಆದ್ದರಿಂದ, ಅವುಗಳನ್ನು ತೊಡೆದುಹಾಕಲು, ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರತಿ ಹಂತದಲ್ಲೂ ನಿಜವಾಗಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನೀವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇಲ್ಲಿ ನಾವು ಮುಖ್ಯವಾಗಿ try...catch construct ಬಳಸಿಕೊಂಡು ಸಿಂಟ್ಯಾಕ್ಸ್ ದೋಷಗಳ ಸ್ಥಳೀಕರಣವನ್ನು ಪರಿಗಣಿಸುತ್ತೇವೆ.



ರಚನೆಯನ್ನು ಹಿಡಿಯುವಲ್ಲಿ ದೋಷವನ್ನು ಹಿಡಿಯಲು ಪ್ರಯತ್ನಿಸಿ

ಪ್ರಯತ್ನಿಸಿ..ಕ್ಯಾಚ್ ರಚನೆಯು 2 ಬ್ಲಾಕ್ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ: ಪ್ರಯತ್ನಿಸಿ, ತದನಂತರ ಹಿಡಿಯಿರಿ. ಸಾಮಾನ್ಯ ಪ್ರವೇಶದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ

ಪ್ರಯತ್ನಿಸಿ (// ಕೋಡ್... ) ಕ್ಯಾಚ್ (ತಪ್ಪು) (// ದೋಷ ನಿರ್ವಹಣೆ )

ಈ ವಿನ್ಯಾಸವು ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

ಟ್ರೈ ಬ್ಲಾಕ್‌ನ ಒಳಗಿನ ಕೋಡ್, ಟ್ರ್ಯಾಪ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ, ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.

ಯಾವುದೇ ದೋಷಗಳು ಎದುರಾಗದಿದ್ದರೆ, ಕ್ಯಾಚ್(ದೋಷ) ಬ್ಲಾಕ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ.

ಆದರೆ ಅದರಲ್ಲಿ ದೋಷ ಸಂಭವಿಸಿದಲ್ಲಿ, ನಂತರ ಪ್ರಯತ್ನದ ಮರಣದಂಡನೆಯು ದೋಷದ ಮೇಲೆ ಅಡಚಣೆಯಾಗುತ್ತದೆ ಮತ್ತು ನಿಯಂತ್ರಣವನ್ನು ಕ್ಯಾಚ್ (ತಪ್ಪು) ಬ್ಲಾಕ್ನ ಪ್ರಾರಂಭಕ್ಕೆ ವರ್ಗಾಯಿಸಲಾಗುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ದೋಷ ವೇರಿಯೇಬಲ್ (ನೀವು ಬೇರೆ ಯಾವುದೇ ಹೆಸರನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು) ಸಂಭವಿಸಿದ ದೋಷದ ಬಗ್ಗೆ ವಿವರವಾದ ಮಾಹಿತಿಯೊಂದಿಗೆ ದೋಷ ವಸ್ತುವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಪ್ರಯತ್ನದಲ್ಲಿ ದೋಷವಿದ್ದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ನಿಲ್ಲುವುದಿಲ್ಲ, ಮತ್ತು ಮೇಲಾಗಿ, ಕ್ಯಾಚ್ ಬ್ಲಾಕ್ನಲ್ಲಿ ದೋಷವನ್ನು ನಿಭಾಯಿಸಲು ನಮಗೆ ಅವಕಾಶವಿದೆ.

ಇದನ್ನು ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ನೋಡೋಣ.

• ದೋಷಗಳಿಲ್ಲದ ಉದಾಹರಣೆ: ಪ್ರಾರಂಭದಲ್ಲಿ, ಎಚ್ಚರಿಕೆ (1) ಮತ್ತು (2) ಅನ್ನು ಪ್ರಚೋದಿಸಲಾಗುತ್ತದೆ: ಪ್ರಯತ್ನಿಸಿ ( ಎಚ್ಚರಿಕೆ ("ಪ್ರಯತ್ನಿಸಿ ನಿರ್ಬಂಧಿಸು"); // (1)