JavaScript - Պայմանական և տրամաբանական օպերատորներ: Պայմանական հայտարարություն if else Javascript-ի սղագրությունը if-ի համար

JavaScript-ն ունի պայմանական կառուցվածք, որն ազդում է ծրագրի կատարման վրա: Եթե ​​(անգլերենով, եթե) ինչ-որ բան գոյություն ունի, ինչ-որ բան ճիշտ է, ապա մի բան արեք, հակառակ դեպքում (անգլերենում՝ else)՝ այլ բան արեք:

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

Եկեք անմիջապես նայենք, թե ինչպես է աշխատում if հայտարարությունը, այն պարզ է և շատ բացատրություն չի պահանջում:

Եթե ​​(պայման) (կոդ՝ գործարկելու համար, եթե պայմանը ճշմարիտ է)

Դա պարզ է՝ եթե պայմանը ճշմարիտ է, ապա (...) բլոկի կոդը գործարկվում է։

Var թվանշան = 4; if (նիշ == 4) ( document.write ("Փոփոխական թվանշանի արժեքը 4 է"); )

Դուք կարող եք մի փոքր տարօրինակ ծածկագիր կազմել.

Var թվանշան = 4; if (true) (document.write («Պայմանը ճշմարիտ է»); )

այլ հայտարարություն

else հայտարարությունը կարող է օգտագործվել if դրույթի հետ միասին: Այն թարգմանվում է որպես «այլապես» և նշում է այլընտրանքային ծածկագիր:

