പിശകുകൾക്കായി ഒരു ബ്ലോക്ക് കോഡ് പരിശോധിക്കാൻ ശ്രമിക്കുക... ക്യാച്ച് നിർമ്മാണം നിങ്ങളെ അനുവദിക്കുന്നു.

JavaScript - പിടിക്കുന്നതിൽ പിശക്

ഇന്റർനെറ്റ് ബ്രൗസുചെയ്യുമ്പോൾ, ഒരു റൺടൈം പിശക് സംഭവിച്ചുവെന്ന് ഞങ്ങളോട് പറയുന്ന ഒരു JavaScript മുന്നറിയിപ്പ് വിൻഡോ ഞങ്ങൾ എല്ലാവരും നേരിട്ടു "നിങ്ങൾക്ക് ഡീബഗ് ചെയ്യാൻ താൽപ്പര്യമുണ്ടോ?" ഇതുപോലുള്ള ഒരു പിശക് സന്ദേശം ഡെവലപ്പർമാർക്ക് ഉപയോഗപ്രദമായേക്കാം, എന്നാൽ ഉപയോക്താക്കൾക്ക് അല്ല. ഉപയോക്താക്കൾ പിശകുകൾ കാണുമ്പോൾ, അവർ വെബ് പേജ് വിടാൻ പ്രവണത കാണിക്കുന്നു.

JavaScript പിശക് സന്ദേശങ്ങൾ എങ്ങനെ തടസ്സപ്പെടുത്താമെന്നും കൈകാര്യം ചെയ്യാമെന്നും ഈ ട്യൂട്ടോറിയൽ നിങ്ങളെ പഠിപ്പിക്കും, അതിനാൽ നിങ്ങൾക്ക് കാഴ്ചക്കാരെ നഷ്‌ടപ്പെടില്ല.

ശ്രമിക്കുക ... നിർമ്മാണം പിടിക്കുക

പിശകുകൾക്കായി ഒരു ബ്ലോക്ക് കോഡ് പരിശോധിക്കാൻ ശ്രമിക്കുക... ക്യാച്ച് നിർമ്മാണം നിങ്ങളെ അനുവദിക്കുന്നു. ട്രൈ ബ്ലോക്കിൽ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നതും പരിശോധിക്കപ്പെടുന്നതുമായ കോഡ് അടങ്ങിയിരിക്കുന്നു, കൂടാതെ പിശകുകൾ സംഭവിച്ചാൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന കോഡും ക്യാച്ച് ബ്ലോക്കിൽ അടങ്ങിയിരിക്കുന്നു.

വാക്യഘടന

ശ്രമിക്കുക { //കുറച്ച് കോഡ് ഇവിടെ പ്രവർത്തിപ്പിക്കുക } പിടിക്കുക (പിശക്) { //ഇവിടെ കൈകാര്യം ചെയ്യുന്നതിൽ പിശക് }

ശ്രമിക്കുക ... പിടിക്കുക എന്നത് ചെറിയ അക്ഷരത്തിലാണ് (ചെറിയ അക്ഷരങ്ങളിൽ) എഴുതിയിരിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കുക. വലിയ അക്ഷരങ്ങൾ ഉപയോഗിക്കുന്നത് JavaScript പിശക് സൃഷ്ടിക്കും!

ഉദാഹരണങ്ങൾ

ചുവടെയുള്ള ഉദാഹരണം "സ്വാഗതം അതിഥി!" പോപ്പ്അപ്പ് പ്രദർശിപ്പിക്കേണ്ടതാണ്. മൗസ് ബട്ടൺ അമർത്തുമ്പോൾ. എന്നിരുന്നാലും, സന്ദേശം() ഫംഗ്‌ഷനിൽ അക്ഷരത്തെറ്റുണ്ട്. അലർട്ട്() എന്നത് adddlert() ആയി പ്രിന്റ് ചെയ്തിരിക്കുന്നു. ഒരു JavaScript പിശക് സംഭവിക്കുന്നു. ക്യാച്ച് ബ്ലോക്ക് പിശക് പിടിക്കുകയും അത് കൈകാര്യം ചെയ്യാൻ അധിക കോഡ് നടപ്പിലാക്കുകയും ചെയ്യുന്നു. എന്താണ് സംഭവിച്ചതെന്ന് ഉപയോക്താവിനെ അറിയിക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃത പിശക് സന്ദേശം കോഡ് പ്രദർശിപ്പിക്കുന്നു:

ഉപയോക്താക്കൾക്ക് തുടരാൻ ശരി ക്ലിക്കുചെയ്യുക അല്ലെങ്കിൽ പ്രധാന പേജിലേക്ക് പോകാൻ റദ്ദാക്കുക എന്നതിൽ ക്ലിക്കുചെയ്യാൻ കഴിയുമെന്ന് പറയുന്ന ഒരു ഇഷ്‌ടാനുസൃത സന്ദേശം കാണിക്കുന്നതിന് ഇനിപ്പറയുന്ന ഉദാഹരണം ഒരു സ്ഥിരീകരണ ബോക്‌സ് ഉപയോഗിക്കുന്നു. രീതി തെറ്റായി നൽകുകയാണെങ്കിൽ, ഉപയോക്താവ് റദ്ദാക്കുക ക്ലിക്ക് ചെയ്യുകയും കോഡ് ഉപയോക്താവിനെ റീഡയറക്‌ട് ചെയ്യുകയും ചെയ്യുന്നു. രീതി ശരിയാണെങ്കിൽ, കോഡ് ഒന്നും ചെയ്യുന്നില്ല:

ഉദാഹരണം var txt=""; ഫംഗ്‌ഷൻ സന്ദേശം() { ശ്രമിക്കുക { } പിടിക്കുക (പിശക്) { എങ്കിൽ(!സ്ഥിരീകരിക്കുക(txt)) { document.location.href="http://site/"; } } }

അവസാനമായി അപ്ഡേറ്റ് ചെയ്തത്: 10/23/2018

ചിലപ്പോൾ, ഒരു പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, മുൻകൂട്ടി കാണാൻ അല്ലെങ്കിൽ മുൻകൂട്ടി കാണാൻ ബുദ്ധിമുട്ടുള്ള, ചിലപ്പോൾ അസാധ്യമായ പിശകുകൾ സംഭവിക്കുന്നു. ഉദാഹരണത്തിന്, നെറ്റ്‌വർക്കിലൂടെ ഒരു ഫയൽ കൈമാറുമ്പോൾ, നെറ്റ്‌വർക്ക് കണക്ഷൻ അപ്രതീക്ഷിതമായി ഡ്രോപ്പ് ചെയ്തേക്കാം. അത്തരം സാഹചര്യങ്ങളെ ഒഴിവാക്കലുകൾ എന്ന് വിളിക്കുന്നു. C# ഭാഷ ഡെവലപ്പർമാർക്ക് ഇത്തരം സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാനുള്ള കഴിവ് നൽകുന്നു. C#-ൽ ട്രൈ...ക്യാച്ച്...അവസാനം കൺസ്ട്രക്റ്റ് ഇതിനായി രൂപകല്പന ചെയ്തതാണ്.

() പിടിക്കാൻ ശ്രമിക്കുക () ഒടുവിൽ ()

ഒരു try...catch..ഒടുവിൽ ബ്ലോക്ക് ഉപയോഗിക്കുമ്പോൾ, ട്രൈ ബ്ലോക്കിലെ എല്ലാ പ്രസ്താവനകളും ആദ്യം എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഈ ബ്ലോക്കിൽ അപവാദങ്ങളൊന്നും സംഭവിക്കുന്നില്ലെങ്കിൽ, അതിന്റെ നിർവ്വഹണത്തിന് ശേഷം അവസാനമായി ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നു. എന്നിട്ട് ശ്രമിക്കുക..പിടിക്കുക..അവസാനം അതിന്റെ പണി പൂർത്തിയാക്കുന്നു.

ഒരു ട്രൈ ബ്ലോക്കിൽ പെട്ടെന്ന് ഒരു അപവാദം സംഭവിക്കുകയാണെങ്കിൽ, സാധാരണ എക്സിക്യൂഷൻ ഓർഡർ നിർത്തുകയും CLR ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഒരു ക്യാച്ച് ബ്ലോക്കിനായി തിരയാൻ തുടങ്ങുകയും ചെയ്യുന്നു. ശരിയായ ക്യാച്ച് ബ്ലോക്ക് കണ്ടെത്തിയാൽ, അത് എക്സിക്യൂട്ട് ചെയ്യുന്നു, അത് പൂർത്തിയാക്കിയ ശേഷം, അവസാനം ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

ആവശ്യമായ ക്യാച്ച് ബ്ലോക്ക് കണ്ടെത്തിയില്ലെങ്കിൽ, ഒരു അപവാദം സംഭവിക്കുമ്പോൾ, പ്രോഗ്രാം അസാധാരണമായി അതിന്റെ നിർവ്വഹണം അവസാനിപ്പിക്കുന്നു.

ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക:

ക്ലാസ് പ്രോഗ്രാം ( സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ (സ്ട്രിംഗ് ആർഗ്സ്) ( int x = 5; int y = x / 0; Console.WriteLine($"ഫലം: (y)"); Console.WriteLine ("പ്രോഗ്രാമിന്റെ അവസാനം"); കൺസോൾ.വായിക്കുക (); )

ഈ സാഹചര്യത്തിൽ, സംഖ്യയെ 0 കൊണ്ട് ഹരിക്കുന്നു, ഇത് ഒരു അപവാദം സൃഷ്ടിക്കും. ഞങ്ങൾ ഡീബഗ് മോഡിൽ ആപ്ലിക്കേഷൻ സമാരംഭിക്കുമ്പോൾ, ഒഴിവാക്കലിനെക്കുറിച്ച് ഞങ്ങളെ അറിയിക്കുന്ന ഒരു വിൻഡോ വിഷ്വൽ സ്റ്റുഡിയോയിൽ ഞങ്ങൾ കാണും:

ഈ വിൻഡോയിൽ ഒരു അപവാദം സംഭവിച്ചതായി കാണുന്നു, അത് System.DivideByZeroException എന്ന തരത്തിലാണ്, അതായത് പൂജ്യം കൊണ്ട് ഹരിക്കാനുള്ള ശ്രമം. വിശദാംശങ്ങൾ കാണുക എന്ന ഇനം ഉപയോഗിച്ച്, ഒഴിവാക്കലിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ വിവരങ്ങൾ നിങ്ങൾക്ക് കാണാൻ കഴിയും.

ഈ സാഹചര്യത്തിൽ, പ്രോഗ്രാം പൂർത്തിയാക്കുക മാത്രമാണ് ഞങ്ങൾക്ക് അവശേഷിക്കുന്നത്.

അത്തരം ഒരു പ്രോഗ്രാം ക്രാഷ് ഒഴിവാക്കാൻ, ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കൂ... പിടിക്കുക... ഒടുവിൽ കൺസ്ട്രക്‌റ്റ് ഉപയോഗിക്കണം. അതിനാൽ, നമുക്ക് ഉദാഹരണം ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റിയെഴുതാം:

ക്ലാസ് പ്രോഗ്രാം ( സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്) ( ശ്രമിക്കുക ( int x = 5; int y = x / 0; Console.WriteLine($"ഫലം: (y)"); ) ക്യാച്ച് ( Console.WriteLine("ഒരു അപവാദം സംഭവിച്ചു ! "); ) ഒടുവിൽ ( Console.WriteLine("അവസാനം തടയുക"); ) Console.WriteLine("പ്രോഗ്രാമിന്റെ അവസാനം"); Console.Read(); )

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ പൂജ്യം കൊണ്ട് ഹരിക്കാൻ ശ്രമിക്കുന്നതിനാൽ, ട്രൈ ബ്ലോക്കിൽ ഞങ്ങൾക്ക് വീണ്ടും ഒരു അപവാദം ഉണ്ടാകും. ഒപ്പം വരിയിൽ എത്തുന്നു

Int 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) ; കൺസോൾ.Read(); )

