Արտահայտություններ եւ օպերատորներ: JavaScript օպերատորները նշում են նշանի ցուցակը

Առաջինը կարճ ժամանակով javaScript- ի արտահայտությունների մասին:

JavaScript- ի արտահայտություններ

JavaScript- ում կան հրահանգներ եւ արտահայտություններ:

Հրահանգները չեն վերադարձնում արժեքները:

Արտահայտությունները միշտ Վերադարձնել որոշ արժեքներ: Երբ բնագրիչը տեսնում է արտահայտությունը, այն հաշվարկում է դրա արժեքը եւ արտահայտությունն իր արժեքով փոխարինում է:

Արտահայտությունները պարզ եւ կոմպոզիտային են: Պարզ արտահայտությունները չեն ներառում այլ արտահայտություններ:

Պարզ արտահայտությունները ներառում են.

  1. Նույնականացուցիչներ. STOMAR (փոփոխական անուն);
  2. Գրականություն. «Լար» կամ 675 (համարը կամ թվային բառացի);
  3. Որոշ հիմնաբառեր, ինչպիսիք են սա;

Երբ վերլուծիչը հայտնաբերում է նույնացուցիչը, այն նախ պետք է հաշվարկվի, այսինքն, օրինակ, փոփոխականի անունը փոխարինեք դրա արժեքով:

Բառացիության արժեքը կլինի գրված սցենարի կոդով:

Օպերատորներ եւ JavaScript- ի բարդ արտահայտություններ

Մի քանի բարդ արտահայտություններ համատեղելու համար օգտագործվում են մեկ բարդ օպերատորներ:

Օպերատորներն են.

  • Unary (մեկ օպերան):
  • Երկուական (երկու օպերաներ):
  • Terner օպերատոր: JavaScript- ում (երեք օպերաներ, կա միայն մեկ եռագույն օպերատոր):

Օպերան մի պարզ արտահայտություն է, որին կիրառվում է օպերատորը:

Օրինակ, «+» -ի թվաբանական հավելյալ օպերատորը երկուական օպերատոր է: Այն ամփոփում է ձախ եւ աջ օպերան եւ վերադարձնում գումարը:

Var Digit \u003d 4 + 7;

Ի դեպ, առաջադրանքը տեղի է ունենում հանձնարարականի օպերատորի հետ "\u003d": Այս օպերատորը հաշվարկում է ճիշտ օպերայի արժեքը եւ այն տալիս է ձախ օպերան:

JavaScript- ը Unary Plus- ն ունի, այն ունի միայն մեկ օպերան: Unary Plus- ը թվաբանական օպերատոր չէ, այն վերափոխում է օպերան թվին:

Var myvar \u003d "7"; Document.write (տիպը (Myvar) + "
"); // Տպում է լարային Myvar \u003d + MyVar փաստաթուղթ; Document.write (Icagef (Myvar) +"
"); // տպել փաստաթղթի համարի մեջ

Նախ, MyVAR փոփոխականը պարունակում էր «7» լարը, սա բառացի տողի տեսակ է (լարային), եւ ոչ թվային (համարը): Օպերատորի օգնությամբ Unary Plus Մենք տողի բառացիորեն վերափոխեցինք թվային:

Թվաբանական գործողություններ

Թվաբանական գործողությունները բոլորն էլ հայտնի են մաթեմատիկական գործողություններ:

Թերեւս օպերատորը (բաժնի հավասարակշռությունը) բացատրության կարիք ունի: 9-ը բաժանվում է 5-ի մնացորդների 4-ով, այս հավասարակշռությունն է, որը վերադարձնում է այս օպերատորը: Նաեւ կոչվում է մոդուլը վերցնելը: Ամբողջական թվեր օգտագործելիս այս օպերատորի գործունեության արդյունքը նույնպես ամբողջ թիվ կլինի: Լողացող կետի համարներով գործելիս արդյունքը կլինի լողացող կետի համարը:

5.5 % 2.2 = 1.1

Թվաբանական գործողություններում պետք է հիշել, որ սխալ կատարմամբ, դրանք կարող են արդյունքների արդյունքում.

  • NAN- ը (ոչ մի թիվ) համար չէ:
  • Անսահմանություն - անսահմանություն:

Սա այն է, ինչը կբերի բաժանումը զրոյի.

Var myvar \u003d 0/0; Document.write ("Փոփոխական արժեք." + Myvar + ", դրա տեսակը," + տիպ (Myvar) + "
");

Համեմատության գործողություններ

Համեմատության գործողությունները օգտագործվում են արտահայտությունները համեմատելու համար: Պայմանական օպերատորի հետ արտահայտությունը վերադառնում է բուլյան արժեք, ճշմարտություն կամ կեղծ (ճշմարիտ / կեղծ):

Համեմատեք գործողությունները կարող են իրականացվել գծերով, դա կքննարկվի մեկ այլ դասով: Rect իշտ արդյունքի միակ պայմանն է `համեմատած նույն տիպի տվյալները: Հակառակ դեպքում, JavaScript- ը կփորձի մեկ տեսակի մեկ այլ մուտքագրել տվյալները, եւ դա միշտ չէ, որ հնարավոր է: Սխալներից խուսափելու համար համեմատեք տվյալների միայն մեկ տեսակի:

Հանձնարարական գործողություններ

Առաջադրանքի գործողության առավել ակնհայտ օրինակը պարզ նշանակություն է (\u003d): Այս օպերատորը (\u003d) օգտագործվում է փոփոխականի արժեքը նշանակելու համար:

Բայց կան եւս մի քանի հանձնարարականներ, որոնք կրճատումներ են:

Տրամաբանական գործողություններ

Տրամաբանական գործողությունները հաճախ օգտագործվում են այլ կերպ, եթե դիզայնը JS է: Այս դիզայնի օրինակների վրա է, որ իրենց աշխատանքը ցուցադրվելու է: Բայց նախ տրամաբանական օպերատորների ցուցակը:

Հիմա պարզ օրինակներ.

Եթե \u200b\u200b(ճշմարիտ && ճշմարիտ) փաստաթուղթ: Գրատ («Այն աշխատում է:
"); եթե (ճշմարիտ || կեղծ) փաստաթուղթ: Գրատ.« Այն աշխատում է:
«); եթե (! կեղծ) փաստաթուղթ: Գրատ. (« Այն աշխատում է:
");

Մենք կվերլուծենք այս օրինակները.

Տրամաբանական եւ (&&) օպերատորը կվերադառնա ճշմարտությունը, եթե երկու օպերաներն են ճշմարտությունը:

Հայտարարությունը տրամաբանական է կամ (||) կվերադարձնի ճշմարտությունը, եթե առնվազն մեկ օպերան ճշմարիտ լինի:

Հայտարարությունը տրամաբանական չէ (!) Վերցնում է մեկ օպերան եւ փոխում ճշմարտության / ստի արժեքը հակառակը:

Unare օպերատորներ

Unare օպերատորները օպերատոր են մեկ օպերանով: Ահա նման օպերատորներ.

  • ++ - 1-ին ավելացում (ավելացում): Կարող է լինել նախածանց եւ Postfix, դրա մասին, ստորեւ:
  • - - իջեցում 1-ին (անկում): Կարող է լինել նախածանց եւ հետֆիքս, դրա մասին չափազանց ներքեւում:
  • + - Unary Plus.
  • - - Unary Minus.

Unare Minus

Unary Minus- ը փոխում է արտահայտման նշանը հակառակը: Օրինակ, երբ գրում եք ծրագրում -100, դուք պարզապես 100 մինուս եք օգտագործում թվային բառացի:

Դուք պետք է հստակ հասկանաք, թե ինչպես է գործում միունակ մինուս - այն վերացնում է օպերայի արժեքը հակառակ նշանով: Ահա մի օրինակ, թե ինչպես օգտագործել Unary Minus- ը.

Var myvar \u003d -100; ՓԱՍՏԱԹՂԹ.ԳՐԱՆՔ (-MYVAR + "- Unary Minus- ը աշխատել է, բայց փոփոխականը նույնպես \u003d" + Myvar + ":
«); Myvar \u003d -Myvar; փաստաթուղթ: Գրատ (" Հիմա փոփոխական \u003d "+ Myvar +":
");

Մենք անփոխարինելի օրինակ ենք տալիս կրկնակի Unary Minus- ի: Կարծում եմ, կրթական նպատակներով դա օգտակար կլինի.

Var myvar \u003d -100; ՓԱՍՏԱԹՂԹԵՐ. Գրատ (- Myvar + "-ը աճ է, եւ ոչ թե կրկնակի Unary Minus:
"); ՓԱՍՏԱԹՂԹԵՐ:
"); Փաստաթուղթ: Գրատ (- (- Myvar) +», եւ սա միանշանակ մինուսի կրկնակի կիրառում է:
");

Unary Plus

Unary Plus- ը մաթեմատիկական գործողություններ չի կատարում: Նա տանում է բառացիորեն թվային տիպին:

Var myvar \u003d "78687"; Document.write (տիպը (Myvar) +.
«); Myvar \u003d + Myvar; Document.write (Icagef (Myvar) +.
");

Աճ եւ անկում

Ծրագրավորման դեպքում հաճախ անհրաժեշտ է ավելացնել կամ նվազեցնել յուրաքանչյուր միավորի փոփոխականի արժեքը: Դրա համար կան միացյալ օպերատորներ.

  • ++ - 1-ին ավելացում (ավելացում):
  • - - իջեցում 1-ին (անկում):

Ի տարբերություն Unary Plus- ի եւ մինուս, աճը եւ անկումը փոխում են զանգահարելիս փոփոխականի արժեքը:

Var myvar \u003d 10; Document.write (++ Myvar +.
"); ՓԱՍՏԱԹՂԹԵՐԸ (MYVAR +.
");

Նվազում (-) նման է նման:

Այժմ հաշվի առեք այս օպերատորների նախածանցը եւ հետֆիքսը:

  • ++ Myvar - նախածանց աճը 1-ով:
  • myvar ++ - Postfix- ի ավելացումը 1-ով:

Տարբերությունն է.

  • Այս օպերատորների նախածանցի օգտագործումը նախ հաշվարկում է միացյալ օպերատորի արժեքը, այնուհետեւ օգտագործում է արտահայտման արդյունքը:
  • Postfix- ի օգտագործումը նախ հաշվարկում է արտահայտությունը, այնուհետեւ կատարում է միացյալ օպերատոր (++ կամ -):

Սա կօգնի ձեզ հասկանալ մի պարզ օրինակ.

Var myvar \u003d 10; Document.write ((++ Myvar + 5) + ":

"); var myvar \u003d 10; Document.write ((Myvar ++ + 5) +":
"); Փաստաթուղթ:
");

Բարձրացումը եւ անկումը թույլատրվում է օգտագործել միայն փոփոխականներով, դրանք հնարավոր չէ կիրառել թվային բառացի գրական: Պարզապես տեղադրեք կոդը ++ 7 DAS սխալը սցենարի մեջ:

Այլ օպերատորներ

JavaScript- ում կան այլ օպերատորներ.

  • Ternerary (երեք օպերաների) օպերատոր

var a \u003d 10; VAR B \u003d (A\u003e 1)? 100: 200; Ահազանգ (բ);

Եթե \u200b\u200bպայմանը a\u003e 1. True իշտ է, ապա փոփոխական Բ Հանձնարարեք արժեք 100 Հակառակ դեպքում փոփոխական B- ն նշանակում է արժեքը 200 .

JS 3_4 Առաջադրանք: Կոդը լրացնելու համար. 3 Տեղական փոփոխականներ հայտարարվում են VAR հիմնաբառի միջոցով: Անհրաժեշտ է վերագրել հաջորդ եռագույն հայտարարության արժեքը Max փոփոխականի մեջ. Եթե A- ն ավելի մեծ է, քան B- ն, ապա վերադարձրեք բ.
Կոդի հատվածը.

Եթե \u200b\u200b(a * b< 6) { result = "Мало"; } else { result = "Много"; }


Հարցեր ինքնատիրապետման համար.

  1. Որն է Ternary օպերատորի շարահյուսությունը:
  2. Քանի փաստարկ ունի բազմագույն օպերատոր:

Օպերատորը JavaScript- ում `անջատիչ

Switch JavaScript օպերատորը ծառայում է ստուգել տարբեր արժեքների փոփոխականը.

Շարահյուսություն:

Անջատիչ (փոփոխական կամ արտահայտություն) (գործի տարբերակ 1: //.. Block օպերատորներ .. ընդմիջում գործի տարբերակ 2: //.. Block օպերատորներ.

Փոփոխականի կամ արտահայտման արժեքը ստուգվում է. Յուրաքանչյուրում Գործ Արժեքներից մեկը ստուգվում է, համապատասխան արժեքի դեպքում `դրան համապատասխանող օպերատորների մեկ կամ մեկ այլ բլոկ Գործ.

Ծառայությունից ստանդարտ բառից սկսած բլոկ կարող է բացակայել: Բլոկի օպերատորները կկատարվեն, եթե բոլորի մեջ նշված արժեքներից ոչ մեկը Գործ Հարմար չէ.

Կարեւոր է. Ընդմիջման օպերատորը պահանջվում է համարվող փոփոխական արժեքից յուրաքանչյուրից հետո (յուրաքանչյուրից հետո) Գործ); Եթե \u200b\u200bչօգտագործվի այն, ապա ցուցադրվելու են ստորեւ նշված բոլոր օպերատորները:

Համեմատեք օպերատորի հետ Եթե:

var a \u003d 2; Անջատիչ (ա) (դեպք 0: // Եթե (a \u003d\u003d\u003d 0) գործ 1: // եթե (a \u003d\u003d\u003d 0) ազդանշան («զրո կամ մեկ»); // հետո մենք վերցնում ենք ... ընդմիջում; Գործ 2. // Եթե (a \u003d\u003d\u003d 2) ահազանգ ("երկու"); // հետո մենք վերցնում ենք ... ընդմիջում; լռելյայն. )

Ինչպես խմբավորել մի քանի տարբերակներ:

Նույն օպերատորները կատարելու համար մի քանի խմբավորում Գործ, Ինչպես վերը նշված օրինակում.

Գործ 0: դեպք 1. ահազանգ («զրո կամ մեկ»). Ընդմիջում; ...

A \u003d 0 եւ A \u003d 1-ում նույն օպերատորը կատարվում է. Alert («զրո կամ մեկ»);

Օրինակ 4. Ուղարկեք օգտագործողի կողմից գույնը մուտքագրելու համար: Display ուցադրել թարգմանությունը անգլերեն մուտքի մեջ: Գույնի համար "Կապույտ" մի քանազոր "Կապույտ" Ներկայացնել նույն արժեքը:


✍ լուծում.
  • Ստեղծեք վեբ էջ HTML կմախքով եւ պիտակով Սցենար.
  • Նախաձեռնեք փոփոխականը Գույն
    • var գույն \u003d հուշում ("Ինչ գույն?");

    var գույն \u003d հուշում ("Ինչ գույն?");

  • Ստուգեք փոփոխականի արժեքը դիզայնի միջոցով ՇվեյթշDisplay ուցադրելով յուրաքանչյուր արժեք `համապատասխան թարգմանություն.

    • Անջատիչ (գույն) («Կարմիր» գործը. Alert («Red»); ընդմիջում; «Կանաչ» գործը («կանաչ»);

    Եթե \u200b\u200bփոփոխականը ԳույնԱյն ունի «կարմիր» իմաստը, այնուհետեւ թարգմանությունը վերածում է մոդալ պատուհանի `« կարմիր »եւ դուրս գալ դիզայնից (ընդմիջում;): Եթե \u200b\u200bփոփոխականը Գույն Այն ունի «կանաչ» իմաստը, ցուցադրելու մոդալ պատուհանում `« կանաչ »եւ դուրս գալ դիզայնից (ընդմիջում;):

  • Ծաղիկների համար "Կապույտ" մի քանազոր "Կապույտ" Կատարեք խմբավորում.

    • // ... «Կապույտ» գործը. «Կապույտ». Alert («Կապույտ»); Ընդմիջում; // ...

    Եթե \u200b\u200bփոփոխականը ԳույնԱյն ունի «կապույտ» կամ փոփոխական իմաստ ԳույնԱյն ունի «կապույտ» իմաստը, ապա ցուցադրել թարգմանությունը մոդալ պատուհանի մեջ `« կապույտ »եւ դուրս գալ դիզայնից (ընդմիջում;):

  • Կազմակերպեք արդյունքը այն գույների համար, որոնք նախատեսված չեն ծրագրի կողմից.
    • // ... Լռելյայն. Alert ( «Y Մենք այս գույնի մասին տեղեկություններ չունենք»)) // անջատիչի ավարտը

    // ... լռելյայն. Alert ("Y Մենք տեղեկություններ չունենք այս գույնի մասին")) // անջատիչի ավարտ

  • Փորձարկման սցենար զննարկիչում:

JS 3_6 Առաջադրանք: Գտեք եւ շտկեք սխալները հետեւյալ կոդի հատվածում.

14 15 16 17 Var համար \u003d հուշում ( «Մուտքագրեք համարը 1 կամ 2:); Անջատիչ («1» գործ (փաստաթուղթ. Փաստաթուղթ (մեկ »);); ընդմիջում;« 2 »դեպք (փաստաթուղթ: Default ( «Դուք մուտքագրել եք 1-ից մյուսը այլ արժեք») ; } ; }

var համար \u003d հուշում ("Մուտքագրեք համարը 1 կամ 2:"); Անցում («1» գործ (փաստաթուղթ. Փաստաթուղթ. Գրատ (մեկ "););« 2 »(փաստաթուղթ. 3-ից 2"); ;);)


JS 3_7 Առաջադրանք: Ինչը ցուցադրվելու է էկրանին հաջորդ ծածկագիրը կատարելիս.

1 2 3 4 5 6 7 8 9 10 11 12 13 Var արժեք \u003d "2"; Անցում (արժեք) (գործը "1". Դեպք «2». Դեպք «3». Document.write («Բարեւ»); Լռելյայն. Փաստաթղթեր. Գրատ («Սխալ»);)

var արժեք \u003d "2"; Անցում (արժեք) (գործը "1". Դեպք «2». Դեպք «3». Document.write («Բարեւ»); Լռելյայն. Փաստաթղթեր. Գրատ («Սխալ»);)


JS 3_8 Առաջադրանք: Օգտագործողը պահանջում է համարը `մասնաճյուղի ագռավի քանակը: Կախված մուտքագրված համարից (ոչ ավելի, քան ավելի քան 10), դուրս բերեք հաղորդագրությունը. - Նստում է ճյուղի վրա 1 ագռավ: - նստում է ճյուղի վրա 4 ագռավ - նստում է ճյուղի վրա 10 roron

  1. Կախված ներդրված թվից, փոփոխությունների ավարտը «CROW».
  2. Switch JavaScript օպերատորի օգտագործումը ստուգելու համար:
  3. Պահպանեք այս էջը արդյունքների պանակում (այն օգտակար է հետագա աշխատանքի համար):


Հարցեր ինքնատիրապետման համար.

  1. Որ դեպքում խորհուրդ է տրվում որպես պայմանական օպերատոր, դիզայնը օգտագործելու համար Տեղավորել?
  2. Որն է օպերատորի լռելյայն բլոկը Տեղավորել?
  3. Անհրաժեշտ է դիզայնում օգտագործել ընդմիջման օպերատորը Տեղավորել?
  4. Ինչպես է իրականացվում խմբավորումը օպերատորի արժեքների մի քանի տարբերակների համար Տեղավորել?

JavaScript Language- ի ցիկլային օպերատորներ - համար

Շարահյուսություն:

Համար (վաճառասեղանի սկզբնական արժեքը. Պայմանը; վաճառասեղանի ավելացումը) (//.. Block օպերատորներ ..)

Կարեւոր է. JavaScript- ի ցիկլը օգտագործվում է այն դեպքում, երբ նախապես հայտնի է, թե քանի անգամ պետք է կրկնվեն ցիկլային գործողությունները (քանի հատում է ցիկլում)

  • Որպես կրկնության ստացման նախնական արժեք, որն օգտագործվում է հանձնարարականի արտահայտություն. Օրինակ, i \u003d 0 - ցիկլի հաշվիչը սկսվում է զրոյից.

    • համար (var i \u003d 0; պայման; վաճառասեղանի աճ) (//.. Block օպերատորներ ..)

  • Որպես վաճառասեղանի աճ, ապա միտքը նշվում է, որի միջոցով մետրը պետք է ավելանա. Օրինակ, ցույց է տալիս, որ յուրաքանչյուր ցիկլի կրկնություն կուղեկցվի աճով 1 :

    • Համար (var i \u003d 0; պայման; i ++) (//.. Block օպերատորներ ..)

  • The իկլային պայմանը մետր վերջնական արժեքն է. Օրինակ, I10- ը դադարեցնում է ցիկլը.

    • համար (var i \u003d 0; i<10; i++) { //..блок операторов.. }

Դիտարկենք JavaScript- ում ցիկլը օգտագործելու օրինակ.

Օրինակ 5: Ցուցադրել թվերի հաջորդականությունը 0 1 2 3 ... 9 , յուրաքանչյուր նիշ `նոր տողից: 0 1 2 ... 8 9


✍ լուծում.
  • Համարների հաջորդականությունը ցուցադրելու համար մենք կօգտագործենք ցիկլ վաճառող, որը պետք է փոխի իր արժեքը 0 նախքան 9 Ըստ հաջորդականության:
  • Այսպիսով, համար ցիկլի հաշվիչի սկզբնական արժեքը Սահմանեք արժեքը հավասար 0 ; որպես Ցիկլի պայմանները Վերջնական արժեքը սահմանեք - II \u003d 9; Քայլի հաշվիչը պետք է հավասար լինի 1 (I ++), քանի որ հաջորդականության անդամների միջեւ տարբերությունը մեկն է.

    • համար (var i \u003d 0; i<10; i++) { document.write(i+"
    "); }

    Օրինակ, ցիկլի հաշվիչի արժեքները ցուցադրվում են էկրանին, քանի որ I ++ Counter- ի աճը, համապատասխանաբար, կհայտնվի էկրանին 0 1 2 3 ... 9 , եւ յուրաքանչյուր նիշ `նոր տողից (պիտակ
    ).

  • Փորձարկման սցենար զննարկիչում:

JS 3_9 Առաջադրանք: 1 նախքան 15 .

  1. Որպես թվերի հաջորդականություն, օգտագործեք ցիկլի հաշվիչը Համար.
  2. Փոփոխական-հավելողի համար օգտագործեք փոփոխական նույնացուցիչը Գումար:.

Կոդի հատվածը.

Որովհետեւ (var i \u003d ...; ...; ...) (գումար \u003d գումար + ...;) ...

Cycle ելքի օպերատորներ Ընդմիջում մի քանազոր Շարունակել. JavaScript- ում: Օպերատոր Ելք

Ընդմիջման օպերատորը ընդհատում է ցիկլի ամբողջ մարմինը, այսինքն: Ելեք ցիկլից մինչեւ javaScript:

Մինչ Շարունակվող օպերատորը ընդհատում է ցիկլի ներկայիս կրկնության կատարումը, բայց շարունակելով շրջանի կատարումը հետեւյալ կրկնությունից:

Հաշվի առեք ընդմիջման եւ շարունակելու օպերատորները.

Օրինակ: Շեղել կոդի բեկորային ալգորիթմը: Ինչ է ստացվելու:

Կոդի հատվածը.

1 2 3 4 5 6 համար (var i \u003d 0; i< 10 ; i++ ) { if (i== 4 ) continue ; document.write (i+ "
"); եթե (i \u003d\u003d 8) ընդմիջում;)

համար (var i \u003d 0; i<10;i++) { if (i==4) continue; document.write(i+"
"); եթե (i \u003d\u003d 8) ընդմիջում;)


✍ լուծում.
  • Օրինակի երրորդ շարքում կա մի պայման, որի պատճառով գործիչը 4 Չի ցուցադրվի. Օպերատոր Շարունակել.Անցեք ցիկլի հաջորդ կրկնությանը, առանց ընթացիկ ավարտելու:
  • Ցիկլից 5-րդ տողում, բայց միեւնույն ժամանակ գործիչ 8 Այն կցուցադրվի, քանի որ ելքային հայտարարությունը կախված է պայմանից (4-րդ գծում): Հանդիպում ԸնդմիջումԹարգմանիչը կավարտի ցիկլի աշխատանքը:
  • Այսպես Էկրանի վրա կլինի. 0 1 2 3 5 6 7 8 - Յուրաքանչյուր թվանշան նոր տողից:

JS 3_10 Առաջադրանք: Հանել բոլոր ամբողջ թվերի գումարը 1 նախքան 15 , վերացնել թվերի ընդհանուր քանակից 5 մի քանազոր 7 .

Ելք օպերատոր

Javastipt Langus- ը ծրագրի կոդից ապահովում է ելքի օպերատոր `ելքի հայտարարությունը:
Ամենից հաճախ օպերատորը օգտագործվում է օգտագործողի մուտքի սխալը բացառելու համար:


Դիտարկենք.

Օրինակ 6: Հարցման օգտվողը մուտքագրեք մի շարք: Եթե \u200b\u200bոչ համարը մուտքագրված է, ապա ցուցադրել հաղորդագրություն: «Համարը անհրաժեշտ է»: եւ դադարեցրեք ծրագրի աշխատանքը:


✍ լուծում.
  • Նախաձեռնեք փոփոխականը Թիվ Օգտագործողի կողմից մուտքագրված արժեքը մոդալային պատուհանում.

    • var համար \u003d հուշում («Մուտքագրեք համարը»);

  • Օգտագործելով տողի վերափոխման թեւերի վերափոխման թարախի գործառույթը `ստուգեք, թե մուտքագրված արժեքը համարն է.

    • Համարը \u003d parseint (համարը); // վերադարձնել nan - ոչ համարը

    Այն դեպքում, երբ ոչ մի թիվ չի մուտքագրվում, գործառույթը կվերադարձնի NAN արժեքը (անգլերենից: Ոչ մի թիվ - ոչ համարը):

  • Ստուգեք փոփոխականի արժեքը Թիվ Օգտագործելով ISNAN գործառույթը.

    • x \u003d Isnan (համարը); // Վերադարձեք ճշմարիտ, եթե արժեքը թվային չէ

    ISNAN գործառույթը վերադարձնում է արժեքը Ճիշտ. Եթե \u200b\u200bփոփոխականը թիվ չէ

  • Միջոցով Կանոններ «սուտ» Կազմակերպեք փոփոխական արժեքի ստուգում X., Եթե \u200b\u200bարժեքը թվային ելք չէ համապատասխան մեկնաբանություն եւ լրացրեք ծրագիրը.

    • Եթե \u200b\u200b(x) (ազդանշան («համարը»); ելք; // Ելք ծրագրի)

  • Ծրագիրը շարունակելու համար (եթե մուտքագրված արժեքը համարն էր), ելնելով հետեւյալ պատուհանը `մուտքային առաջարկով.

    • alert («Մուտքագրեք երկրորդ համարը»); // Երբ մտնում եք, օպերատորը չի իրականացվում

  • Փորձարկման սցենար զննարկիչում:

Հարցեր ինքնատիրապետման համար.

  1. Թվարկեք երեք ցիկլի պարամետրերը Համար Եւ բացատրեք նրանց նպատակը:
  2. Ինչ օպերատորներ են նախատեսված ցիկլից դուրս գալու եւ դրա ընդհատման համար: Ներկայացրեք դրանց օգտագործման օրինակներ:
  3. Որի համար նախատեսված է օպերատորը Ելք?

Մի քանի մետր կա մեկում:

Հնարավոր է հետաքրքիր աշխատանք, երբ ցիկլը հնարավոր է, երբ օգտագործվում է Միեւնույն ժամանակ, ցիկլում երկու հաշվիչ.
Դիտարկենք.

Օրինակ 7: Օգտագործելով սցենարը, տպեք հետեւյալ զույգերը փոփոխական է երեք տող. I \u003d 0 J \u003d 2 I \u003d 1 J \u003d 3 I \u003d 2 J \u003d 4


✍ լուծում.
  • Ցիկլի մեջ կազմակերպեք երկու մետր. Counter i հաջորդականության համար 0 1 2 , մետր j հաջորդականության արդյունքի համար 2 3 4 :
    • 1 2 3 համար (i \u003d 0, j \u003d 2; i< 10 , j< 5 ; i++, j++ ) { }

    համար (i \u003d 0, j \u003d 2; i<10, j<5; i++, j++) { }

    Cycle- ի երեք պարամետրերից յուրաքանչյուրն այժմ ունի երկու արժեք, որոնք նշված են: ստորակետերով (Օրինակ, առաջին պարամետրը `երկու արժեքով. I \u003d 0, J \u003d 2): Պարամետրերը իրենք են նշված ստորակետով(;).

  • Յուրաքանչյուր տողից դուրս գալու համար օգտագործեք պիտակը
    :
    • 1 2 3 4 համար (i \u003d 0, j \u003d 2; i< 10 , j< 5 ; i++, j++ ) { document.write ("
    i \u003d ", ես," J \u003d ", J);)

    համար (i \u003d 0, j \u003d 2; i<10, j<5; i++, j++) { document.write("
    i \u003d ", ես," J \u003d ", J);)

«Թռչման մասին» սերնդի էջը. Ինչպես է:

Հետեւյալ առաջադրանքի կատարումը կատարելուց առաջ դիտեք օրինակ: Դինամիկ շենք HTML էջ JavaScript- ի հետ:

Օրինակ 8:

  • Դուք պետք է դինամիկորեն ստանձնեք նշված եւ համարակալված ցուցակները վեբ էջում, կախված օգտվողի կողմից մուտքագրված տվյալներից. Օգտագործողի կողմից մուտքագրելու պահանջը Ցուցակի դիտում (համարակալված (թվանշանը 1) կամ նշվում է (թվանշանի 2)) եւ հետո list ուցակիների քանակը.
  • Կախված պատասխանից, ցուցադրեք պիտակներ կամ նշված կամ համարակալված ցուցակը անհրաժեշտ քանակությամբ իրերի միջոցով:
  • Եթե \u200b\u200bմուտքագրված ցանկի գոյություն ունեցող տեսակ է, ապա հաղորդագրություն թողարկեք «Մուտքագրեք ճիշտ տեսակը»: եւ դուրս գալ ծրագիրից ():

Հիշեցրեք պիտակները.
Թվային ցուցակների Tags:

<ol\u003e <li\u003e <li\u003e <li\u003e </ ol\u003e

Նշված ցուցակը Tags.

var Listtype \u003d հուշում ("Մուտքագրեք" 1 "- Եթե նշված ցուցակը," 2 "- Եթե համարակալված ցուցակը");

  • Ստուգեք մուտքագրված արժեքը. Թվարկված ցուցակի համար (թվանշանի 1) ցուցադրում է պիտակը
      , պիտակավորված (թվանշանի 2) - պիտակ
        , Եթե \u200b\u200bմեկ այլ արժեք մուտքագրված է, ելքային դիտողությունը եւ ավարտեք ծրագիրը.

            ") Այլ (ահազանգ (" Մուտքագրեք ճիշտ տեսակը); ելք;)

          • Նախաձեռնեք փոփոխականը kolvo. Օգտագործողի կողմից մուտքագրված արժեքը մոդալային պատուհանում.

            • var kolvo \u003d հուշում («Մուտքագրեք իրերի քանակը»);

          • Լարային արժեքը թվային օգտագործման համար Parseint գործառույթը.

            • համար (var i \u003d 1; i<=kolvo; i++) document.write("");

          • Քանի որ ցուցակները փակված են համապատասխան պիտակներով, կախված ցուցակի ցուցակից, ելքային պիտակներ.
            • Եթե \u200b\u200b(Listype \u003d\u003d "1") փաստաթուղթ:«Այլ, եթե (Listype \u003d\u003d" 2 ") փաստաթուղթ:" ) ;

            Եթե \u200b\u200b(Listype \u003d\u003d "1") փաստաթուղթ:

        «Այլ, եթե (Listype \u003d\u003d" 2 ") փաստաթուղթ:
      ");

    1. Փորձարկման սցենար զննարկիչում:

      2. JS 3_11 Առաջադրանք:
      Գրեք սցենար, որը ցուցադրում է պիտակներ մուտքագրումՏարբեր տեսակների (վերահսկում), կախված մուտքագրված թվերից.

      1 - տեքստի դաշտ,
      2 - կոճղ,
      3 - Ռադիո(անջատիչ):

      Ստացված տվյալների քանակը պետք է նաեւ պահանջվի:

      Հիշեցրեք պիտակները.

      1 - տեքստի դաշտ. 2 - կոճակի համար. 3-ի համար `ռադիո.

      Արդյունքի օրինակ.

      JS 3_12 Առաջադրանք: Նկարեք 9x9 շախմատի տախտակ, օգտագործելով JavaScript- ը ցիկլերի համար: «Նկարիչ» տախտակը հետեւում է սեղանի համար HTML պիտակների.

      Հիշեցրեք պիտակները.

      <Սեղանի սահման \u003d "1" լայնություն \u003d "30%"\u003e <tR\u003e <tD\u003e-</ TD\u003e -</ TD\u003e </ TR\u003e </ Աղյուսակ\u003e

      --

      • 9 տող նկարելու համար անհրաժեշտ է մեկ մետրով ցիկլի համար արտաքին կազմակերպել:
      • Յուրաքանչյուր տողում 9 բջիջ նկարել, անհրաժեշտ է կազմակերպել ներքին (ներկառուցված) ցիկլի համար J.
      • Պիտակների բջիջներ եւ տողեր նկարելու համար օգտագործեք փաստաթուղթը:

      Արդյունք.

      Բացի այդ.

      1. Սեղանի բջիջներում ցուցադրեք բազմապատկման աղյուսակը `օգտագործելով ցիկլի հաշվիչները (I եւ J):
      2. Առաջին շարքը եւ առաջին սյունը `կարմիր ֆոնով դուրս գալու համար (BGCOLOR սեղանի բջիջների հատկանիշ).
        <tD BGCOLOR \u003d "RED"\u003e-</ TD\u003e

        -

      Արդյունք.


      Հարցեր ինքնատիրապետման համար.

      1. Բացատրեք, թե ինչ է նշանակում «Դինամիկ էջի կառուցման» հայեցակարգը:
      2. Ինչ լեզվով դիզայնը առավել հաճախ օգտագործվում է էջը կառուցելիս:

      Cyclic JavaScript - Մինչ լեզու օպերատորները

      Whele օպերատորի շարահյուսություն.

      Մինչդեռ (պայման) (//.... Block օպերատորներ ..);

      Օրինակ: Հեռացնել երկխոսության տուփը 1000 (2, 4, 8 ... 512): Օգտագործեք ազդանշանային () մեթոդ


      ✍ լուծում.
      • Script ցուցակագրման համար.
        • 1 2 3 4 5 var a \u003d 1; Մինչդեռ (A.< 1000 ) { a*= 2 ; alert(a) ; }

        var a \u003d 1; Մինչդեռ (A.< 1000){ a*=2; alert(a); }

        a * \u003d 2 → Օգտագործվում է կոմպոզիտային հանձնարարականի գործողություն. Ապրանք, որը զուգորդվում է հանձնարարության, այսինքն: նույնը, A \u003d A * 2-ը

      • Փորձեք արդյունքը զննարկչի մեջ:

      Ինչպես են կոտրվում եւ շարունակում են օպերատորները աշխատել ցիկլի ընթացքում:

      Օրինակ:

      var a \u003d 1; Մինչդեռ (A.< 1000 ) { a*= 2 ; if (a== 64 ) continue ; if (a== 256 ) break ; alert(a) ; }

      var a \u003d 1; Մինչդեռ (A.< 1000){ a*=2; if (a==64) continue; if (a==256) break; alert(a); }

      Որոշեք աստիճաններ, որպեսզի դուրս գան 128 ներառական եւ արժեք 64 կարոտելու է: Նրանք: Երկխոսության տուփերում մենք կտեսնենք. 2 4 8 16 32 128

      JS 3_13 Առաջադրանք: Ինչ արժեքներ կբարձրանան հետեւյալ կոդի բեկորը:

      var counter \u003d 5; Մինչդեռ (վաճառասեղան:< 10) { counter++; document.write("Counter " + counter); break; document.write("Эта строка не выполнится."); }


      JS 3_14 Առաջադրանք: Գրեք շինարարության ծածկագիրը Հ. աստիճանի Յ.Օգտագործելով ցիկլը: Հայցեք փոփոխականների արժեքները եւ արդյունքը դուրս բերեք ազդանշանային ():

      Ամբողջական ծածկագիր.

      1 2 3 4 5 6 7 8 9 var x \u003d ...; var y \u003d ...; Counter \u003d 1; chislo \u003d x; Մինչ (...) (chislo \u003d x * ...; counter \u003d ...;) Alert (chislo);

      var x \u003d ...; var y \u003d ...; Counter \u003d 1; chislo \u003d x; Մինչ (...) (chislo \u003d x * ...; counter \u003d ...;) Alert (chislo);

      Ուղղակի սխալը ծրագրի համար, որը նախատեսված է համարի քանակը գտնելու համար.

      1 2 3 4 5 6 7 8 9 10 11 12 13 Var counter \u003d հուշում («Մուտքագրեք համարը»); var factorial \u003d 1; Document.write ( «Factorial համարներ» + Counter + «! \u003d»); Արա (եթե (counter \u003d\u003d 0) (ֆակտորային \u003d 1; ընդմիջում;) ֆակտորային \u003d ֆակտորիա / հաշվիչ; counter \u003d counter +; ՓԱՍՏԱԹՂԹԵՐ .ԳՈՐԾԱՐԱՐ (ֆակտորիա);

      var counter \u003d հուշում («Մուտքագրեք համարը»); var factorial \u003d 1; Document.write ("Factorial Number:" Counter +! \u003d "); Արա (եթե (counter \u003d\u003d 0) (ֆակտորային \u003d 1; ընդմիջում;) ֆակտորային \u003d ֆակտորիա / հաշվիչ; counter \u003d counter +; ՓԱՍՏԱԹՂԹԵՐ .ԳՈՐԾԱՐԱՐ (ֆակտորիա);


      JS 3_16 Առաջադրանք: Փոփոխեք ծրագիրը օգտվողի անունը մուտքագրելու մասին.

      Հարցրեք օգտագործողի անունը, մինչեւ օգտագործողը իսկապես մտնի անունը (այսինքն, դաշտը իսկապես կլցվի, եւ Չեղարկման ստեղնը չի կարող սեղմվել): Երբ անունը մուտքագրվում է, ապա ելք «Բարեւ, անուն»:, Փաստաթուղթ:

      Ինչպես որոնել javaScript- ում սխալներ:

      Որոշ դեպքերում էջում գտնվող ծածկագիրը չի գործում անհասկանալի, ինչի համար: Որտեղ սխալ փնտրել: Նման դեպքերում դուք կարող եք կիրառել փորձը..Կատիկ հայտարարությունը:

      Փորձը ..Catch օպերատորը փորձում է կատարել կոդի բեկոր, եւ եթե կոդի մեջ սխալ կա, ապա հնարավոր է էկրանին սխալ տալ:
      Սխալը պահվում է E.MESSage օբյեկտում:

      Դիտարկենք օպերատորի աշխատանքը `օգտագործելով օրինակ.

      Օրինակ: Ծրագրում գրեք սխալի օպերատոր: Ստուգեք սխալի առկայությունը ենթադրյալ սխալ կոդով. Եթե օրենսգրքի սխալը առկա է. Հաղորդագրություն թողարկեք «Սխալների մշակում. Սխալ անուն», Սխալ գործող օպերատորը ստուգելուց հետո, անկախ նրանից, թե օրենսգրքի սխալ կա, հաղորդագրություն է թողարկում «Հարդարման գործողություններ»


      ✍ լուծում.
      • Որպես սխալով հաղորդագրություն, մենք օգտագործում ենք արագ () մեթոդը, որը գրված է սխալով. pROMT (), Սխալ հաղորդագրության կցորդը փորձի մեջ.

        • Ահազանգ («to»); Փորձեք (PROMT («Մուտքագրեք համարը»); // օպերատորը սխալով)

        Փորձեք անգլերենով: - «Փորձում», այսպիսով, մենք փորձի օպերատորը դնում ենք կոդի բեկորների դիմաց, որը, թերեւս, սխալ է պարունակում (մեր դեպքում, իսկապես սխալ կա):

      • Սխալի ծանուցման հաղորդագրությունը պետք է տեղադրվի Catch Block- ում.
        • 6 7 8 9 Catch (E) (ազդանշան ( "Սխալների մշակում."+ E.message); )

        catch (E) (Alert ("Սխալ մշակում." E.MESSAGE);)

        Եթե \u200b\u200bսխալն իսկապես այնտեղ է, ապա բռնել հայտարարությունը (անգլերենից: Catch- ը) խնայում է այս սխալը E օբյեկտում: Ապագայում այն \u200b\u200bկարող է ցուցադրվել E.MESSAGE երկխոսության վանդակում:

      • Վերջնական հաղորդագրությունը, որը պետք է լինի արտադրանքի, անկախ այն բանից, թե արդյոք սխալը օրենսգրքում է, այն վերջապես արգելափակեք.

        • Վերջապես (ահազանգ («Վերջնական գործողություններ»);) ահազանգ («հետո»);

        Եթե \u200b\u200bդեռեւս սխալ կա, ապա թարգմանիչը մեր օրինակով իր արդյունքից հետո կուղղվի բռնի բլոկի կատարմանը, ապա վերջապես (վերջապես »), որը միշտ կավարտվի Սխալը եղել է, թե ոչ: Նույնիսկ եթե սխալ է տեղի ունենում բռնի բլոկում:

      Կարեւոր է. Վերջապես դիզայնի բլոկը պարտադիր չէ:


      JS 3_17 Առաջադրանք: Կատարեք վերեւից նկարագրված օրինակ, հետեւյալ փոփոխություններով.

    2. Հեռացրեք վերջապես բլոկը եւ հետեւեք կոդի կատարմանը:
    3. Սխալ օպերատորի փոխարեն անթույլատրելիորեն դրեք եւ տեսեք, թե որն է արդյունքը:

      4. Ամփոփում.

      Դասը նկարագրեց հետեւյալ JavaScript Լեզուների օպերատորները եւ դիզայնը.

      JavaScript պայմանական օպերատորներ.

    4. Եթե \u200b\u200bօպերատորը
    5. Պայմանական նշանակություն (Ternary օպերատոր)
    6. Անջատիչ անջատիչ օպերատոր

      7. Cycle օպերատորներ.

    7. Ցիկլ
    8. Մինչ ցիկլը
    9. Ցիկլը ... մինչդեռ
    10. Ցիկլը ... in

      11. Վերջնական առաջադրանք JS 3_18:
      Ստեղծեք խաղ երկուի համար.

      1. Ծրագիրը խնդրում է առաջին խաղացողին մուտք գործել մի շարք 1 նախքան 100 (Երկրորդ նվագարկիչը չի տեսնում մուտքագրման համարը): Երկրորդ խաղացողը այնուհետեւ խնդրում է գուշակել մուտքագրված համարը: Ի պատասխան հաղորդագրություն է ցուցադրվում: «Քիչ» կամ «ԼՈՏ» Կախված պատասխանը մուտքագրվածից: Եթե \u200b\u200bխաղացողը կռահում է, - ցուցադրվում է շնորհավորանք: Եթե \u200b\u200bոչ գուշակություն. Խաղը շարունակվում է (մինչեւ համարը գուշակվի):
      2. Հաշվարկեք փորձերի քանակը եւ հանեք արդյունքը, երբ համարը լուծվի:


      Հարցեր ինքնատիրապետման համար.

      1. Որ դեպքերում խորհուրդ է տրվում օգտագործել ցիկլում: Անվանեք դրա օգտագործման օրինակ:
      2. Որն է փորձի նպատակը:
      3. Բացատրեք յուրաքանչյուր փորձելու համար:
      Բովանդակություն

      JavaScript- ը աջակցում է օպերատորների կոմպակտ հավաքածու, որը կարող է օգտագործվել ինտերակտիվ վեբ էջեր ստեղծելու համար: Այս գլխում ներկայացված է այս օպերատորների ակնարկ:

      Այս գլխում կա հետեւյալ բաժինները, որոնք ապահովում են յուրաքանչյուր օպերատորի համառոտ նկարագիրը.

      • Օպերատորների բլոկ. { }
      • Պայմանական օպերատորներ. Եթե \u200b\u200b... այլապես մի քանազոր Տեղավորել
      • Cycle օպերատորներ. Որովհետեւ, մինչդեռ, արեք ... Մինչդեռ, պիտակ, կոտրեք եւ շարունակեք (Պիտակ Ինքնին ցիկլի օպերատոր չէ, բայց հաճախ օգտագործվում է նշված օպերատորների հետ)
      • Մանիպուլյացիայի օպերատորներ օբյեկտներով. Համար ... in մի քանազոր Հետ
      • Մեկնաբանություններ
      • Բացառության բեռնաթափման օպերատորներ. Փորձեք ... բռնել: մի քանազոր Նետել
      Expression անկացած արտահայտություն նույնպես օպերատոր է: Տես Գլուխ 3-ը «Արտահայտություններ եւ գործառնություններ» բաժնում ամբողջական տեղեկատվություն գործողությունների մասին:

      Օգտագործեք անջատիչ կետի խորհրդանիշը (;) `օպերատորներին` JavaScript կոդում առանձին:

      Տեսեք JavaScript Core Book- ը: Տեղեկատու: Մանրամասներ այս գլխից օպերատորների մասին:

      1. Օպերատորների բլոկ

      Օպերատորի միավորը օգտագործվում է խմբային օպերատորներին: Բլոկը սահմանափակվում է պատկերված փակագծերով.

      (Հայտարարություն 1 հայտարարություն 2 ... Հայտարարություն)

      2. Պայմանական օպերատորներ

      Պայմանական օպերատորը հրամաններ է, որոնք կատարվում են, եթե նշված պայմանը Ճիշտ., JavaScript- ը աջակցում է երկու պայմանական օպերատորների. Եթե \u200b\u200b... այլապես մի քանազոր Տեղավորել.

      2.1. Եթե \u200b\u200b... այլ օպերատոր

      Այս օպերատորը օգտագործվում է որոշակի օպերատորներ կատարելու համար, եթե տրամաբանական պայման է Ճիշտ.; Օգտագործեք կամընտիր բլոկ Այլապես կատարել այլ օպերատորներ, եթե պայմանը կեղծ, Եթե \u200b\u200bօպերատորը այսպիսին է.

      եթե (պայման) [այլ (պետություններ 2)]

      Վիճակը կարող է լինել ցանկացած JavaScript արտահայտություն, որը հաշվարկվում է Ճիշտ. կամ կեղծ, Կատարված օպերատորները կարող են լինել ցանկացած JavaScript օպերատորներ, ներառյալ բույնի օպերատորները եթե, Եթե \u200b\u200bանհրաժեշտ է կատարել ավելի քան մեկ օպերատոր օպերատորներից հետո եթե կամ ԱյլապեսԴուք պետք է եզրակացնեք այս օպերատորները, որոնք կատարվում են գանգուր փակագծերում ():

      Պայմանական օպերատորում պետք չէ օգտագործել պարզ առաջադրանքներ: Օրինակ, մի օգտագործեք այս ծածկագիրը.

      Եթե \u200b\u200bՁեզ անհրաժեշտ է առաջադրանքը օգտագործել պայմանական օպերատորում, մուտքագրեք լրացուցիչ փակագծեր հանձնարարականի գործողության շուրջ: Օրինակ, Եթե \u200b\u200b((x \u003d y)).

      Մի շփոթեք պրիմիտիվ Բուլյան:-Նշում Ճիշտ. մի քանազոր կեղծ Արժեքներով Ճիշտ. մի քանազոր կեղծ Օբյեկտ Բուլյան:, Ցանկացած առարկա, որի արժեքը չէ չսահմանված., ԴԱՏԱՐԿ, զրո., ** nan ** կամ դատարկ լար, ներառյալ օբյեկտ Բուլյան: իմաստով կեղծ, հաշվարկվում է Ճիշտ.Երբ փոխանցվում է պայմանական օպերատորին: Օրինակ:

      var b \u003d նոր բուլյան (կեղծ); Եթե \u200b\u200b(բ) // Այս պայմանը հաշվարկվում է իրականում

      Օրինակ.

      Այս օրինակում գործառույթը checkdata. Վերադարձը Ճիշտ.Եթե \u200b\u200bնիշերի քանակը Տեքստ:- ACK հավասար է երեքին. Հակառակ դեպքում ցուցադրում է նախազգուշացում եւ վերադառնում կեղծ.

      Գործառույթի ստուգում () (եթե (փաստաթուղթ. Form1: Threghl. Մուտքագրեք ուղիղ երեք կառույցներ:«+ Փաստաթուղթ: Ձեւ 1. THELE. Արժեք +» վավեր չէ: ") Վերադարձ կեղծ))

      2.2. Անջատիչ օպերատոր

      Օպերատոր Տեղավորել Թույլ է տալիս ծրագիրը հաշվարկել արտահայտությունը եւ փորձել համեմատել գործի նշանի մեջ արտահայտման արժեքի արժեքը: Եթե \u200b\u200bպատահում է զուգադիպությունը, ծրագիրը կատարում է հարակից օպերատոր: Օպերատոր Տեղավորել Կարծես թե այդպիսին է.

      Անջատիչ (արտահայտություն) (դեպքի պիտակ, հայտարարություն; ընդմիջում; դեպքի պիտակ, հայտարարություն; ... լռելյայն, հայտարարություն;

      Ծրագիրը նախ փնտրում է Պիտակզուգադիպող ԱրտահայտությունԵւ ապա կատարում է հարակից հայտարարություն / օպերատոր: Եթե \u200b\u200bզուգադիպությունը Պիտակ չի գտնվել, ծրագիրը ընտրովի է փնտրում Լռելյայն: Հայտարարություն/ Լռելյայն հայտարարություն, եւ եթե այն գտնվի, կատարում է հարակից օպերատոր: Եթե Լռելյայն: Հայտարարություն Չի գտնվել, ծրագիրը շարունակում է օպերատորը կատարել օպերատորի ավարտից հետո Տեղավորել.

      Ընտրովի օպերատոր Ընդմիջումբեմադրում Գործ Պիտակ, ապահովում է, որ ծրագիրը կխանգարի օպերատորի կատարումը ՏեղավորելՀենց գտնված զուգադիպությունը կատարվում է, եւ կշարունակի կատարել օպերատորի հետեւից անցնող օպերատորից Տեղավորել, Եթե Ընդմիջում Բացակայող, ծրագիրը շարունակում է իրականացնել հաջորդ օպերատորը օպերատորի ներսում Տեղավորել.

      Օրինակ.

      Այստեղ, եթե Նախկրթրություն Այն հաշվարկվում է «Բանան» -ում, ծրագիրը համընկնում է «բանան» գործով եւ կատարում է հարակից օպերատոր: Եթե \u200b\u200bկոտրումը հայտնաբերվի, ծրագիրը ընդհատում է Տեղավորել եւ իրականացնում է օպերատորը օպերատորի բլոկից հետո Տեղավորել, Եթե Ընդմիջում Բացակա, օպերատոր Գործ Կատարվեն նաեւ «կեռաս»:

      Անջատիչ (Expr) («Նարնջեր» գործ. Փաստաթուղթ: Գրեք (" Նարինջը 0,59 դոլար է:
      "); Ընդմիջում; գործը« խնձոր ». Փաստաթուղթ: Գրեք (« Խնձորները 0,32 դոլար են:
      "); Ընդմիջում; գործը« բանան ». Փաստաթուղթ: Գրեք (" Բանանները 0,48 դոլար են:
      «); Ընդմիջում;« կեռաս »գործ. Փաստաթուղթ: Գրեք (" Կեռասը 3,00 դոլար է:
      "); Ընդմիջում; լռելյայն. Փաստաթուղթ: Գրեք (" կներեք, մենք դուրս ենք գալիս "+ I +" - ից ":
      ");) Փաստաթուղթ: Գրեք (" Կա որեւէ այլ բան, որ դու դուր ես գալիս:
      " ) ;

      3. Cycle օպերատորներ

      Ցիկլ / Հանգույց Սա օպերատորների մի շարք է, որը կատարվում է մի քանի անգամ, մինչ նշված պայմանը: JavaScript- ը աջակցում է ցիկլային օպերատորներին Համար, Անել ... մինչ մի քանազոր Մինչդեռ, Ինչպես նաեւ Պիտակ (Պիտակ Ինքնին ցիկլի օպերատոր չէ, բայց հաճախ օգտագործվում է նշված օպերատորների հետ): Բացի այդ, դուք կարող եք օգտագործել օպերատորներ Ընդմիջում մի քանազոր Շարունակել. Ցիկլերի օպերատորների ներսում:

      Մեկ այլ ցիկլի օպերատոր, Համար ... inԿատարում է նաեւ իր օպերատորները ցիկլորեն, բայց նախկինում աշխատում էր օբյեկտների հետ: Տես մանիպուլյացիայի օպերատորների օպերատորները:

      3.1. Օպերատոր

      Ցիկլ Համար կրկնվում է այնքան ժամանակ, որքան նշված արժեքը կեղծ, JavaScript ցիկլ Համար Կարծես ցիկլեր Համար Java եւ C. օպերատոր Համար Կարծես թե այդպիսին է.

      Որովհետեւ ([itiacexpression]; [Վիճակը]; [asprementexpression]) (պետություններ)

      Երբ ցիկլը Համար Կատարվել է, հետեւում է.

      1. Նախաձեռնող արտահայտություն նախաձեռնությունԵթե \u200b\u200bառկա է կատարվում: Այս արտահայտությունը սովորաբար նախաձեռնում է մեկ կամ մի քանի ցիկլի հաշվիչ, եւ շարահյուսությունը թույլ է տալիս ցանկացած բարդության արտահայտություններ: Այս արտահայտությունը կարող է նաեւ փոփոխականներ հայտարարել:


      2. Հաշվարկվում է պայման / պայմանական արտահայտություն: Եթե \u200b\u200bարժեքը Վիճակը - ճշմարիտ է:, Հայտարարությունները / ցիկլի օպերատորները կատարվում են: Եթե \u200b\u200bարժեքը Վիճակը - կեղծ, ցիկլ Համար Դադարեցնում է աշխատանքը: Եթե \u200b\u200bարտահայտություն Վիճակ Լրիվ բացակայում է, որ ենթադրվում է, որ Վիճակը - ճշմարիտ է:


      3. կատարել Հայտարարություններ:


      4. Արտահայտման արդիականացում Աճում է:Եթե \u200b\u200bառկա է, կատարված եւ վերահսկողությունը վերադառնում է 2-րդ քայլին:


      Օրինակ.

      Այս հատկությունը պարունակում է օպերատոր Համարորը հաշվում է ընտրված ընտրանքների քանակը պտտվող ցուցակում (առարկա Ընտրելթույլ տալով ընտրել մի քանի դիրքեր): Օպերատոր Համար Հայտարարում է փոփոխական Ես Եւ նախաձեռնում է այն զրոյի: Նա ավելի քիչ է ստուգում Ես Օբեկտների ընտրանքներ Ընտրել, իրականացնում է օպերատորին եթե Եւ փոփոխականի աճը Ես ցիկլի յուրաքանչյուր անցումից հետո մեկ միավոր:

      Ընտրեք երաժշտական \u200b\u200bորոշ տեսակներ, ապա կտտացրեք ստորեւ նշված կոճակը.

      «Alert (" Ընտրված ընտրանքների քանակը. "HowMen (Document.selectform.musictypes)">

      3.2. Օպերատորը անում է ... մինչդեռ

      Օպերատոր Անել ... մինչ կրկնել է նշված արտահայտությունը - Կեղծ. Օպերատոր Անել ... մինչ Կարծես թե այդպիսին է.

      Անել (հայտարարություն) մինչ (պայման)

      Հայտարարություն Կատարվում է մեկ անգամ, նախքան վիճակը / վիճակը ստուգելը: Եթե Վիճակը - ճշմարիտ է:Օպերատորը կրկին կատարվում է: Յուրաքանչյուր կատարման ավարտին Վիճակ Ստուգվում. Եթե Վիճակը - կեղծԿատարման դադարեցումը եւ վերահսկողությունը փոխանցվում է օպերատորին հետո Անել ... մինչ.

      Օրինակ.

      Այս օրինակում ցիկլում արա Նյութը առնվազն մեկ անգամ եւ կրկնում է այն ժամանակաշրջանում Ես ավելի քիչ 5 .

      Արա (i + \u003d 1; փաստաթուղթ: Գրեք (i);) մինչ (ես< 5 ) ;

      3.3. Անիվի օպերատոր

      Օպերատոր Մինչդեռ կատարում է իր օպերատորները, մինչ նշված վիճակը / պայմանը - Ճիշտ., Օպերատոր Մինչդեռ Կարծես թե այդպիսին է.

      Մինչդեռ (պայման)

      Եթե Վիճակ դառնալ կեղծCycle իկլերի ներսում օպերատորները դադարեցնում են վազքը, եւ վերահսկողությունը փոխանցվում է օպերատորին, ցիկլից հետո հաջորդը:

      Պայմաններ. Պայմանները / պայմանը տեղի են ունենում նախքան օպերատորները կատարվում են ցիկլի ներսում: Եթե Վիճակ Վերադարձը Ճիշտ., օպերատորները մահապատժի են ենթարկվում եւ Վիճակ Կրկին ստուգվեց: Եթե \u200b\u200bվիճակը վերադառնա կեղծCitycle կանգառների դադարեցումը եւ վերահսկողությունը փոխանցվում է օպերատորին, օպերատորի հետեւից գնալու համար Մինչդեռ.

      Օրինակ 1.

      Այս ցիկլը Մինչդեռ Իրեր, մինչ այժմ Ն. ավելի քիչ 3 :

      n \u003d 0; x \u003d 0; Մինչդեռ (N.< 3 ) { n ++; x += n ; }

      Յուրաքանչյուր կրկնությամբ, ցիկլը մեծանում է Ն. եւ այս արժեքն ավելացնում է փոփոխականին x., Հետեւաբար, x. մի քանազոր Ն. Վերցրեք հետեւյալ արժեքները.

      • Առաջին հատվածից հետո. n \u003d 1 եւ x \u003d 1
      • Երկրորդ հատվածից հետո. n \u003d 2 եւ x \u003d 3
      • Երրորդ հատվածից հետո. n \u003d 3 եւ x \u003d 6
      Ցիկլի երեք փոխանցումն ավարտելուց հետո Վիճակ Ն.< 3 Այլեւս ճշմարիտ չէ, ուստի ցիկլի կատարումը ընդհատվում է:

      Օրինակ 2. Անսահմանային ցիկլ:

      Համոզվեք, որ ցիկլի վիճակը մի օր է կեղծ; Հակառակ դեպքում, ցիկլը երբեք չի ընդհատվի: Հաջորդ ցիկլի օպերատորները Մինչդեռ կատարվում են անսահման, քանի որ պայմանը երբեք չի լինի կեղծ:

      Մինչդեռ (ճշմարիտ) (Alert («Բարեւ, աշխարհ»))

      3.4. Պիտակների օպերատոր

      Օպերատոր Պիտակ Այն նույնականացում է, որին կարող եք դիմել ծրագրի ցանկացած վայր: Օրինակ, կարող եք օգտագործել Պիտակ Anc իկլը հայտնաբերելու համար, ապա օգտագործեք օպերատորներ Ընդմիջում կամ Շարունակել. Ցիկլը ընդհատելու կամ կատարումը շարունակելու համար:

      Syntax օպերատոր Պիտակ Կարծես թե այդպիսին է.

      Պիտակ, հայտարարություն

      Իմաստ Պիտակ Կարող է լինել ցանկացած հավատարիմ JavaScript նույնացուցիչ, որը վերապահված բառ չէ: Օպերատոր / Հայտարարություն նույնականացված Պիտակկարող է լինել ցանկացած օպերատոր:

      Օրինակ.

      Այս օրինակում Պիտակ Մարկլոպ: նույնացնում է ցիկլը Մինչդեռ.

      markLoop. Մինչ (themark \u003d\u003d ճշմարիտ) դոզան (); )

      3.5. Օպերատորի ընդմիջում

      Օգտագործեք օպերատորը Ընդմիջում Ցիկլերը ընդհատելու համար Տեղավորել կամ օպերատորը պիտակավորված է Պիտակ.
      • Եթե \u200b\u200bօգտագործում եք Ընդմիջում առանց Պիտակ, նա անմիջապես ընդհատում է ամենամոտը Մինչդեռ, անել, Համար կամ Տեղավորել եւ վերահսկում է հաջորդ օպերատորին:
      • Եթե \u200b\u200bօգտագործում եք Ընդմիջում դեպի Պիտակ, Այն ընդհատում է նշված նշված օպերատորը:
      Syntax օպերատոր Ընդմիջում Նման.

      մեկը Ընդմիջում 2: Break Label

      Առաջին տարբերակը ընդհատում է մոտակա ցիկլը կամ Տեղավորել; Երկրորդ տարբերակը ընդհատում է պիտակը ունեցող նշված օպերատորը:

      Օրինակ.

      Itteration- ը իրականացվում է զանգվածի տարրերի վրա, մինչեւ տարրի ինդեքսը գտնվի արժեքով Արժեք.:

      համար (i \u003d 0; i< a . length ; i ++ ) { if (a [ i ] = theValue ) break ; }

      3.6. Շարունակեք օպերատորը

      Օպերատոր Շարունակել. Օգտագործվում է օպերատորները վերագործարկելու համար Մինչդեռ, անել, Համար մի քանազոր Պիտակ.
      • Եթե \u200b\u200bօգտագործում եք Շարունակել. առանց Պիտակ, դա ընդհատում է մոտակա ցիկլի ներկայիս կրկնությունը Մինչդեռ, արեք-մինչ կամ Համար Եւ շարունակում է կատարել այս ցիկլը հաջորդ կրկնությամբ: Ի տարբերություն օպերատորի Ընդմիջում, շարունակեք: Ամբողջովին չի ընդհատում ցիկլի կատարումը: Ցիկլում Մինչդեռ Նա շարունակվում է Վիճակ, Ցիկլի համար Աճյունադրություն.
      • Եթե \u200b\u200bօգտագործեք շարունակեք Պիտակ, դա վերաբերում է ցիկլի օպերատորին Պիտակ.
      Syntax օպերատոր Շարունակել. Նման.

      մեկը Շարունակեք 2-ը: Շարունակեք պիտակը

      Օրինակ 1.

      Սա ցիկլերի օրինակ է Մինչդեռ Օպերատորի հետ Շարունակել.որը կատարվում է, եթե արժեքը Ես հավասարապես 3 , Այս կերպ, Ն. Ստանում է 1, 3, 7 եւ 12 արժեքներ:

      i \u003d 0; n \u003d 0; Մինչդեռ (ես< 5 ) { i ++; if (i == 3 ) continue ; n += i ; }

      Օրինակ 2.

      Օպերատորը նման է checkiandj., պարունակում է օպերատոր, որը նշված է որպես checkj., Եթե \u200b\u200bհայտնաբերվել է Շարունակել., ծրագիրը ընդհատում է ընթացիկ կրկնությունը checkj. Եւ սկսում է հաջորդ կրկնությունը: Ամեն անգամ, երբ շարունակվում է, checkj. նորից սկսում է կրկնությունը, մինչեւ իր վիճակը վերադառնա կեղծ, Եթե \u200b\u200bվերադարձվի կեղծ, իրականացվում է օպերատորի մնացած մասը checkiandj. մի քանազոր checkiandj. Պահանջում է, քանի դեռ նրա վիճակը կվերադառնա կեղծ: Եթե \u200b\u200bվերադառնա կեղծ, ծրագիրը շարունակվում է իրականացնել օպերատորից հետո հաջորդից հետո checkiandj..

      Եթե \u200b\u200bշարունակվի Պիտակ համար checkiandj.Ծրագիրը կշարունակի ելույթ ունենալ օպերատորի սկզբից checkiandj..

      Ստուգում. Մինչդեռ (ես< 4 ) { document . write (i + "
      «); i + \u003d 1; checkj. Մինչ (j\u003e 4) (փաստաթուղթ. գրել (J +"
      "); j - \u003d 1; եթե ((j% 2) \u003d\u003d 0) շարունակեք ստուգումը; փաստաթուղթը: Գրեք (J +" -ը տարօրինակ է:
      «);) Փաստաթուղթ: Գրեք (" I \u003d "+ I +"
      «); Փաստաթուղթ: Գրեք (" j \u003d "+ J +"
      " ) ; }

      4. Օպերատորների մանիպուլյացիայի օբյեկտներ

      JavaScript- ը օգտագործում է օպերատորները Համար ... in մի քանազոր Հետ Օբյեկտները շահարկելու համար:

      4.1. Օպերատոր ... in

      Օպերատոր Համար ... in Iztering նշում է նշված փոփոխականը օբյեկտի բոլոր հատկություններում: Յուրաքանչյուր ձեռք բերված JavaScript գույքի համար կատարում է նշված օպերատորները: Օպերատոր Համար ... in Կարծես թե այդպիսին է.

      Համար (օբյեկտի փոփոխական) (

      Օրինակ.

      Այս հատկությունը որպես փաստարկ է վերցնում օբյեկտի եւ օբյեկտի անունը: Այնուհետեւ այն բնութագրվում է այս օբյեկտի բոլոր հատկություններով եւ վերադարձնում է տողը `հատկությունների ցանկը եւ դրանց արժեքները:

      Գործառույթի աղբանոց (OBJ, OBJ_Name) (var արդյունք \u003d ""; համար (var i inbj- ում) (Արդյունք + \u003d obj_name + ":
      ") Արդյունք + \u003d"

      "; Վերադարձի արդյունքը;)

      Օբյեկտի համար Ավտոմեքենա հատկություններով Դարձնել մի քանազոր Մոդել Արդյունքը նման կլինի.

      Մեքենա: Make \u003d Ford Car. Մոդել \u003d Mustang:

      4.2. Օպերատոր

      Օպերատոր Հետ Սահմանում է լռելյայն օբյեկտը օպերատորի բլոկի հավաքածուի համար: JavaScript- ը Unqualified անունները դիտում է օպերատորի բլոկում եւ որոշում է, թե անունները հանդիսանում են կանխադրված օբյեկտի հատկություններ: Եթե \u200b\u200bորակավորված անունը սեփականություն է, ապա այս գույքը օգտագործվում է օպերատորում. Հակառակ դեպքում օգտագործվում է տեղական կամ գլոբալ փոփոխական:

      Օպերատորով այսպիսին է.

      (Օբյեկտի) հետ (պետություններ)

      Օրինակ.

      Ահա օպերատորը Հետ Նշում է, որ օբյեկտը Մաթեմատիկա. Դա լռելյայն օբյեկտ է: Օպերատորից հետո օպերատորները վերաբերում են գույքին Քերեն եւ մեթոդներին cos. մի քանազոր Մեղք: Առանց օբյեկտի նշելու: JavaScript- ը ընդունում է օբյեկտը Մաթեմատիկա. որպես առարկա այս կոչերի համար:

      var a, x, y ;; var r \u003d 10 with (մաթեմատիկա) (a \u003d pi * r * r; x \u003d r * cos (pi); y \u003d r * sin (pi / 2);)

      Նշում:

      Օպերատորի միջոցով օգտագործելը կարող է զգալիորեն դանդաղեցնել ծրագրի կատարումը:

      5. Մեկնաբանություններ

      Մեկնաբանությունները, որպես կանոն, բացատրում են օրենսգրքով կատարված գործողությունները: Մեկնաբանությունները անտեսվում են թարգմանչի կողմից: JavaScript- ը աջակցում է Java- ին եւ C ++ մեկնաբանություններին.
      • Մեկ գծի մեկնաբանություն `գծի սկզբում կրկնակի կտրատմամբ (//):
      • Բազմաֆունկցիոնալ մեկնաբանություն խորհրդանիշներով / * սկզբում եւ խորհրդանիշներով * / վերջում:
      Օրինակ.

      Ահա երկու մեկնաբանության օրինակ.

      // սա մեկ տող մեկնաբանություն է: / * Եվ սա բազմակողմանի է: Դա կարող է լինել ցանկացած երկարություն, եւ ամեն ինչ այստեղ կարող եք տեղադրել ցանկացած վայրում: * /

      6. Կատարման վերամշակման օպերատորներ

      Դուք կարող եք բացառություն առաջացնել օպերատորին Նետել եւ կարգավորել այն օպերատորների կողմից Փորձեք ... բռնել:.

      Օպերատոր Փորձեք ... բռնել: Այն օգտագործվում է նաեւ Java- ի բացառությունները կարգավորելու համար: Տես «Java բացառության գործընթացը JavaScript» - ում եւ «JavaScript Exception- ի վերամշակումը Java- ում»:

      6.1. Նետել օպերատորը

      Օպերատոր Նետել Օգտագործվում էր բացառություն կանչելու համար: Եթե \u200b\u200bբացառություն եք անվանում, նշում եք բացառության արժեքը պարունակող արտահայտություն.

      Նետեք արտահայտություն

      Հետեւյալ ծածկագիրը առաջացնում է մի քանի բացառություններ:

      Նետեք «ERROR2»; // արտադրում է բացառություն լարային արժեքովՆետել 42; // արտադրում է բացառություն 42 արժեքովՆետեք ճշմարիտ; // ստեղծում է բացառություն ճշմարիտ

      Բացառություն կանչելիս կարող եք օբյեկտ նշել: Այնուհետեւ կարող եք դիմել բլոկում օբյեկտի հատկություններին: Բռնել, Հետեւյալ օրինակը ստեղծում է առարկա mYUESERException Տիպ USERException եւ օգտագործում է այն օպերատորում Նետել.

      // ստեղծել օբյեկտի տեսակը USERExceptionԳործառույթ USERException (սա. Հաղորդագրություն \u003d հաղորդագրություն; սա) name \u003d "userexception";) // ստեղծել օբյեկտի օրինակmyuserexception \u003d նոր USERException («արժեքը չափազանց բարձր»); Նետեք myuserexception;

      6.2. Փորձեք ... բռնել օպերատորը

      Օպերատոր Փորձեք ... բռնել: Նշում է օպերատորի բլոկը, փորձելով կատարել դրանք եւ սահմանել մեկ կամ մի քանի պատասխան տարբերակներ, երբ բացառություն է առաջանում: Եթե \u200b\u200bբացառություն է տեղի ունեցել, օպերատորը Փորձեք ... բռնել: հոգ է տանում նրան:

      Օպերատոր Փորձեք ... բռնել: Բաղկացած է դաշից Փորձեքորոնք պարունակում են մեկ կամ մի քանի օպերատորներ, եւ զրո կամ ավելի բլոկներ Բռնելպարունակում է օպերատորներ, որոնք նշում են գործողությունները բլոկում բացառություն զանգահարելիս Փորձեք, Այսինքն, եթե ուզում եք կատարել բլոկը Փորձեք Եվ դա չի իրականացվում, դուք վերահսկում եք բլոկին Բռնել, Եթե \u200b\u200bորեւէ բլոկ օպերատոր Փորձեք (կամ բլոկից առաջացած օպերատորի գործառույթը) Փորձեք) Բացառություն է առաջացնում, կառավարումը անմիջապես փոխանցվում է բլոկին: Բռնել, Եթե \u200b\u200bբացառությունը չի առաջացել, բլոկը Բռնել բաց թողեց: Արգելք Վերջապես Կատարվել է արգելափակելուց հետո Փորձեք մի քանազոր ԲռնելԲայց նախքան օպերատորը կատարելը, որն անցնում է օպերատորի բլոկից հետո Փորձեք ... բռնել:.

      Հետեւյալ օրինակը օգտագործում է օպերատորը Փորձեք ... բռնել:, Զանգահարվում է գործառույթ, որը պահանջում է ամսվա անվանումը զանգվածից, հիմնվելով գործառույթով փոխանցված արժեքի վրա: Եթե \u200b\u200bարժեքը չի համապատասխանում ամսվա քանակին (1-12), բացառություն է առաջանում արժեքի պատճառով «InvalidMonthno» Բլոկ օպերատորներ Բռնել Սահմանեք փոփոխական B. monhname. արժեք «Անհայտ»:

      function GetMonthname (Mo) (Mo \u003d MO - 1; // Զտել զանգվածի ինդեքսում ամսվա քանակը (1 \u003d Jan, 12 \u003d դեկտեմբեր)vAR ամիսներ \u003d Նոր զանգված («Jan ան», «Փետր», «Ապրիլ», «Հնարավոր», «Հուլիս», «Հոկտեմբեր», «Հոկտեմբեր», «Դեկտեմբեր»); Եթե \u200b\u200b(ամիսներ [mo]! \u003d Null) (վերադարձի ամիսներ [Mo]) այլ (նետեք «InvalidMonthno»)) փորձեք ( // Այս օպերատորներին կատարելու փորձ.Ամսվա \u003d getmonthname (Mymonth) // գործառույթը կարող է բացառություն առաջացնել) Բռնել (ե) (ամսական \u003d "Անհայտ" LogMyErrors (ե) // Բացառություն պատճառած օբյեկտը փոխանցվում է բացառության բեռնաթափմամբ}

      Նետել; Հաշմանդամների մասին տեղեկատվություն ստանալու համար կարող եք օգտագործել այս նույնականացումը: JavaScript- ը բլոկ մուտք գործելիս ստեղծում է այս նույնականացումը Բռնել; Նույնականացումը գոյություն ունի միայն կատարման ժամանակահատվածում Բռնել; Բլոկի կատարումը կատարելուց հետո Բռնել Նույնացուցիչն այլեւս հասանելի չէ:

      Օրինակ, հետեւյալ ծածկագիրը բացառություն է առաջացնում: Եթե \u200b\u200bբացառություն է լինում, վերահսկումը փոխանցվում է բլոկին Բռնել.

      Փորձեք (նետեք «myexception» // Բացառություն է ստեղծվում) Բռնել (ե) ( // օպերատորներ `ցանկացած բացառություն մշակելու համարlogMyErrors (ե) // Բացառությունը փոխանցվում է սխալի վարիչին}

      Բազմաթիվ բռնել բլոկներ

      Միակ օպերատոր Փորձեք Կարող է պարունակել մի քանի պայմանական բլոկներ ԲռնելԴրանցից յուրաքանչյուրը մշակում է բացառության որոշակի տեսակ: Այս դեպքում համապատասխան պայմանական բլոկի մուտքը Բռնել Այն իրականացվում է միայն այս բլոկի համար սահմանված բացառություն զանգահարելիս: Կարող եք նաեւ ընտրել առանձին միավոր: Բռնել Բոլոր չճանաչված բացառությունների համար, որպես վերջնական բլոկ Բռնել օպերատորում:

      Օրինակ, հետեւյալ գործառույթը առաջացնում է եւս երեք գործառույթ (հայտարարված այլուր), որոնք ստուգում են դրա փաստարկները: Եթե \u200b\u200bթեստային գործառույթը որոշում է, որ ստուգված բաղադրիչը սխալ է, այն վերադարձնում է 0-ը, ստիպելով զանգահարելու գործառույթը որոշակի բացառություն կանչելու համար:

      Գործառույթ GetCustinfo (անուն, ID, էլ. Փոստ) (var n, i, e; եթե (! Valiate_Name (Անունը)) նետում է «ԱնվավերNameException» Ene n \u003d name ; Եթե (! Վարժապետ_Էներգիա (էլ. Փոստ)) նետեք «InvalideMailException» Else E \u003d էլ. Փոստ.

      Պայմանական բլոկներ Բռնել Կառավարեք զանգը համապատասխան բացառության վարիչին:
      " ) { // զանգում է սխալ ID- ների / նույնացուցիչների բեռնափոխադրողինbad_ID_HANDLER (E)) CATCH (EF IF E \u003d\u003d "InvalideMailException") ( // առաջացնում է սխալ էլփոստի հասցեների բեռնաթափումbad_Email_handler (E)) Catch (E) ( // Unquanciful Exception- ը գրանցվում է Log ֆայլումlogerror (E))

      Վերջապես միավոր

      Վերջապես բլոկը պարունակում է օպերատորներ, որոնք կատարվում են արգելափակումից հետո Փորձեք մի քանազոր Բռնել, բայց նախքան օպերատորի հետեւից օպերատորները կատարելը Փորձեք ... բռնել:, Արգելք Վերջապես Այն իրականացվում է, անկախ նրանից, թե արդյոք բացառություն է առաջացել: Եթե \u200b\u200bբացառությունը կոչվում է, բլոկ օպերատորներ Վերջապես կատարվում են նույնիսկ եթե բլոկ չկա Բռնել բացառություն չէի անցել:

      Դուք կարող եք օգտագործել բլոկը Վերջապես Սցենարի ճիշտ ավարտի համար, երբ բացառություն է լինում. Օրինակ, գուցե հարկ լինի ազատվել ռեսուրսը, որը կապված է սցենարի հետ: Հաջորդ օրինակում ֆայլը բացվում է, եւ օպերատորները դրա հետ աշխատում են (սերվեր JavaScript- ը թույլ է տալիս մուտք գործել ֆայլեր): Եթե \u200b\u200bբացառություն է կանչվում բաց ֆայլի, բլոկի հետ Վերջապես Փակում է ֆայլը նախքան սցենարը ձախողվի:

      Բացիրֆիլ (); Փորձեք (WritemyFile (Themeda)) վերջապես (փակվում է () // ռեսուրսը միշտ փակում է}

      Օպերատորների տեղադրումը փորձեք ... բռնել

      Կարող եք ներդնել մեկ կամ մի քանի օպերատորներ: Փորձեք ... բռնել: միմյանց. Եթե \u200b\u200bներքին օպերատորը Փորձեք ... բռնել: Չունի դաշինք ԲռնելՊատահականությունը ստուգված բլոկ է Բռնել պարունակում է այն օպերատոր Փորձեք ... բռնել:

    • Նմանատիպ հոդվածներ