From ee9e6981c47ea0afe4fcbad1807065451e93d9fb Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Fri, 13 May 2022 02:50:49 +0400 Subject: [PATCH 1/2] JavaScript specials Updated. --- .../17-arrow-functions-basics/article.md | 299 ++++++++++++++---- 1 file changed, 236 insertions(+), 63 deletions(-) diff --git a/1-js/02-first-steps/17-arrow-functions-basics/article.md b/1-js/02-first-steps/17-arrow-functions-basics/article.md index 059435949..c147d7cfe 100644 --- a/1-js/02-first-steps/17-arrow-functions-basics/article.md +++ b/1-js/02-first-steps/17-arrow-functions-basics/article.md @@ -1,111 +1,284 @@ -# Սլաքով ֆունկցիաներ. հիմունքներ +# JavaScript-ի հատկանիշները -Կա ևս մեկ շատ պարզ ու հակիրճ շարահյուսություն ֆունկցիաներ ստեղծելու համար, որը հաճախ ավելի հարմար է, քան Ֆունկցիոնալ Արտահայտությունը (Function Expression): +Այս գլխում՝ հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի այն առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս: -Այն կոչվում է «սլաքով ֆունկցիաներ» (arrow functions), քանի որ այն ունի հետևյալ տեսքը. +## Կոդի կառուցվածք + +Դրույթները տարանջատվում են կետ-ստորակետով. + +```js run no-beautify +alert('Ողջույն'); alert('Աշխարհ'); +``` + +Սովորաբար տողադարձը նույնպես դիտվում է որպես տարանջատիչ և սա նույնպես կաշխատի. + +```js run no-beautify +alert('Ողջույն') +alert('Աշխարհ') +``` + +Դա կոչվում է «կետ-ստորակետի ավտոմատ տեղադրում»։ Երբեմն այն չի աշխատում, օրինակ. + +```js run +alert("Այս հաղորդագրությունից հետո սխալ կլինի:") + +[1, 2].forEach(alert) +``` + +Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր դրույթից հետո: + +Կոդի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է. ```js -let func = (arg1, arg2, ..., argN) => expression; +function f() { + // կետ-ստորակետ պետք չէ ֆունկցիոնալ հռչակագրից հետո +} + +for(;;) { + // կետ-ստորակետ պետք չէ ցիկլից հետո +} ``` -Սա ստեղծում է ֆունկցիա `func`, որն ընդունում է `arg1..argN` արգումենտները, այնուհետև արժևորում է `expression`-ը աջ կողմում իրենց կիրառմամբ և վերադարձնում արդյունք։ +...Սակայն, եթե մենք «ավելնորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի: + +Մանրամասն՝ . -Այլ կերպ ասած՝ սա կրճատ տարբերակն է ստորև գրելաձևի. +## Խիստ ռեժիմ + +Ժամանակակից JavaScript-ի բոլոր առանձնահատկություններն ակտիվացնելու համար կոդի սկզբում հարկավոր է նշել `"use strict"`։ ```js -let func = function(arg1, arg2, ..., argN) { - return expression; -}; +'use strict'; + +... ``` -Եկեք տեսնենք հստակ օրինակ: +Այդ ցուցումը պետք է լինի սքրիփթի սկզբում կամ ֆունկցիայի մարմնի սկզբում: -```js run -let sum = (a, b) => a + b; +Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք կնախընտրենք ժամանակակից վարքագիծը: + +Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք կսովորենք հետագայում) անուղղակիորեն ակտիվացնում են խիստ ռեժիմը։ + +Ավելին՝ ։ -/* Այս սլաքով ֆունկցիան ավելի կրճատ է, քան․ +## Փոփոխականներ -let sum = function(a, b) { - return a + b; -}; -*/ +Կարող են հռչակվել՝ օգտագործելով․ -alert( sum(1, 2) ); // 3 +- `let` +- `const` (հաստատուն, չի կարող փոփոխվել) +- `var` (հին ոճ, կդիտարկենք ավելի ուշ) + +Փոփոխականի անվանումը կարող է պարունակել․ +- Տառեր և թվեր, բայց առաջին նիշը չի կարող լինել թիվ: +- `$` և `_` նիշերը նորմալ են, համարժեք են տառերին։ +- Թույլատրվում են նաև ոչ լատինական այբուբեններ և հիերոգլիֆներ, բայց սովորաբար չեն օգտագործվում: + +Փոփոխականները տիպավորվում են դինամիկ կերպով և կարող են պահել ցանկացած արժեք. + +```js +let x = 5; +x = "Պողոս"; ``` -Ինչպես տեսնում եք, `(a, b) => a + b` նշանակում է ֆունկցիա, որն ընդունում է երկու արգումենտ՝ `a` և `b` անվանումներով. Կատարման ժամանակ այն արժևորում է `a + b` արտահայտությունը և վերադարձնում արդյունք։ +Տվյալների 8 տիպեր կան. + +- `number` ինչպես կոտորակային, այնպես էլ ամբողջ թվերի համար, +- `bigint` կամայական երկարություն ունեցող ամբողջ թվերի համար, +- `string` տողերի համար, +- `boolean` տրամաբանական արժեքների համար՝ `true/false`, +- `null` մեկ արժեք ունեցող տեսակ՝ `null`, նշանակում է «դատարկ» կամ «գոյություն չունեցող», +- `undefined` մեկ արժեք ունեցող տեսակ՝ `undefined`, նշանակում է «չսահմանված», +- `object` և `symbol` բարդ տվյալների կառուցվածքների և ունիկալ նույնականացուցիչների համար. մենք դեռ չենք սովորել դրանք։ -- Եթե ունենք միայն մեկ արգումենտ, ապա կոր փակագծերը արգումենտի շուրջ կարելի է չնշել՝ կրճատելով գրելաձևը․ +`typeof` օպերատորը վերադարձնում է արժեքի տեսակը երկու բացառությամբ. +```js +typeof null == "object" // սխալ լեզվում +typeof function(){} == "function" // ֆունկցիաները մշակվում են առանձնահատուկ կերպով +``` - Օրինակ. +Ավելին՝ և ։ - ```js run - *!* - let double = n => n * 2; - // նույնն է, ինչ․ let double = function(n) { return n * 2 } - */!* +## Փոխազդեցություն + +Մենք բրաուզերն ենք օգտագործում որպես աշխատանքային միջավայր, ուստի UI-ի (օգտատիրոջ ինտերֆեյս) հիմնական ֆունկցիաները կլինեն. + +[`prompt(question, [default])`](mdn:api/Window/prompt) +: Հարց է տալիս `question`, այնուհետև վերադարձնում է այն, ինչ մուտքագրել է այցելուն կամ `null`, եթե այցելուն սեղմել է «Cancel»: + +[`confirm(question)`](mdn:api/Window/confirm) +: Հարց է տալիս `question` և առաջարկում ընտրություն կատարել՝ «Ok» կամ «Cancel». Ընտրությունը վերադարձվում է որպես `true/false`։ + +[`alert(message)`](mdn:api/Window/alert) +: Արտատպում է հաղորդագրություն `message`։ + +Բոլոր այս ֆունկցիաները *modal* են, նրանք դադարեցնում են կոդի գործարկումը և թույլ չեն տալիս այցելուներին փոխազդեցություն ունենալ էջի հետ, մինչև նրանք «չպատասխանեն»։ + +Օրինակ. + +```js run +let userName = prompt("Ձեր անո՞ւնը:", "Ալիսա"); +let isTeaWanted = confirm("Թեյ կցանկանա՞ք:"); + +alert( "Այցելու՝ " + userName ); // Ալիսա +alert( "Թեյ ուզեց՝ " + isTeaWanted ); // true +``` + +Ավելին՝ ։ - alert( double(3) ); // 6 +## Օպերատորներ + +JavaScript-ը սպասարկում է հետևյալ օպերատորները. + +Թվաբանական +: Կանոնավոր՝ `* + - /`, նաև `%` մնացորդի համար և `**` աստիճան բարձրացնելու համար։ + + Բինար գումարումը `+` միացնում է տողերը։ ԵՎ եթե օպերանդներից մեկը տող է, մյուսը նույնպես փոխակերպվում է տողի․ + + ```js run + alert( '1' + 2 ); // '12', տող + alert( 1 + '2' ); // '12', տող ``` -- Եթե արգումենտներ չկան, կոր փակագծերը դատարկ են, բայց դրանք պետք է առկա լինեն․ +Վերագրում +: Կա պարզ վերագրում՝ `a = b`, և համակցված վերագրում՝ `a *= 2`։ + +Բիթային +: Բիթային օպերատորները աշխատում են 32-բիթ ամբողջ թվերի հետ ամենացածր՝ բիթային մակարդակում. տեսեք [դոկումենտացիան](mdn:/JavaScript/Guide/Expressions_and_Operators#Bitwise)-ում, երբ դրա կարիքը լինի: + +Պայմանական +: Միակ օպերատորը երեք պարամետրով՝ `cond ? resultA : resultB`։ Եթե `cond` պայմանը ճշմարիտ է, վերադարձվում է `resultA`, հակառակ դեպքում՝ `resultB`։ + +Տրամաբանական օպերատորներ +: Տրամաբանական ԵՎ `&&` ու ԿԱՄ `||` օպերատորները իրականացնում են «կարճ միացման» արժեվորում, այնուհետև վերադարձնում են արժեք՝ որտեղ կանգ են առել (պարտադիր չէ `true`/`false`). Տրամաբանական ՈՉ `!` վերածում է օպերանդը տրամաբանական տեսակի և վերադարձնում հակառակ արժեքը։ + +Զրոյական միավորման օպերատոր +: `??` օպերատորը փոփոխականների ցանկից հատկանշված արժեքի ընտրության հնարավորություն է տալիս: `a ?? b`-ի արդյունքը կլինի `a`, եթե այն `null/undefined` չէ, հակառակ դեպքում՝ `b`: + +Համեմատություններ +: հավասարության ստուգումը `==` տարբեր տիպերի արժեքների դեպքում նրանց փոխակերպում է թվի (բացի `null` և `undefined` տիպերից, որոնք միայն իրար կարող են հավասար լինել), այսպիսով սրանք հավասար են. ```js run - let sayHi = () => alert("Ողջույն"); + alert( 0 == false ); // true + alert( 0 == '' ); // true + ``` + + Այլ համեմատությունները նույնպես արժեքները փոխակերպում են թվի: + + Խիստ հավասարության օպերատորը `===` չի կատարում փոխակերպում․ նրա համար տարբեր տիպերը միշտ ունեն տարբեր արժեքների նշանակություն։ + + `null` և `undefined` արժեքները հատուկ են․ նրանք հավասար են `==` իրար և ուրիշ ոչինչի հավասար չեն։ + + Մեծ/փոքր համեմատությունները տողերին համեմատում են նիշ-առ-շիշ, մյուս տիպերը փոխակերպվում են թվի։ + +Այլ օպերատորներ +: Կա մի քանի ալյ օպերատոր, օր․՝ ստորակետի օպերատորը։ + +Ավելին՝ , , , ։ + +## Ցիկլներ + +- Մենք դիտարկել ենք 3 տեսակի ցիկլ․ - sayHi(); + ```js + // 1 + while (condition) { + ... + } + + // 2 + do { + ... + } while (condition); + + // 3 + for(let i = 0; i < 10; i++) { + ... + } ``` -Սլաքով ֆունկցիաները կարող են օգտագործվել նույն կերպ, ինչպես Ֆունկցիոնալ Արտահայտությունները։ +- `for(let...)` ցիկլում հռչակված փոփոխականը հասանելի է միայն ցիկլի ներսում։ Բայց մենք կարող ենք նաև բաց թողնել `let`-ը և կրկին օգտագործել արդեն իսկ գոյություն ունեցող փոփոխականը: +- `break/continue` հրահանգները թույլ են տալիս դուրս գալ ամբողջ ցիկլից/ընթացիկ կրկնությունից: Օգտագործեք պիտակներ ներդրված ցիկլները կանգնեցնելու համար։ + +Մանրամասն՝ ։ + +Ավելի ուշ, օբյեկտների հետ աշխատելու համար մենք կուսումնասիրենք ցիկլների ավելի շատ տեսակներ: + +## Կոնստրուկցիա «switch» -Օրինակ՝ դինամիկ կերպով ֆունկցիա ստեղծելու համար․ +«switch» կոնստրուկցիան կարող է փոխարինել մի քանի `if` ստուգումների. Համեմատությունների ժամանակ այն օգտագործում է `===` խիստ հավասարման օպերատորը։ + +Օրինակ՝ ```js run -let age = prompt("Քանի՞ տարեկան եք:", 18); +let age = prompt('Ձեր տարի՞քը:', 18); + +switch (age) { + case 18: + alert("Չի աշխատի"); // prompt-ի վերադարձրած արդյունքը տող է, թիվ չէ + break; -let welcome = (age < 18) ? - () => alert('Ողջույն') : - () => alert("Ողջույններ"); + case "18": + alert("Սա կաշխատի"); + break; -welcome(); + default: + alert("Վերոնշյալներին ոչ հավասար ցանկացած արժեք"); +} ``` -Սլաքով ֆունկցիաները սկզբից կարող են անսովոր և ոչ այդքան հեշտ ընթերցվող թվալ, բայց դա արագ փոխվում է, երբ աչքերը սովորում են կառուցվածքին: +Մանրամասն՝ ։ -Դրանք շատ հարմար են պարզ՝ մի տողանի գործողությունների համար, երբ կզլանանք գրել ավելի շատ բառեր։ +## Ֆունկցիաներ -## Բազմատողանի սլաքով ֆունկցիաներ +Մենք դիտարկեցինք JavaScript-ում ֆունկցիաներ ստեղծելու երեք տարբերակ․ -Սլաքով ֆունկցիաները, որոնք մենք տեսանք մինչ այս, շատ պարզ էին։ Նրանք ստանում էին արգումենտներ `=>`-ի ձախ կողմում, արժևորում և դրանցով վերադարձնում էին արտահայտությունն աջ կողմում: +1. Ֆունկցիոնալ Հռչակագիր (Function Declaration). ֆունկցիան հիմնական կոդի հոսքում․ -Երբեմն մեզ պետք է լինում ավելի բարդ ֆունկցիա՝ մի քանի արտահայտություններով և դրույթներով։ Այդ դեպքում կարող ենք դրանք վերցնել ձևավոր փակագծերի մեջ: Հիմնական տարբերությունը նրանում է, որ ձևավոր փակագծերի ժամանակ պատասխան վերադարձնելու համար անհրաժեշտ է օգտագործել `return` դրանց ներսում (ինչպես սովորական ֆունկցիաներում)։ + ```js + function sum(a, b) { + let result = a + b; -Այսպես․ + return result; + } + ``` -```js run -let sum = (a, b) => { // ձևավոր փակագիծը բացում է բազմատողանի ֆունկցիան - let result = a + b; -*!* - return result; // եթե օգտագործում ենք ձևավոր փակագծեր, ապա անհրաժեշտ է հստակ նշել «return» -*/!* -}; - -alert( sum(1, 2) ); // 3 -``` +2. Ֆունկցիոնալ Արտահայտություն (Function Expression). ֆունկցիան արտահայտության համատեքստում․ -```smart header="Սպասվում է ավելին" -Այստեղ գովեցինք սլաքով ֆունկցիաները հակիրճ լինելու համար։ Բայց սա դեռ ամենը չէ։ + ```js + let sum = function(a, b) { + let result = a + b; -Սլաքով ֆունկցիաներն ունեն նաև այլ հետաքրքիր առանձնահատկություններ: + return result; + }; + ``` -Դրանց խորը ուսումնասիրման համար մեզ առաջին հերթին պետք է ծանոթանալ JavaScript-ի որոշ այլ հայեցակետերի հետ, այնպես որ մենք կվերադառնանք սլաքով ֆունկցիաներին ավելի ուշ՝ գլխում: +3. Սլաքով ֆունկցիաներ (arrow functions)․ -Առայժմ մենք կարող ենք օգտագործել սլաքով ֆունկցիաները մեկ տողանի գործողությունների և հետկանչերի (callback) համար: -``` + ```js + // արտահայտությունն աջ կողմում է + let sum = (a, b) => a + b; + + // կամ բազմատողանի շարահյուսություն ձևավոր փակագծերով { ... }, այստեղ return-ը անհրաժեշտ է + let sum = (a, b) => { + // ... + return a + b; + } + + // առանց արգումենտների + let sayHi = () => alert("Ողջույն"); + + // մեկ արգումենտով + let double = n => n * 2; + ``` + + +- Ֆունկցիաները կարող են ունենալ տեղական (local) փոփոխականներ․ դրանք հայտարարվում են իրենց մարմնի ներսում կամ պարամետրերի ցանկում: Նման փոփոխականները հասանելի են միայն ֆունկցիայի ներսում: +- Պարամետրերը կարող են ունենալ նախնական արժեք․ `function sum(a = 1, b = 2) {...}`։ +- Ֆունկցիաները միշտ ինչ-որ բան են վերադարձնում. եթե չկա `return` դրույթը, ապա արդյունքը `undefined` է։ -## Ամփոփում +Մանրամասն՝ , ։ -Սլաքով ֆունկցիաները հարմար են պարզ գործողությունների համար, հատկապես՝ մեկ տողանի։ Դրանք լինում են երկու տեսակի. +## Սպասվում է ավելին -1. Առանց ձևավոր փակագծերի՝ `(...args) => expression`, աջ կողմում արտահայտությունն է. ֆունկցիան արժեվորում է այն և վերադարձնում արդյունքը: Կոր փակագծերը կարելի է նաև չնշել, եթե առկա է միայն մեկ արգումենտ, օր․՝ `n => n*2`։ -2. Ձևավոր փակագծերով՝ `(...args) => { body }`, փակագծերը թույլ են տալիս գրել մի քանի դրույթ ֆունկցիայի ներսում, բայց պատասխան վերադարձնելու համար անհրաժեշտ է հստակ նշել `return`: +Սա JavaScript-ի առանձնահատկությունների համառոտ ցանկն էր: Այս պահի դրությամբ մենք ուսումնասիրել ենք միայն հիմունքները: Այս ձեռնարկում ավելի ուշ կգտնեք JavaScript-ի վերաբերյալ ավելի շատ հատկանիշներ և ընդլայնված առանձնահատկություններ։ From 9ed27862c36fb8035717c5e1940df5a5161858b2 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Fri, 13 May 2022 04:31:12 +0400 Subject: [PATCH 2/2] JavaScript specials Updated --- .../18-javascript-specials/article.md | 74 +++++++++---------- 1 file changed, 37 insertions(+), 37 deletions(-) diff --git a/1-js/02-first-steps/18-javascript-specials/article.md b/1-js/02-first-steps/18-javascript-specials/article.md index 303fd84ca..49aabc3f8 100644 --- a/1-js/02-first-steps/18-javascript-specials/article.md +++ b/1-js/02-first-steps/18-javascript-specials/article.md @@ -1,10 +1,10 @@ # JavaScript-ի հատկանիշները -Այս գլխում, հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս: +Այս գլխում՝ հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի այն առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս: ## Կոդի կառուցվածք -Հայտարարությունները տարանջատվում են կետ-ստորակետով. +Դրույթները տարանջատվում են կետ-ստորակետով. ```js run no-beautify alert('Ողջույն'); alert('Աշխարհ'); @@ -25,13 +25,13 @@ alert("Այս հաղորդագրությունից հետո սխալ կլինի: [1, 2].forEach(alert) ``` -Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր հայտարարությունից հետո: +Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր դրույթից հետո: -Կոդերի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է. +Կոդի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է. ```js function f() { - // կետ-ստորակետ պետք չէ ֆունկցիայի հայտարարումից հետո + // կետ-ստորակետ պետք չէ ֆունկցիոնալ հռչակագրից հետո } for(;;) { @@ -39,7 +39,7 @@ for(;;) { } ``` -...Սակայն, եթե մենք «ավելնորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի: +...Սակայն, եթե մենք «ավելորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի: Մանրամասն՝ . @@ -55,64 +55,64 @@ for(;;) { Այդ ցուցումը պետք է լինի սքրիփթի սկզբում կամ ֆունկցիայի մարմնի սկզբում: -Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք կնախընտրեինք ժամանակակից վարքագիծը: +Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք կնախընտրենք ժամանակակից վարքագիծը: -Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք պետք է սովորենք հետագայում) լռեցյալ ակտիվացնում են խիստ ռեժիմը։ +Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք կսովորենք հետագայում) անուղղակիորեն ակտիվացնում են խիստ ռեժիմը։ Ավելին՝ ։ ## Փոփոխականներ -Կարող ենք հայտարարել, օգտագործելով․ +Կարող են հռչակվել՝ օգտագործելով․ - `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" // ֆունկցիաները մշակվում են առանձնահատուկ կերպով ``` Ավելին՝ և ։ ## Փոխազդեցություն -Մենք բրաուզերն ենք օգտագործում որպես աշխատանքային միջավայր, ուստի 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,7 +133,7 @@ JavaScript-ը սպասարկում է հետևյալ օպերատորները. Թվաբանական : Կանոնավոր՝ `* + - /`, նաև `%` մնացորդի համար և `**` աստիճան բարձրացնելու համար։ - Բինար գումարումը `+` միացնում է տողերը։ Եթե օպերանդներից մեկը տող է, մյուսը նույնպես վերածվում է տողի․ + Բինար գումարումը `+` միացնում է տողերը։ ԵՎ եթե օպերանդներից մեկը տող է, մյուսը նույնպես փոխակերպվում է տողի․ ```js run alert( '1' + 2 ); // '12', տող @@ -141,35 +141,35 @@ JavaScript-ը սպասարկում է հետևյալ օպերատորները. ``` Վերագրում -: Կա պարզ վերագրում `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` հրահանգները թույլ են տալիս դուրս գալ ամբողջ ցիկլից/ընթացիկ կրկնությունից: Օգտագործեք պիտակներ ներդրված ցիկլները կանգնեցնելու համար։ Մանրամասն՝ ։ @@ -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` է։ Մանրամասն՝ , ։