ഉപയോക്താവ് ഒരു നമ്പറല്ല, ഒരു സ്ട്രിംഗ് അല്ലെങ്കിൽ മറ്റ് ചില പ്രതീകങ്ങൾ നൽകിയാൽ, പ്രോഗ്രാം ഒരു പിശക് എറിയുന്നു. ഒരു വശത്ത്, സാധ്യമായ ഒരു പിശക് കൈകാര്യം ചെയ്യാൻ നിങ്ങൾക്ക് ഒരു ട്രൈ.. ക്യാച്ച് ബ്ലോക്ക് ഉപയോഗിക്കാനാകുന്ന സാഹചര്യം ഇതാണ്. എന്നിരുന്നാലും, പരിവർത്തനത്തിന്റെ സാധുത പരിശോധിക്കുന്നത് കൂടുതൽ അനുയോജ്യമാണ്:

സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗുകൾ) ( കൺസോൾ.റൈറ്റ്ലൈൻ("ഒരു നമ്പർ നൽകുക"); int x; സ്ട്രിംഗ് ഇൻപുട്ട് = കൺസോൾ.ReadLine(); എങ്കിൽ (Int32.TryParse(ഇൻപുട്ട്, ഔട്ട് x)) ( x *= x; കൺസോൾ . WriteLine("സംഖ്യയുടെ ചതുരം: " + x); ) വേറെ ( Console.WriteLine("അസാധുവായ ഇൻപുട്ട്"); ) Console.Read(); )

പരിവർത്തനം നടത്താൻ കഴിയുമെങ്കിൽ Int32.TryParse() രീതി true നൽകുന്നു, അത് സാധ്യമല്ലെങ്കിൽ തെറ്റ്. പരിവർത്തനം സാധുവാണെങ്കിൽ, x എന്ന വേരിയബിളിൽ നൽകിയ നമ്പർ അടങ്ങിയിരിക്കും. അതിനാൽ, try...catch ഉപയോഗിക്കാതെ, നിങ്ങൾക്ക് സാധ്യമായ ഒരു ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യാൻ കഴിയും.

