Jaribu...catch construct hukuruhusu kuangalia kizuizi cha msimbo kwa hitilafu.
JavaScript - Hitilafu InapataWakati wa kuvinjari Mtandao, sote tumekumbana na dirisha la onyo la JavaScript likituambia kwamba hitilafu ya wakati wa utekelezaji imetokea na kuuliza "Je, ungependa kurekebisha?" Ujumbe wa hitilafu kama huu unaweza kuwa na manufaa kwa wasanidi programu, lakini si kwa watumiaji. Watumiaji wanapoona makosa, huwa wanaondoka kwenye ukurasa wa Wavuti.
Mafunzo haya yatakufundisha jinsi ya kukatiza na kushughulikia ujumbe wa hitilafu wa JavaScript ili usipoteze watazamaji wako.
jaribu ... catch constructJaribu ... catch construct inakuruhusu kuangalia kizuizi cha msimbo kwa makosa. Kizuizi cha kujaribu kina msimbo ambao utatekelezwa na kuangaliwa, na kizuizi cha kukamata kina nambari ambayo itatekelezwa ikiwa makosa yatatokea.
Sintaksia| jaribu { // Tumia nambari fulani hapa } kukamata (kukosa) { // Hitilafu katika kushughulikia hapa } |
Kumbuka kuwa jaribu ... catch imeandikwa kwa herufi ndogo (herufi ndogo). Kutumia herufi kubwa kutazalisha hitilafu ya JavaScript!
MifanoMfano ulio hapa chini unapaswa kuonyesha kidukizo cha "Karibu Mgeni!". wakati kifungo cha panya kinasisitizwa. Walakini, kuna typo katika kazi ya message(). alert() imechapishwa kama addlert(). Hitilafu ya JavaScript hutokea. Kizuizi cha kukamata kinashika hitilafu na kutekeleza nambari ya ziada ili kulishughulikia. Msimbo unaonyesha ujumbe wa hitilafu maalum ukimjulisha mtumiaji kilichotokea:
Mfano ufuatao unatumia kisanduku cha uthibitishaji ili kuonyesha ujumbe maalum unaowaambia watumiaji kwamba wanaweza kubofya SAWA ili kuendelea au kubofya Ghairi ili kwenda kwenye ukurasa mkuu. Ikiwa mbinu itarejesha sivyo, mtumiaji amebofya Ghairi na msimbo unaelekeza mtumiaji kwingine. Ikiwa njia inarudi kweli, nambari haifanyi chochote:
Mfano
|
Sasisho la mwisho: 10/23/2018
Wakati mwingine, wakati wa kutekeleza programu, makosa hutokea ambayo ni vigumu kuona au kutarajia, na wakati mwingine hata haiwezekani. Kwa mfano, wakati wa kuhamisha faili kwenye mtandao, unganisho la mtandao linaweza kushuka bila kutarajia. hali kama hizo huitwa ubaguzi. Lugha ya C # huwapa wasanidi programu uwezo wa kushughulikia hali kama hizi. Jaribio ... catch ... hatimaye kujenga katika C # imeundwa kwa hili.
Jaribu ( ) kukamata ( ) hatimaye ( )
Unapotumia jaribu...kamata..hatimaye zuia, taarifa zote kwenye kisanduku cha kujaribu hutekelezwa kwanza. Ikiwa hakuna ubaguzi hutokea katika kizuizi hiki, basi baada ya utekelezaji wake kizuizi hatimaye huanza kutekelezwa. Na kisha jaribu..kamata..mwishowe inakamilisha kazi yake.
Iwapo ubaguzi utatokea ghafla katika kisanduku cha kujaribu, agizo la kawaida la utekelezaji litakoma na CLR inaanza kutafuta kizuizi cha kukamata ambacho kinaweza kushughulikia ubaguzi. Ikiwa kizuizi sahihi cha kukamata kinapatikana, kinatekelezwa, na baada ya kukamilisha, kizuizi cha mwisho kinatekelezwa.
Ikiwa kizuizi cha kukamata kinachohitajika hakipatikani, basi wakati ubaguzi unatokea, programu inasitisha utekelezaji wake usio wa kawaida.
Fikiria mfano ufuatao:
Mpango wa Darasa ( static void Main(string args) ( int x = 5; int y = x / 0; Console.WriteLine($"Matokeo: (y)"); Console.WriteLine("Mwisho wa mpango"); Console.Soma (); ) )
Katika kesi hii, nambari imegawanywa na 0, ambayo itatoa ubaguzi. Na tunapoendesha programu katika hali ya utatuzi, tutaona dirisha kwenye Visual Studio ambayo inatufahamisha kuhusu ubaguzi:
Katika dirisha hili tunaona kwamba ubaguzi umetokea, ambao ni wa aina ya System.DivideByZeroException, yaani, jaribio la kugawanya kwa sifuri. Kwa kutumia kipengee cha Maelezo ya Tazama, unaweza kuona maelezo ya kina zaidi kuhusu ubaguzi.
Na katika kesi hii, jambo pekee lililobaki kwetu ni kukamilisha programu.
Ili kuzuia hitilafu kama hiyo ya programu, unapaswa kutumia jaribu...kamata...hatimaye unda ili kushughulikia hali zisizofuata kanuni. Kwa hivyo, wacha tuandike tena mfano kama ifuatavyo:
Mpango wa Darasa ( static void Main(string args) ( jaribu ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) catch ( Console.WriteLine("Imetokea ubaguzi ! "); ) hatimaye ( Console.WriteLine("Hatimaye zuia"); ) Console.WriteLine("Mwisho wa mpango");Console.Read(); ) )
Katika kesi hii, tutakuwa na ubaguzi tena katika kizuizi cha kujaribu, kwani tunajaribu kugawanya kwa sifuri. Na kufikia mstari
Int y = x / 0;
utekelezaji wa programu utaacha. CLR itapata kizuizi cha kukamata na kudhibiti uhamishaji kwenye kizuizi hicho.
Baada ya kizuizi cha kukamata, kizuizi cha mwisho kitatekelezwa.
Isipokuwa imetokea! hatimaye kuzuia Mwisho wa programu
Kwa hivyo, mpango huo bado hautafanya mgawanyiko kwa sifuri na kwa hivyo hautachapisha matokeo ya mgawanyiko huu, lakini sasa hautaanguka, na ubaguzi utashughulikiwa kwenye kizuizi cha kukamata.
Ikumbukwe kwamba ujenzi huu unahitaji kizuizi cha kujaribu. Ikiwa tuna kizuizi cha kukamata, tunaweza kuacha kizuizi cha mwisho:
Jaribu ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) kamata ( Console.WriteLine("Isiofuata kanuni imetokea!"); )
Kinyume chake, ikiwa tuna kizuizi hatimaye, tunaweza kuacha kizuizi cha kukamata na sio kushughulikia ubaguzi:
Jaribu ( int x = 5; int y = x / 0; Console.WriteLine($"Result: (y)"); ) hatimaye ( Console.WriteLine("Finally Block");)
Walakini, ingawa ujenzi kama huo ni sahihi kabisa kutoka kwa mtazamo wa sintaksia ya C #, hata hivyo, kwa kuwa CLR haiwezi kupata kizuizi kinachohitajika cha kukamata, ubaguzi hautashughulikiwa na programu itaanguka.
Ushughulikiaji na Masharti ya KighairiIdadi ya hali za kipekee zinaweza kutabiriwa na msanidi programu. Kwa mfano, acha programu ihusishe kuingiza nambari na kutoa mraba wake:
Utupu Mkuu tulivu(string args) ( Console.WriteLine("Weka nambari"); int x = Int32.Parse(Console.ReadLine()); x *= x; Console.WriteLine("Nambari ya mraba: " + x) ; Console.Soma();)
Ikiwa mtumiaji ataingiza sio nambari, lakini kamba au herufi zingine, programu itatupa hitilafu. Kwa upande mmoja, hii ndiyo hali hasa unapoweza kutumia try..catch block kushughulikia hitilafu inayowezekana. Walakini, itakuwa bora zaidi kuangalia uhalali wa ubadilishaji:
Utupu kuu tuli (Args za kamba) ( Console.WriteLine("Weka nambari"); int x; ingizo la kamba = Console.ReadLine(); ikiwa (Int32.TryParse(ingizo, nje x)) ( x *= x; Console . AndikaLine("Mraba wa nambari: " + x); ) mwingine ( Console.WriteLine("Ingizo batili"); ) Console.Soma(); )
Mbinu ya Int32.TryParse() hurejesha kuwa kweli ikiwa ubadilishaji unaweza kufanywa, na sivyo ikiwa hauwezi. Ikiwa ubadilishaji ni halali, kigezo cha x kitakuwa na nambari iliyoingizwa. Kwa hivyo, bila kutumia jaribu ... catch, unaweza kushughulikia ubaguzi unaowezekana.
Kwa mtazamo wa utendaji, kutumia try..catch blocks ni ghali zaidi kuliko kutumia masharti. Kwa hivyo, ikiwezekana, badala ya kujaribu..kamata, ni bora kutumia ujenzi wa masharti ili kuangalia hali za kipekee.
Katika lugha ya T-SQL, kama ilivyo katika lugha zingine nyingi za programu, inawezekana kufuatilia na kuzuia makosa; leo tutaangalia ujenzi wa TRY CATCH, kwa msaada ambao tunaweza kushughulikia hali za kipekee, i.e. makosa yasiyotarajiwa.
Kama unavyoelewa tayari, hatuzungumzii makosa ya kisintaksia, ambayo seva ya SQL inatujulisha hata kabla ya utekelezaji wa maagizo ya SQL wenyewe, lakini juu ya makosa ambayo yanaweza kutokea katika sehemu fulani ya nambari chini ya hali fulani.
Mfano rahisi zaidi ni kugawanya kwa sifuri. Kama unavyojua, huwezi kugawanya kwa sifuri, lakini takwimu hii bado inaweza kuonekana katika shughuli za mgawanyiko. Pia kuna makosa mengine ambayo yanaweza kutokea katika operesheni kwenye data isiyo ya kawaida, isiyo sahihi, ingawa shughuli sawa kwenye data ya kawaida hufanywa bila makosa yoyote.
Kwa hiyo, katika lugha ya Transact-SQL kuna ujenzi maalum TRY...CATCH, ilionekana katika toleo la 2005 la seva ya SQL, na ambayo hutumiwa kwa kushughulikia makosa. Ikiwa mtu yeyote anafahamu lugha nyingine za programu, basi ujenzi huu una uwezekano mkubwa unaojulikana kwako, kwa kuwa hutumiwa katika lugha nyingi za programu.
Kumbuka! Kwa uchunguzi wa kina zaidi wa lugha ya T-SQL, ninapendekeza kwamba waandaaji wa programu wanaoanza kusoma kitabu Njia ya Programu ya T-SQL. Mafunzo ya lugha ya Transact-SQL.
JARIBU CATCH kujenga katika T-SQLTRY CATCH ni muundo wa Transact-SQL kwa kushughulikia makosa. Kila kitu unachotaka kuangalia kwa makosa, i.e. Unaweka msimbo ambamo makosa yanaweza kutokea kwenye kizuizi cha TRY. Mwanzo wa kizuizi hiki unaonyeshwa na maagizo ya BEGIN TRY, na mwisho wa kizuizi, ipasavyo, na END TRY.
Chochote unachotaka kufanya ikiwa kosa linatokea, i.e. Maagizo hayo ambayo lazima yatekelezwe ikiwa hitilafu hutokea kwenye kizuizi cha TRY, unaweka kwenye kizuizi cha CATCH, mwanzo wake unaonyeshwa na BEGIN CATCH, na mwisho wake ni END CATCH. Ikiwa hakuna hitilafu zilizotokea kwenye kizuizi cha TRY, basi kizuizi cha CATCH kinarukwa na maagizo yanayofuata yanatekelezwa. Ikiwa makosa yanatokea, basi maagizo kwenye kizuizi cha CATCH yanatekelezwa, na kisha maagizo yanayofuata kizuizi hiki yanatekelezwa, kwa maneno mengine, maagizo yote yanayofuata kizuizi cha CATCH yatatekelezwa, isipokuwa, kwa kweli, tulikomesha kwa nguvu utekelezaji wa kifurushi kwenye kizuizi cha CATCH.
Kizuizi cha CATCH yenyewe haipitishi habari yoyote juu ya makosa yaliyogunduliwa kwa programu ya kupiga simu; ikiwa unahitaji, kwa mfano, kujua nambari au maelezo ya kosa, basi kwa hili unaweza kutumia SELECT, RAISERROR au PRINT taarifa kwenye CATCH block.
Mambo muhimu kuhusu muundo wa TRY CATCH katika T-SQL- Kizuizi cha CATCH lazima kije mara baada ya kizuizi cha TRY; kuweka maagizo kati ya vizuizi hivi haruhusiwi;
- TRY CATCH hupata hitilafu zote kwa kutumia msimbo wa ukali zaidi ya 10 ambao haufungi miunganisho ya hifadhidata;
- Katika muundo wa TRY...CATCH, unaweza tu kutumia pakiti moja na block moja ya taarifa za SQL;
- Muundo wa JARIBU...CATCH unaweza kuwekewa kiota, kwa mfano, katika kizuizi cha TRY kunaweza kuwa na JARIBU...CATCH ujenzi mwingine, au kwenye kizuizi cha CATCH unaweza kuandika kidhibiti hitilafu endapo hitilafu zitatokea kwenye kizuizi chenyewe;
- Taarifa ya GOTO haiwezi kutumika kuweka vizuizi vya TRY au CATCH, inaweza tu kutumika kuruka hadi kwenye lebo ndani ya vizuizi vya TRY au CATCH;
- Kushughulikia TRY...CATCH hitilafu katika vitendakazi vilivyobainishwa na mtumiaji havitumiki;
- Muundo wa JARIBU...CATCH haushughulikii hitilafu zifuatazo: ujumbe wa onyo na taarifa wenye kiwango cha ukali cha 10 au chini zaidi, usitishaji wa muunganisho unaosababishwa na mteja, na usitishaji wa msimamizi kwa kutumia taarifa ya KILL.
Ili kupata habari kuhusu makosa ambayo yalisababisha kutekelezwa kwa kizuizi cha CATCH, unaweza kutumia kazi zifuatazo:
- ERROR_NUMBER() - hurejesha nambari ya hitilafu;
- ERROR_MESSAGE() - inarudisha maelezo ya kosa;
- ERROR_STATE () - inarudi msimbo wa hali ya hitilafu;
- ERROR_SEVERITY() - inarudisha ukali wa kosa;
- ERROR_PROCEDURE() - inarudisha jina la utaratibu uliohifadhiwa au kichocheo ambacho hitilafu ilitokea;
- ERROR_LINE() - Hurejesha nambari ya mstari wa maagizo yaliyosababisha hitilafu.
Ikiwa chaguo hizi za kukokotoa zitaitwa nje ya kizuizi cha CATCH zitarudisha NULL.
Mfano wa kutumia muundo wa TRY...CATCH kwa kushughulikia makosaIli kuonyesha jinsi muundo wa TRY...CATCH unavyofanya kazi, hebu tuandike taarifa rahisi ya SQL ambapo tunafanya makosa kimakusudi, kama vile kujaribu kugawanya kwa sifuri.
Mwanzo wa kizuizi cha kushughulikia hitilafu ANZA JARIBU --Maelekezo ambayo makosa yanaweza kutokea TANGAZA @TestVar1 INT = 10, @TestVar2 INT = 0, @Rez INT SET @Rez = @TestVar1 / @TestVar2 END TRY --Mwanzo wa CATCH block ANZA KUSHIKA - -Vitendo vitakavyofanywa ikiwa hitilafu itatokea SELECT ERROR_NUMBER() AS [Nambari ya hitilafu], ERROR_MESSAGE() AS [Maelezo ya hitilafu] WEKA @Rez = 0 END CATCH SELECT @Rez AS [Matokeo]
Katika kesi hii, tunaonyesha nambari ya makosa na maelezo kwa kutumia kazi za ERROR_NUMBER () na ERROR_MESSAGE (), na pia tunatoa thamani 0 kwa mabadiliko ya mwisho ya matokeo, kama tunavyoona, maagizo baada ya kuzuia CATCH inaendelea kutekelezwa.
Hiyo ndiyo yote kwangu, natumai nyenzo hiyo ilikuwa muhimu kwako, kwaheri!
Katika mfano huu, tumefanya kosa la kuchapa kwenye msimbo (katika sehemu ya jaribu).
Mfano unapaswa kutahadharisha "Karibu mgeni!", lakini tahadhari haijaandikwa vibaya.
Kizuizi cha kukamata kinashika hitilafu, na kutekeleza nambari kushughulikia:
jaribu (
addlert("Karibu mgeni!");
}
kukamata (kukosea) (
document.getElementById("demo").innerHTML = err.message;
}
Mifano zaidi ya "Jaribu Mwenyewe" hapa chini.
Ufafanuzi na MatumiziTaarifa ya kujaribu/kamata/mwisho hushughulikia baadhi ya hitilafu au zote ambazo zinaweza kutokea katika kizuizi cha msimbo, huku zikiendelea kutumia msimbo.
Hitilafu zinaweza kuwa hitilafu za usimbaji zilizofanywa na mtayarishaji programu, hitilafu kutokana na uingizaji usio sahihi, na mambo mengine yasiyotarajiwa.
Taarifa ya kujaribu hukuruhusu kufafanua kizuizi cha msimbo ili kujaribiwa kwa makosa wakati inatekelezwa.
Taarifa ya kukamata inakuwezesha kufafanua kizuizi cha msimbo wa kutekelezwa, ikiwa hitilafu itatokea kwenye kizuizi cha kujaribu.
Taarifa ya mwisho hukuruhusu kutekeleza nambari, baada ya kujaribu na kukamata, bila kujali matokeo.
Kumbuka: Taarifa za kukamata na hatimaye zote ni za hiari, lakini unahitaji kutumia mojawapo (ikiwa sio zote mbili) unapotumia taarifa ya kujaribu.
Kidokezo: Hitilafu inapotokea, JavaScript kawaida itaacha na kutoa ujumbe wa hitilafu. Tumia taarifa ya kutupa ili kuunda hitilafu maalum (tupa ubaguzi). Ukitumia kutupa pamoja na try and catch , unaweza kudhibiti mtiririko wa programu na kutoa ujumbe maalum wa hitilafu.
Kwa maelezo zaidi kuhusu hitilafu za JavaScript, soma Mafunzo ya Makosa ya JavaScript.
Usaidizi wa Kivinjari| jaribu/kamata/mwishowe | Ndiyo | Ndiyo | Ndiyo | Ndiyo | Ndiyo |
Jaribu (
tryCode - Block of code kujaribu
}
kamata ( kosa) {
catchCode - Block of code kushughulikia makosa
}
hatimaye (
finallyCode - Block of code kutekelezwa bila kujali matokeo ya kujaribu / catch
}
| tryCode | Inahitajika. Kizuizi cha msimbo cha kujaribiwa kwa makosa wakati kinatekelezwa |
| kosa | Inahitajika ikiwa inatumiwa na samaki. Hubainisha kigezo cha ndani ambacho kinarejelea hitilafu. Tofauti inaweza kurejelea kitu cha Hitilafu (ina maelezo kuhusu hitilafu iliyotokea, kama vile ujumbe ""mwendeshaji" haujafafanuliwa"). Ikiwa ubaguzi uliundwa na taarifa ya kurusha, kigezo kinarejelea kitu kilichoainishwa katika taarifa ya kutupa (ona "Mifano Zaidi"). |
| msimbo wa kukamata | Hiari. Kizuizi cha nambari ya kutekelezwa, ikiwa hitilafu itatokea kwenye kizuizi cha kujaribu. Ikiwa hakuna hitilafu itatokea, kizuizi hiki cha msimbo hakitekelezwi kamwe |
| hatimaye Kanuni | Hiari. Kizuizi cha nambari ya kutekelezwa bila kujali matokeo ya kujaribu / kukamata |
| Hati ya ECMA3 |
Mfano huu unachunguza pembejeo. Ikiwa thamani si sahihi, ubaguzi (hitilafu) hutupwa.
Isipokuwa (kukosea) kunanaswa na taarifa ya kukamata na ujumbe wa makosa maalum unaonyeshwa:
Tafadhali weka nambari kati ya 5 na 10:
Ingizo la Mtihani
kazi myFunction() (
var ujumbe, x;
ujumbe = document.getElementById("ujumbe");
message.innerHTML = "";
x = document.getElementById("demo").thamani;
jaribu (
if(x == "") kutupa "ni Tupu";
if(isNaN(x)) tupa "sio nambari";
ikiwa(x> 10) kutupa "juu sana";
ikiwa (x< 5) throw "too low";
}
kukamata (kukosea) (
message.innerHTML = "Ingizo" + err;
}
}
Habari! Katika somo hili ningependa kuzungumza juu ya makosa katika JavaScript na jinsi ya kuyashughulikia. Baada ya yote, mara nyingi hutokea kwamba makosa hutokea mara kwa mara, na sio hata suala la kuwa na uzoefu wa programu au hata ukosefu wake kamili. Baada ya yote, waandaaji wa programu walio na msimu pia hufanya makosa; hakuna mtu aliye salama kutokana na hili.
Makosa ni hasa ya aina 2 - kisintaksia na kimantiki. Makosa ya kisintaksia ni pamoja na makosa katika majina ya vigeu, vitendakazi na makosa katika sintaksia ya msimbo. Kimsingi, makosa kama haya ni rahisi kupata kupitia koni ya kivinjari.
Lakini makosa ya kimantiki sio rahisi sana nao kwa sababu husababisha utekelezwaji sahihi wa nambari ya programu. Kwa hivyo, ili kuziondoa, utahitaji kurekebisha programu ili kuelewa kile kinachotokea katika kila hatua ya hati. Hapa tutazingatia hasa ujanibishaji wa makosa ya sintaksia kwa kutumia jaribio...catch construct. 
Jaribu...pata muundo wa kunasa makosa
Muundo wa try..catch una vizuizi 2: jaribu, na kisha kamata. Hapa kuna mfano wa kiingilio cha jumla
Jaribu ( // code... ) catch (err) ( // utunzaji wa makosa )
Ubunifu huu hufanya kazi kama hii:
Kwa hiyo, ikiwa kuna hitilafu katika kujaribu, script haina kuacha, na hata zaidi ya hayo, tuna fursa ya kushughulikia kosa ndani ya kuzuia catch.
Hebu tuangalie hili kwa mifano.
- Mfano bila makosa: wakati wa kuanza, tahadhari (1) na (2) itaanzishwa: jaribu ( tahadhari("Jaribu kuzuia"); // (1)
