diff --git a/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md b/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
index 209a0702c..cf9c62b9f 100644
--- a/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
+++ b/1-js/02-first-steps/08-operators/4-fix-prompt/solution.md
@@ -1,6 +1,6 @@
-The reason is that prompt returns user input as a string.
+Պատճառը այն է որ մուտքագրված թվերը վերդարձվում են որպես տող։
-So variables have values `"1"` and `"2"` respectively.
+Այսպիսով փոփոխականները ունեն `"1"` և `"2"` արժեքները։
```js run
let a = "1"; // prompt("First number?", 1);
@@ -9,9 +9,9 @@ let b = "2"; // prompt("Second number?", 2);
alert(a + b); // 12
```
-What we should do is to convert strings to numbers before `+`. For example, using `Number()` or prepending them with `+`.
+Այն, ինչ մենք պետք է անենք, տողերը թվեր փոխարկելն է `+`-ից առաջ։ Օրինակ՝ կիրառելով `Number()` կամ դնելով դիմացից `+`։
-For example, right before `prompt`:
+Օրինակ՝ `prompt`-ից անմիջապես առաջ:
```js run
let a = +prompt("First number?", 1);
@@ -20,7 +20,7 @@ let b = +prompt("Second number?", 2);
alert(a + b); // 3
```
-Or in the `alert`:
+Կամ `alert`-ի մեջ:
```js run
let a = prompt("First number?", 1);
@@ -29,4 +29,4 @@ let b = prompt("Second number?", 2);
alert(+a + +b); // 3
```
-Using both unary and binary `+` in the latest code. Looks funny, doesn't it?
+Կիրառվել են և ունար և բինար `+`վերջին կոդւոմ։ Հիանալի տեսք ունի, այդպես չէ՞
diff --git a/1-js/02-first-steps/08-operators/4-fix-prompt/task.md b/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
index b3ea4a3a3..d15855531 100644
--- a/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
+++ b/1-js/02-first-steps/08-operators/4-fix-prompt/task.md
@@ -2,13 +2,13 @@ importance: 5
---
-# Fix the addition
+# Ուղղել գումարումը
-Here's a code that asks the user for two numbers and shows their sum.
+Գրված է կոդի հատված, որը օգտագործողից ստանում է երկու թվեր և ցուցադրում է դրանց գումարը։
-It works incorrectly. The output in the example below is `12` (for default prompt values).
+Սա աշխատում է սխալ։ Ելքային արդյունքը, պատկերված օրինակում `12`-է (լռելայն արժեքների դեպքում)։
-Why? Fix it. The result should be `3`.
+Ինչու՞ ուղղել դա։ Արդյունքը պետք է լինի `3`.
```js run
let a = prompt("First number?", 1);
diff --git a/1-js/02-first-steps/08-operators/article.md b/1-js/02-first-steps/08-operators/article.md
index decf5bcfc..e5f7aca52 100644
--- a/1-js/02-first-steps/08-operators/article.md
+++ b/1-js/02-first-steps/08-operators/article.md
@@ -1,15 +1,15 @@
-# Basic operators, maths
+# Մաթեմատիկական տարրական գործողություններ
-We know many operators from school. They are things like addition `+`, multiplication `*`, subtraction `-`, and so on.
+Մենք գպրոցից գիտեն շատ գործողություններ։ Դրանցից են, օրինակ գումարում `+`, բազմապատկում `*`, հանում `-` և այլն։
-In this chapter, we’ll start with simple operators, then concentrate on JavaScript-specific aspects, not covered by school arithmetic.
+Այս հատվածում, մենք կսկսենք պարզ գործողույթուններից, ապա կկենտրոնանանք JavaScript-ի հատուկ ասպեկտների վրա, որոնք գոյություն չունեն դպրոցական թվաբանության մեջ։
-## Terms: "unary", "binary", "operand"
+## "ունար", "բինար" և "օպերանդ" հասկացությունները
-Before we move on, let's grasp some common terminology.
+Մինչ առաջ անցնելը, եկեք հասկանանք որոշ տերմինների նշանակությունը։
-- *An operand* -- is what operators are applied to. For instance, in the multiplication of `5 * 2` there are two operands: the left operand is `5` and the right operand is `2`. Sometimes, people call these "arguments" instead of "operands".
-- An operator is *unary* if it has a single operand. For example, the unary negation `-` reverses the sign of a number:
+- *Նշան* -- հասկացություն, որը կազմում է գործողությունների հիմքը։ Օրինակ ՝ `5 * 2` –ի բազմապատկման մեջ կան երկու օպերանդներ՝ ձախ օպերանդը՝ `5`, իսկ աջը՝ `2`: Երբեմն, մարդիկ «օպերանդներ»-ի փոխարեն, անվանում են «արգումենտներ»:
+- Գործողությունը համարվում է *ունար* եթե այն ունի միայն մեկ օպերանդ։ Օրինակ՝ ունար ժխտումը `-` հակադարձում է թվի նշանը:
```js run
let x = 1;
@@ -17,50 +17,50 @@ Before we move on, let's grasp some common terminology.
*!*
x = -x;
*/!*
- alert( x ); // -1, unary negation was applied
+ alert( x ); // -1, կիրառվել է ունար ժխտում
```
-- An operator is *binary* if it has two operands. The same minus exists in binary form as well:
+- Գործողույթունը համարվում է *երկուական* եթե այն ունի երկու օպերանդ. Նույն մինուսը գոյություն ունի նաև հանման տեսքով:
```js run no-beautify
let x = 1, y = 3;
- alert( y - x ); // 2, binary minus subtracts values
+ alert( y - x ); // 2, երկուական մինուսը ցույց է տալիս արժեքների տարբերությունը
```
- Formally, in the examples above we have two different operators that share the same symbol: the negation operator, a unary operator that reverses the sign, and the subtraction operator, a binary operator that subtracts one number from another.
+ Վերը նշված օրինակներում մենք ունենք երկու տարբեր օպերատորներ, որոնք կիրառում են նույն նշանը. Ժխտման օպերատոր, նշանը հակադարձող ունարի օպերատոր և հանում օպերատոր, երկուական օպերատոր, որը հանում է մեկ թիվը մյուսից:
-## Maths
+## Մաթեմատիկա
-The following math operations are supported:
+Հետևյալ մաթեմատիկական գործողությունները աջակցվում են․
-- Addition `+`,
-- Subtraction `-`,
-- Multiplication `*`,
-- Division `/`,
-- Remainder `%`,
-- Exponentiation `**`.
+- Գումարում `+`,
+- Հանում `-`,
+- Բազմապատկում `*`,
+- Բաժանում `/`,
+- Մնացորդ `%`,
+- Աստիճան բարձրացնել (անգլ․՝ Exponentiation) `**`.
-The first four are straightforward, while `%` and `**` need a few words about them.
+Առաջին չորս գործողությունները պարզ են, մինչդեռ `%` և `**` գործողությունների համար, մի քան խոսք ավելին։
-### Remainder %
+### Մնացորդ %
-The remainder operator `%`, despite its appearance, is not related to percents.
+Մնացորդի օպերատորը հետևյալն է `%`, չնայած նշանի պատկերմանը, դա կապված չէ տոկոսների հետ:
-The result of `a % b` is the [remainder](https://en.wikipedia.org/wiki/Remainder) of the integer division of `a` by `b`.
+Հետրյալ հավասարման `a % b` արդյունքը [remainder](https://en.wikipedia.org/wiki/Remainder) `a` բաժանած `b` մնացորդն է։
-For instance:
+Օրինակ՝
```js run
-alert( 5 % 2 ); // 1, a remainder of 5 divided by 2
-alert( 8 % 3 ); // 2, a remainder of 8 divided by 3
+alert( 5 % 2 ); // 1, 5-ը բաժանած 2-ի մնացորդը
+alert( 8 % 3 ); // 2, 8-ը բաժանած 3-ի մնացորդը
```
-### Exponentiation **
+### Աստիճան բարձրացնել **
-The exponentiation operator `a ** b` raises `a` to the power of `b`.
+Աստիճան բարձրացնելու օպերատորը `a ** b` բարձրացնում է `a`-ն `b`-ի աստիճան.
-In school maths, we write that as ab.
+Դպրոցական մաթեմատիկայում այն գրում ենք հետևյալ տեսքով ab։
-For instance:
+Օրինակ՝
```js run
alert( 2 ** 2 ); // 2² = 4
@@ -68,9 +68,9 @@ alert( 2 ** 3 ); // 2³ = 8
alert( 2 ** 4 ); // 2⁴ = 16
```
-Just like in maths, the exponentiation operator is defined for non-integer numbers as well.
+Ինչպես մաթեմատիկայում, այստեղ նույնպես հետևայալ օպերատորը կարող ենք կիրառել ոչ ամբողջ թվերի դեպքում։
-For example, a square root is an exponentiation by ½:
+Օրինակ՝ ½-ի աստիճանը:
```js run
alert( 4 ** (1/2) ); // 2 (power of 1/2 is the same as a square root)
@@ -78,62 +78,62 @@ alert( 8 ** (1/3) ); // 2 (power of 1/3 is the same as a cubic root)
```
-## String concatenation with binary +
+## Տողերի միավորումը երկուական +-ով
-Let's meet features of JavaScript operators that are beyond school arithmetics.
+Եկեք ծանոթանանք JavaScript-ի հնարավորությունների հետ, որոնք հիմքում ընկած է դպրոցական թվաբանությունը։
-Usually, the plus operator `+` sums numbers.
+Սովորաբար, `+` գործողությունը գումարում է թվերը։
-But, if the binary `+` is applied to strings, it merges (concatenates) them:
+Բայց, երբ երկուական `+`-ը կիրառովում է տողերի համար, դա միացնում է դրանք․
```js
let s = "my" + "string";
alert(s); // mystring
```
-Note that if any of the operands is a string, then the other one is converted to a string too.
+Նշում, եթե ցանկացած օպրանդ տող է, ապա մյուս օպերանդը նույնպես ձևափոխվում է տողի։
-For example:
+Օրինակ՝
```js run
alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"
```
-See, it doesn't matter whether the first operand is a string or the second one.
+Կապ չունի այն, որ առաջին օպերանդն է տող, թե երկրորդը․
-Here's a more complex example:
+Դիտարկենք ավելի բարդ օրինակ՝
```js run
-alert(2 + 2 + '1' ); // "41" and not "221"
+alert(2 + 2 + '1' ); // "41", այլ ոչ թե "221"
```
-Here, operators work one after another. The first `+` sums two numbers, so it returns `4`, then the next `+` adds the string `1` to it, so it's like `4 + '1' = '41'`.
+Այստեղ օպերատորները աշխատում են հաջորդաբար։ Առաջին `+`-ը գումարում է երկու թվերը, վարադարձնում է `4`, ապա հաջորդ `+`-ը ավալցանում`1` տողային փոփոխականը, այսպիսով դա նման է հետևյալին `4 + '1' = '41'`.
```js run
-alert('1' + 2 + 2); // "122" and not "14"
+alert('1' + 2 + 2); // "122", այլ ոչ թե "14"
```
-Here, the first operand is a string, the compiler treats the other two operands as strings too. The `2` gets concatenated to `'1'`, so it's like `'1' + 2 = "12"` and `"12" + 2 = "122"`.
+Այստեղ առաջին օպերանդը տող է, կոմպիլյատորը վերաբերվում է մյուս օպերանդներին նույնպես տող . `2`-ը կմիավորվի `'1'`-ի հետ, այսպիսով դա նման է հետևյալին `'1' + 2 = "12"` և `"12" + 2 = "122"`.
-The binary `+` is the only operator that supports strings in such a way. Other arithmetic operators work only with numbers and always convert their operands to numbers.
+Երկուական `+`-ը միակ օպերատորնե, որը նման կերպ է վարվում տողերի հետ։ Մյուս թվաբանական օպերատորները աշխատում են միայն թվերի հետ և միշտ կերպափոխում են օպերանդները թվերի։
-Here's the demo for subtraction and division:
+Դիտարկենք հանման և բաժանման ցուցադրությունը․
```js run
-alert( 6 - '2' ); // 4, converts '2' to a number
-alert( '6' / '2' ); // 3, converts both operands to numbers
+alert( 6 - '2' ); // 4, '2'-ը ձևափոխվում է թվի
+alert( '6' / '2' ); // 3, երկու օպերանդներնել ձևափոխվում են թվերի
```
-## Numeric conversion, unary +
+## Թվային կերպափոխումներ, ունար +
-The plus `+` exists in two forms: the binary form that we used above and the unary form.
+Գոյություն ունի `+`-ի երկու տեսակ․ երկուական տեսակ, որը մենք կիրառեցինք վերևում և ունար տեսակ։
-The unary plus or, in other words, the plus operator `+` applied to a single value, doesn't do anything to numbers. But if the operand is not a number, the unary plus converts it into a number.
+Ունար գումարում կամ մեկ այլ խոսքով `+` որը կիրառվում է մեկ արժեքների դեպքում, թվերի վրա չի ազդում։ Բայց եթե օպերանդը թիվ չէ, ապա ունար գումարումը այն կերպափոխում է թվի։
-For example:
+Օրինակ՝
```js run
-// No effect on numbers
+// Թվերի վրա ազդեցություն չի ունենում
let x = 1;
alert( +x ); // 1
@@ -141,77 +141,77 @@ let y = -2;
alert( +y ); // -2
*!*
-// Converts non-numbers
+// Կերպափոխում է ոչ թվային արժեքները
alert( +true ); // 1
alert( +"" ); // 0
*/!*
```
-It actually does the same thing as `Number(...)`, but is shorter.
+Այն իրականում անում է նույնը, ինչ `Number(...)`-ը, բայց կարճ տարբերակով։
-The need to convert strings to numbers arises very often. For example, if we are getting values from HTML form fields, they are usually strings. What if we want to sum them?
+Տողերը թվերի կերպափոխելու անհրաժեշտությունը շատ հաճախ է առաջանում։ Օրինակ՝ եթե մենք ստանում ենք դաշտերը HTML ֆորմայից, դրանք սովորաբար տողային տիպի են։ Ի՞նչ կլինի այդ դեպքում դրանց գումարը։
-The binary plus would add them as strings:
+Երկուական գումարումը դրանք կավելացնի իրար ինչպես տող։
```js run
let apples = "2";
let oranges = "3";
-alert( apples + oranges ); // "23", the binary plus concatenates strings
+alert( apples + oranges ); // "23", երկուական գումարը միացնում է տողերը իրար հետ
```
-If we want to treat them as numbers, we need to convert and then sum them:
+Եթե մենք ուզում ենք նրանց վերաբերվել որպես թվերի, կարիք կա կերպափոխելու դրանք և կատարել դրանց գումարումը:
```js run
let apples = "2";
let oranges = "3";
*!*
-// both values converted to numbers before the binary plus
+// երկու արժեքները մինչև երկուական գումարմանը մասնակցելը, կերպափոխվում են թվերի
alert( +apples + +oranges ); // 5
*/!*
-// the longer variant
+// երկար տարբերակը
// alert( Number(apples) + Number(oranges) ); // 5
```
-From a mathematician's standpoint, the abundance of pluses may seem strange. But from a programmer's standpoint, there's nothing special: unary pluses are applied first, they convert strings to numbers, and then the binary plus sums them up.
+Մաթեմատիկական տեսանկյունից, պլյուսների առատությունը կարող է տարօրինակ թվալ։ Բայց ծրագրավորողների տեսանկյունից, հատուկ ոչինչ չկա: ունար պլյուսը կիրառվում է սկզբից, դրանք կերպափոխում են տողերը թվերի, իսկ երկուական պլյուսը գումարում է դրանք։
-Why are unary pluses applied to values before the binary ones? As we're going to see, that's because of their *higher precedence*.
+Ինչու՞ է ունար պլյուսը կիրառվում սկզբից, նախքան երկուականը, դա կախված է *բարձր առաջնահերթություն*.
-## Operator precedence
+## Օպերատորների առաջնահերթություն
-If an expression has more than one operator, the execution order is defined by their *precedence*, or, in other words, the default priority order of operators.
+Եթե արդահայտությունը ունի մեկից ավել օպերատորներ, ապա կատարման հերթականությունը սահմանվում է կախված նրանց *առաջնահերթությունից*, կամ այլ բառով, օպերատորների կանխադրված առաջնահերթ կարգը։
-From school, we all know that the multiplication in the expression `1 + 2 * 2` should be calculated before the addition. That's exactly the precedence thing. The multiplication is said to have *a higher precedence* than the addition.
+Դպրոցից մենք գիտեն արտահայտությունում բազմապատկման կարգի մասին `1 + 2 * 2` պետք է կատարվի մինչ գումարումը։ Դա հենց առաջնահերթությունն է: Ասում են, որ բազմապատկումը ունի *ավելի բարձր առաջնահերթություն* քան թե գումարումը։
-Parentheses override any precedence, so if we're not satisfied with the default order, we can use them to change it. For example, write `(1 + 2) * 2`.
+Փակագծերը ավելի առաջնահերթ են քան մյուսները, ուստի, եթե մենք համամիտ չենք առաջնահերթությունից, կարող ենք օգտագործել դրանք, այն փոխելու համար: Օրինակ՝ գրելով `(1 + 2) * 2`.
-There are many operators in JavaScript. Every operator has a corresponding precedence number. The one with the larger number executes first. If the precedence is the same, the execution order is from left to right.
+Կան բազմաթիվ օպերատորներ JavaScript-ում։ Յուրաքանչյուր օպերատոր ունի իր համապատասխան առաջնահերթության համարը: Ավելի մեծ թիվ ունեցողը կատարվում է առաջինը։ Եթե առաջնահերթությունը նույնն է, ապա կատարման հերթականությունը ձախից դեպի աջ է։
-Here's an extract from the [precedence table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (you don't need to remember this, but note that unary operators are higher than corresponding binary ones):
+Ահա քաղվածքը [precedence table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence) (դուք պարտավոր չեք հիշել սա, բայց նշեք, որ ունար օպերատորներն ավելի բարձր են, քան համապատասխան երկուականները):
-| Precedence | Name | Sign |
+| Առաջնահերթւոյուն | Անվանում | Նշան |
|------------|------|------|
| ... | ... | ... |
-| 17 | unary plus | `+` |
-| 17 | unary negation | `-` |
-| 16 | exponentiation | `**` |
-| 15 | multiplication | `*` |
-| 15 | division | `/` |
-| 13 | addition | `+` |
-| 13 | subtraction | `-` |
+| 17 | ունար պլյուս | `+` |
+| 17 | ունար ժխտում | `-` |
+| 16 | ընդլայնում | `**` |
+| 15 | բազմապատկում | `*` |
+| 15 | բաժանում | `/` |
+| 13 | գումարում | `+` |
+| 13 | հանում | `-` |
| ... | ... | ... |
-| 3 | assignment | `=` |
+| 3 | վերագրում | `=` |
| ... | ... | ... |
-As we can see, the "unary plus" has a priority of `17` which is higher than the `13` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+Կարող ենք տեսնել, "ունար պլյուս"-ը ունի `17` գերակայությունը, որը մեծ է քան `13`-ը "գումարում" (երկուական պլյուս)։ Ահա թե ինչու է, `"+apples + +oranges"` արտահայտությունում, ունար պլյուսը կատարվում նախքան գումարումը։
-## Assignment
+## Վերագրում
-Let's note that an assignment `=` is also an operator. It is listed in the precedence table with the very low priority of `3`.
+Պետք է նշել այն, որ վերագրումը `=` նույնպես օպերատոոր է։ Այն գերակայության աղյուսակում ունի շատ ցածր դիրքը `3`։
-That's why, when we assign a variable, like `x = 2 * 2 + 1`, the calculations are done first and then the `=` is evaluated, storing the result in `x`.
+Ահա ինչու, երբ մենք վերագրում ենք փոփոխկան, ինչպիսին է `x = 2 * 2 + 1`, հաշվարկը կատարվում է սկզբում և հետո կատարվում է`=`, պահպանելով արդյունքը `x`-ում։
```js
let x = 2 * 2 + 1;
@@ -219,15 +219,15 @@ let x = 2 * 2 + 1;
alert( x ); // 5
```
-### Assignment = returns a value
+### Վերագրումը = վերադարձնում է արժեք
-The fact of `=` being an operator, not a "magical" language construct has an interesting implication.
+Վերագրման `=` օպերատոր լինլու փաստը, ունի ոչ "կախարդական" ենթատեքստ։
-All operators in JavaScript return a value. That's obvious for `+` and `-`, but also true for `=`.
+JavaScript-ում բոլոր օպերատորները վերադարձնում են արժեք։ Դա ակնհայտ է `+`-ի և `-`-ի համար, բայց նաև `=`-ի համար։
-The call `x = value` writes the `value` into `x` *and then returns it*.
+`x = value`-ի կանչը գրանցում է `value`-ն `x`-ի մեջ *և վերադարձնում է այն*։
-Here's a demo that uses an assignment as part of a more complex expression:
+Այա վերագրման կիրառման օրինակ, որպես բարդ արտահայտության հատված:
```js run
let a = 1;
@@ -241,15 +241,15 @@ alert( a ); // 3
alert( c ); // 0
```
-In the example above, the result of expression `(a = b + 1)` is the value which was assigned to `a` (that is `3`). It is then used for further evaluations.
+Վերը նշված օրինակում, հետևյալ արտահայտության `(a = b + 1)` արժեքը դա այն է, որը պետք է վերագրվի `a`-ին (դա `3`-ն է)։ Այնուհետեւ այն օգտագործվում է հետագա արժեվորման համար։
-Funny code, isn't it? We should understand how it works, because sometimes we see it in JavaScript libraries.
+Զվարճալի կոդ է, այնպես չէ՞: Մենք պետք է հասկանանք թե ինչպես է այն աշխատում, քանի որ երբեմն այն կարող եք հանդիպել JavaScript-ի գրադարաններում։
-Although, please don't write the code like that. Such tricks definitely don't make code clearer or readable.
+Ամեն դեպքում, խնդրում եմ, կոդը այդպես մի գրեք: Նման հնարքները հաստատ հստակ ու հասկանալի չեն դարձնում կոդը:
-### Chaining assignments
+### Կապակցված վերագրումներ
-Another interesting feature is the ability to chain assignments:
+Մեկ այլ հետաքրքիր առանձնահատկություն է վերգրումների կապակցումը․
```js run
let a, b, c;
@@ -263,22 +263,22 @@ alert( b ); // 4
alert( c ); // 4
```
-Chained assignments evaluate from right to left. First, the rightmost expression `2 + 2` is evaluated and then assigned to the variables on the left: `c`, `b` and `a`. At the end, all the variables share a single value.
+Կապակցումը կատարվում է աջից դեպի ձախ։ Առաջին կատարվում է ամենաաջակողմյան `2 + 2` արդահայտությունը, ապա վերագրվում է ձախ կողմի փոփոխականին․ `c`, `b` և `a`։ Ամենավերջում, բոլոր փոփոխականները հավաքվում է մեկ արժեքի մեջ։
-Once again, for the purposes of readability it's better to split such code into few lines:
+Կրկին անգամ, ընթերցելիության նկատառումներից ելնելով, լավ է որ այն բաժանված է մի քանի տողերի․
```js
c = 2 + 2;
b = c;
a = c;
```
-That's easier to read, especially when eye-scanning the code fast.
+Սա հեշտ է ընթերցվում, հատկապես այն դեպքւոմ, երբ աչքը արագ է դիտարկում կոդը։
-## Modify-in-place
+## Փոփոխել տեղում
-We often need to apply an operator to a variable and store the new result in that same variable.
+Երբեմն մենք կարիք ենք ունենում, կիրառել օպերատորը և պահպանել նոր արդյունքը նույն փոփոխականի մեջ։
-For example:
+Օրինակ՝
```js
let n = 2;
@@ -286,67 +286,67 @@ n = n + 5;
n = n * 2;
```
-This notation can be shortened using the operators `+=` and `*=`:
+Այս ամենը կարող ենք կարճ գրել `+=` և `*=`:
```js run
let n = 2;
-n += 5; // now n = 7 (same as n = n + 5)
-n *= 2; // now n = 14 (same as n = n * 2)
+n += 5; // այժմ n = 7 (նույնն է ինչ n = n + 5)
+n *= 2; // այժմ n = 14 (նույնն է ինչ n = n * 2)
alert( n ); // 14
```
-Short "modify-and-assign" operators exist for all arithmetical and bitwise operators: `/=`, `-=`, etc.
+Կարճ "ձևափոխել և վերագրել" օպերատորները գոյություն ունեն բոլոր մաթեմատիկական և բիթային օպերատորների համար․ `/=`, `-=` և այլն։
-Such operators have the same precedence as a normal assignment, so they run after most other calculations:
+Նման օպերատորներն ունեն նույն գերակայությունը, ինչ սովորական վերագրումները, այնպես որ նրանք աշխատում են շատ այլ հաշվարկներից հետո.
```js run
let n = 2;
n *= 3 + 5;
-alert( n ); // 16 (right part evaluated first, same as n *= 8)
+alert( n ); // 16 (նախ կատարվում է աջ մասը, նույնն է ինչ n *= 8)
```
-## Increment/decrement
+## Ինկրեմենտ/դեկրեմենտ
-Increasing or decreasing a number by one is among the most common numerical operations.
+Թիվը մեկով մեծացնելը կամ փոքրացնելը ամենատարածված թվային գործողություններից է։
-So, there are special operators for it:
+Այսպիսով դրա համար կան հատուկ օպերատորներ․
-- **Increment** `++` increases a variable by 1:
+- **Ինկրեմենտ** `++` փոփոխականի ավելացումը 1-ով․
```js run no-beautify
let counter = 2;
- counter++; // works the same as counter = counter + 1, but is shorter
+ counter++; // կաշխատի որպես counter = counter + 1, բայց կարճ տարբերակով
alert( counter ); // 3
```
-- **Decrement** `--` decreases a variable by 1:
+- **Դեկրեմենտ** `--` փոքրացնել փոփոխականը 1-ով․
```js run no-beautify
let counter = 2;
- counter--; // works the same as counter = counter - 1, but is shorter
+ counter--; // կաշխատի որպես counter = counter - 1, բայց կարճ տարբերակով
alert( counter ); // 1
```
```warn
-Increment/decrement can only be applied to variables. Trying to use it on a value like `5++` will give an error.
+Ինկրեմենտ/դեկրեմենտ պետք է կրատվի փոփոխականների համար։ Այն փորձելով օգտագործել օրինակ՝ `5++` փոփոխականի համար կստանանք սխալ։
```
-The operators `++` and `--` can be placed either before or after a variable.
+`++` և `--` օպերատորները կարող են տեղադրվել փոփոխականից առաջ և հետո։
-- When the operator goes after the variable, it is in "postfix form": `counter++`.
-- The "prefix form" is when the operator goes before the variable: `++counter`.
+- Երբ օպերատորը կիրառվում է փոփոխականից հետո, դա համարվում է "պոստֆիքս կառուցվածք"․ `counter++`.
+- "պրեֆիքս կառուցվածք"-ը երբ կիրառվում է փոփոխականից առաջ․ `++counter`.
-Both of these statements do the same thing: increase `counter` by `1`.
+Բոլոր գործեղությունները կատարում են նույնը․ ավելացնում են `counter`-ին `1`.
-Is there any difference? Yes, but we can only see it if we use the returned value of `++/--`.
+Կա՞ արդյոք տարբերություն․ Այո, բայց դա մենք կարող ենք տեսնել դա միայն վերադարձվող արժեքում `++/--`.
-Let's clarify. As we know, all operators return a value. Increment/decrement is no exception. The prefix form returns the new value while the postfix form returns the old value (prior to increment/decrement).
+Եկեք պարզաբանենք։ Ինչպես գիտենք բոլոր օպերատորները վերադարձնում են արժեք։ Ինկրեմենտ/դեկրեմենտ-ը բացառություն չեն։ Պրեֆիքս տեսքը վերադարձնում է նոր արժեք, մինչ դեռ պոստֆիքը վերադարձնում է հին արժեքը (նախքան ինկրեմենտ/դեկտրեմենտ-ը).
-To see the difference, here's an example:
+Տարբերությունը տեսնելու համար, դիտարկենք օրինակը․
```js run
let counter = 1;
@@ -355,36 +355,36 @@ let a = ++counter; // (*)
alert(a); // *!*2*/!*
```
-In the line `(*)`, the *prefix* form `++counter` increments `counter` and returns the new value, `2`. So, the `alert` shows `2`.
+Հետևյալ տողում `(*)`, *պրեֆիք*-ը `++counter` ավելացնում է `counter`-ի արժեքը և վերադարձնում է նոր արժեքը, `2`։ Այսպիսով `alert`-ը ցույց կտա`2`։
-Now, let's use the postfix form:
+Դիտարկենք պոստֆիքս կառուցվածքը․
```js run
let counter = 1;
-let a = counter++; // (*) changed ++counter to counter++
+let a = counter++; // (*) ++counter-ը ձևափոխվել է counter++ - ի
alert(a); // *!*1*/!*
```
-In the line `(*)`, the *postfix* form `counter++` also increments `counter` but returns the *old* value (prior to increment). So, the `alert` shows `1`.
+Հետևյալ տեղում `(*)`, *պոստվիքս* կառուցվածքը `counter++` նույնպես ավելացնում է `counter`-ի արժեքը, բայց վերադարձնում է *հին* արժեքը (նախքան ավելացումը)։ Այսպիսով `alert`-ը ցույց կտա `1`։
-To summarize:
+Ամփոփում․
-- If the result of increment/decrement is not used, there is no difference in which form to use:
+- Եթե ինկրեմենտ/դեկրեմենտ-ի արժեքները չեն օգտագործվում, ապա տարբերություն չկա թե որ մեկը կկիրառվի․
```js run
let counter = 0;
counter++;
++counter;
- alert( counter ); // 2, the lines above did the same
+ alert( counter ); // 2, վերը նշված տողերը իրականացնում են նույնը
```
-- If we'd like to increase a value *and* immediately use the result of the operator, we need the prefix form:
+- Եթե մենք ցանկանում են ավելացնել արժեքը *և* անմիջապես օգտագործել օպերատորի արժեքը, մենք պետք է օգտագործենք պրեֆիքս կառուցվածքը․
```js run
let counter = 0;
alert( ++counter ); // 1
```
-- If we'd like to increment a value but use its previous value, we need the postfix form:
+- Եթե ցանկանում ենք ավելացնել արժեքը, բայց օգտագործել նախորդ արժեքը, կարիք կա կիրառելու պոստֆիքս կառուցվածքը․
```js run
let counter = 0;
@@ -392,27 +392,27 @@ To summarize:
```
````smart header="Increment/decrement among other operators"
-The operators `++/--` can be used inside expressions as well. Their precedence is higher than most other arithmetical operations.
+Հետևյալ օպերատորները `++/--` կարող են կիրառվել նաև արտահայտությունների ներսում։ Նրանց գերակայությունն ավելի բարձր է, քան մյուս թվաբանական գործողություններինը։
-For instance:
+Օրինակ՝
```js run
let counter = 1;
alert( 2 * ++counter ); // 4
```
-Compare with:
+Համեմատել հետևյալի հետ
```js run
let counter = 1;
-alert( 2 * counter++ ); // 2, because counter++ returns the "old" value
+alert( 2 * counter++ ); // 2, քանի որ counter++ վերադարձնում է "հին" արժեքը
```
-Though technically okay, such notation usually makes code less readable. One line does multiple things -- not good.
+Չնայած տեխնիկապես սա լավ է, սովորաբար նման կիարառությունը կոդը դարձնում է քիչ ընթեռնելի։ Մի տողը կատարում է բազմաթիվ գործողություններ -- դա լավ չէ։
-While reading code, a fast "vertical" eye-scan can easily miss something like `counter++` and it won't be obvious that the variable increased.
+Քանի դեռ ընթերցվում է կոդը, արագ "ուղղահայաց" դիտարկումը կարող է բաց քողնել այնպիսի բան, ինչպիսին է `counter++`-ը և ակնհայտ չի լինի, որ փոփոխականի արժեքը ավելացել է։
-We advise a style of "one line -- one action":
+Մենք խորհուրդ ենք տալիս "մեկ տող -- մեկ գործողություն" ոճը:
```js run
let counter = 1;
@@ -421,59 +421,59 @@ counter++;
```
````
-## Bitwise operators
+## Բիթային օպերատորներ
-Bitwise operators treat arguments as 32-bit integer numbers and work on the level of their binary representation.
+Բիթային օպերատորները արգումենտներին վերաբերվում են որպես 32-բիթ երկարությամբ ամբողջ թվերի և աշխատում են իրենց երկուական ներկայացման մակարդակով:
-These operators are not JavaScript-specific. They are supported in most programming languages.
+Այս օպերատորները կոնկրետ JavaScript-ինը չեն։ Դրանք աջակցվում են ծրագրավորման լեզուների մեծ մասում։
-The list of operators:
+Օպերատորների ցանկը․
-- AND ( `&` )
-- OR ( `|` )
-- XOR ( `^` )
-- NOT ( `~` )
-- LEFT SHIFT ( `<<` )
-- RIGHT SHIFT ( `>>` )
-- ZERO-FILL RIGHT SHIFT ( `>>>` )
+- և ( `&` )
+- կամ ( `|` )
+- Բացառող կամ (XOR) ( `^` )
+- ժխտում ( `~` )
+- Ձախ տեղաշարժ ( `<<` )
+- Աջ տեխաշարժ ( `>>` )
+- Զրոյի ավելացմամբ աջ տեղաշարժ ( `>>>` )
-These operators are used very rarely, when we need to fiddle with numbers on the very lowest (bitwise) level. We won't need these operators any time soon, as web development has little use of them, but in some special areas, such as cryptography, they are useful. You can read the [Bitwise Operators](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise) chapter on MDN when a need arises.
+Այս օպերատորները շատ հազվադեպ են օգտագործվում, երբ մենք պետք է կիրառենք թվերը ամենացածր (բիթային) մակարդակում։ Այս օպերատորները մեզ շուտ պետք չեն, քանի որ վեբ ծրագրավորման մեջ դրանք քիչ են օգտագործում, բայց որոշ հատուկ ոլորտներում, ինչպիսին է գաղտանգրությունը, դրանք կիրառվում են։ Դուք կարող եք կարդալ [Բիթային օպերատորն](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise) հոդվածը MDN-ում, երբ անհարժեշտ է։
-## Comma
+## Ստորակետ
-The comma operator `,` is one of the rarest and most unusual operators. Sometimes, it's used to write shorter code, so we need to know it in order to understand what's going on.
+Ստորակետ օպերատորը `,` ամենահազվագյուտ և անսովոր օպերատորներից է։ Երբեմն դա օգտագործվում է ավելի կարճ կոդ գրելու համար, այնպես որ մենք պետք է դա իմանանք, որպեսզի հասկանանք, թե ինչ է կատարվում:
-The comma operator allows us to evaluate several expressions, dividing them with a comma `,`. Each of them is evaluated but only the result of the last one is returned.
+Հետևյալ օպերատորը թույլ է տալիս հաշվարկել մի քանի արտահայտություններ բաժանելով դրանք `,`-ով։ Նրանցից յուրաքանչյուրը հաշվարկվում է, բայց վերադարձվում է միայն վերջին արդյունքը։
-For example:
+Օրինակ՝
```js run
*!*
let a = (1 + 2, 3 + 4);
*/!*
-alert( a ); // 7 (the result of 3 + 4)
+alert( a ); // 7 (3 + 4-ի արդյունքը)
```
-Here, the first expression `1 + 2` is evaluated and its result is thrown away. Then, `3 + 4` is evaluated and returned as the result.
+Այստես առաջին արտահայտությունը`1 + 2` վերլուծվում է, և արդյունքը անտեսվում է. Որից հետո, `3 + 4` արտահայտությունը վերլուծվում է, և վերադարձվում է որպես արդյունք։
```smart header="Comma has a very low precedence"
-Please note that the comma operator has very low precedence, lower than `=`, so parentheses are important in the example above.
+Խնդրում ենք նկատի ունենալ, որ ստորակետի օպերատորը շատ ցածր առաջնահերթություն ունի, ցածր քան `=`, այնպես որ փակագծերը կարևոր են վերը նշված օրինակում։
-Without them: `a = 1 + 2, 3 + 4` evaluates `+` first, summing the numbers into `a = 3, 7`, then the assignment operator `=` assigns `a = 3`, and the rest is ignored. It's like `(a = 1 + 2), 3 + 4`.
+Առանց դրանց: `a = 1 + 2, 3 + 4` վերլուծվում է `+`-ը առաջին հերթին, ստանալով `a = 3, 7`, ապա վերագրամն օպերատորը `=` վերագրում է `a = 3`, իսկ մնացածը անտեսվում է։ Դա նման է հետևյալին `(a = 1 + 2), 3 + 4`։
```
-Why do we need an operator that throws away everything except the last expression?
+Ինչու՞ է մեզ պետք օպերատոր, որը անտեսում է ամեն ինչ, բացի վերջին արտահայտությունից:
-Sometimes, people use it in more complex constructs to put several actions in one line.
+Երբեմն, երբեմն մարդիկ օգտագործում են դա, առավել բարդ կառուցվածքներում,մի շարք գործողություններ դնելում համար մեկ տողում։
-For example:
+Օրինակ՝
```js
-// three operations in one line
+// երեք օպերատորներ մեկ տողում
for (*!*a = 1, b = 3, c = a * b*/!*; a < 10; a++) {
...
}
```
-Such tricks are used in many JavaScript frameworks. That's why we're mentioning them. But usually they don't improve code readability so we should think well before using them.
+Նման հնարքներ կիրառվում են JavaScript-ի մի շարք ֆրեյմվորկներում։ Ահա թե ինչում մենք դիտարկեցինք դրանք։ Բայց երբեմն դրանք չեն բարելավում կոդի ընթեռնելիությունը, ուստի դրանք օգտագործելուց առաջ պետք է լավ մտածել։