ഒരു പ്രകടനത്തിന്റെ വീക്ഷണകോണിൽ, സോപാധികമായി ഉപയോഗിക്കുന്നതിനേക്കാൾ വില കൂടുതലാണ് try..catch blocks ഉപയോഗിക്കുന്നത്. അതിനാൽ, സാധ്യമെങ്കിൽ, ശ്രമിക്കൂ.. പിടിക്കുന്നതിനുപകരം, അസാധാരണമായ സാഹചര്യങ്ങൾ പരിശോധിക്കാൻ സോപാധികമായ നിർമ്മാണങ്ങൾ ഉപയോഗിക്കുന്നതാണ് നല്ലത്.

T-SQL ഭാഷയിൽ, മറ്റ് പല പ്രോഗ്രാമിംഗ് ഭാഷകളിലെയും പോലെ, പിശകുകൾ ട്രാക്കുചെയ്യാനും തടസ്സപ്പെടുത്താനും കഴിയും; ഇന്ന് നമ്മൾ TRY CATCH നിർമ്മാണം നോക്കും, അതിന്റെ സഹായത്തോടെ നമുക്ക് അസാധാരണമായ സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ കഴിയും, അതായത്. അപ്രതീക്ഷിത പിശകുകൾ.

നിങ്ങൾ ഇതിനകം മനസ്സിലാക്കിയതുപോലെ, ഞങ്ങൾ സംസാരിക്കുന്നത് വാക്യഘടന പിശകുകളെക്കുറിച്ചല്ല, SQL നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നതിന് മുമ്പുതന്നെ SQL സെർവർ ഞങ്ങളെ അറിയിക്കുന്നു, പക്ഷേ ചില വ്യവസ്ഥകളിൽ ഒരു പ്രത്യേക വിഭാഗ കോഡിൽ സംഭവിക്കാവുന്ന പിശകുകളെക്കുറിച്ചാണ്.

ഏറ്റവും ലളിതമായ ഉദാഹരണം പൂജ്യത്താൽ വിഭജിക്കലാണ്, നിങ്ങൾക്കറിയാവുന്നതുപോലെ, നിങ്ങൾക്ക് പൂജ്യം കൊണ്ട് ഹരിക്കാനാവില്ല, എന്നാൽ ഈ കണക്ക് ഡിവിഷൻ പ്രവർത്തനങ്ങളിൽ ഇപ്പോഴും ദൃശ്യമാകും. സാധാരണ ഡാറ്റയിലെ അതേ പ്രവർത്തനങ്ങൾ പിഴവുകളില്ലാതെ നടത്തപ്പെടുന്നുണ്ടെങ്കിലും, നിലവാരമില്ലാത്തതും തെറ്റായതുമായ ഡാറ്റയിലെ പ്രവർത്തനങ്ങളിൽ സംഭവിക്കാവുന്ന മറ്റ് പിശകുകളും ഉണ്ട്.

അതിനാൽ, ട്രാൻസാക്റ്റ്-എസ്‌ക്യുഎൽ ഭാഷയിൽ ഒരു പ്രത്യേക നിർമ്മാണം TRY...CATCH ഉണ്ട്, ഇത് SQL സെർവറിന്റെ 2005 പതിപ്പിൽ പ്രത്യക്ഷപ്പെട്ടു, ഇത് പിശക് കൈകാര്യം ചെയ്യാൻ ഉപയോഗിക്കുന്നു. ആർക്കെങ്കിലും മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകൾ പരിചിതമാണെങ്കിൽ, ഈ നിർമ്മാണം നിങ്ങൾക്ക് മിക്കവാറും പരിചിതമായിരിക്കും, കാരണം ഇത് പല പ്രോഗ്രാമിംഗ് ഭാഷകളിലും ഉപയോഗിക്കുന്നു.

കുറിപ്പ്! T-SQL ഭാഷയെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ പഠനത്തിന്, പുതിയ പ്രോഗ്രാമർമാർ T-SQL പ്രോഗ്രാമറുടെ പാത എന്ന പുസ്തകം വായിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു. ഇടപാട്-SQL ഭാഷാ ട്യൂട്ടോറിയൽ.

T-SQL-ൽ CATCH നിർമ്മാണം പരീക്ഷിക്കുക

TRY CATCH എന്നത് പിശക് കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ട്രാൻസാക്റ്റ്-എസ്‌ക്യുഎൽ നിർമ്മാണമാണ്. പിശകുകൾക്കായി നിങ്ങൾ പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്ന എല്ലാം, അതായത്. TRY ബ്ലോക്കിൽ പിശകുകൾ സംഭവിക്കാനിടയുള്ള കോഡ് നിങ്ങൾ സ്ഥാപിക്കുന്നു. ഈ ബ്ലോക്കിന്റെ ആരംഭം BEGIN TRY നിർദ്ദേശവും ബ്ലോക്കിന്റെ അവസാനവും, അതനുസരിച്ച്, END TRY വഴിയും സൂചിപ്പിക്കുന്നു.

ഒരു പിശക് സംഭവിച്ചാൽ നിങ്ങൾ ചെയ്യേണ്ടതെന്തും, അതായത്. TRY ബ്ലോക്കിൽ ഒരു പിശക് സംഭവിച്ചാൽ നടപ്പിലാക്കേണ്ട നിർദ്ദേശങ്ങൾ, നിങ്ങൾ CATCH ബ്ലോക്കിൽ സ്ഥാപിക്കുന്നു, അതിന്റെ ആരംഭം BEGIN CATCH എന്നും അതിന്റെ അവസാനം END CATCH എന്നും സൂചിപ്പിക്കുന്നു. TRY ബ്ലോക്കിൽ പിശകുകളൊന്നും സംഭവിച്ചില്ലെങ്കിൽ, CATCH ബ്ലോക്ക് ഒഴിവാക്കുകയും അത് പിന്തുടരുന്ന നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുകയും ചെയ്യും. പിശകുകൾ സംഭവിക്കുകയാണെങ്കിൽ, CATCH ബ്ലോക്കിലെ നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നു, തുടർന്ന് ഈ ബ്ലോക്കിന് ശേഷമുള്ള നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നു, മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, CATCH ബ്ലോക്കിന് ശേഷമുള്ള എല്ലാ നിർദ്ദേശങ്ങളും നടപ്പിലാക്കും, തീർച്ചയായും, ഞങ്ങൾ നിർബന്ധിതമായി നിർവ്വഹണം അവസാനിപ്പിച്ചില്ലെങ്കിൽ ക്യാച്ച് ബ്ലോക്കിലെ പാക്കേജ്.

CATCH ബ്ലോക്ക് തന്നെ കോളിംഗ് ആപ്ലിക്കേഷനിലേക്ക് കണ്ടെത്തിയ പിശകുകളെക്കുറിച്ചുള്ള ഒരു വിവരവും കൈമാറുന്നില്ല; ഉദാഹരണത്തിന്, പിശകിന്റെ നമ്പറോ വിവരണമോ കണ്ടെത്താൻ നിങ്ങൾക്ക് വേണമെങ്കിൽ, ഇതിനായി നിങ്ങൾക്ക് SELECT, RAISERROR അല്ലെങ്കിൽ PRINT പ്രസ്താവനകൾ ഉപയോഗിക്കാം. ക്യാച്ച് ബ്ലോക്ക്.

T-SQL-ലെ TRY CATCH നിർമ്മാണത്തെക്കുറിച്ചുള്ള പ്രധാന പോയിന്റുകൾ

• TRY ബ്ലോക്കിന് ശേഷം ഉടൻ തന്നെ CATCH ബ്ലോക്ക് വരണം; ഈ ബ്ലോക്കുകൾക്കിടയിൽ നിർദ്ദേശങ്ങൾ സ്ഥാപിക്കുന്നത് അനുവദനീയമല്ല;
• ഡാറ്റാബേസ് കണക്ഷനുകൾ ക്ലോസ് ചെയ്യാത്ത 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() ആയി [പിശക് നമ്പർ], ERROR_MESSAGE() ആയി [പിശക് വിവരണം] സജ്ജമാക്കുക @Rez = 0 END ക്യാച്ച് @Rez ആയി തിരഞ്ഞെടുക്കുക [ഫലം]

ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ ERROR_NUMBER(), ERROR_MESSAGE() ഫംഗ്‌ഷനുകൾ ഉപയോഗിച്ച് പിശക് നമ്പറും വിവരണവും പ്രദർശിപ്പിക്കുന്നു, കൂടാതെ അന്തിമ ഫല വേരിയബിളിന് മൂല്യം 0 നൽകുകയും ചെയ്യുന്നു, ഞങ്ങൾ കാണുന്നത് പോലെ, CATCH ബ്ലോക്കിന് ശേഷമുള്ള നിർദ്ദേശങ്ങൾ തുടർന്നും നടപ്പിലാക്കുന്നു.

എനിക്ക് അത്രയേയുള്ളൂ, മെറ്റീരിയൽ നിങ്ങൾക്ക് ഉപയോഗപ്രദമായിരുന്നുവെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു, ബൈ!

ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ കോഡിൽ ഒരു അക്ഷരത്തെറ്റ് വരുത്തി (ട്രൈ ബ്ലോക്കിൽ).

ഉദാഹരണം "സ്വാഗതം അതിഥി!" എന്ന അലേർട്ട് നൽകണം, എന്നാൽ മുന്നറിയിപ്പ് തെറ്റായി എഴുതിയിരിക്കുന്നു.