Var թվանշան = 4; եթե (նիշ

Ուշադրություն դարձրեք այս օրինակի գանգուր փակագծերի տարբեր ուղղագրությանը if և else հայտարարությունների համար: Ամենևին պետք չէ այսպես գրել, երկու շարահյուսությունները ճիշտ են։

Հայտարարությունից հետո ուրիշը կարող է գնալ նոր հրահանգներեթե. Սա կստուգի բազմաթիվ պայմաններ:

Var թվանշան = 4; եթե (նիշ

JavaScript-ը չունի elseif հայտարարություն (մեկ բառով), ինչպես PHP-ն ունի:

Եթե ​​Ձեզ անհրաժեշտ է միայն մեկ հայտարարություն կատարել, ապա արգելափակել գանգուր փակագծերը (...) անհրաժեշտ չեն: Մեր օրինակում դուք պետք չէ գրել դրանք.

Var թվանշան = 4; եթե (նիշ

Սխալ է JavaScript-ում

if (condition) հայտարարությունը գնահատում և փոխակերպում է փակագծերում դրված պայմանը (արտահայտությունը) բուլյան տիպի (true կամ false):

Կրկնենք, որ JavaScript-ում սուտ կա.

• Թիվ 0 (զրո):
• Դատարկ տող «»:
• Բուլյան արժեքը false :)
• Արժեքը զրոյական է:
• Արժեքն անորոշ է:
• Արժեքը NaN է (ոչ թիվ):

Մնացած ամեն ինչ ճիշտ է։

Մի քանի հնարավոր սխալներ.

If ("false") document.write("Սա ճիշտ է:
"); if (false) document.write ("Սա ճիշտ է:

");

Այստեղ դուք պետք է տարբերեք «false» տողը (կցված չակերտների մեջ) բուլյան false արժեքից:

If (" ") document.write("Սա ճիշտ է:
"); else document.write("Սա կեղծ է:
");

Այստեղ դուք պետք է տարբերեք « » տողը (ներսում բացատ) դատարկ տողից: Տողի ներսում բացատը դարձնում է ոչ դատարկ, այլ նիշ պարունակող: Թարգմանչի համար տառը կամ տարածությունը նշանակություն չունի՝ նիշը նիշ է:

JavaScript-ի այլ պայմանական պայմաններ

• JavaScript անջատիչի կառուցում:
• Օպերատորի հարցական նշան

Այս հոդվածում մենք կանդրադառնանք JavaScript լեզվի պայմանական և տրամաբանական օպերատորներին:

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

Պայմանական հայտարարություններ JavaScript (ECMAScript) օպերատորներ են, որոնք, կախված որոշ պայմաններից, թույլ են տալիս կատարել մեկ կամ մի քանի հատուկ հրահանգներ:

JavaScript-ում պայմանական հայտարարությունների ձևերը.

• պայմանական եթե հայտարարություն (մեկ ճյուղով);
• պայմանական հայտարարություն if...else (երկու ճյուղով);
• պայմանական հայտարարություն else if... (մի քանի ճյուղերով);
• եռակի օպերատոր (?: );
• անջատիչի ընտրության հայտարարություն.

Պայմանական եթե հայտարարություն

if դրույթի շարահյուսությունը հետևյալն է.

Եթե ​​(պայմանի) հայտարարություն

Պայմանական օպերատորեթե բաղկացած է.

• հիմնաբառեթե ;
• պայմաններ (փակագծերում դրված արտահայտություններ), որոնք պետք է գնահատվեն ճշմարիտ կամ սխալ (կամ տրվեն այս արժեքներից մեկին).
• հրահանգներ, որոնք պետք է հետևեն, եթե պայմանը ճշմարիտ է կամ դրված է դրան:

Օրինակ:

Եթե ​​(ճշմարիտ) հաշվարկ = 4;

Այս օրինակն օգտագործում է true որպես պայման: Սա նշանակում է, որ հրահանգների քանակը = 4 միշտ կկատարվի: Այս օրինակըՊարզապես տրված է if դրույթի գործողության սկզբունքը բացատրելու համար, քանի որ այն զուրկ է որևէ իմաստից։

Օրինակ՝ ձայների փոփոխականի արժեքը մեծացնենք 1-ով, եթե այն (նրա տեսակը) թիվ է.

Եթե ​​(ձայների տեսակ === «թիվ») ձայներ++;

Եթե ​​մի քանի հրահանգներ պետք է կատարվեն, դրանք պետք է տեղադրվեն գանգուր փակագծերում.

If (ձայների տեսակ === «համար») ( votes++; console.log («Ձայների թիվը՝ « + ձայներ); )

Եթե ​​(ձայների տեսակ === «թիվ») (ձայներ++; )

Եթե ​​... այլ հայտարարություն

If...else հայտարարությունը օգտագործվում է, երբ անհրաժեշտ է կատարել որոշ հրահանգներ, եթե պայմանը ճիշտ է, իսկ մյուսները, եթե այն կեղծ է:

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

Եթե ​​(պայման) (մեկ կամ մի քանի հայտարարություն (կկատարվի, երբ պայմանը ճշմարիտ է կամ վերածվում է ճշմարիտի) ) else (մեկ կամ մի քանի հայտարարություն (կկատարվի, երբ պայմանը false է կամ կրճատվում է կեղծի) )

Օրինակ, եկեք հաղորդագրություն տպենք վահանակին, թե արդյոք թիվը զույգ է, թե ոչ.

If (համար % 2) ( console.log («Թիվը կենտ է»); ) else (consol.log («Թիվը զույգ է»); )

Պայմանները ճիշտ կամ կեղծ բերելու կանոն

Եթե ​​if-ի պայմանում արտահայտությունը ճշմարիտ կամ կեղծ չէ, ապա JavaScript-ը այն կփոխանցի այդ արժեքներից մեկին: Նա կատարում է այս գործողությունը՝ օգտագործելով այսպես կոչված «ստի կանոնը»։

Այս կանոնի իմաստը. ցանկացած արտահայտություն ճշմարիտ է, բացառությամբ հետևյալ արժեքների:

• կեղծ (կեղծ);
• «» կամ «» (դատարկ տող);
• NaN (հատուկ թվային տվյալների տեսակը «ոչ թիվ»);
• 0 (թիվ «զրո»);
• null («դատարկ» արժեք);
• undefined («չսահմանված» արժեք):

Օրինակ, եկեք ցուցադրենք ողջույնի հաղորդագրություն բրաուզերի վահանակում, կախված նրանից, թե ինչ արժեք է պահվում nameUser փոփոխականում.

If (nameUser) ( console.log ("Բարև, " + անուն + "!"); ) else ( console.log ("Բարև, հյուր!");

Եթե ​​nameUser փոփոխականը պարունակում է դատարկ տող, ապա ըստ ստի կանոնի, այն կփոխանցվի դեպի false արժեքը։ Հետևաբար, «Բարև, հյուր» հաղորդագրությունը կտպվի վահանակի վրա: .

Եվ եթե, օրինակ, nameUser փոփոխականը պարունակում է «Timur» տողը, ապա պայմանի արտահայտությունը կնվազեցվի ճիշտ արժեքի: Արդյունքում, վահանակը կցուցադրի «Բարև, Թիմուր» հաղորդագրությունը: .

ուրիշ, եթե... հայտարարություն (բազմաթիվ պայմաններ)

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

Եթե ​​(պայման 1) (հրահանգներ 1) else if (պայման 2) (հրահանգներ 2) else if (պայման 3) (հրահանգներ 3 //...) else if (պայման N) (հրահանգներ N) else (հրահանգներ, որոնք կկատարվեն, եթե ոչ մեկը պայմանները ճշմարիտ չեն կամ չեն իջեցվել այս արժեքին)

Պայմանական (եռակի) օպերատոր (?:)

Երրորդական օպերատոր– JavaScript օպերատոր, որը կարող է օգտագործվել, երբ անհրաժեշտ է, կախված պայմանից, կատարել երկու տրված արտահայտություններից մեկը:

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

Վիճակը? արտահայտություն 1. արտահայտություն 2

Եռյակային օպերատորը բաղկացած է երեք օպերանդներից, որոնք առանձնացված են սիմվոլների միջոցով: Եվ. Երրորդական օպերատորի վիճակը նշված է առաջին օպերանդում: Այն կարող է փակվել նաև փակագծերում: Եթե ​​պայմանը ճշմարիտ է կամ կնվազեցվի այս արժեքին, կկատարվի արտահայտություն1, հակառակ դեպքում՝ 2 արտահայտությունը:

Օրինակ:

(թիվ > 10) ? console.log("Թիվը 10-ից մեծ է!") : console.log("Թիվը փոքր է կամ հավասար է 10-ի");

JavaScript-ը թույլ է տալիս մի քանի եռակի օպերատորներ (?:):

Var dayNumber = new Date().getDay(); օր = (օրվահամար === 0) ? «Կիրակի». (օր Թիվ === 1) ? «Երկուշաբթի» : (օր Թիվ === 2) ? «Երեքշաբթի» : (օր Թիվ === 3) ? «Չորեքշաբթի» : (օր Թիվ === 4) ? «Հինգշաբթի» : (օր Թիվ === 5) ? «Ուրբաթ». (օր Թիվ === 6) ? «Շաբաթ»՝ «Շաբաթվա անհայտ օր»; console.log ("Այսօր " + day.toLowerCase() + ".");

Վերոնշյալ օրինակը, բայց օգտագործելով if...else հայտարարության բազմակի նշում.

Var dayNumber = new Date().getDay(); եթե (օր Թիվ === 0) (օր = «Կիրակի»; ) ուրիշ եթե (օր Թիվ === 1) (օր = «Երկուշաբթի»; else if (օրԹիվ === 3) (օր = «Չորեքշաբթի»; ) else if (օրԹիվ === 4) (օր = «Հինգշաբթի»; ) else if (օրԹիվ === 5) (օր = «Ուրբաթ»; ) else if (dayNumber === 6) (օր = "Շաբաթ"; ) else (օր = "Շաբաթվա անհայտ օր"; ) console.log("Today" + day.toLowerCase() + ".");

անջատիչ հայտարարություն

Switch հայտարարությունը նախատեսված է մի քանի հրահանգներից մեկը կատարելու համար՝ կախված արտահայտության արժեքից: Այս կամ այն ​​տարբերակի ընտրությունը որոշվում է արտահայտության արդյունքի խիստ հավասարությամբ գործի (գործի) արժեքին:

Փոխարկել հայտարարության շարահյուսությունը.

Անջատիչ (արտահայտություն) ( case value1: // ... հրահանգներ, որոնք կկատարվեն, եթե արտահայտության գնահատման արդյունքը լինի «value1» ընդմիջում; // կամընտիր հրահանգ (եթե չի օգտագործվում, կկատարվի switch-ի հայտարարության հաջորդ հրամանը ) case value2: // ... հրահանգներ, որոնք կկատարվեն, եթե արտահայտության գնահատման արդյունքը լինի «value2» break; // կամընտիր հրահանգ (եթե չօգտագործվի, կկատարվի անջատիչի օպերատորի հաջորդ հրամանը) // . .. case valueN․ // հրահանգներ, որոնք կկատարվեն, եթե արտահայտության արդյունքը հավասար չէ մեկից ավելի արժեքների)

Նախնական հիմնաբառը կամընտիր է: Այն օգտագործվում է, երբ դուք պետք է նշեք հրահանգներ, որոնք պետք է կատարվեն, եթե արտահայտության արդյունքը հավասար չէ գործի (case) որևէ արժեքի:

Ընդմիջման հայտարարությունը կամընտիր է: Այն նախագծված է ընդհատելու անջատիչի քաղվածքի կատարումը և փոխանցելու այն հրահանգը, որը գալիս է դրանից հետո:

Օրինակ, եկեք բրաուզերի վահանակում ցուցադրենք կոնֆետների քանակի մասին հաղորդագրություն.

Var countCandyBoys = 1, countCandyGirls = 2, հաղորդագրություն; անջատիչ (countCandyBoys + countCandyGirls) (պատյան 1. հաղորդագրություն = «Մեկ կոնֆետ»; ընդմիջում; դեպք 2. դեպք 3. հաղորդագրություն = «Երկու կամ երեք կոնֆետ»; ընդմիջում; դեպք 4. հաղորդագրություն = «Չորս կոնֆետ»; ընդմիջում; լռելյայն. message = "Ոչ մեկ, ոչ երկու, ոչ երեք կամ չորս կոնֆետ"; ) // տպել հաղորդագրություն կոնսոլի կոնսոլին.log(message);

Վերոնշյալ օրինակում գնահատված արտահայտությունը 3 է: Հետևաբար, հաղորդագրությունը = «Երկու կամ երեք կոնֆետ» և ընդմիջման հրահանգները կկատարվեն: Ընդմիջման հրահանգը կդադարեցնի անջատիչի հայտարարության հետագա կատարումը և կառավարումը կփոխանցի այն հրահանգին, որը գալիս է դրանից հետո, այսինքն. console.log(հաղորդագրություն) . Այն կցուցադրի հաղորդագրություն վահանակում «Երկու-երեք կոնֆետ».

Օրինակ, եկեք ցուցադրենք շաբաթվա ընթացիկ օրը վահանակում.

Վար օր = ""; switch(new Date().getDay()) ( case 0: day = "Sunday"; break; case 1: day = "Monday"; break; case 2: day = "Tuesday"; break; case 3: day = "Date"; «Չորեքշաբթի»; ընդմիջում; դեպք 4. օր = «հինգշաբթի», ընդմիջում; դեպք 5. օր = «ուրբաթ», ընդմիջում; դեպք 6. օր = «շաբաթ», ընդմիջում; լռելյայն. օր = «շաբաթվա անհայտ օր»: ;) console.log("Today" + day.toLowerCase() + ".");

Օրինակ, որը չի օգտագործում ընդմիջման հայտարարություն.

Var արդյունք = «հաջողություն»; անջատիչ (արդյունք) (գործի «հաջողություն»:

Այս օրինակում switch հայտարարության արտահայտությունը հաջողություն է: Հետևաբար, կկատարվի console.log («Հաջողություն») հայտարարությունը, որը կտպագրի «Հաջողություն» հաղորդագրությունը: կոնսոլին։ Բայց քանի որ դրանից հետո ընդմիջման հայտարարություն չկա, սցենարի կատարումը կշարունակվի հաջորդ տարբերակում։ Այսպիսով, հրահանգները կկատարվեն այնքան ժամանակ, մինչև ուղու վրա ընդմիջում չառաջանա կամ անջատիչի հայտարարության վերջը հասնի: Այս օրինակի գործարկման արդյունքում 3 հաղորդագրություն կուղարկվի վահանակ՝ «Հաջողություն»: , «Անվավեր captcha»:և «Սխալ»: .

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

Ուղղված օրինակ.

Var արդյունք = «հաջողություն»; անջատիչ (արդյունք) (պատյան «հաջողություն». );)

Տրամաբանական օպերատորներ

JavaScript-ը տարբերակում է հետևյալ տրամաբանական օպերատորները.

• && - տրամաբանական «ԵՎ»;
• || - տրամաբանական «OR»;
• ! - տրամաբանական «ՉԻ»:

Եթե ​​ներս տրամաբանական արտահայտություն operand1 && operand2-ը բուլյան արժեքներ են, ապա այս արտահայտության արդյունքը ճիշտ կլինի, եթե դրանցից յուրաքանչյուրը ճիշտ է: հակառակ դեպքում այս արտահայտության արժեքը կեղծ կլինի:

Կեղծ && կեղծ // կեղծ ճիշտ && կեղծ // կեղծ կեղծ && ճշմարիտ // կեղծ ճիշտ && ճշմարիտ // ճշմարիտ

Եթե ​​բուլյան արտահայտությունը operand1 && operand2 օգտագործում է ոչ բուլյան արժեքներ, ապա արտահայտության արդյունքը կլինի operand1, եթե այն կարող է փոխանցվել false-ի; հակառակ դեպքում այս արտահայտության արդյունքը կլինի operand2:

5 && 0 // 0 1 && 5 // 5 «գիծ» && չսահմանված // չսահմանված «տող1» && «տող2» // «տող2»

Եթե ​​տրամաբանական արտահայտության մեջ օպերանդ1 || operand2-ն օգտագործում է բուլյան արժեքներ, ապա այս արտահայտության արդյունքը կլինի ճշմարիտ, եթե դրանցից գոնե մեկը ճիշտ է. հակառակ դեպքում այս արտահայտության արժեքը կեղծ կլինի:

Սխալ || կեղծ // կեղծ ճշմարիտ || կեղծ // ճշմարիտ կեղծ || ճշմարիտ // ճշմարիտ ճշմարիտ || ճշմարիտ // ճշմարիտ

Եթե ​​տրամաբանական արտահայտության մեջ օպերանդ1 || operand2-ն օգտագործում է ոչ բուլյան արժեքներ, այս արտահայտության արդյունքը կլինի operand1, եթե այն կարող է փոխանցվել true; հակառակ դեպքում այս արտահայտության արդյունքը կլինի operand2:

5 || 0 // 5 1 || 5 // 1 «գիծ» || undefined // "string" "string1" || «տող2» // «տող1»

Բուլյան արտահայտությունը!operand1 կգնահատի true, եթե operand1-ը false է կամ կարող է տրվել այդ արժեքին; հակառակ դեպքում այս արտահայտության արդյունքը կեղծ կլինի:

Սխալ // ճշմարիտ !true // false !"string" // false !5 // false"

Պայմանական օպերատորթույլ է տալիս բաց թողնել կամ կատարել կոդի որոշակի բլոկ՝ կախված նշված արտահայտության՝ պայմանի հաշվարկման արդյունքից: Պայմանական հայտարարությունը, կարելի է ասել, որոշման կետ է ծրագրի մեջ, երբեմն այն կոչվում է նաև ճյուղային հայտարարություն: Եթե ​​պատկերացնեք, որ ծրագիրը ճանապարհ է, և PHP թարգմանիչ- ճանապարհորդը, որը քայլում է դրա երկայնքով, այնուհետև պայմանական հայտարարությունները կարելի է համարել որպես խաչմերուկներ, որտեղ ծրագրի կոդը ճյուղավորվում է երկու կամ ավելի ճանապարհների, և այդպիսի խաչմերուկներում թարգմանիչը պետք է ընտրի, թե որ ճանապարհն է հաջորդելու:

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

if հայտարարությունը ճյուղի հայտարարություններից ամենապարզն է:

if դրույթի շարահյուսությունը հետևյալն է.

if դրույթը նախ գնահատում է փակագծերում նշված պայմանական արտահայտությունը, որի արդյունքը բուլյան արժեք է։ Եթե ​​ստացված արդյունքը ճշմարիտ է, ապա հրահանգը կատարվում է։ Եթե ​​արտահայտությունը վերադարձնում է false, ապա հրահանգը չի կատարվում: Ցանկացած բարդության արտահայտություն կարող է օգտագործվել որպես պայման:

Եթե ​​if դրույթի մարմինը օգտագործում է միայն մեկ հրահանգ, ապա այն փակել գանգուր փակագծերում հնարավոր է, բայց ոչ անհրաժեշտ: Այնուամենայնիվ, եթե դուք պետք է կատարեք մեկից ավելի հրահանգներ if-ի տեքստում, ապա այս մի քանի հրահանգները պետք է փակվեն գանգուր փակագծերում: Խնդրում ենք նկատի ունենալ, որ փակվող գանգուր ամրացումից հետո չպետք է լինի ստորակետ:

Հետևյալ կոդը ցույց է տալիս if դրույթի օգտագործումը.

Եթե ​​հայտարարությունները կարող են տեղադրվել այլ if հայտարարությունների մեջ.

ուշադրություն դարձնել վերջին օրինակըՊարտադիր չէ, որ հրահանգը գրվի հենց if դրույթի տակ, եթե հրահանգը չափի մեծ չէ, ապա այն կարելի է գրել մեկ տողով։

եթե ուրիշ հայտարարություն

Եվ այսպես, մենք իմացանք, որ if հայտարարությունը թույլ է տալիս կատարել հրահանգներ, եթե պայմանը ճշմարիտ է: Եթե ​​պայմանը կեղծ է, ապա ոչ մի գործողություն չի կատարվում։ Այնուամենայնիվ, հաճախ անհրաժեշտ է կատարել որոշակի հրահանգներ, եթե որոշակի պայմանը ճիշտ է, և այլ հրահանգներ, եթե պայմանը կեղծ է: Հենց նման դեպքերի համար է, որ եթե ուրիշ ճյուղավորում է օգտագործվում։ Այն բաղկացած է if դրույթից, որին հաջորդում է հայտարարությունների բլոկն ու else բանալի բառը, որին հաջորդում է հայտարարությունների մեկ այլ բլոկի:

if else հայտարարության շարահյուսությունը հետևյալն է.

Another հայտարարությունը կամընտիր է: Another-ից հետո տեղակայված հրահանգների բլոկը կատարվում է լռելյայն, այսինքն. երբ in if պայմանական արտահայտությունը վերադարձնում է false: else հայտարարությունը չի կարող օգտագործվել if դրույթից առանձին: else բլոկը պետք է հայտնվի միայն if հայտարարությունից հետո, այն կարելի է համարել լռելյայն գործողություն:

Մի փոքր փոփոխելով մեր նախորդ օրինակը, մենք կարող ենք տեսնել, թե ինչպես է աշխատում if else հայտարարությունը, եթե պայմանը վերադարձնում է false:

If else հայտարարությունը կարող է տեղադրվել: Նման ներդիր պայմանական հայտարարությունները գործնականում բավականին հաճախ են լինում: If դրույթը տեղադրված է, եթե այն տեղադրված է մեկ այլ if or else բլոկի ներսում: Եթե ​​ձեր կոդը անընդմեջ օգտագործում է բազմաթիվ if հայտարարություններ, մյուսը միշտ վերաբերում է ամենամոտին, եթե՝

Վերջին else-ը չի տարածվում if($a)-ի վրա, քանի որ այն ներառված չէ ներքին միավոր, ուստի դրան ամենամոտը if($i)-ն է: Բլոկի ներսում else հայտարարությունը կապված է if($b)-ի հետ, քանի որ սա if-ն ամենամոտն է դրան:

elseif/else if կառուցում

if/else հայտարարությունը գնահատում է պայմանական արտահայտության արժեքը և կատարում որոշակի հատված ծրագրի կոդը. Բայց ի՞նչ, եթե ձեզ անհրաժեշտ է կատարել բազմաթիվ բեկորներից մեկը: Եթե ​​Ձեզ անհրաժեշտ է անընդմեջ ստուգել մի քանի պայմաններ, ապա elseif-ը կամ եթե շինարարությունը հարմար է դրա համար (սա նույն կոնստրուկցիան է, պարզապես այլ կերպ է գրված): Ֆորմալ կերպով, դա անկախ PHP կոնստրուկտ չէ, դա պարզապես սովորական ծրագրավորման ոճ է, որը բաղկացած է կրկնվող if/else հայտարարություններից: Այն թույլ է տալիս ստուգել լրացուցիչ պայմանները, մինչև չգտնվի ճշմարիտը կամ չհասնի else բլոկը: elseif/else if կառուցումպետք է հայտնվի if դրույթից հետո և else հայտարարությունից առաջ, եթե այդպիսին կա:

Այստեղ ստուգվում է երեք պայման և, կախված $username փոփոխականի արժեքից, կատարվում են տարբեր գործողություններ։

Այս կտորում իսկապես առանձնահատուկ բան չկա: Այն պարզապես if հայտարարությունների հաջորդականություն է, որտեղ if յուրաքանչյուր դրույթը նախորդ if դրույթի else դրույթի մասն է: Նրանց համար, ովքեր առաջին անգամ են հանդիպել նշագրման այս ձևին և իրականում չեն հասկանում, թե ինչպես է այն աշխատում, մենք կվերագրենք նույն օրինակը, միայն համարժեք շարահյուսական ձևով, որն ամբողջությամբ ցույց է տալիս կառուցվածքների բույնը.

Այս ինտերակտիվ օրինակի աղբյուրը պահվում է GitHub պահեստում: Եթե ​​ցանկանում եք նպաստել ինտերակտիվ օրինակների նախագծում, խնդրում ենք կլոնավորել https://github.com/mdn/interactive-examples և ուղարկել մեզ հետաձգման հարցում:

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

if (condition) statement1 condition Արտահայտություն, որը համարվում է ճշմարտություն կամ կեղծ: հայտարարություն 1 Հայտարարություն, որը կատարվում է, եթե պայմանը ճշմարտացի է: Կարող է լինել ցանկացած հայտարարություն, ներառյալ հետագա ներդրված եթե հայտարարությունները: Բազմաթիվ հայտարարություններ կատարելու համար օգտագործեք բլոկի հայտարարություն (( ... ))՝ այդ հայտարարությունները խմբավորելու համար: Ոչ մի հայտարարություն չկատարելու համար օգտագործեք դատարկ հայտարարություն: statement2 Հայտարարություն, որը կատարվում է, եթե պայմանը false է, իսկ else դրույթը գոյություն ունի: Կարող է լինել ցանկացած հայտարարություն, ներառյալ բլոկների հայտարարությունները և հետագա ներկառուցված հայտարարությունները:

Նկարագրություն

Բազմաթիվ if...else հայտարարություններ կարող են տեղադրվել այլ if դրույթ ստեղծելու համար: Նշենք, որ JavaScript-ում elseif (մեկ բառով) հիմնաբառ չկա:

Եթե ​​(պայման 1) պնդում1 else if (պայման2) պնդում2 else if (պայման3) հայտարարությունը3 ... else հայտարարությունը N

Տեսնելու համար, թե ինչպես է սա աշխատում, այսպիսի տեսք կունենար, եթե բույնը պատշաճ կերպով կտրված լիներ.

Եթե ​​(պայման 1) դրույթ 1 այլ կերպ, եթե (պայման 2) հայտարարությունը2 այլ կերպ, եթե (պայման 3) ...

Մի դրույթի մեջ մի քանի հայտարարություններ կատարելու համար օգտագործեք բլոկային հայտարարություն ((...))՝ այդ հայտարարությունները խմբավորելու համար: Ընդհանուր առմամբ, լավ պրակտիկա է միշտ օգտագործել բլոկային հայտարարությունները, հատկապես կոդում, որը ներառում է nested if հայտարարություններ.

Եթե ​​(պայման) (հայտարարություններ 1 ) else (հայտարարություններ 2)

Մի շփոթեք բուլյան պարզունակ ճշմարիտ և կեղծ արժեքները բուլյան օբյեկտի ճշմարտացիության կամ կեղծիքի հետ: Ցանկացած արժեք, որը կեղծ չէ, չսահմանված, null, 0, -0, NaN կամ դատարկ տողը (""), և ցանկացած առարկա, ներառյալ բուլյան օբյեկտը, որի արժեքը false է, համարվում է ճշմարտացի, երբ օգտագործվում է որպես պայման: Օրինակ:

Var b = նոր բուլյան (կեղծ); եթե (բ) // այս պայմանը ճշմարտացի է

Օրինակներ

Օգտագործելով, եթե ... այլ կերպ

if (cipher_char === from_char) (արդյունք = արդյունք + to_char; x++;) այլ կերպ (արդյունք = արդյունք + clear_char;)

Օգտագործելով այլ կերպ, եթե

Նկատի ունեցեք, որ JavaScript-ում elseif շարահյուսություն չկա: Այնուամենայնիվ, դուք կարող եք այն գրել այլի միջև բացատով և եթե՝

Եթե ​​(x > 50) ( /* անել ճիշտը */ ) else if (x > 5) ( /* անել ճիշտը */ ) else ( /* անել ճիշտը */ )

Առաջադրանք պայմանական արտահայտության շրջանակներում

Ցանկալի է չօգտագործել պարզ հանձնարարություններ պայմանական արտահայտության մեջ, քանի որ հանձնարարությունը կարելի է շփոթել հավասարության հետ՝ ծածկագրի վրայից նայելիս: Օրինակ, մի օգտագործեք հետևյալ կոդը.

Եթե ​​(x = y) ( /* արեք ճիշտը */ )

Եթե քեզ պետք էԱռաջադրանքը պայմանական արտահայտության մեջ օգտագործելու համար սովորական պրակտիկա է հանձնարարության շուրջ լրացուցիչ փակագծեր դնելը: Օրինակ:

Եթե ​​((x = y)) ( /* արեք ճիշտը */ )

Տեխնիկական պայմաններ

Հստակեցում	Կարգավիճակ	Մեկնաբանություն
ECMAScript-ի վերջին սևագիր (ECMA-262)	Նախագիծ
ECMAScript 2015 (6-րդ հրատարակություն, ECMA-262) «եթե հայտարարության» սահմանումը այդ ճշգրտման մեջ:	Ստանդարտ
ECMAScript 5.1 (ECMA-262) «եթե հայտարարության» սահմանումը այդ ճշգրտման մեջ:	Ստանդարտ
ECMAScript 3-րդ հրատարակություն (ECMA-262) «եթե հայտարարության» սահմանումը այդ ճշգրտման մեջ:	Ստանդարտ
ECMAScript 1-ին հրատարակություն (ECMA-262) «եթե հայտարարության» սահմանումը այդ ճշգրտման մեջ:	Ստանդարտ	Նախնական սահմանում

Բրաուզերի համատեղելիություն

Այս էջի համատեղելիության աղյուսակը ստեղծվում է կառուցվածքային տվյալների հիման վրա: Եթե ​​ցանկանում եք նպաստել տվյալներին, խնդրում ենք ստուգել https://github.com/mdn/browser-compat-data և ուղարկել մեզ հետ կանչելու հարցում:

Թարմացրեք համատեղելիության տվյալները GitHub-ում

	Սեղան						Բջջային						Սերվեր
	Chrome	Եզր	Firefox	Internet Explorer	Օպերա	Սաֆարի	Android վեբ դիտում	Chrome Android-ի համար	Firefox Android-ի համար	Օպերա Android-ի համար	Safari iOS-ում	Samsung ինտերնետ	Node.js
եթե... ուրիշ	Chrome-ի ամբողջական աջակցություն 1	Edge Ամբողջական աջակցություն 12	Firefox-ի ամբողջական աջակցություն 1	IE Ամբողջական աջակցություն 3	Opera Ամբողջական աջակցություն Այո	Safari Ամբողջական աջակցություն Այո	WebView Android-ի ամբողջական աջակցություն 1	Chrome Android-ի ամբողջական աջակցություն 18	Firefox Android-ի ամբողջական աջակցություն 4	Opera Android Ամբողջական աջակցություն Այո	Safari iOS-ի ամբողջական աջակցություն Այո	Samsung Internet Android Ամբողջական աջակցություն 1.0	nodejs Ամբողջական աջակցություն Այո

IN Առօրյա կյանքՀաճախ անհրաժեշտ է լինում ինչ-որ որոշում կայացնել՝ կախված ինչ-որ պայմանից։ Օրինակ, եթե հանգստյան օրերին եղանակը տաք է, մենք կգնանք ծովափ, հակառակ դեպքում, եթե ամպամած է, կնստենք տանը։

Դա շատ հաճախ է պատահում նաև ծրագրավորման մեջ։ Դրա համար կան երկու պայմանական հայտարարություններ են՝ if-else և switch-case. Այս հոդվածում ես ձեզ կպատմեմ if-else օպերատորի մասին, իսկ հաջորդ հոդվածում՝ switch-case-ի մասին։

if-else պայմանական դրույթի շարահյուսությունհաջորդը՝

Եթե ​​պայմանը true է, ապա գործարկվում է if բլոկի կոդը, հակառակ դեպքում, եթե պայմանը false է, ապա կատարվում է else բլոկի կոդը:

Ավելի լավ հասկանալու համար բերենք մի այսպիսի պարզ օրինակ, մենք ունենք որոշակի գումար և ցանկանում ենք մեքենա գնել, և այստեղ անմիջապես առաջանում է հետևյալ պայմանը՝ եթե բավականաչափ գումար ունենք, ապա կարող ենք գնել այս մեքենան, այլապես մենք չի կարող.

Վար փող = 35000; // Ասենք ունենք 35000 եվրո // Մեքենան, որը ուզում ենք գնել, արժե 50000 եվրո։ Եվ առաջանում է հետևյալ պայմանը, եթե (money > 50000)( document.write(«Մենք կարող ենք մեքենա գնել»);

Մենք պահում ենք փաստաթուղթը, բացում այն ​​բրաուզերում և տեսնում ենք, որ էջում հայտնվում է հետևյալ հաղորդագրությունը. «Մեքենա գնելու համար գումար չկա»: Եթե ​​մենք ունենայինք ավելի քան 50,000 եվրո, ապա կկատարվեր if բլոկի կոդը: Եթե ​​մենք ունենայինք ուղիղ 50,000 եվրո, ապա մենք նույնպես չէինք կարողանա մեքենա գնել, քանի որ 50,000-ը 50,000-ից ավելի չէ: Որպեսզի այս դեպքում պայմանը ճիշտ լինի, պետք է ստորագրել ավելի մեծ կամ հավասար: (>=) .

Մեկնաբանություն Հավասարության տրամաբանական գործողությունը գրվում է երկու հավասար նշանով (==). Կա նաև տրամաբանական գործողություն՝ փոքր կամ հավասար (

օգտագործելով գանգուր braces

Եթե ​​կա միայն մեկ օպերատոր, ապա գանգուր բրեկետներ անհրաժեշտ չեն, եթե բլոկում մեկից ավելի օպերատոր կա, ապա գանգուր բրեկետներ են պահանջվում:

Վերևի օրինակը հիանալի կերպով կաշխատի առանց գանգուր փակագծերի, քանի որ երկու բլոկները պարունակում են միայն մեկ հայտարարություն:

Ներսում, եթե կարող եք գրել ցանկացած տրամաբանական գործողություններ , լինեն դրանք պարզ, թե բարդ։ Կարող եք նաև օգտագործել AND (&&) և OR (||) օպերատորները:

Մեկնաբանություն Another բլոկի առկայությունը պարտադիր չէ.

Օրինակ, եթե a-ն հավասար է b-ի, իսկ c-ն՝ d-ի, ապա ցուցադրում ենք համապատասխան հաղորդագրությունը, հակառակ դեպքում, եթե այլ բլոկ չկա, ապա ուղղակի անցնում ենք հաջորդ տողին։

Var a = 4, b = 4, c = 8, d = 8; if((a == b) && (c == d)) document.write("a-ն հավասար է b-ի ԵՎ c-ն հավասար է d-ին"); document.write («Կոդերի հաջորդ տողը»);

Եթե ​​- ուրիշ եթե - ուրիշ հայտարարություն

If բլոկից հետո կարող են լինել մեկ կամ մի քանի այլ if բլոկներ, իսկ վերջում՝ else բլոկ։ Սա օգտակար է, երբ անհրաժեշտ է օգտագործել մեկից ավելի պայման:

Ավելի լավ հասկանալու համար օրինակ վերցնենք առօրյայից։ Օրինակ, մենք ունենք որոշակի քանակությամբ վարդակներ: Եթե ​​սենյակում ունենք միայն մեկ վարդակ, ապա կարող ենք միացնել միայն մեկ սարք, եթե կան երկու վարդակներ, ապա կարող ենք միացնել երկու սարք, իսկ եթե ավելին են, ապա կարող ենք միացնել էլեկտրական ցանց, բոլոր սարքերը տանից։

Հիմա անցնենք ծրագրավորմանը։

Var socket = 2; // Տան վարդակների քանակը if(socket == 1)  document.write("

Մենք կարող ենք միացնել միայն մեկ սարք

"); else if(socket == 2)( document.write("

Մենք կարող ենք միացնել միայն երկու սարք

"); document.write("

Օրինակ հեռուստացույց և նոութբուք

"); )else( document.write("

Մենք կարող ենք միացնել բոլոր սարքերը՝ տանից մինչև էլեկտրական ցանց

"); }

Կախված socket փոփոխականի արժեքից, կաշխատի այս կամ այն ​​կոդի բլոկը: Ինչպես հավանաբար արդեն հասկացաք, եթե վարդակը հավասար է 1-ի, ապա կոդերի առաջին բլոկը կաշխատի: Եթե ​​վարդակը հավասար է 2-ի, ապա կոդի երկրորդ բլոկը կաշխատի, իսկ եթե վարդակն ունի որևէ այլ արժեք (նույնիսկ բացասական թիվ), ապա կաշխատի երրորդ կոդի բլոկը:

Սառճաբանություն՝ if else-ի համար

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

Օրինակ, եթե a փոփոխականի արժեքը մեծ է b փոփոխականի արժեքից, ապա x փոփոխականում մենք կգրենք հետևյալ հաղորդագրությունը՝ «a փոփոխականը մեծ է b փոփոխականից», հակառակ դեպքում կգրենք, որ «a փոփոխականը. b փոփոխականից պակաս»։

Var a = 50, b = 100, x; x = (ա > բ) ? «

Փոփոխական ա ավելինփոփոխական բ

" : "

Փոփոխական ա ավելի քիչփոփոխական բ

"; //Արդյունք ստացված արդյունքը document.write(x);

Դա այն ամենն է, ինչ ես ուզում էի ձեզ ասել այս հոդվածում: Պայմանական if-else հայտարարությունը օգտագործվում է մեկից ավելի ձևերով յուրաքանչյուր սցենարում, ուստի շատ կարևոր է այն իմանալ և հասկանալ: Հաջորդ հոդվածում ես ձեզ կպատմեմ մեկ այլ պայմանական օպերատորի անջատիչ դեպքի մասին: