Merge pull request #129 from galenteryan/specials

JavaScript specials

Author: galenteryan

1-js/02-first-steps/18-javascript-specials/article.md

@@ -1,10 +1,10 @@
 # JavaScript-ի հատկանիշները
 
-Այս գլխում, հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս:
+Այս գլխում՝ հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի այն առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս:
 
 ## Կոդի կառուցվածք
 
-Հայտարարությունները տարանջատվում են կետ-ստորակետով.
+Դրույթները տարանջատվում են կետ-ստորակետով.
 
 ```js run no-beautify
 alert('Ողջույն'); alert('Աշխարհ');
@@ -25,21 +25,21 @@ alert("Այս հաղորդագրությունից հետո սխալ կլինի:
 [1, 2].forEach(alert)
 ```
 
-Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր հայտարարությունից հետո:
+Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր դրույթից հետո:
 
-Կոդերի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է.
+Կոդի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է.
 
 ```js
 function f() {
-  // կետ-ստորակետ պետք չէ ֆունկցիայի հայտարարումից հետո
+  // կետ-ստորակետ պետք չէ ֆունկցիոնալ հռչակագրից հետո
 }
 
 for(;;) {
   // կետ-ստորակետ պետք չէ ցիկլից հետո
 }
 ```
 
-...Սակայն, եթե մենք «ավելնորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի:
+...Սակայն, եթե մենք «ավելորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի:
 
 Մանրամասն՝ <info:structure>.
 
@@ -55,64 +55,64 @@ for(;;) {
 
 Այդ ցուցումը պետք է լինի սքրիփթի սկզբում կամ ֆունկցիայի մարմնի սկզբում:
 
-Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք կնախընտրեինք ժամանակակից վարքագիծը:
+Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք կնախընտրենք ժամանակակից վարքագիծը:
 
-Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք պետք է սովորենք հետագայում) լռեցյալ ակտիվացնում են խիստ ռեժիմը։
+Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք կսովորենք հետագայում) անուղղակիորեն ակտիվացնում են խիստ ռեժիմը։
 
 Ավելին՝ <info:strict-mode>։
 
 ## Փոփոխականներ
 
-Կարող ենք հայտարարել, օգտագործելով․
+Կարող են հռչակվել՝ օգտագործելով․
 
 - `let`
 - `const` (հաստատուն, չի կարող փոփոխվել)
 - `var` (հին ոճ, կդիտարկենք ավելի ուշ)
 
-Փոփոխականի անվանումը կարող է ներառել․
+Փոփոխականի անվանումը կարող է պարունակել․
 - Տառեր և թվեր, բայց առաջին նիշը չի կարող լինել թիվ:
 - `$` և `_` նիշերը նորմալ են, համարժեք են տառերին։
 - Թույլատրվում են նաև ոչ լատինական այբուբեններ և հիերոգլիֆներ, բայց սովորաբար չեն օգտագործվում:
 
-Փոփոխականները տեսակավորվում են դինամիկ կերպով և կարող են պահել ցանկացած արժեք.
+Փոփոխականները տիպավորվում են դինամիկ կերպով և կարող են պահել ցանկացած արժեք.
 
 ```js
 let x = 5;
 x = "Պողոս";
 ```
 
-Տվյալների 8 տեսակ կա.
+Տվյալների 8 տիպեր կան.
 
 - `number` ինչպես կոտորակային, այնպես էլ ամբողջ թվերի համար,
 - `bigint` կամայական երկարություն ունեցող ամբողջ թվերի համար,
 - `string` տողերի համար,
 - `boolean` տրամաբանական արժեքների համար՝ `true/false`,
-- `null` -- մեկ արժեք ունեցող տեսակ՝ `null`, նշանակում է «դատարկ» կամ «գոյություն չունի»,
-- `undefined` -- մեկ արժեք ունեցող տեսակ՝ `undefined`, նշանակում է «չնշված»,
-- `object` և `symbol` -- բարդ տվյալների կառուցվածքների և յուրահատուկ նույնացուցիչների համար, մենք դեռ չենք սովորել դրանք։
+- `null` մեկ արժեք ունեցող տեսակ՝ `null`, նշանակում է «դատարկ» կամ «գոյություն չունեցող»,
+- `undefined` մեկ արժեք ունեցող տեսակ՝ `undefined`, նշանակում է «չսահմանված»,
+- `object` և `symbol` բարդ տվյալների կառուցվածքների և ունիկալ նույնականացուցիչների համար. մենք դեռ չենք սովորել դրանք։
 
 `typeof` օպերատորը վերադարձնում է արժեքի տեսակը երկու բացառությամբ.
 ```js
 typeof null == "object" // սխալ լեզվում
-typeof function(){} == "function" // ֆունկցիաները վերարտադրվում են առանձնահատուկ կերպով
+typeof function(){} == "function" // ֆունկցիաները մշակվում են առանձնահատուկ կերպով
 ```
 
 Ավելին՝ <info:variables> և <info:types>։
 
 ## Փոխազդեցություն
 
-Մենք բրաուզերն ենք օգտագործում որպես աշխատանքային միջավայր, ուստի UI-ի (օգտվողի ինտերֆեյս) հիմնական ֆունկցիաները կլինեն.
+Մենք բրաուզերն ենք օգտագործում որպես աշխատանքային միջավայր, ուստի UI-ի (օգտատիրոջ ինտերֆեյս) հիմնական ֆունկցիաները կլինեն.
 
 [`prompt(question, [default])`](mdn:api/Window/prompt)
-: Հարց է տալիս `question`, այնուհետև վերադարձնում է այն, ինչ մուտքագրել է այցելուն կամ՝ `null`, եթե այցելուն սեղմել է «Cancel»:
+: Հարց է տալիս `question`, այնուհետև վերադարձնում է այն, ինչ մուտքագրել է այցելուն կամ `null`, եթե այցելուն սեղմել է «Cancel»:
 
 [`confirm(question)`](mdn:api/Window/confirm)
 : Հարց է տալիս `question` և առաջարկում ընտրություն կատարել՝ «Ok» կամ «Cancel». Ընտրությունը վերադարձվում է որպես `true/false`։
 
 [`alert(message)`](mdn:api/Window/alert)
-: Ցուցադրում է հաղորդագրություն `message`։
+: Արտատպում է հաղորդագրություն `message`։
 
-Բոլոր այս ֆունկցիաները *մոդալ* են, նրանք դադարեցնում են կոդի կատարումը և թույլ չեն տալիս այցելուներին փոխազդեցություն ունենալ էջի հետ, մինչև նրանք չպատասխանեն։
+Բոլոր այս ֆունկցիաները *modal* են, նրանք դադարեցնում են կոդի գործարկումը և թույլ չեն տալիս այցելուներին փոխազդեցություն ունենալ էջի հետ, մինչև նրանք «չպատասխանեն»։
 
 Օրինակ.
 
@@ -133,43 +133,43 @@ JavaScript-ը սպասարկում է հետևյալ օպերատորները.
 Թվաբանական
 : Կանոնավոր՝ `* + - /`, նաև `%` մնացորդի համար և `**` աստիճան բարձրացնելու համար։
 
-    Բինար գումարումը `+` միացնում է տողերը։ Եթե օպերանդներից մեկը տող է, մյուսը նույնպես վերածվում է տողի․
+    Բինար գումարումը `+` միացնում է տողերը։ ԵՎ եթե օպերանդներից մեկը տող է, մյուսը նույնպես փոխակերպվում է տողի․
 
     ```js run
     alert( '1' + 2 ); // '12', տող
     alert( 1 + '2' ); // '12', տող
     ```
 
 Վերագրում
-: Կա պարզ վերագրում `a = b` և համակցված վերագրում `a *= 2`։
+: Կա պարզ վերագրում՝ `a = b`, և համակցված վերագրում՝ `a *= 2`։
 
 Բիթային
-: Բիթային օպերատորները աշխատում են 32-բիթ ամբողջ թվերի հետ ամենացածր՝ բիթային մակարդակում. տեսեք [docs](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise)-ում, երբ դրա կարիքը լինի:
+: Բիթային օպերատորները աշխատում են 32-բիթ ամբողջ թվերի հետ ամենացածր՝ բիթային մակարդակում. տեսեք [դոկումենտացիան](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise)-ում, երբ դրա կարիքը լինի:
 
 Պայմանական
 : Միակ օպերատորը երեք պարամետրով՝ `cond ? resultA : resultB`։ Եթե `cond` պայմանը ճշմարիտ է, վերադարձվում է `resultA`, հակառակ դեպքում՝ `resultB`։
 
 Տրամաբանական օպերատորներ
-: Տրամաբանական ԵՎ `&&` ու ԿԱՄ `||` օպերատորները իրականացնում են «կարճ միացման» արժեվորում, այնուհետև վերադարձնում են արժեք՝ որտեղ կանգ են առել (պարտադիր չէ `true`/`false`). Տրամաբանական ՈՉ `!` կերպափոխում է օպերանդը տրամաբանական տեսակի և վերադարձնում է հակառակ արժեքը։
+: Տրամաբանական ԵՎ `&&` ու ԿԱՄ `||` օպերատորները իրականացնում են «կարճ միացման» արժեվորում, այնուհետև վերադարձնում են արժեք՝ որտեղ կանգ են առել (պարտադիր չէ `true`/`false`). Տրամաբանական ՈՉ `!` վերածում է օպերանդը տրամաբանական տեսակի և վերադարձնում հակառակ արժեքը։
 
 Զրոյական միավորման օպերատոր
 : `??` օպերատորը փոփոխականների ցանկից հատկանշված արժեքի ընտրության հնարավորություն է տալիս: `a ?? b`-ի արդյունքը կլինի `a`, եթե այն `null/undefined` չէ, հակառակ դեպքում՝ `b`:
 
 Համեմատություններ
-: հավասարության ստուգումը `==` տարբեր տեսակի արժեքների դեպքում նրանց կերպափոխում է թվի (բացի `null` և `undefined` տեսակներից, որոնք միայն իրար կարող են հավասար լինել), այսպիսով սրանք հավասար են.
+: հավասարության ստուգումը `==` տարբեր տիպերի արժեքների դեպքում նրանց փոխակերպում է թվի (բացի `null` և `undefined` տիպերից, որոնք միայն իրար կարող են հավասար լինել), այսպիսով սրանք հավասար են.
 
     ```js run
     alert( 0 == false ); // true
     alert( 0 == '' ); // true
     ```
 
-    Այլ համեմատությունները նույնպես արժեքները կերպափոխում են թվի:
+    Այլ համեմատությունները նույնպես արժեքները փոխակերպում են թվի:
 
-    Խիստ հավասարության օպերատորը `===` չի կատարում կերպափոխում․ նրա համար տարբեր տեսակները միշտ ունեն տարբեր արժեքների նշանակությունը։
+    Խիստ հավասարության օպերատորը `===` չի կատարում փոխակերպում․ նրա համար տարբեր տիպերը միշտ ունեն տարբեր արժեքների նշանակություն։
 
-    `null` և `undefined` արժեքները հատուկ են․ նրանք հավասար են `==` իրար և ուրիշ ոչնչի հավասար չեն։
+    `null` և `undefined` արժեքները հատուկ են․ նրանք հավասար են `==` իրար և ուրիշ ոչինչի հավասար չեն։
 
-    Մեծ/փոքր համեմատությունները տողերին համեմատում են նիշ-առ-շիշ, մյուս տեսակներին կերպափոխվում են թվի։
+    Մեծ/փոքր համեմատությունները տողերին համեմատում են նիշ-առ-շիշ, մյուս տիպերը փոխակերպվում են թվի։
 
 Այլ օպերատորներ
 : Կա մի քանի ալյ օպերատոր, օր․՝ ստորակետի օպերատորը։
@@ -197,7 +197,7 @@ JavaScript-ը սպասարկում է հետևյալ օպերատորները.
     }
     ```
 
-- `for(let...)` ցիկլում հայտարարված փոփոխականը հասանելի է միայն ցիկլի ներսում։ Բայց մենք կարող ենք նաև բաց թողնել `let`-ը և կրկին օգտագործել արդեն իսկ գոյություն ունեցող փոփոխականը:
+- `for(let...)` ցիկլում հռչակված փոփոխականը հասանելի է միայն ցիկլի ներսում։ Բայց մենք կարող ենք նաև բաց թողնել `let`-ը և կրկին օգտագործել արդեն իսկ գոյություն ունեցող փոփոխականը:
 - `break/continue` հրահանգները թույլ են տալիս դուրս գալ ամբողջ ցիկլից/ընթացիկ կրկնությունից: Օգտագործեք պիտակներ ներդրված ցիկլները կանգնեցնելու համար։
 
 Մանրամասն՝ <info:while-for>։
@@ -206,7 +206,7 @@ JavaScript-ը սպասարկում է հետևյալ օպերատորները.
 
 ## Կոնստրուկցիա «switch»
 
-կոնստրուկցիա «switch»-ը կարող է փոխարինել մի քանի `if` ստուգումներ. Համեմատությունների ժամանակ այն օգտագործում է `===` խիստ հավասարման օպերատորը։
+«switch» կոնստրուկցիան կարող է փոխարինել մի քանի `if` ստուգումների. Համեմատությունների ժամանակ այն օգտագործում է `===` խիստ հավասարման օպերատորը։
 
 Օրինակ՝
 
@@ -223,7 +223,7 @@ switch (age) {
     break;
 
   default:
-    alert("Ցանկացած արժեք՝ վերոնշյալներին ոչ հավասար");
+    alert("Վերոնշյալներին ոչ հավասար ցանկացած արժեք");
 }
 ```
 
@@ -233,7 +233,7 @@ switch (age) {
 
 Մենք դիտարկեցինք JavaScript-ում ֆունկցիաներ ստեղծելու երեք տարբերակ․
 
-1. Function Declaration -- ֆունկցիան հիմնական կոդի հոսքում․
+1. Ֆունկցիոնալ Հռչակագիր (Function Declaration). ֆունկցիան հիմնական կոդի հոսքում․
 
     ```js
     function sum(a, b) {
@@ -243,7 +243,7 @@ switch (age) {
     }
     ```
 
-2. Function Expression -- ֆունկցիան արտահայտության համատեքստում․
+2. Ֆունկցիոնալ Արտահայտություն (Function Expression). ֆունկցիան արտահայտության համատեքստում․
 
     ```js
     let sum = function(a, b) {
@@ -253,7 +253,7 @@ switch (age) {
     };
     ```
 
-3. Սլաքով ֆունկցիաներ․
+3. Սլաքով ֆունկցիաներ (arrow functions)․
 
     ```js
     // արտահայտությունն աջ կողմում է
@@ -273,9 +273,9 @@ switch (age) {
     ```
 
 
-- Ֆունկցիաները կարող են ունենալ տեղական (local) փոփոխականներ․ դրանք հայտարարվում են իրենց մարմնի ներսում կամ պարամետրերի ցանկում. Նման փոփոխականները հասանելի են միայն ֆունկցիայի ներսում:
+- Ֆունկցիաները կարող են ունենալ տեղական (local) փոփոխականներ․ դրանք հայտարարվում են իրենց մարմնի ներսում կամ պարամետրերի ցանկում: Նման փոփոխականները հասանելի են միայն ֆունկցիայի ներսում:
 - Պարամետրերը կարող են ունենալ նախնական արժեք․ `function sum(a = 1, b = 2) {...}`։
-- Ֆունկցիաները միշտ ինչ-որ բան են վերադարձնում. եթե չկա `return` հայտարարությունը, ապա արդյունքը `undefined` է։
+- Ֆունկցիաները միշտ ինչ-որ բան են վերադարձնում. եթե չկա `return` դրույթը, ապա արդյունքը `undefined` է։
 
 Մանրամասն՝ <info:function-basics>, <info:arrow-functions-basics>։