ക്യാച്ച് ബ്ലോക്ക് പിശക് പിടിക്കുകയും അത് കൈകാര്യം ചെയ്യാൻ ഒരു കോഡ് നടപ്പിലാക്കുകയും ചെയ്യുന്നു:

ശ്രമിക്കുക (
addlert("സ്വാഗതം അതിഥി!");
}
പിടിക്കുക (തെറ്റ്) (
document.getElementById("ഡെമോ").innerHTML = err.message;
}

കൂടുതൽ "സ്വയം പരീക്ഷിക്കുക" ഉദാഹരണങ്ങൾ ചുവടെ.

നിർവചനവും ഉപയോഗവും

കോഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ തന്നെ കോഡിന്റെ ഒരു ബ്ലോക്കിൽ സംഭവിക്കാവുന്ന ചില അല്ലെങ്കിൽ എല്ലാ പിശകുകളും ട്രൈ/ക്യാച്ച്/ഫൈനൽ സ്റ്റേറ്റ്മെന്റ് കൈകാര്യം ചെയ്യുന്നു.

പ്രോഗ്രാമർ വരുത്തിയ കോഡിംഗ് പിശകുകൾ, തെറ്റായ ഇൻപുട്ട് മൂലമുള്ള പിശകുകൾ, മറ്റ് അപ്രതീക്ഷിതമായ കാര്യങ്ങൾ എന്നിവ പിശകുകൾ ആകാം.

എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പിശകുകൾക്കായി പരിശോധിക്കേണ്ട ഒരു ബ്ലോക്ക് കോഡ് നിർവ്വചിക്കാൻ ട്രൈ സ്റ്റേറ്റ്മെന്റ് നിങ്ങളെ അനുവദിക്കുന്നു.

ട്രൈ ബ്ലോക്കിൽ ഒരു പിശക് സംഭവിച്ചാൽ, എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡിന്റെ ഒരു ബ്ലോക്ക് നിർവ്വചിക്കാൻ ക്യാച്ച് സ്റ്റേറ്റ്മെന്റ് നിങ്ങളെ അനുവദിക്കുന്നു.

ഫലം പരിഗണിക്കാതെ തന്നെ, ശ്രമിച്ച് പിടിച്ചതിന് ശേഷം കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ അന്തിമ പ്രസ്താവന നിങ്ങളെ അനുവദിക്കുന്നു.

കുറിപ്പ്: ക്യാച്ച്, അവസാന പ്രസ്താവനകൾ എന്നിവ രണ്ടും ഓപ്‌ഷണലാണ്, എന്നാൽ ട്രൈ സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുമ്പോൾ നിങ്ങൾ അവയിലൊന്ന് (രണ്ടും അല്ലെങ്കിൽ) ഉപയോഗിക്കേണ്ടതുണ്ട്.

നുറുങ്ങ്: ഒരു പിശക് സംഭവിക്കുമ്പോൾ, JavaScript സാധാരണയായി നിർത്തുകയും ഒരു പിശക് സന്ദേശം സൃഷ്ടിക്കുകയും ചെയ്യും. ഒരു ഇഷ്‌ടാനുസൃത പിശക് സൃഷ്‌ടിക്കാൻ ത്രോ സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കുക (ഒരു ഒഴിവാക്കൽ ഇടുക). ട്രൈ ആൻഡ് ക്യാച്ച് ഉപയോഗിച്ച് നിങ്ങൾ ഒരുമിച്ച് ത്രോ ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് പ്രോഗ്രാം ഫ്ലോ നിയന്ത്രിക്കാനും ഇഷ്‌ടാനുസൃത പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കാനും കഴിയും.

JavaScript പിശകുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, JavaScript പിശകുകളുടെ ട്യൂട്ടോറിയൽ വായിക്കുക.

ബ്രൗസർ പിന്തുണ പ്രസ്താവന

ശ്രമിക്കുക/പിടിക്കുക/അവസാനം	അതെ	അതെ	അതെ	അതെ	അതെ

വാക്യഘടന

ശ്രമിക്കുക(
tryCode - ശ്രമിക്കാനുള്ള കോഡിന്റെ ബ്ലോക്ക്
}
പിടിക്കുക( തെറ്റ്) {
catchCode - പിശകുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള കോഡിന്റെ ബ്ലോക്ക്
}
ഒടുവിൽ (
അവസാനം കോഡ് - ട്രൈ / ക്യാച്ച് ഫലം പരിഗണിക്കാതെ തന്നെ എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡിന്റെ ബ്ലോക്ക്
}

പാരാമീറ്റർ മൂല്യങ്ങൾ പാരാമീറ്റർ വിവരണം

ട്രൈകോഡ്	ആവശ്യമാണ്. കോഡിന്റെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ പിശകുകൾക്കായി പരിശോധിക്കേണ്ടതാണ്
തെറ്റ്	ക്യാച്ചിനൊപ്പം ഉപയോഗിക്കുകയാണെങ്കിൽ അത് ആവശ്യമാണ്. പിശക് സൂചിപ്പിക്കുന്ന ഒരു പ്രാദേശിക വേരിയബിൾ വ്യക്തമാക്കുന്നു. വേരിയബിളിന് പിശക് ഒബ്‌ജക്‌റ്റിനെ പരാമർശിക്കാൻ കഴിയും ("അഡ്‌ലർട്ട്" നിർവചിച്ചിട്ടില്ല" എന്ന സന്ദേശം പോലെ പിശക് സംഭവിച്ചതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു). ത്രോ പ്രസ്താവനയാണ് ഒഴിവാക്കൽ സൃഷ്ടിച്ചതെങ്കിൽ, വേരിയബിൾ ത്രോ പ്രസ്താവനയിൽ വ്യക്തമാക്കിയ ഒബ്ജക്റ്റിനെ സൂചിപ്പിക്കുന്നു ("കൂടുതൽ ഉദാഹരണങ്ങൾ" കാണുക)
ക്യാച്ച്കോഡ്	ഓപ്ഷണൽ. ട്രൈ ബ്ലോക്കിൽ ഒരു പിശക് സംഭവിച്ചാൽ, കോഡിന്റെ ബ്ലോക്ക് എക്സിക്യൂട്ട് ചെയ്യണം. പിശക് സംഭവിച്ചില്ലെങ്കിൽ, ഈ കോഡ് ബ്ലോക്ക് ഒരിക്കലും എക്സിക്യൂട്ട് ചെയ്യില്ല
അവസാനം കോഡ്	ഓപ്ഷണൽ. ട്രൈ / ക്യാച്ച് ഫലം പരിഗണിക്കാതെ തന്നെ എക്സിക്യൂട്ട് ചെയ്യേണ്ട കോഡിന്റെ ബ്ലോക്ക്

സാങ്കേതിക വിശദാംശങ്ങൾ JavaScript പതിപ്പ്:

ECMAScript 3

കൂടുതൽ ഉദാഹരണങ്ങൾ

ഈ ഉദാഹരണം ഇൻപുട്ട് പരിശോധിക്കുന്നു. മൂല്യം തെറ്റാണെങ്കിൽ, ഒരു ഒഴിവാക്കൽ (പിശക്) എറിയപ്പെടും.

ഒഴിവാക്കൽ (പിശക്) ക്യാച്ച് സ്റ്റേറ്റ്‌മെന്റിൽ പിടിക്കപ്പെടുകയും ഒരു ഇഷ്‌ടാനുസൃത പിശക് സന്ദേശം പ്രദർശിപ്പിക്കുകയും ചെയ്യുന്നു:

ദയവായി 5 നും 10 നും ഇടയിലുള്ള ഒരു നമ്പർ നൽകുക:

ടെസ്റ്റ് ഇൻപുട്ട്

ഫംഗ്ഷൻ myFunction() (
var സന്ദേശം, x;
സന്ദേശം = document.getElementById("സന്ദേശം");
message.innerHTML = "";
x = document.getElementById("ഡെമോ").മൂല്യം;
ശ്രമിക്കുക (
if(x == "") "Empty" എറിയുക;
എങ്കിൽ (isNaN(x)) "ഒരു സംഖ്യയല്ല" എറിയുക;
if(x > 10) "വളരെ ഉയരത്തിൽ" എറിയുക;
എങ്കിൽ (x< 5) throw "too low";
}
പിടിക്കുക (തെറ്റ്) (
message.innerHTML = "ഇൻപുട്ട്" + പിശക്;
}
}

ഹലോ! ഈ പാഠത്തിൽ ജാവാസ്ക്രിപ്റ്റിലെ പിശകുകളെക്കുറിച്ചും അവ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്നതിനെക്കുറിച്ചും സംസാരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. എല്ലാത്തിനുമുപരി, കാലാകാലങ്ങളിൽ പിശകുകൾ സംഭവിക്കുന്നത് പലപ്പോഴും സംഭവിക്കുന്നു, കൂടാതെ പ്രോഗ്രാമിംഗ് അനുഭവം അല്ലെങ്കിൽ അതിന്റെ പൂർണ്ണമായ അഭാവം പോലും ഇത് പ്രശ്നമല്ല. എല്ലാത്തിനുമുപരി, പരിചയസമ്പന്നരായ പ്രോഗ്രാമർമാരും തെറ്റുകൾ വരുത്തുന്നു; ആരും ഇതിൽ നിന്ന് മുക്തരല്ല.

പിശകുകൾ പ്രധാനമായും 2 തരത്തിലാണ് - വാക്യഘടനയും ലോജിക്കലും. വാക്യഘടന പിശകുകളിൽ വേരിയബിളുകളുടെ പേരുകളിലെ പിശകുകൾ, ഫംഗ്ഷനുകൾ, കോഡ് വാക്യഘടനയിലെ പിശകുകൾ എന്നിവ ഉൾപ്പെടുന്നു. തത്വത്തിൽ, അത്തരം പിശകുകൾ ബ്രൗസർ കൺസോളിലൂടെ പിടിക്കാൻ എളുപ്പമാണ്.

എന്നാൽ ലോജിക്കൽ പിശകുകൾ അവരുമായി അത്ര ലളിതമല്ല, കാരണം അവ പ്രോഗ്രാം കോഡിന്റെ തെറ്റായ നിർവ്വഹണത്തിലേക്ക് നയിക്കുന്നു. അതിനാൽ, അവ ഇല്ലാതാക്കാൻ, സ്ക്രിപ്റ്റിന്റെ ഓരോ ഘട്ടത്തിലും യഥാർത്ഥത്തിൽ എന്താണ് സംഭവിക്കുന്നതെന്ന് മനസിലാക്കാൻ നിങ്ങൾ പ്രോഗ്രാം ഡീബഗ് ചെയ്യേണ്ടതുണ്ട്. ഇവിടെ നമ്മൾ പ്രധാനമായും പരിഗണിക്കുന്നത് വാക്യഘടനയിലെ പിശകുകളുടെ പ്രാദേശികവൽക്കരണമാണ് try...catch നിർമ്മിതി ഉപയോഗിച്ച്.



ശ്രമിക്കൂ...എറർ ക്യാച്ചിംഗ് ഘടന

try..catch നിർമ്മിതിയിൽ 2 ബ്ലോക്കുകൾ അടങ്ങിയിരിക്കുന്നു: ശ്രമിക്കുക, തുടർന്ന് പിടിക്കുക. ഒരു പൊതു പ്രവേശനത്തിന്റെ ഒരു ഉദാഹരണം ഇതാ

ശ്രമിക്കുക (// കോഡ്... ) പിടിക്കുക (പിശക്) ( // പിശക് കൈകാര്യം ചെയ്യൽ )

ഈ ഡിസൈൻ ഇതുപോലെ പ്രവർത്തിക്കുന്നു:

ട്രാപ്പ് എന്ന് വിളിക്കപ്പെടുന്ന ട്രൈ ബ്ലോക്കിനുള്ളിലെ കോഡ് എക്സിക്യൂട്ട് ചെയ്യുന്നു.

പിശകുകളൊന്നും നേരിട്ടില്ലെങ്കിൽ, ക്യാച്ച്(പിശക്) ബ്ലോക്ക് അവഗണിക്കപ്പെടും.

എന്നാൽ അതിൽ ഒരു പിശക് സംഭവിക്കുകയാണെങ്കിൽ, പിശകിന്റെ മേൽ ശ്രമത്തിന്റെ നിർവ്വഹണം തടസ്സപ്പെടും, കൂടാതെ നിയന്ത്രണം ക്യാച്ച് (പിശക്) ബ്ലോക്കിന്റെ തുടക്കത്തിലേക്ക് മാറ്റും. ഈ സാഹചര്യത്തിൽ, പിശക് വേരിയബിളിൽ (നിങ്ങൾക്ക് മറ്റേതെങ്കിലും പേര് തിരഞ്ഞെടുക്കാം) സംഭവിച്ച പിശകിനെക്കുറിച്ചുള്ള വിശദമായ വിവരങ്ങളുള്ള ഒരു പിശക് ഒബ്ജക്റ്റ് അടങ്ങിയിരിക്കും.

അതിനാൽ, ശ്രമത്തിൽ ഒരു പിശക് ഉണ്ടെങ്കിൽ, സ്ക്രിപ്റ്റ് നിർത്തുന്നില്ല, അതിലുപരിയായി, ക്യാച്ച് ബ്ലോക്കിനുള്ളിലെ പിശക് കൈകാര്യം ചെയ്യാൻ ഞങ്ങൾക്ക് അവസരമുണ്ട്.

ഉദാഹരണങ്ങൾ സഹിതം ഇത് നോക്കാം.

• പിശകുകളില്ലാത്ത ഉദാഹരണം: സ്റ്റാർട്ടപ്പിൽ, അലേർട്ട് (1), (2) എന്നിവ പ്രവർത്തനക്ഷമമാകും: ശ്രമിക്കുക (അലേർട്ട്("തടയാൻ ശ്രമിക്കുക"); // (1)