diff --git a/1-js/01-getting-started/1-intro/article.md b/1-js/01-getting-started/1-intro/article.md
index 2f4f518f3..f26f3fb24 100644
--- a/1-js/01-getting-started/1-intro/article.md
+++ b/1-js/01-getting-started/1-intro/article.md
@@ -1,122 +1,122 @@
-# An Introduction to JavaScript
+# Ներածություն
 
-Let's see what's so special about JavaScript, what we can achieve with it, and what other technologies play well with it.
+Եկեք տեսնենք, թե ինչ հատկություններ ունի JavaScript-ը, ինչի կարող ենք հասնել նրանով, և ուրիշ ինչ տեխնոլոգիաներ են դրա հետ լավ աշխատում։
 
-## What is JavaScript?
+## Ի՞նչ է JavaScript-ը (ՋավաՍքրիփթ)
 
-*JavaScript* was initially created to "make web pages alive".
+*JavaScript-ը* սկզբից ստեղծվել է, որպեսզի *«կյանք տա կայքերին»*։
 
-The programs in this language are called *scripts*. They can be written right in a web page's HTML and run automatically as the page loads.
+Այս լեզվում ծրագրերը կոչվում են *script-ներ* (սքրիփթ). Նրանք կարող են գրվել ուղղակիորեն կայքի HTML-ի (Էյչ-Թի-Էմ-Էլ) մեջ և աշխատել ավտոմատ կերպով, երբ էջը բեռնվի։
 
-Scripts are provided and executed as plain text. They don't need special preparation or compilation to run.
+Script-ների ներկայացվում և աշխատում են ինչպես հասարակ տեքստ։ Նրանք կարիք չունեն հատուկ նախապատրաստության աշխատելուց առաջ։
 
-In this aspect, JavaScript is very different from another language called [Java](https://en.wikipedia.org/wiki/Java_(programming_language)).
+Այս առումով JavaScript-ը շատ է տարբերվում մեկ այլ լեզվից, որը կոչվում է [Java](https://en.wikipedia.org/wiki/Java_(programming_language)):
 
-```smart header="Why is it called <u>Java</u>Script?"
-When JavaScript was created, it initially had another name: "LiveScript". But Java was very popular at that time, so it was decided that positioning a new language as a "younger brother" of Java would help.
+```smart header="Ինչու՞ <u>Java</u>Script"
+Երբ JavaScript ստեղծվել էր, այն սկզբում ուրիշ անուն ուներ՝ «LiveScript» (ԼայվՍքրիփթ)։ Սակայն Java-ն շատ տարածված էր այդ ժամանակ, և որոշվեց, որ լեզվի տարածմանը կօգնի ներկայացնել նոր լեզուն ինչպես Java-ի «կրտսեր եղբայր»։
 
-But as it evolved, JavaScript became a fully independent language with its own specification called [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript), and now it has no relation to Java at all.
+Բայց երբ այն զարգացավ, JavaScript-ը դարձավ լիովին անկախ լեզու՝ իր հատկանշական մասերով, որոնք անվանվեցին [ECMAScript](http://en.wikipedia.org/wiki/ECMAScript) (ԷՔՄԱՍքրիփթ), և հիմա այն ընդհանրապես ոչ մի կապ չունի Java-ի հետ։
 ```
 
-Today, JavaScript can execute not only in the browser, but also on the server, or actually on any device that has a special program called [the JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine).
+Այսօր, JavaScript-ը կարող է աշխատել ոչ միայն browser-ներում (բրաուզեր), այլ նաև server-ներում (սերվեր), կամ ցանկացած սարքերում, որոնք ունեն մի հատուկ ծրագիր, որը կոչվում է [JavaScript engine](https://en.wikipedia.org/wiki/JavaScript_engine) (ՋավաՍքրիթփ էնջըն).
 
-The browser has an embedded engine sometimes called a "JavaScript virtual machine".
+Browser-ն ունի իր մեջ ներառված engine, որը նաև անվանում են «JavaScript virtual machine» (ՋավաՍքրիփթ վըրչուըլ մըշին)։ 
 
-Different engines have different "codenames". For example:
+Տարբեր engin-ներ ունեն տարբեր «կեղծանուններ»՝
 
-- [V8](https://en.wikipedia.org/wiki/V8_(JavaScript_engine)) -- in Chrome, Opera and Edge.
-- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- in Firefox.
-- ...There are other codenames like "Chakra" for IE, "JavaScriptCore", "Nitro" and "SquirrelFish" for Safari, etc.
+- [V8](https://hy.wikipedia.org/wiki/V8_(JavaScript_%D5%B7%D5%A1%D6%80%D5%AA%D5%AB%D5%B9)) -- Chrome-ում, Opera-ում և Edge-ում։
+- [SpiderMonkey](https://en.wikipedia.org/wiki/SpiderMonkey) -- Firefox-ում։
+- ...Կան այլ կեղծանուններ, ինչպես «Chakra» IE-ի համար, «JavaScriptCore», «Nitro» և «SquirrelFish»՝ Safari-ի համար, և այլն։
 
-The terms above are good to remember because they are used in developer articles on the internet. We'll use them too. For instance, if "a feature X is supported by V8", then it probably works in Chrome, Opera and Edge.
+Նշված տերմինները պետք է հիշել, քանի որ նրանք շատ են օգտագործվում համացանցի հոդվածներում։ Մենք նույնպես կօգտագործենք։ Օրինակ, եթե նշված է, որ «Ա հատկությունը օգտագործվում է V8-ում», ապա այն հավանաբար կաշխատի Chrome-ում, Opera-ում և Edge-ում։
 
-```smart header="How do engines work?"
+```smart header="Ինչպե՞ս են աշխատում engine-ները"
 
-Engines are complicated. But the basics are easy.
+Engine-ները բարդ են, բայց հիմունքները այդքան էլ դժվար չէ հասկանալ։
 
-1. The engine (embedded if it's a browser) reads ("parses") the script.
-2. Then it converts ("compiles") the script to machine code.
-3. And then the machine code runs, pretty fast.
+1. Engine-ը (ներառվածը, եթե browser-ի մասին է խոսքը) կարդում է (parse) script-ը։
+2. Ապա այն փոխում է (compile) script-ը մեքենայական կոդի։
+3. Վերջապես մեքենան աշխատեցնում է կոդը, բավականին արագ։
 
-The engine applies optimizations at each step of the process. It even watches the compiled script as it runs, analyzes the data that flows through it, and further optimizes the machine code based on that knowledge.
+Engine-ը բարեփոխումներ (optimization) է անում ամեն քայլին։ Այն նույնիսկ հետևում է պատրաստ script-ի աշխատանքի ընթացքին, վերլուծում տվյալների հոսքը և կրկին բարեփոխումներ կատարում այդ գիտելիքների օգնությամբ։ Երբ դա արված է, script-ը շատ արագ է աշխատում։
 ```
 
-## What can in-browser JavaScript do?
+## Ի՞նչ է կարող browser-ի միջի JavaScript-ը անել
 
 Modern JavaScript is a "safe" programming language. It does not provide low-level access to memory or the CPU, because it was initially created for browsers which do not require it.
 
-JavaScript's capabilities greatly depend on the environment it's running in. For instance, [Node.js](https://wikipedia.org/wiki/Node.js) supports functions that allow JavaScript to read/write arbitrary files, perform network requests, etc.
+JavaScript-ի հնարավորությունները մեծ մասով կախված են միջավայրից, որում այն աշխատում է։ Օրինակ՝ [Node.js](https://wikipedia.org/wiki/Node.js)-ը ունի ֆունկցիաներ, որոնք թույլատրում են JavaScript-ին կարդալ կամ գրել որևէ ֆայլի մեջ, կատարել ցանցային հարցումներ և այլն։
 
-In-browser JavaScript can do everything related to webpage manipulation, interaction with the user, and the webserver.
+Browser-ի միջի JavaScript-ը կարող է անել ամեն ինչ կապված կայքերի կառավարման հետ և օգտագործողի և server-ի կապի հետ։ver.
 
-For instance, in-browser JavaScript is able to:
+Օրինակ՝ browser-ի միջի JavaScript-ը կարող է՝to:
 
-- Add new HTML to the page, change the existing content, modify styles.
-- React to user actions, run on mouse clicks, pointer movements, key presses.
-- Send requests over the network to remote servers, download and upload files (so-called [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming)) and [COMET](https://en.wikipedia.org/wiki/Comet_(programming)) technologies).
-- Get and set cookies, ask questions to the visitor, show messages.
-- Remember the data on the client-side ("local storage").
+- Ավելացնել նոր HTML էջ, փոխել ներկա պարունակությունը, փոխել ոճը։
+- Պատասխանել օգտագործողի գործողություններին, աշխատել մկնիկի սեղման, շարժման ժամանակ։
+- Ուղարկել հարցումներ համացանցով server-ների, ներբեռնել և վերբեռնել ֆայլեր (այսպես կոչված [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming)) և [COMET](https://en.wikipedia.org/wiki/Comet_(programming)) տեխնոլոգիաներ)։
+- Ստանալ և փոխել cookie-ներ, հարցեր տալ հաճախորդին, ցույց տալ նամակներ։
+- Հիշել օգտատերի տվյալները («local storage»).
 
-## What CAN'T in-browser JavaScript do?
+## Ի՞նչ չի կարող JavaScript-ը անել
 
-JavaScript's abilities in the browser are limited to protect the user's safety. The aim is to prevent an evil webpage from accessing private information or harming the user's data.
+JavaScript-ի հնարավորությունները browser-ում սահմանափակ են ապահովության նկատառումներով։ Նպատակն է կանխել չարամիտ կայքերի հասանելիությունը օգտագործողի անձնական տվյալներին։
 
-Examples of such restrictions include:
+Այսպիսի սահմանափակումների օրինակներ են՝
 
-- JavaScript on a webpage may not read/write arbitrary files on the hard disk, copy them or execute programs. It has no direct access to OS functions.
+- JavaScript-ը էջում չի կարող կարդալ գամ գրել որևը կոշտ սկավառակը ֆայլի մեջ, պատճենել դրանք կամ աշխատեցնել ծրագրեր։ Այն չունի ուղիղ հասանելիություն օպերացիոն համակարգի ֆունկցիաներին։
 
-    Modern browsers allow it to work with files, but the access is limited and only provided if the user does certain actions, like "dropping" a file into a browser window or selecting it via an `<input>` tag.
+    Ժամանակակից browser-ները թույլ են տալիս աշխատել ֆայլերի հետ, բայց հասանելիությունը տրամադրվում է միայն որոշակի դեպքերում, օրինակ՝ երբ օգտագործողը «նետում» է ֆայլերը պատուհանի մեջ կամ ընտրում `<input>` tag-ի միջոցով։
 
-    There are ways to interact with the camera/microphone and other devices, but they require a user's explicit permission. So a JavaScript-enabled page may not sneakily enable a web-camera, observe the surroundings and send the information to the [NSA](https://en.wikipedia.org/wiki/National_Security_Agency).
-- Different tabs/windows generally do not know about each other. Sometimes they do, for example when one window uses JavaScript to open the other one. But even in this case, JavaScript from one page may not access the other page if they come from different sites (from a different domain, protocol or port).
+    Գոյություն ունեն մեթոդներ տեսախցիկին, կամ խոսափողին և այլ սարքերնի հասանելիություն տրամադրելու, բայց դրանք պահանջում են օգտագործողի կողմից կատարված կամավոր գործողություն, որպեսզի էջը գաղտնիաբար չօգտագործի տեսախցիկը և տվյալներ ուղարկի [NSA](https://en.wikipedia.org/wiki/National_Security_Agency)-ին։
+- Տարբեր պատուհանները հիմնականում չգիտեն իրար մասին։ Որոշ դեպքերում, սակայն, գիտեն, օրինակ՝ երբ մի էջը օգտագործում է JavaScript, որ բացի մյուսը։ Սակայն նույնիսկ այս դեպքում, մի էջի JavaScript-ը չի կարող հասանելիություն ունենալ մյուս էջին, եթե նրանք տարբեր կայքից են (տարբեր դոմեյնից, protocol-ից կամ port-ից)։ 
 
-    This is called the "Same Origin Policy". To work around that, *both pages* must agree for data exchange and must contain special JavaScript code that handles it. We'll cover that in the tutorial.
+    Սա կոչվում է «Same Origin Policy»։ Երկու էջերն էլ պետք է պայմանավորվեն տվյալների փոխանակման համար և պարունակեն հատուկ JavaScript կոդ, որը կառավարում է դա։ Մենք կխոսենք դրա մասին դասընթացի մեջ։
 
-    This limitation is, again, for the user's safety. A page from `http://anysite.com` which a user has opened must not be able to access another browser tab with the URL `http://gmail.com`, for example, and steal information from there.
-- JavaScript can easily communicate over the net to the server where the current page came from. But its ability to receive data from other sites/domains is crippled. Though possible, it requires explicit agreement (expressed in HTTP headers) from the remote side. Once again, that's a safety limitation.
+    Այս սահմանափակումը, նույնպես, օգտագործողի ապահովության համար է։ `http://anysite.com`-ից էջը, որը օգտագործողը բացել է, չպետք է հասանելիություն ունենա ուրիշ պատուհանին, օրինակ `http://gmail.com`-ին, ու գողանա տվյալներ։
+- JavaScript-ը կարող է հեշտորեն կապվել ցանցով server-ի հետ, որտեղից որ կայքը գալիս է։ Բայց նրա հնարավորությունը, տվյալներ ստանալ այլ աղբյուրներից, սահմանափակ է։ Չնայած, որ հնարավոր է, սակայն այն պահանջում է հատուկ համաձայնություն (արտահայտված HTTP header-ներով) server-ից։ Կրկին, սա արված է օգտագործողի ապահովության համար։
 
 ![](limitations.svg)
 
-Such limitations do not exist if JavaScript is used outside of the browser, for example on a server. Modern browsers also allow plugins/extensions which may ask for extended permissions.
+Այսպիսի սահմանափակումներ չկան, երբ JavaScript-ը օգտագործվում է browser-ից դուրս, օրինակ՝ server-ներում։ Ժամանակակից browser-ները նույնպես ունեն plug-in-ներ, որոնք կարող են հարցնել հավելյալ թույլտվություններ։
 
-## What makes JavaScript unique?
+## Ի՞նչն է դարձնում JavaScript-ը յուրօրինակ
 
-There are at least *three* great things about JavaScript:
+Կան գոնե *երեք* լավ բաներ JavaScript-ի մասին՝
 
 ```compare
-+ Full integration with HTML/CSS.
-+ Simple things are done simply.
-+ Supported by all major browsers and enabled by default.
++ HTML/CSS-ի հետ ներառում։
++ Հասարակ բաները արվում են հասարակ կերպով։
++ Բոլոր մեծ browser-ները աշխատում են JavaScript—ի հետ։
 ```
-JavaScript is the only browser technology that combines these three things.
+JavaScript-ը միակ browser-ային տեխնոլոգիան է, որը ներառում է այս 3 կետերը։
 
-That's what makes JavaScript unique. That's why it's the most widespread tool for creating browser interfaces.
+Ահա, թե ինչն է սարքում դրան այսքան տարբերվող։ Ահա, թե ինչու է ամենատարածված գործիքը browser-ային ինտերֆեյսեր սարքելու համար։
 
-That said, JavaScript can be used to create servers, mobile applications, etc.
+Ինչպես նաև, JavaScript-ը թույլ է տալիս ստեղծել server-ներ, mobile ծրագրեր և այլն։
 
-## Languages "over" JavaScript
+## Լեզուներ՝ JavaScript-ի «վրա»
 
-The syntax of JavaScript does not suit everyone's needs. Different people want different features.
+JavaScript-ի գրելաձևը բոլորին չի բավարարում։ Տարբեր մարդիկ ցանկանում են տարբեր հատկություններ։
 
-That's to be expected, because projects and requirements are different for everyone.
+Դա սպասելի է, քանի որ ծրագրերն ու պահանջները տարբեր են բոլորի մոտ։
 
-So, recently a plethora of new languages appeared, which are *transpiled* (converted) to JavaScript before they run in the browser.
+Վերջերս բազում նոր լեզուներ են առաջացել, որոնք *transpile* են լինում (փոխվում) JavaScript-ի մինչև browser-ում աշխատելը։
 
-Modern tools make the transpilation very fast and transparent, actually allowing developers to code in another language and auto-converting it "under the hood".
+Ժամանակակից գործիքները դարձնում են փոփոխվելը շատ արագ և թափանցիկ, թույլատրելով ծրագրավորողներին աշխատել այլ լեզվով, և ավտո-փոխակերպում են այն JavaScript-ի աննկատ կերպով։
 
-Examples of such languages:
+Այսպիսի լեզուների օրինակներ են՝
 
-- [CoffeeScript](https://coffeescript.org/) is "syntactic sugar" for JavaScript. It introduces shorter syntax, allowing us to write clearer and more precise code. Usually, Ruby devs like it.
-- [TypeScript](https://www.typescriptlang.org/) is concentrated on adding "strict data typing" to simplify the development and support of complex systems. It is developed by Microsoft.
-- [Flow](https://flow.org/) also adds data typing, but in a different way. Developed by Facebook.
-- [Dart](https://www.dartlang.org/) is a standalone language that has its own engine that runs in non-browser environments (like mobile apps), but also can be transpiled to JavaScript. Developed by Google.
-- [Brython](https://brython.info/) is a Python transpiler to JavaScript that enables the writing of applications in pure Python without JavaScript.
-- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) is a modern, concise and safe programming language that can target the browser or Node.
+- [CoffeeScript](https://coffeescript.org/)-ը ունի կարճ գրելաձև, թույլ է տալիս ծրագրավորողին գրել ավելի մաքուր և ճշգրիտ կոդ։ Հիմնականում Ruby-ի ծրագրավորողներն են հավանում այն։
+- [TypeScript](https://www.typescriptlang.org/)-ը կենտրոնացած է խիստ տիպերի ներմուծման վրա, հեշտացնելով դժվար համակարգերի ծրագրավորումն ու հետագա ապահովումը։ Այն ստեղծվել է Microsoft-ի կողմից։
+- [Flow](https://flow.org/)-ը նույնպես ավելացնում է տվյալների տիպեր, սակայն այլ կերպ է աշխատում։ Ստեղծված է Facebook-ի կողմից։
+- [Dart](https://www.dartlang.org/)-ը առանձին լեզու է, որը ունի իր սեփական engine-ը և աշխատում է ոչ-browser-ային միջավայրներում, ինչպես mobile ծրագրերում, սակայն կարող է թարգմանվել JavaScript-ի։ Ստեղծվել է Google-ի կողմից։
+- [Brython](https://brython.info/) թարգմանում է Python-ը JavaScript-ի։
+- [Kotlin](https://kotlinlang.org/docs/reference/js-overview.html) ժամանակակից, հակիրճ և ապահով ծրագրավորման լեզու է, կա հնարավորություն կոդը թարգմանելու նաև browser-ների or Node-ի համար։
 
-There are more. Of course, even if we use one of these transpiled languages, we should also know JavaScript to really understand what we're doing.
+Կան ուրիշներ։ Իհարկե, եթե նույնիսկ օգտագործենք թարգմանված լեզուները, պետք է իմանանք JavaScript, որպեսզի հասկանանք՝ ինչ ենք անում։
 
-## Summary
+## Ամփոփում
 
-- JavaScript was initially created as a browser-only language, but it is now used in many other environments as well.
-- Today, JavaScript has a unique position as the most widely-adopted browser language, fully integrated with HTML/CSS.
-- There are many languages that get "transpiled" to JavaScript and provide certain features. It is recommended to take a look at them, at least briefly, after mastering JavaScript.
+- JavaScript-ը սկզբում ստեղծվել է միայն browser-ների համար, սակայն այն հիմա օգտագործվում է շատ այլ միջավայրներում նույնպես։
+- Այսօր JavaScript-ը ունի իր ուրույն տեղը որպես ամենաընդունված browser-ի լեզու, HTML/CSS-ի հետ լրիվ ներառմամբ։ 
+- Կան շատ լեզուներ, որոնք «թարգմանվում» են JavaScript-ի և տրամադրում որոշ հատկություններ։ Խորհուրդ է տրվում աչքի անցկացնել դրանք, գոնե մակերեսային, JavaScript-ում խորանալուց հետո։
diff --git a/1-js/01-getting-started/2-manuals-specifications/article.md b/1-js/01-getting-started/2-manuals-specifications/article.md
index 3fa243336..5a5e356e8 100644
--- a/1-js/01-getting-started/2-manuals-specifications/article.md
+++ b/1-js/01-getting-started/2-manuals-specifications/article.md
@@ -1,37 +1,37 @@
 
-# Manuals and specifications
+# Ձեռնարկներ և բնութագրեր
 
-This book is a *tutorial*. It aims to help you gradually learn the language. But once you're familiar with the basics, you'll need other resources.
+Այս գիրքը *ուսուցողական ձեռնարկ* է, որի նպատակն է օգնել Ձեզ աստիճանաբար յուրացնել լեզուն: Երբ ծանոթանաք հիմնական հասկացություններին, ուսուցումը շարունակելու համար այլ աղբյուրների կարիք կլինի:
 
-## Specification
+## Բնութագիր (Specification)
 
-[The ECMA-262 specification](https://www.ecma-international.org/publications/standards/Ecma-262.htm) contains the most in-depth, detailed and formalized information about JavaScript. It defines the language.
+[ECMA-262 ստանդարտը](https://www.ecma-international.org/publications/standards/Ecma-262.htm) պարունակում է ամենախորը, մանրամասն և պատշոնապես ձևակերպված տեղեկատվությունը JavaScript-ի մասին: Այն սահմանում է լեզուն:
 
-But being that formalized, it's difficult to understand at first. So if you need the most trustworthy source of information about the language details, the specification is the right place. But it's not for everyday use.
+Բայց լեզվի նման ձևակերպումը դժվար է հասկանալ սկզբում: Եթե Ձեզ պետք է լեզվի մանրամասների մասին տեղեկատվության ամենավստահելի աղբյուրը, ապա այս պաշտոնական փաստաթուղթն է հենց այդ աղբյուրը: Սակայն այն նախատեսված չէ ամենօրյա օգտագործման համար:
 
-A new specification version is released every year. Between these releases, the latest specification draft is at <https://tc39.es/ecma262/>.
+Ամեն տարի թողարկվում է հատկորոշման նոր տարբերակ: Այս թողարկումների միջև ամենաթարմ սևագիրը գտնվում է <https://tc39.es/ecma262/> հասցեում:
 
-To read about new bleeding-edge features, including those that are "almost standard" (so-called "stage 3"), see proposals at <https://github.com/tc39/proposals>.
+Լեզվի նորագույն հնարավորությունների մասին կարդալու համար (ներառյալ «գրեթե ստանդարտ»՝ այսպես կոչված «stage 3» հնարավորությունները) այցելեք առաջարկությունների կայքը՝ <https://github.com/tc39/proposals> հասցեով:
 
-Also, if you're developing for the browser, then there are other specifications covered in the [second part](info:browser-environment) of the tutorial.
+Ինչպես նաև, եթե Դուք լուծում եք մշակում վեբ զննիչների համար, ապա ձեռնարկի [երկրորդ մասում](info:browser-environment) ունենք տեղեկատվություն այլ բնութագրերի մասին:
 
-## Manuals
+## Ձեռնարկներ
 
-- **MDN (Mozilla) JavaScript Reference** is the main manual with examples and other information. It's great to get in-depth information about individual language functions, methods etc.
+- **MDN (Mozilla) JavaScript Reference**-ը հիմնական ձեռնարկ է՝ հագեցած օրինակներով և այլ տեղեկություններով: Այն օգտակար է լեզվի առանձին հնարավորությունների, մեթոդների և այլնի մասին խորացած տեղեկություններ ստանալու համար.
 
-    You can find it at <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference>.
+    Այն կարելի է գտնել <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference> հասցեով:
 
-Although, it's often best to use an internet search instead. Just use "MDN [term]" in the query, e.g. <https://google.com/search?q=MDN+parseInt> to search for the `parseInt` function.
+Հաճախ ավելի լավ է կատարել որոնում համացանցում: Ուղղակի օգտագործեք "MDN [տերմին]"-ը որոնման մեջ, օրինակ՝ <https://google.com/search?q=MDN+parseInt>, `parseInt` ֆունկցիան որոնելու համար.
 
-## Compatibility tables
+## Համատեղելիության աղյուսակներ
 
-JavaScript is a developing language, new features get added regularly.
+JavaScript-ը զարգացող լեզու է, և պարբերաբար նոր հնարավորություններ են ավելացվում:
 
-To see their support among browser-based and other engines, see:
+Օգտվեք հետևյալ կայքերից՝ տարբեր վեբ զննիչներում և շարժիչներում դրանց հասանելիությունը ստուգելու համար.
 
-- <https://caniuse.com> - per-feature tables of support, e.g. to see which engines support modern cryptography functions: <https://caniuse.com/#feat=cryptography>.
-- <https://kangax.github.io/compat-table> - a table with language features and engines that support those or don't support.
+- <https://caniuse.com> - աջակցության աղյուսակներ՝ յուրաքանչյուր հատկանիշի համար, օրինակ՝ ցույց է տալիս այն շարժիչները, որոնցում սպասարկվում են գաղտնագրման ժամանակակից ֆուկցիաները: <http://caniuse.com/#feat=cryptography>:
+- <https://kangax.github.io/compat-table> - աղյուսակ է, կազմված լեզվի հնարավորություններից և շարժիչներից, որոնցում այդ հնարավորությունները սպասարկվում են կամ չեն սպասարկվում:
 
-All these resources are useful in real-life development, as they contain valuable information about language details, their support, etc.
+Բոլոր այս կայքերն օգտակար են առօրյա աշխատանքում, քանի որ պարունակում են արժեքավոր տեղեկություններ լեզվի հատկանիշների, դրանց սպասարկման մասին և այլն․․․
 
-Please remember them (or this page) for the cases when you need in-depth information about a particular feature.
+Խնդրում ենք մտապահել այդ կայքերը (կամ այս էջը) այն դեպքերի համար, երբ անհրաժեշտ կլինի մանրամասն տեղեկություններ ստանալ որևէ հնարավորության մասին:
diff --git a/1-js/01-getting-started/3-code-editors/article.md b/1-js/01-getting-started/3-code-editors/article.md
index ca6194741..96ef12669 100644
--- a/1-js/01-getting-started/3-code-editors/article.md
+++ b/1-js/01-getting-started/3-code-editors/article.md
@@ -1,49 +1,49 @@
-# Code editors
+# Խմբագրիչներ
 
-A code editor is the place where programmers spend most of their time.
+Ծրագրավորողները ժամանակի մեծ մասն անցկացում են խմբագրիչներում:
 
-There are two main types of code editors: IDEs and lightweight editors. Many people use one tool of each type.
+Կան երկու հիմնական տիպի խմբագրիչներ. IDE-ներ (ամբողջացված մշակման միջավայրեր) և թեթև խմբագրիչներ: Շատերն օգտագործում են դրանցից որևէ մեկը:
 
 ## IDE
 
-The term [IDE](https://en.wikipedia.org/wiki/Integrated_development_environment) (Integrated Development Environment) refers to a powerful editor with many features that usually operates on a "whole project." As the name suggests, it's not just an editor, but a full-scale "development environment."
+[IDE](https://en.wikipedia.org/wiki/Integrated_development_environment)-ն (ամբողջացված մշակման միջավայր) հզոր խմբագրիչ է բազմաթիվ հնարավորություններով, որում կարելի է մշակել և կառավարել ամբողջական նախագծեր: Ինչպես անունն է հուշում՝ այն ուղղակի խմբագրիչ չէ, այլ մշակման ամփոփ միջավայր:
 
-An IDE loads the project (which can be many files), allows navigation between files, provides autocompletion based on the whole project (not just the open file), and integrates with a version management system (like [git](https://git-scm.com/)), a testing environment, and other "project-level" stuff.
+IDE-ն բեռնում է նախագիծը (որը կարող է պարունակել բազմաթիվ ֆայլեր), թույլ է տալիս նավարկել ֆայլերի միջև, տրամադրում է ինքնալրացում (autocompletion), ինտեգրվում է տարբերակների կառավարման համակարգերի (VCS) հետ (օրինակ՝ [git](https://git-scm.com/)), ունի փորձարկման միջավայր և այլն:
 
-If you haven't selected an IDE yet, consider the following options:
+IDE-ների օրնակներ են.
 
-- [Visual Studio Code](https://code.visualstudio.com/) (cross-platform, free).
-- [WebStorm](https://www.jetbrains.com/webstorm/) (cross-platform, paid).
+- [Visual Studio Code](https://code.visualstudio.com/) (հասանելի է տարբեր հարթակների համար, անվճար է):
+- [WebStorm](https://www.jetbrains.com/webstorm/) (հասանելի է տարբեր հարթակների համար, վճարովի է):
 
-For Windows, there's also "Visual Studio", not to be confused with "Visual Studio Code". "Visual Studio" is a paid and mighty Windows-only editor, well-suited for the .NET platform. It's also good at JavaScript. There's also a free version [Visual Studio Community](https://www.visualstudio.com/vs/community/).
+Windows-ի համար կա նաև «Visual Studio»-ն, որը տարբերվում է «Visual Studio Code»-ից. «Visual Studio»-ն վճարովի և բազմաֆունկցիոնալ խմբագրիչ է, ստեղծված միայն Windows-ի համար և հարմարեցված .NET հարթակի համար: Ունի նաև [Visual Studio Community](https://www.visualstudio.com/vs/community/) անվճար տարբերակը:
 
-Many IDEs are paid, but have a trial period. Their cost is usually negligible compared to a qualified developer's salary, so just choose the best one for you.
+Շատ IDE-ներ վճարովի են, բայց ունեն փորձարկման շրջան: Նրանց գինը սովորաբար աննշան է փորձառու ծրագրավորողի աշխատավարձի հետ համեմատած, այնպես որ ուղղակի ընտրեք այն, որը Ձեր կարիքներին առավել լավ է համապատասխանում:
 
-## Lightweight editors
+## Թեթև խմբագրիչներ
 
-"Lightweight editors" are not as powerful as IDEs, but they're fast, elegant and simple.
+«Թեթև խմբագրիչներ»-ը IDE-ների նման հզոր չեն, բայց արագագործ են և պարզ:
 
-They are mainly used to open and edit a file instantly.
+Հիմնականում օգտագործվում են ֆայլերը արագ խմբագրելու համար:
 
-The main difference between a "lightweight editor" and an "IDE" is that an IDE works on a project-level, so it loads much more data on start, analyzes the project structure if needed and so on. A lightweight editor is much faster if we need only one file.
+IDE-ների և «թեթև խմբագրիչներ»-ի հիմնական տարբերությունն այն է, որ IDE-ն աշխատում է նախագծի մակարդակով, բեռնում է շատ ավելի տվայլներ, անհրաժեշտության դեպքում վերլուծում է նախագծի կառուցվածը և այլն: Թեթև խմբագրիչը շատ ավելի արագ է աշխատում, եթե միայն մեկ ֆայլի հետ գործ ունենք:
 
-In practice, lightweight editors may have a lot of plugins including directory-level syntax analyzers and autocompleters, so there's no strict border between a lightweight editor and an IDE.
+Գործնականում թեթև խմբագրիչները կարող են ունենալ բազմաթիվ հավելումներ (plugins), որոնք կարող են խմբագրիչի հնարավորություններ մեծացնել, այնպես որ թեթև խմբագրիչների և IDE-ների մեջ խիստ տարանջատում չկա:
 
-There are many options, for instance:
+Հետևյալ խնբագրիչներն արժանի են Ձեր ուշադրությանը.
 
-- [Sublime Text](https://www.sublimetext.com/) (cross-platform, shareware).
-- [Notepad++](https://notepad-plus-plus.org/) (Windows, free).
-- [Vim](https://www.vim.org/) and [Emacs](https://www.gnu.org/software/emacs/) are also cool if you know how to use them.
+- [Sublime Text](http://www.sublimetext.com) (հասանելի է տարբեր հարթակների համար, վճարովի է).
+- [Notepad++](https://notepad-plus-plus.org/) (Windows, անվճար է).
+- [Vim](http://www.vim.org/), [Emacs](https://www.gnu.org/software/emacs/).
 
-## Let's not argue
+## Այլ խմբագրիչներ
 
-The editors in the lists above are those that either I or my friends whom I consider good developers have been using for a long time and are happy with.
+Վերոնշյալ խմբագրիչները իմ, իմ ընկերների, որվքեր իմ համար լավ ծրագրավորողներ են օգտագործվում են երկար ժանանակ, և մենք գոհ ենք այդ խմբագրիչներով:
 
-There are other great editors in our big world. Please choose the one you like the most.
+Ընդհանրապես ասած գոյություն ունեն նաև այլ խմբագրիչներ: Դուք ազատ են ընտրել այն խմբագրիչը, որ ձեզ դուր է գալիս։
 
-The choice of an editor, like any other tool, is individual and depends on your projects, habits, and personal preferences.
+Խմբագրիչի (ինչպես մնացած գործիքների) ընտրությունը Ձեր անձնական գործն է և կարող է կախված լինել նախագծից, սովորություններից, կամ անձնական նախընտրություններից:
 
-The author's personal opinion:
+Հեղինակի անձնական կարծիքը հետևյալն է.
 
-- I'd use [Visual Studio Code](https://code.visualstudio.com/) if I develop mostly frontend.
-- Otherwise, if it's mostly another language/platform and partially frontend, then consider other editors, such as XCode (Mac), Visual Studio (Windows) or Jetbrains family (Webstorm, PHPStorm, RubyMine etc, depending on the language).
+- Frontend նախագծերի համար ես կօգտագործեի [Visual Studio Code](https://code.visualstudio.com/)։
+- Հակառակ դեպքում, այլ պլատֆորմների/լեզուների համար կդիտարկիե այլ խմբագրչներ, օրինակ XCode (Mac), Visual Studio (Windows) կամ Jetbrains ընտանիքի խմբագրիչ (Webstorm, PHPStorm, RubyMine, և այլն, կախված լեզվից)։
diff --git a/1-js/01-getting-started/4-devtools/article.md b/1-js/01-getting-started/4-devtools/article.md
index bbe8af920..6cb2089d7 100644
--- a/1-js/01-getting-started/4-devtools/article.md
+++ b/1-js/01-getting-started/4-devtools/article.md
@@ -1,63 +1,67 @@
-# Developer console
+# Ծրագրավորման բարձակ (Developer console)
 
-Code is prone to errors. You will quite likely make errors... Oh, what am I talking about? You are *absolutely* going to make errors, at least if you're a human, not a [robot](https://en.wikipedia.org/wiki/Bender_(Futurama)).
+Կոդը կարող է պարունակել սխալներ: Դուք ամենայն հավանականությամբ թույլ կտաք սխալներ ... Օ, ինչի՞ մասին եմ խոսում: Դուք *անպայման* սխալներ եք գործելու, եթե դուք իհարկե մարդ եք, ոչ թե [ռոբոտ](https://en.wikipedia.org/wiki/Bender_(Futurama))։
 
-But in the browser, users don't see errors by default. So, if something goes wrong in the script, we won't see what's broken and can't fix it.
+Բայց զննիչում օգտվողները հիմնականում չեն տեսնում սխալներ: Այսպիսով, եթե սցենարում ինչ-որ բան այն չէ, մենք չենք տեսնի, թե որն է սխալը և չենք կարող շտկել այն:
 
-To see errors and get a lot of other useful information about scripts, "developer tools" have been embedded in browsers.
+Սխալները տեսնելու և սցենարների վերաբերյալ շատ այլ օգտակար տեղեկություններ ստանալու համար «ծրագրավորման գործիքները» տեղադրվել են վեբ զննիչներում:
 
-Most developers lean towards Chrome or Firefox for development because those browsers have the best developer tools. Other browsers also provide developer tools, sometimes with special features, but are usually playing "catch-up" to Chrome or Firefox. So most developers have a "favorite" browser and switch to others if a problem is browser-specific.
+Ծրագրավորողներից շատերը ծրագրավորման համար օգտագործում են Chrome կամ Firefox, քանի որ այդ զննիչներն ունեն ծրագրավորման լավագույն գործիքները: Մյուս զննիչներն էլ տրամադրում են ծրագրավորման գործիքներ, որոնք երբեմն ունեն հատուկ առանձնահատկություններ, բայց սովորաբար դրանք նման են Chrome-ի կամ Firefox-ի ծրագրավորման գործիքներին: Այսպիսով, ծրագրավորողների մեծամասնությունը ունի «սիրված» զննիչ և անցնում է մյուս զննիչներին, եթե խնդիրը հատուկ է տվյալ զննիչին:
 
-Developer tools are potent; they have many features. To start, we'll learn how to open them, look at errors, and run JavaScript commands.
+Ծրագրավորման գործիքները ուժեղ են, դրանք շատ առանձնահատկություններ ունեն: Սկսելու համար մենք կսովորենք, թե ինչպես բացել դրանք, դիտել սխալները և գործարկել JavaScript հրամաններ:
 
 ## Google Chrome
 
-Open the page [bug.html](bug.html).
+Բացեք [bug.html](bug.html) էջը։
 
-There's an error in the JavaScript code on it. It's hidden from a regular visitor's eyes, so let's open developer tools to see it.
+Այնտեղ JavaScript կոդի մեջ սխալ կա: Այն թաքնված է սովորական այցելուի աչքից, ուստի եկեք բացենք ծրագրավորման գործիքները՝ այն տեսնելու համար:
 
-Press `key:F12` or, if you're on Mac, then `key:Cmd+Opt+J`.
+Սեղմեք `key:F12` կամ, եթե ունեք Mac, սեղմեք `key:Cmd+Opt+J`։
 
-The developer tools will open on the Console tab by default.
+Ծրագրավորման գործիքները ինքնուրույն կբացվեն բարձակի ներդիրում:
 
-It looks somewhat like this:
+Դա ունի այսպիսի տեսք։
 
 ![chrome](chrome.webp)
 
-The exact look of developer tools depends on your version of Chrome. It changes from time to time but should be similar.
+Ծրագրավորման գործիքների տեսքը կախված է Chrome-ի տարբերակից: Այն ժամանակ առ ժամանակ փոխվում է, բայց պետք է հիմնականում նման լինի:
 
-- Here we can see the red-colored error message. In this case, the script contains an unknown "lalala" command.
-- On the right, there is a clickable link to the source `bug.html:12` with the line number where the error has occurred.
+- Այստեղ մենք կարող ենք տեսնել կարմիրով գունավորված սխալի հաղորդագրությունը: Այս դեպքում սցենարը պարունակում է անհայտ «lalala» հրաման:
+- Աջ կողմում կա աղբյուրի վրա սեղմվող հղում `bug.html:12` տողի համարով, որտեղ սխալը տեղի է ունեցել:
 
-Below the error message, there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands. Press `key:Enter` to run them.
+Սխալի հաղորդագրության տակ կա կապույտ գույնի `>` նշան։ Այն նշում է այն տողը, որտեղ մենք կարող ենք մուտքագրել JavaScript հրամաններ: Սեղմեք `key:Enter` դրանք գործարկելու համար:
 
-Now we can see errors, and that's enough for a start. We'll come back to developer tools later and cover debugging more in-depth in the chapter <info:debugging-chrome>.
+Այժմ մենք կարող ենք տեսնել սխալները, որը բավական է սկզբի համար: Ավելի ուշ մենք կանդրադառնանք ծրագրավորման գործիքներին և ավելի խորը կծանոթանանք սխալների ողղմանը հետևյալ գլխում <info:debugging-chrome>.
 
-```smart header="Multi-line input"
-Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+```smart header="Բազմատող մուտք"
+Սովորաբար, երբ մենք կոդ ենք գրում բարձակի (console) մեջ և սեղմում ենք `key:Enter`, այն կատարվում է:
 
-To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+Բազմաթիվ տողեր ներմուծելու համար սեղմեք `key:Shift+Enter`։ Այս կերպ կարելի է մուտքագրել JavaScript կոդի երկար ֆրագմենտներ:
 ```
 
-## Firefox, Edge, and others
+## Firefox, Edge, և ուրիշները
 
-Most other browsers use `key:F12` to open developer tools.
+Շատ այլ զննիչներ օգտագործում են `key:F12` ծրագրավորման գործիքները բացելու համար:
 
-The look & feel of them is quite similar. Once you know how to use one of these tools (you can start with Chrome), you can easily switch to another.
+Նրանց տեսքը և աշխատանքը բավականին նման է: Երբ իմանաք, թե ինչպես օգտագործել այս գործիքներից մեկը (կարող եք սկսել Chrome-ից), կարող եք հեշտությամբ անցնել մյուսին:
 
 ## Safari
 
-Safari (Mac browser, not supported by Windows/Linux) is a little bit special here. We need to enable the "Develop menu" first.
+Safari (Mac զննիչ, հասանելի չէ Windows և Linux ՕՀ-երում) այն մի փոքր առանձնահատուկ է: Մենք նախ պետք է միացնենք «ծրագրավորման գործիքները»:
 
+<<<<<<< HEAD
+Բացեք Preferences էջը և գնացեք "Advanced" պատուհան։ Ներքևում checkbox կա ծրագրավորման գործիքների համար։
+=======
 Open Settings and go to the "Advanced" pane. There's a checkbox at the bottom:
+>>>>>>> 51bc6d3cdc16b6eb79cb88820a58c4f037f3bf19
 
 ![safari](safari.png)
 
-Now `key:Cmd+Opt+C` can toggle the console. Also, note that the new top menu item named "Develop" has appeared. It has many commands and options.
+Հիմա `key:Cmd+Opt+C` կարող է բացել բարձակը (console): Նաև նշենք, որ հայտնվել է «ծրագրավորման գործիքներ» անվանմամբ ընտրացանկի նոր վերին կետը: Այն ունի շատ հրամաններ և տարբերակներ:
 
-## Summary
+## Ամփոփում
 
-- Developer tools allow us to see errors, run commands, examine variables, and much more.
-- They can be opened with `key:F12` for most browsers on Windows. Chrome for Mac needs `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (need to enable first).
+- Ծրագրավորման գործիքները մեզ թույլ են տալիս տեսնել սխալներ, գործարկել հրամաններ, ուսումնասիրել փոփոխականները և ավելին:
+- Դրանք կարելի է բացել `key:F12` Windows-ի համար նախատեսված շատ զննիչներում՝ օրինակ Chrome-ում։ Mac-ի համար պետք է սեղմել `key:Cmd+Opt+J`, Safari: `key:Cmd+Opt+C` (բայց անհրաժեշտ է նախ ակտիվացնել).
 
-Now we have the environment ready. In the next section, we'll get down to JavaScript.
+Այժմ մեր միջավայրը պատրաստ է: Հաջորդ բաժնում մենք կանդրադառնանք JavaScript- ին:
diff --git a/1-js/01-getting-started/index.md b/1-js/01-getting-started/index.md
index b327c7860..e36a66a4c 100644
--- a/1-js/01-getting-started/index.md
+++ b/1-js/01-getting-started/index.md
@@ -1,3 +1,3 @@
-# An introduction
+# Ներածություն
 
-About the JavaScript language and the environment to develop with it.
+JavaScript լեզվի և այն միջավայրի մասին, որով ծրագրավորելու ենք:
diff --git a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
index afed6a91d..b3650ef64 100644
--- a/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
+++ b/1-js/02-first-steps/01-hello-world/1-hello-alert/task.md
@@ -2,11 +2,11 @@ importance: 5
 
 ---
 
-# Show an alert
+# Ցուցադրել հաղորդագրություն
 
-Create a page that shows a message "I'm JavaScript!".
+Ստեղծեք էջ, որը ցույց է տալիս «I'm JavaScript!» հաղորդագրությունը։
 
-Do it in a sandbox, or on your hard drive, doesn't matter, just ensure that it works.
+Կարող եք անել այստեղ, կամ ձեր համակարգչում, տարբերություն չկա։ Միայն համոզվեք, որ լուծումն աշխատում է։
 
 [demo src="solution"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
index f42c41e6d..50e1a0547 100644
--- a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
+++ b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/solution.md
@@ -1,8 +1,8 @@
-The HTML code:
+HTML կոդը՝
 
 [html src="index.html"]
 
-For the file `alert.js` in the same folder:
+`alert.js` ֆայլը՝
 
 [js src="alert.js"]
 
diff --git a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
index 26168d6a7..3aafb3982 100644
--- a/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
+++ b/1-js/02-first-steps/01-hello-world/2-hello-alert-ext/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Show an alert with an external script
+# Ցուցադրել հաղորդագրություն արտաքին սկրիպտի միջոցով
 
-Take the solution of the previous task <info:task/hello-alert>. Modify it by extracting the script content into an external file `alert.js`, residing in the same folder.
+Վերցրեք նախորդ խնդրի լուծումը <info:task/hello-alert>։ Տեղափոխեք script պիտակի պարունակությունը `alert.js` ֆայլի մեջ, որը պետք է գտնվի նույն պանակում։
 
-Open the page, ensure that the alert works.
+Բացեք էջը և համոզվեք, որ լուծումն աշխատում է։
diff --git a/1-js/02-first-steps/01-hello-world/article.md b/1-js/02-first-steps/01-hello-world/article.md
index 35f82bf5d..d5ec0e815 100644
--- a/1-js/02-first-steps/01-hello-world/article.md
+++ b/1-js/02-first-steps/01-hello-world/article.md
@@ -1,17 +1,17 @@
 # Hello, world!
 
-This part of the tutorial is about core JavaScript, the language itself.
+Ձեռնարկի այս մասը վերաբերում է բուն JavaScript լեզվին։
 
-But we need a working environment to run our scripts and, since this book is online, the browser is a good choice. We'll keep the amount of browser-specific commands (like `alert`) to a minimum so that you don't spend time on them if you plan to concentrate on another environment (like Node.js). We'll focus on JavaScript in the browser in the [next part](/ui) of the tutorial.
+Մեզ հարկավոր է աշխատանքային միջավայր, որտեղ գործարկելու ենք մեր սկրիպտերը։ Քանի որ այս ձեռնարկը առցանց է, ապա զննիչը լավ ընտրություն է։ Զննիչներին հատուկ հրամանները (օրինակ՝ `alert`) կօգտագործենք հնարավորինս քիչ, որպեսզի դրանց վրա շատ ժամանակ չծախսեք, եթե պլանավորում եք այլ միջավայրում աշխատել (օրինակ՝ Node.js)։ Մենք կկենտրոնանանք զննիչներում JavaScript–ի աշխատանքին ձեռնարկի [հաջորդ բաժնում](/ui)։
 
-So first, let's see how we attach a script to a webpage. For server-side environments (like Node.js), you can execute the script with a command like `"node my.js"`.
+Սկզբում տեսնենք, թե ինչպես էջին կցել որևէ սկրիպտ։ Սերվերային միջավայրերում (օրինակ՝ Node.js) սկրիպտը կարելի է գործարկել հետևյալ կամ նմանատիպ հրամանով՝ `"node my.js"`։
 
 
-## The "script" tag
+## «script» պիտակը (tag)
 
-JavaScript programs can be inserted almost anywhere into an HTML document using the `<script>` tag.
+JavaScript ծրագրերը կարելի է ներդնել HTML փաստաթղթի գրեթե ցանկացած մասում՝ օգտագործելով `<script>` պիտակը։
 
-For instance:
+Օրինակ՝
 
 ```html run height=100
 <!DOCTYPE HTML>
@@ -19,7 +19,7 @@ For instance:
 
 <body>
 
-  <p>Before the script...</p>
+  <p>Սկրիպտից առաջ...</p>
 
 *!*
   <script>
@@ -27,7 +27,7 @@ For instance:
   </script>
 */!*
 
-  <p>...After the script.</p>
+  <p>...սկրիպտից հետո։</p>
 
 </body>
 
@@ -35,24 +35,24 @@ For instance:
 ```
 
 ```online
-You can run the example by clicking the "Play" button in the right-top corner of the box above.
+Կարող եք գործարկել օրինակը սեղմելով «Play» կոճակը։
 ```
 
-The `<script>` tag contains JavaScript code which is automatically executed when the browser processes the tag.
+`<script>` պիտակը պարունակում է JavaScript կոդ, որն ավտոմատ գործարկվում է, երբ զննիչը մշակում է պիտակը։
 
 
-## Modern markup
+## Ժամանակակից նշարկում (markup)
 
-The `<script>` tag has a few attributes that are rarely used nowadays but can still be found in old code:
+`<script>` պիտակը ունի մի քանի հատկանիշներ (attributes), որոնք ներկայումս այնքան էլ հաճախ չեն օգտագործվում, բայց հին կոդերում դեռ կարելի է դրանց հանդիպել։
 
-The `type` attribute: <code>&lt;script <u>type</u>=...&gt;</code>
-: The old HTML standard, HTML4, required a script to have a `type`. Usually it was `type="text/javascript"`. It's not required anymore. Also, the modern HTML standard totally changed the meaning of this attribute. Now, it can be used for JavaScript modules. But that's an advanced topic, we'll talk about modules in another part of the tutorial.
+`type` հատկանիշը՝ <code>&lt;script <u>type</u>=...&gt;</code>
+:  Հին HTML ստանդարտը՝ HTML4–ը, պահանջում էր, որ script–ն ունենա `type` հատկանիշը։ Սովորաբար այն ընդունում էր `type="text/javascript"` տեսքը։ Սա այլևս պարտադիր չէ։ Ինչպես նաև, ժամանակակից HTML ստանդարտը ամբողջովին փոխել է այս հատկանիշի նշանակությունը։ Այժմ այն կարող է օգտագործվել JavaScript մոդուլների համար։ Բայց դա ավելի բարդ թեմա է, որին կանդրադառնանք ձեռնարկի ուրիշ բաժնում։
 
-The `language` attribute: <code>&lt;script <u>language</u>=...&gt;</code>
-: This attribute was meant to show the language of the script. This attribute no longer makes sense because JavaScript is the default language. There is no need to use it.
+`language` հատկանիշը՝ <code>&lt;script <u>language</u>=...&gt;</code>
+: Այս հատկանիշը նպատակ ուներ նշել այն լեզուն, որով գրված էր սկրիպտը։ Այժմ այն անիմաստ է, քանի որ JavaScript–ն է այդ լեզուն, և այս հատկանիշն օգտագործելու կարիք չկա։
 
-Comments before and after scripts.
-: In really ancient books and guides, you may find comments inside `<script>` tags, like this:
+Մեկնաբանություններ սկրիպերից առաջ և հետո։
+: Շատ հին գրքերում և ձեռնարկներում `<script>` պիտակների մեջ կարելի է հանդիպել հետևյալ տիպի մեկնաբանությունների՝
 
     ```html no-beautify
     <script type="text/javascript"><!--
@@ -60,28 +60,28 @@ Comments before and after scripts.
     //--></script>
     ```
 
-    This trick isn't used in modern JavaScript. These comments hide JavaScript code from old browsers that didn't know how to process the `<script>` tag. Since browsers released in the last 15 years don't have this issue, this kind of comment can help you identify really old code.
+    Սա ժամանակակից JavaScript–ում այլևս չի օգտագործվում։ Այս մեկնաբանությունները թաքցնում են JavaScript կոդը հին զննիչներում, որոնք չգիտեն, թե ինչպես մշակել `<script>` պիտակը։ Քանի որ վեջին 15 տարիների ընթացքում թողարկված զննիչներն այս խնդիրը չունեն, ապա նման մեկնաբանություններն օգտագործելու իմաստ չկա։
 
 
-## External scripts
+## Արտաքին սկրիպտեր
 
-If we have a lot of JavaScript code, we can put it into a separate file.
+Եթե JavaScript կոդը շատ է, ապա կարելի է այն առանձին ֆայլի մեջ տեղադրել։
 
-Script files are attached to HTML with the `src` attribute:
+Նման ֆայլերը HTML–ին կցվում են `src` հատկանիշի միջոցով՝
 
 ```html
 <script src="/path/to/script.js"></script>
 ```
 
-Here, `/path/to/script.js` is an absolute path to the script from the site root. One can also provide a relative path from the current page. For instance, `src="script.js"`, just like `src="./script.js"`, would mean a file `"script.js"` in the current folder.
+Այստեղ, `/path/to/script.js`–ը կայքի արմատից (root) սկրիպտի բացարձակ ուղին է (absolute path)։ Կարելի է տրամադրել նաև հարաբերական ուղի տվյալ էջից։ Օրինակ՝ `src="script.js"`–ը, ինչպես `src="./script.js"`-ը, նշանակում է, որ `"script.js"` ֆայլը գտնվում է տվյալ պանակում (folder)։
 
-We can give a full URL as well. For instance:
+Կարելի է նաև նշել ամբողջական URL։ Օրինակ՝
 
 ```html
 <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.js"></script>
 ```
 
-To attach several scripts, use multiple tags:
+Մի քանի սկրիպտեր կցելու համար կարելի է օգտագործել մի քանի պիտակներ՝
 
 ```html
 <script src="/js/script1.js"></script>
@@ -90,29 +90,29 @@ To attach several scripts, use multiple tags:
 ```
 
 ```smart
-As a rule, only the simplest scripts are put into HTML. More complex ones reside in separate files.
+Սովորաբար միայն պարզ սկրիպտերն են ներդնում HTML–ում։ Առավել բարդերը տեղակայվում են առանձին ֆայլերում։
 
-The benefit of a separate file is that the browser will download it and store it in its [cache](https://en.wikipedia.org/wiki/Web_cache).
+Առանձին ֆայլի առավելությունն այն է, որ զննիչը ներբեռնում է այն և պահում իր [cache](https://en.wikipedia.org/wiki/Web_cache)–ում։
 
-Other pages that reference the same script will take it from the cache instead of downloading it, so the file is actually downloaded only once.
+Մյուս էջերը, որոնք հղում ունեն այդ նույն սկրիպտին, նորից ներբեռնելու փոխարեն կվերցնեն այն cache–ից։
 
-That reduces traffic and makes pages faster.
+Սա էջերը դարձնոմ է ավելի արագ և նվազեցնում է traffic–ը։
 ```
 
-````warn header="If `src` is set, the script content is ignored."
-A single `<script>` tag can't have both the `src` attribute and code inside.
+````warn header="Եթե `src` հատկանիշը դրված է, ապա սկիպտի պարունակությունն արհամարհվում է։"
+`<script>` պիտակը չի կարող միաժամանակ `src` հատկանիշն ունենալ և պարունակել կոդ։
 
-This won't work:
+Սա չի աշխատի՝
 
 ```html
 <script *!*src*/!*="file.js">
-  alert(1); // the content is ignored, because src is set
+  alert(1); // այս պարունակությունը արհամարհվում է, քանի որ դրված է src հատկանիշը
 </script>
 ```
 
-We must choose either an external `<script src="…">` or a regular `<script>` with code.
+Այսինքն՝ պետք է ընտրություն կատարենք արտաքին `<script src="…">` պիտակի և սովորական `<script>` պիտակի միջև, որը կոդ է պարունակում։
 
-The example above can be split into two scripts to work:
+Վերևում բերված օրինակը աշխատեցնելու համար այն կարելի է բաժանել երկու սկրիպտերի միջև․
 
 ```html
 <script src="file.js"></script>
@@ -122,11 +122,11 @@ The example above can be split into two scripts to work:
 ```
 ````
 
-## Summary
+## Ամփոփում
 
-- We can use a `<script>` tag to add JavaScript code to a page.
-- The `type` and `language` attributes are not required.
-- A script in an external file can be inserted with `<script src="path/to/script.js"></script>`.
+- Կարող ենք օգտագործել `<script>` պիտակը՝ էջում JavaScript կոդ ավելացնելու համար։
+- `type` և `language` հատկանիշները պարտադիր չեն։
+- Արտաքին ֆայլում պահվող սկրիպտը կարելի է կցել էջին հետևյալ կերպ՝ `<script src="path/to/script.js"></script>`։
 
 
-There is much more to learn about browser scripts and their interaction with the webpage. But let's keep in mind that this part of the tutorial is devoted to the JavaScript language, so we shouldn't distract ourselves with browser-specific implementations of it. We'll be using the browser as a way to run JavaScript, which is very convenient for online reading, but only one of many.
+Այնքա՜ն բան կա սովորելու զննիչներում սկրիպտերի աշխատանքի և էջերի հետ դրանց փոխազդեցության մասին։ Հիշենք, որ ձեռնարկի այս բաժինը նվիրված է JavaScript լեզվին, այնպես որ պետք չէ ինքներս մեզ շեղենք զննիչներին հատուկ առանձնահատկություններով։ Մենք կօգտագործենք զննիչը JavaScript կոդը գործարկելու համար, ինչը հարմար է առցանց ընթերցանության համար։
diff --git a/1-js/02-first-steps/02-structure/article.md b/1-js/02-first-steps/02-structure/article.md
index e81fd343d..33eede157 100644
--- a/1-js/02-first-steps/02-structure/article.md
+++ b/1-js/02-first-steps/02-structure/article.md
@@ -1,44 +1,44 @@
-# Code structure
+# Կոդի կառուցվածքը
 
-The first thing we'll study is the building blocks of code.
+Առաջին հերթին ուսումնասիրենք կոդի կառուցման տարրական էլեմենտները։
 
-## Statements
+## Դրույթներ (statements)
 
-Statements are syntax constructs and commands that perform actions.
+Դրույթները շարահյուսական (syntax) կառույցներ և հրամաններ են, որոնք իրականացնում են գործողություններ։
 
-We've already seen a statement, `alert('Hello, world!')`, which shows the message "Hello, world!".
+Մենք արդեն հանդիպել են դրույթի օրինակի՝ `alert('Hello, world!')`, որի գործողությունն է ցույց տալ «Hello, world!» հաղորդագրությունը։
 
-We can have as many statements in our code as we want. Statements can be separated with a semicolon.
+Կոդում կարող ենք ունենալ այնքան դրույթներ, որքան կամենանք։ Դրույթներն իրարից բաժանվում են կետ-ստորակետով (semicolon)։
 
-For example, here we split "Hello World" into two alerts:
+Օրինակ՝ բաժանենք «Hello, world!»–ը երկու alert դրույթների․
 
 ```js run no-beautify
 alert('Hello'); alert('World');
 ```
 
-Usually, statements are written on separate lines to make the code more readable:
+Դրույթները սովորաբար տեղադրում են առանձին տողերում՝ կոդն ավելի ընթեռնելի դարձնելու համար։
 
 ```js run no-beautify
 alert('Hello');
 alert('World');
 ```
 
-## Semicolons [#semicolon]
+## Կետ-ստորակետ [#semicolon]
 
-A semicolon may be omitted in most cases when a line break exists.
+Կետ-ստորակետը դեպքերի մեծամասնությունում կարելի է բաց թողել, եթե առակա է նոր տողին անցում․
 
-This would also work:
+Հետևյալ օրինակը կաշխատի՝
 
 ```js run no-beautify
 alert('Hello')
 alert('World')
 ```
 
-Here, JavaScript interprets the line break as an "implicit" semicolon. This is called an [automatic semicolon insertion](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion).
+Այստեղ JavaScript–ն ընկալում է նոր տողին անցումը որպես կետ-ստորակետ։ Սա կոչվում է [կետ-ստորակետի ինքաշխատ ավելացում](https://tc39.github.io/ecma262/#sec-automatic-semicolon-insertion) (automatic semicolon insertion)։
 
-**In most cases, a newline implies a semicolon. But "in most cases" does not mean "always"!**
+**Դեպքերի մեծամասնությունում նոր տողին անցումը դիտարկվում է որպես կետ-ստորակետ։ Կան դեպքեր, երբ այս պնդումը ճիշտ չէ։**
 
-There are cases when a newline does not mean a semicolon. For example:
+Որոշ դեպքերում նոր տողին անցումը չի դիտվում որպես կետ-ստորակետ։ Օրինակ՝
 
 ```js run no-beautify
 alert(3 +
@@ -46,14 +46,14 @@ alert(3 +
 + 2);
 ```
 
-The code outputs `6` because JavaScript does not insert semicolons here. It is intuitively obvious that if the line ends with a plus `"+"`, then it is an "incomplete expression", so a semicolon there would be incorrect. And in this case, that works as intended.
+Կոդն արտածում է `6`, քանի որ JavaScript–ն այստեղ կետ-ստորակետ չի ավելացնում։ Ակնհայտ է․ քանի որ տողն ավարտվում է `"+"`–ով, ապա այն անավարտ արտահայտություն է և կետ–ստորակերի կարիք չկա։
 
-**But there are situations where JavaScript "fails" to assume a semicolon where it is really needed.**
+**Կան դեպքեր, երբ JavaScript–ը կետ–ստորակետ չի դնում, բայց իրականում այն անհրաժեշտ է։**
 
-Errors which occur in such cases are quite hard to find and fix.
+Այս դեպքերում առաջացող սխալները բավական դժվար է գտնել և ուղղել։
 
-````smart header="An example of an error"
-If you're curious to see a concrete example of such an error, check this code out:
+````smart header="Սխալի օրինակ"
+Ահա կոդ, որի միջոցով կհանգենք նման սխալի՝
 
 ```js run
 alert("Hello");
@@ -61,9 +61,9 @@ alert("Hello");
 [1, 2].forEach(alert);
 ```
 
-No need to think about the meaning of the brackets `[]` and `forEach` yet. We'll study them later. For now, just remember the result of running the code: it shows `Hello`, then `1`, then `2`.
+Այժմ չմտածենք այն մասին, թե ինչ են նշանակում `[]` փակագծերը և `forEach`–ը։ Դրանց մասին սովորելու ենք հետագայում։ Այս պահին հիշենք այս կոդի արդյունքը՝ այն արտածում է `Hello`, `1`, հետո `2`։
 
-Now let's remove the semicolon after the `alert`:
+Հիմա եկեք `alert`-ից հետո գտնվող կետ–ստորակետը ջնջենք՝
 
 ```js run no-beautify
 alert("Hello")
@@ -71,85 +71,82 @@ alert("Hello")
 [1, 2].forEach(alert);
 ```
 
-The difference compared to the code above is only one character: the semicolon at the end of the first line is gone.
+Միակ տարբերությունը բերված կոդում այդ կետ֊ստորակետն է, որն այլևս չկա։
+Եթե գործարկենք այս կոդը միայն `Hello`֊ը կարտածվի (սխալը տեսնելու համար անհրաժեշտ է բացել բարձակը)։
 
-If we run this code, only the first `Hello` shows (and there's an error, you may need to open the console to see it). There are no numbers any more.
+Սխալն առաջանում է այն պատճառով, որ JavaScript–ը `[...]`–ից առաջ կետ–ստորակետ չի դնում։ Քանի որ կետ–ստորակետն ինքնաշխատ չի ավելացվում, այս օրինակում ողջ կոդը դիտվում է որպես մեկ դրույթ։
 
-That's because JavaScript does not assume a semicolon before square brackets `[...]`. So, the code in the last example is treated as a single statement.
-
-Here's how the engine sees it:
+Ահա, թե ինչպես է JavaScript շարժիչը տեսնում այն՝
 
 ```js run no-beautify
-alert("Hello")[1, 2].forEach(alert);
+alert("Սրանից հետո սխալ է լինելու")[1, 2].forEach(alert)
 ```
 
-Looks weird, right? Such merging in this case is just wrong. We need to put a semicolon after `alert` for the code to work correctly.
-
-This can happen in other situations also.
+Պարզ է, որ այստեղ երկու դրույթ պետք է լինի՝ ոչ թե մեկ։ Դրույթների նման միաձուլումն էլ հանգեցնում է սխալին։ Սա կարող է տեղի ունենալ նաև այլ իրավիճակներում։
 ````
 
-We recommend putting semicolons between statements even if they are separated by newlines. This rule is widely adopted by the community. Let's note once again -- *it is possible* to leave out semicolons most of the time. But it's safer -- especially for a beginner -- to use them.
+Խորհուրդ ենք տալիս դրույթներից հետո դնել կետ–ստորակետ, նույնիսկ եթե դրույթներն առաձին տողերում են։ Սա տարածված կանոն է։ Եվս մեկ անգամ կրկնենք․ դեպքերի մեծամասնությունում *հնարավոր է* բաց թողել կետ–ստորակետը, բայց ավելի ապահով է (հատկապես սկսնակների համար) օգտագործել այն։
 
-## Comments [#code-comments]
+## Մեկնաբանություններ [#code-comments]
 
-As time goes on, programs become more and more complex. It becomes necessary to add *comments* which describe what the code does and why.
+Ժամանակի ընթացքում ծրագրերի բարդությունն աճում է։ Անհրաժեշտ է լինում հաճախ *մեկնաբանությունների* միջոցով նկարագրել, թե ինչ է անում տվյալ կոդը և ինչու։
 
-Comments can be put into any place of a script. They don't affect its execution because the engine simply ignores them.
+Մեկնաբանությունները կարող են զետեղվել սկրիպտի կամայական հատվածում։ Դրանք չեն ազդում կոդի աշխատանքի վրա, քանի որ արհամարհվում են շարժիչի կողմից։
 
-**One-line comments start with two forward slash characters `//`.**
+**Միատող մեկնաբանությունները սկսվում են կրկնակի շեղ գծերով՝ `//`։**
 
-The rest of the line is a comment. It may occupy a full line of its own or follow a statement.
+Տողի մնացած մասը դառնում է մեկնաբանություն։ Այն կարող է զբաղեցնել ամբողջ տողը, կամ գտնվել դրույթից հետո։
 
-Like here:
+Ինչպես հետևյալ օրինակում՝
 ```js run
-// This comment occupies a line of its own
+// Այս մեկնաբանությունը գտնվում է առանձին տողում և զբաղեցնում է ամբողջ տողը
 alert('Hello');
 
-alert('World'); // This comment follows the statement
+alert('World'); // Այս մեկնաբանությունը գտնվում է դրույթից հետո
 ```
 
-**Multiline comments start with a forward slash and an asterisk <code>/&#42;</code> and end with an asterisk and a forward slash <code>&#42;/</code>.**
+**Բազմատող մեկնաբանությունները սկսվում են շեղ գծով և աստղանիշով՝ <code>/&#42;</code>, վերջանում աստղանիշով և շեղ գծով՝ <code>&#42;/</code>։**
 
-Like this:
+Ինչպես այս օրինակում՝
 
 ```js run
-/* An example with two messages.
-This is a multiline comment.
+/* Այս օրինակն արտածում է երկու հաղորդագրություն։
+Սա բազմատող մեկնաբանություն է։
 */
 alert('Hello');
 alert('World');
 ```
 
-The content of comments is ignored, so if we put code inside <code>/&#42; ... &#42;/</code>, it won't execute.
+Մեկնաբանության պարունակությունն արհամարհվում է, այնպես որ, եթե կոդ տեղադրենք <code>/&#42; ... &#42;/</code>–ի մեջ, ապա այն չի գործարկվի։
 
-Sometimes it can be handy to temporarily disable a part of code:
+Սովորաբար օգտակար է ժամանակավորապես անջատել կոդի մի մասը՝
 
 ```js run
-/* Commenting out the code
+/* Այս կոդը գտնվում է մեկնաբանության մեջ և չի գործարկվի
 alert('Hello');
 */
 alert('World');
 ```
 
-```smart header="Use hotkeys!"
-In most editors, a line of code can be commented out by pressing the `key:Ctrl+/` hotkey for a single-line comment and something like `key:Ctrl+Shift+/` -- for multiline comments (select a piece of code and press the hotkey). For Mac, try `key:Cmd` instead of `key:Ctrl` and `key:Option` instead of `key:Shift`.
+```smart header="Օգտագործեք ստեղների համադրություններ"
+Բազմաթիվ խմբագրիչներում տողը կարելի է զետեղել մեկնաբանության մեջ, սեղմելով `key:Ctrl+/` ստեղները՝ միատող մեկնաբանության համար, և `key:Ctrl+Shift+/` ստեղները (կամ նմանատիպ այլ համադրություն)՝ բազմատող մեկնաբանությունների համար։ Mac–ում `key:Ctrl`–ի փոխարեն օգտագործեք `key:Cmd`, իսկ `key:Shift`–ի փոխարեն՝ `key:Option`։
 ```
 
-````warn header="Nested comments are not supported!"
-There may not be `/*...*/` inside another `/*...*/`.
+````warn header="Մեկնաբանությունները չեն ներդրվում"
+Չի կարելի ներդնել `/*...*/`–ը այլ բազմատող մեկնաբանության մեջ։
 
-Such code will die with an error:
+Այս կոդը սխալ կառաջացնի՝
 
 ```js run no-beautify
 /*
-  /* nested comment ?!? */
+  /* ներդրված մեկնաբանություն ?!? */
 */
 alert( 'World' );
 ```
 ````
 
-Please, don't hesitate to comment your code.
+Աշխատեք թողնել մեկնաբանություններ ձեր կոդում։
 
-Comments increase the overall code footprint, but that's not a problem at all. There are many tools which minify code before publishing to a production server. They remove comments, so they don't appear in the working scripts. Therefore, comments do not have negative effects on production at all.
+Մեկնաբանությունները մեծացնում են սկրիպտի ծավալը, սակայն դա ընդհանրապես խնդիր չէ։ Կան բազմաթիվ գործիքներ, որոնք հնարավորինս փոքրացնում են կոդը և բերում վերջնական տեսքի՝ միչև այն սերվեր վերբեռնելը։ Դրանք ջնջում են մեկնաբանությունները, այնպես որ վերջնական սկրիպտում դրանք բացակայում են։
 
-Later in the tutorial there will be a chapter <info:code-quality> that also explains how to write better comments.
+Այս ձեռնարկի <info:code-quality> բաժնում կանդրադառնանք այն հարցին, թե ինչպես գրել լավ մեկնաբանություններ։
diff --git a/1-js/02-first-steps/03-strict-mode/article.md b/1-js/02-first-steps/03-strict-mode/article.md
index 9586733cc..93adc3598 100644
--- a/1-js/02-first-steps/03-strict-mode/article.md
+++ b/1-js/02-first-steps/03-strict-mode/article.md
@@ -1,58 +1,58 @@
-# The modern mode, "use strict"
+# "use strict"
 
-For a long time, JavaScript evolved without compatibility issues. New features were added to the language while old functionality didn't change.
+Երկար ժամանակ JavaScript–ը զարգանում էր առանց համատեղելիության խնդիրների։ Լեզվում նոր հնարավորություններ էին ավելացվում, իսկ հները փոփոխության չէին ենթարկվում։
 
-That had the benefit of never breaking existing code. But the downside was that any mistake or an imperfect decision made by JavaScript's creators got stuck in the language forever.
+Այս մոտեցման առավելությունն այն էր, որ գոյություն ունեցող կոդը միշտ աշխատում էր առանց փոփոխության։ Մյուս կողմից, JavaScript–ը նախագծողների ցանկացած սխալը, կամ թերի որոշումը դատապարտված էր մնալ լեզվում ընդմիշտ։
 
-This was the case until 2009 when ECMAScript 5 (ES5) appeared. It added new features to the language and modified some of the existing ones. To keep the old code working, most such modifications are off by default. You need to explicitly enable them with a special directive: `"use strict"`.
+Սա ճիշտ էր մինչև 2009 թ․, երբ հայտնվեց ECMAScript 5–ը (ES5)։ Այն լեզվում ավելացրեց նոր հնարավորություններ և փոփոխեց որոշ արդեն գոյություն ունեցողները։ Որպեսզի հին կոդն աշխատեր, այդ փոփոխությունները անջատած էին լռելյայն։ Դրանք պետք էր բացահայտ միացնել, օգատգործելով հատուկ հրահանգ՝ `"use strict"`։
 
-## "use strict"
+## "use strict" հրահանգը
 
-The directive looks like a string: `"use strict"` or `'use strict'`. When it is located at the top of a script, the whole script works the "modern" way.
+Այս հրահանգն իրենից ներկայացնում է սովորական տող՝ `"use strict"`, կամ `'use strict'`։ Երբ այն գտնվում է սկրիպտի վերևում, ապա սկրիպն աշխատում է ժամանակակից ձևով։
 
-For example:
+Օրինակ՝
 
 ```js
 "use strict";
 
-// this code works the modern way
+// այս կոդն աշխատում է ժամանակակից ձևով
 ...
 ```
 
-Quite soon we're going to learn functions (a way to group commands), so let's note in advance that `"use strict"` can be put at the beginning of a function. Doing that enables strict mode in that function only. But usually people use it for the whole script.
+Շուտով սովորելու ենք ֆունկցիաների մասին, այնպես որ նախօրոք ասենք, որ `"use strict"`–ը կարելի է տեղադրել ֆունկցիայի սկզբում։ Դա միացնում է ժամանակակից ռեժիմը միայն այդ ֆունկցիայում։ Սովորաբար `"use strict"`–ն օգտագործվում է ողջ սկրիպտի համար։
 
-````warn header="Ensure that \"use strict\" is at the top"
-Please make sure that `"use strict"` is at the top of your scripts, otherwise strict mode may not be enabled.
+````warn header="Համոզվեք, որ \"use strict\"–ը գտվում է վերևում"
+Համոզվեք, որ `"use strict"`–ը գտվում է սկրիպտի վերևում, հակառակ դեպքում այն կարող է չաշխատել։
 
-Strict mode isn't enabled here:
+Այս օրինակում այն չի աշխատում՝
 
 ```js no-strict
 alert("some code");
-// "use strict" below is ignored--it must be at the top
+// "use strict"–ն այստեղ արհամարհվում է՝ այն պետք է գտնվի ամենավերևում
 
 "use strict";
 
-// strict mode is not activated
+// ժամանակակից ռեժիմը միացված չէ
 ```
 
-Only comments may appear above `"use strict"`.
+`"use strict"`–ից առաջ կարող են լինել միայն մեկնաբանություններ՝
 ````
 
-```warn header="There's no way to cancel `use strict`"
-There is no directive like `"no use strict"` that reverts the engine to old behavior.
+```warn header="Հնարավոր չէ չեղարկել `use strict`–ի գործողությունը"
+Գոյություն չունի `"no use strict"` հրահանգ, որը չեղարկում է շարժիչի պահվածքը։
 
-Once we enter strict mode, there's no going back.
+Այսպիսով՝ `use strict`–ի գործողությունը չի կարելի չեղարկել։
 ```
 
-## Browser console
+## Զննիչի բարձակը (browser console)
 
-When you use a [developer console](info:devtools) to run code, please note that it doesn't `use strict` by default.
+[Ծրագրավորման բարձակ](info:devtools)–ում `use strict`–ը լռելյայն չի օգտագործում։
 
-Sometimes, when `use strict` makes a difference, you'll get incorrect results.
+Երբեմն `use strict`–ի կիրառումը կարող է հանգեցնել սխալ արդյունքների։
 
-So, how to actually `use strict` in the console?
+Ունեմն ինչպե՞ս օգտագործել `use strict`–ը բարձակում։
 
-First, you can try to press `key:Shift+Enter` to input multiple lines, and put `use strict` on top, like this:
+Կարող եք սեղմել `key:Shift+Enter` ստեղները մի քանի տող ներմուծելու համար և գրել `use strict` վերևում՝
 
 ```js
 'use strict'; <Shift+Enter for a newline>
@@ -60,30 +60,26 @@ First, you can try to press `key:Shift+Enter` to input multiple lines, and put `
 <Enter to run>
 ```
 
-It works in most browsers, namely Firefox and Chrome.
+Սա կաշխատի հիմնական զննիչներում (Firefox, Chrome)։
 
-If it doesn't, e.g. in an old browser, there's an ugly, but reliable way to ensure `use strict`. Put it inside this kind of wrapper:
+Եթե օգտագործում եք շատ հին զննիչ, ապա կարելի է `use strict`–ը դնել ֆունկցիայի մեջ՝
 
 ```js
 (function() {
   'use strict';
 
-  // ...your code here...
+  // ...ձեր կոդն այստեղ...
 })()
 ```
 
-## Should we "use strict"?
+## Արդյոք պե՞տք է օգտագործել "use strict" հրահանգը
 
-The question may sound obvious, but it's not so.
+Պատասխանը կարող է ակնհայտ թվալ, բայց դա այդպես չէ։
 
-One could recommend to start scripts with `"use strict"`... But you know what's cool?
+Գուցե ինչ–որ մեկը խորդուրդ տա սկսել բոլոր սկրիպտերը `"use strict"`–ով։ Սակայն, ժամանակակից JavaScript–ի «class»–երը և «module»–ները (որոնք մենք հետո կուսումնասիրենք), օգտագործում են `use strict`–ը լռելյայն։ Այնպես որ կարիք չկա օգտագործել `"use strict"` հրահանգը այդ դեպքերում։
 
-Modern JavaScript supports "classes" and "modules" - advanced language structures (we'll surely get to them), that enable `use strict` automatically. So we don't need to add the `"use strict"` directive, if we use them.
+**Այսպիսով՝ մենք կօգտագործենք `"use strict";`–ի մեր սկրիպտերում։ Հետո, երբ ձեր կոդն ամբողջովին կգտնվի «class»–երում և «module»–ներում՝ կարող եք այն բաց թողել։**
 
-**So, for now `"use strict";` is a welcome guest at the top of your scripts. Later, when your code is all in classes and modules, you may omit it.**
+Հաջորդ բաժիններում, որտեղ կսովորենք լեզվի այլ հնարավորությունների մասին, կտեսնենք տարբերությունը `"use strict"`–ով և առանց դրա։
 
-As of now, we've got to know about `use strict` in general.
-
-In the next chapters, as we learn language features, we'll see the differences between the strict and old modes. Luckily, there aren't many and they actually make our lives better.
-
-All examples in this tutorial assume strict mode unless (very rarely) specified otherwise.
+Այս ձեռնարկի բոլոր օրինակները ենթադրում են `"use strict"`–ի կիրառում, եթե հակառակը նշված չէ (խիստ հազվադեպ դեպքերում)։
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
index 9249e1c84..adc05f57c 100644
--- a/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/1-hello-variables/solution.md
@@ -1,7 +1,7 @@
-In the code below, each line corresponds to the item in the task list.
+Ստորև բերված կոդում յուրաքանչյուր տող համապատասխանում է հանձնարարության ամեն մի կետի:
 
 ```js run
-let admin, name; // can declare two variables at once
+let admin, name; // կարող ենք հայտարարել միանգամից երկու փոփոխական
 
 name = "John";
 
diff --git a/1-js/02-first-steps/04-variables/1-hello-variables/task.md b/1-js/02-first-steps/04-variables/1-hello-variables/task.md
index 84f009e8c..25b05f765 100644
--- a/1-js/02-first-steps/04-variables/1-hello-variables/task.md
+++ b/1-js/02-first-steps/04-variables/1-hello-variables/task.md
@@ -2,9 +2,9 @@ importance: 2
 
 ---
 
-# Working with variables
+# Աշխատում ենք փոփոխականների հետ
 
-1. Declare two variables: `admin` and `name`.
-2. Assign the value `"John"` to `name`.
-3. Copy the value from `name` to `admin`.
-4. Show the value of `admin` using `alert` (must output "John").
+1. Հայտարարեք երկու փոփոխական. `admin` և `name`:
+2. `name`-ին վերագրեք `"John"` արժեքը:
+3. Պատճենեք `name`-ի արժեքը `admin`-ի մեջ:
+4. Ցույց տվեք `admin`-ի արժեքը `alert`-ի միջոցով (պետք է արտատպի "John"):
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
index 392f4e26f..bfafac0eb 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/solution.md
@@ -1,21 +1,21 @@
-## The variable for our planet
+## Մեր մոլորակի անունը պարունակող փոփոխականը
 
-That's simple:
+Այստեղ ամեն ինչ պարզ է՝
 
 ```js
 let ourPlanetName = "Earth";
 ```
 
-Note, we could use a shorter name `planet`, but it might not be obvious what planet it refers to. It's nice to be more verbose. At least until the variable isNotTooLong.
+Կարող էինք նաև օգտագործել ավելի կարճ `planet` անունը, բայց հասկանալի չէր լինի, թե որ մոլորակի անունն է այն: Ավելի լավ է փոփոխականի անունը լինի երկար, բայց հասկանալի: Բայց ոչ շատ երկար:
 
-## The name of the current visitor
+## Տվյալ հաճախորդի անունը պահող փոփոխականը
 
 ```js
 let currentUserName = "John";
 ```
 
-Again, we could shorten that to `userName` if we know for sure that the user is current.
+Կարող էինք ընտրել նաև `userName` անունը, եթե հաստատ գիտենք, որ հաճախորդը տվյալ պահին կայքում է:
 
-Modern editors and autocomplete make long variable names easy to write. Don't save on them. A name with 3 words in it is fine.
+Ժամանակակից խմբագրիչները կարող են նպաստել փոփոխականների երկար անուններ գրելուն: Արժի փոփոխականի անունը պահել կարճ, ոչ ավել, քան երեք բառ:
 
-And if your editor does not have proper autocompletion, get [a new one](/code-editors).
+Եվ եթե Ձեզ խմբագրիչը չունի կոդի ինքնաշխատ հուշումներ (autocompletion) տրամադրելու հնարավորությունը, խորհուրդ ենք տալիս [փոխել այն](/code-editors):
diff --git a/1-js/02-first-steps/04-variables/2-declare-variables/task.md b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
index f364badf4..b03486f48 100644
--- a/1-js/02-first-steps/04-variables/2-declare-variables/task.md
+++ b/1-js/02-first-steps/04-variables/2-declare-variables/task.md
@@ -2,7 +2,7 @@ importance: 3
 
 ---
 
-# Giving the right name
+# Ընտրում ենք փոփոխականի ճիշտ անուն
 
-1. Create a variable with the name of our planet. How would you name such a variable?
-2. Create a variable to store the name of a current visitor to a website. How would you name that variable?
+1. Հայտարարեք փոփոխական, որը կպարունակի մեր մոլորակի անունը: Ի՞նչ կդնեիք նման փոփոխականի անունը:
+2. Հայտարարեք փոփոխական, որը կպարունակի կայքի տվյալ հաճախորդի անունը: Ի՞նչ կդնեիք նման փոփոխականի անունը:
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
index acd643fde..f4de464d8 100644
--- a/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
+++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/solution.md
@@ -1,5 +1,5 @@
-We generally use upper case for constants that are "hard-coded". Or, in other words, when the value is known prior to execution and directly written into the code.
+Ընդհանուր առմամբ մեծատառերով գրվում են այսպես կոչված «hard-coded» հաստատունները: Այլ կերպ ասած, երբ հաստատունի արժեքը նախօրոք հայտնի է մինչև կոդը գործարկելը, և այդ արժեքը ուղղակի գրված է կոդում:
 
-In this code, `birthday` is exactly like that. So we could use the upper case for it.
+Այս օրինակում `birthday`-ը պարունակում է նման արժեք, այնպես որ իմաստ ունի այն գրել մեծատառերով:
 
-In contrast, `age` is evaluated in run-time. Today we have one age, a year after we'll have another one. It is constant in a sense that it does not change through the code execution. But it is a bit "less of a constant" than `birthday`: it is calculated, so we should keep the lower case for it.
+Մյուս կողմից, `age`-ի արժեքը հայտնի է դառնում միայն երբ կոդը գործարկվում է: Տարեցտարի այդ փոփոխականի արժեքը փոխվում է: Այն հաստատուն է այն իմաստով, որ իր արժեքը չի փոխում կոդի գործարկման ժամանակ: Բայց այն «ավելի քիչ հաստատուն» է, քան `birthday`-ը, քանի որ արժեքը հաշվվում է սկրիպտի աշխատանքի ընթացքում: Այսպիսով՝ արժի գրել այն փոքրատառ:
diff --git a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
index f3c208a74..39f2eee67 100644
--- a/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
+++ b/1-js/02-first-steps/04-variables/3-uppercast-constant/task.md
@@ -2,9 +2,9 @@ importance: 4
 
 ---
 
-# Uppercase const?
+# Մեծատառ հաստատուններ
 
-Examine the following code:
+Դիտարկենք ստորև բերված կոդը՝
 
 ```js
 const birthday = '18.04.1982';
@@ -12,14 +12,14 @@ const birthday = '18.04.1982';
 const age = someCode(birthday);
 ```
 
-Here we have a constant `birthday` for the date, and also the `age` constant.
+Այստեղ ունենք `birthday` հաստատունը, որն ամսաթիվ է պարունակում, և `age` հաստատունը։
 
-The `age` is calculated from `birthday` using `someCode()`, which means a function call that we didn't explain yet (we will soon!), but the details don't matter here, the point is that `age` is calculated somehow based on the `birthday`.
+`age`-ը հաշվարկվում է `birthday`-ից `someCode()`-ի, ինչը նշանակում է ֆունկցիայի կանչի, ինչի մասին դեռ չենք խոսել (բայց շուտով կխոսենք)։ Այստեղ մանրամասները չենք քննարկում հակիրճության համար, կարևորն այն է, որ `age`-ը ինչ-որ կերտ հաշվարկվում է `birthday`-ի հիման վրա:
 
-Would it be right to use upper case for `birthday`? For `age`? Or even for both?
+Ճիշտ կլինե՞ր մեծատառերով գրել `birthday`-ը: Իսկ `age`-ը՞: Կամ գուցե երկու՞սն էլ:
 
 ```js
-const BIRTHDAY = '18.04.1982'; // make birthday uppercase?
+const BIRTHDAY = '18.04.1982'; // սա՞ գրել մեծատառերով
 
-const AGE = someCode(BIRTHDAY); // make age uppercase?
+const AGE = someCode(BIRTHDAY); // թե՞ age-ը
 ```
diff --git a/1-js/02-first-steps/04-variables/article.md b/1-js/02-first-steps/04-variables/article.md
index e91d0ea7e..d7d389d46 100644
--- a/1-js/02-first-steps/04-variables/article.md
+++ b/1-js/02-first-steps/04-variables/article.md
@@ -1,61 +1,61 @@
-# Variables
+# Փոփոխականներ
 
-Most of the time, a JavaScript application needs to work with information. Here are two examples:
-1. An online shop -- the information might include goods being sold and a shopping cart.
-2. A chat application -- the information might include users, messages, and much more.
+JavaScript ծրագրերը հաճախ աշխատում են տեղեկատվության հետ: Ահա երկու օրինակ.
+1. Առցանց խանութ -- տեղեկատվության մաս են կազմում վաճառվող ապրանքները, զամբյուղը (shopping cart):
+2. A chat application -- տեղեկատվությունթան մաս են կազմում օգտատերերը, հաղորդագրությունները և այլն:
 
-Variables are used to store this information.
+Փոփոխականներն օգտագործվում են այս ամենը պահելու համար:
 
-## A variable
+## Փոփոխական
 
-A [variable](https://en.wikipedia.org/wiki/Variable_(computer_science)) is a "named storage" for data. We can use variables to store goodies, visitors, and other data.
+[Փոփոխականը](https://en.wikipedia.org/wiki/Variable_(computer_science)) տվյալների «պահեստարան» է: Փոփոխականները կարելի է օգտագործել տարբեր տիպի տվյալներ պահելու համար:
 
-To create a variable in JavaScript, use the `let` keyword.
+JavaScript-ում փոփոխական ստեղծելու համար կիրառվում է `let` հիմնաբառը:
 
-The statement below creates (in other words: *declares*) a variable with the name "message":
+Ստորև բերված հայտարատությունը ստեղծում է (այլ կերպ ասած *հայտարարում է*) «message» անունով փոփոխական.
 
 ```js
 let message;
 ```
 
-Now, we can put some data into it by using the assignment operator `=`:
+Այդ փոփոխականի մեջ որևէ տվյալ տեղադրելու համար կիրառենք վերագրման օպերատորը՝ `=`.
 
 ```js
 let message;
 
 *!*
-message = 'Hello'; // store the string 'Hello' in the variable named message
+message = 'Hello'; // տեղադրել տողը «message» անունով փոփոխականի մեջ
 */!*
 ```
 
-The string is now saved into the memory area associated with the variable. We can access it using the variable name:
+Այդ տողն այժմ պահվում է հիշողության այն հատվածում, որը վերագրված է մեր փոփոխականին: Փոփոխականի պարունակությունը կարելի է կարդալ փոփոխականի անվան միջոցով.
 
 ```js run
 let message;
 message = 'Hello!';
 
 *!*
-alert(message); // shows the variable content
+alert(message); // ցույց է տալիս փոփոխականի պարունակությունը
 */!*
 ```
 
-To be concise, we can combine the variable declaration and assignment into a single line:
+Հակիրճ լինելու համար կհամատեղենք փոփոխականների հայտարարումն ու արժեքի վերագրումը մեկ տողում.
 
 ```js run
-let message = 'Hello!'; // define the variable and assign the value
+let message = 'Hello!'; // հայտատարում և արժեք ենք վերագրում փոփոխականին
 
 alert(message); // Hello!
 ```
 
-We can also declare multiple variables in one line:
+Նույն տողում կարելի է հայտարարել մի քանի փոփոխականներ.
 
 ```js no-beautify
 let user = 'John', age = 25, message = 'Hello';
 ```
 
-That might seem shorter, but we don't recommend it. For the sake of better readability, please use a single line per variable.
+Չնայած սա կարող է հարմար թվալ, այնուամենայնիվ մենք խորհուրդ ենք տալիս յուրաքանչյուր փոփոխական հայտարարել նոր տողում:
 
-The multiline variant is a bit longer, but easier to read:
+Մի քանի տողում փոփոխականներ հայտարարելը ավելի երկար է, բայց և ավելի հեշտ է դրանք ընթեռնելը.
 
 ```js
 let user = 'John';
@@ -63,7 +63,7 @@ let age = 25;
 let message = 'Hello';
 ```
 
-Some people also define multiple variables in this multiline style:
+Երբեմն փոփոխականները հայտարարվում են հետևյալ կերպ.
 
 ```js no-beautify
 let user = 'John',
@@ -71,7 +71,7 @@ let user = 'John',
   message = 'Hello';
 ```
 
-...Or even in the "comma-first" style:
+...կամ էլ այսպես:
 
 ```js no-beautify
 let user = 'John'
@@ -79,47 +79,47 @@ let user = 'John'
   , message = 'Hello';
 ```
 
-Technically, all these variants do the same thing. So, it's a matter of personal taste and aesthetics.
+Սրանք բոլորն էլ նույն արդյունքն ունեն և յուրաքանչյուր ոք ընտրում է ըստ ճաշակի և նախընտրության:
 
-````smart header="`var` instead of `let`"
-In older scripts, you may also find another keyword: `var` instead of `let`:
+````smart header="`var`՝ `let`-ի փոխարեն"
+`let`-ի փոխարեն կարող է հանդիպել նաև `var` հիմնաբառը.
 
 ```js
 *!*var*/!* message = 'Hello';
 ```
 
-The `var` keyword is *almost* the same as `let`. It also declares a variable but in a slightly different, "old-school" way.
+`var` հիմնաբառը *գրեթե* նույն `let`-ն է: Այն նույնպես հայտարարում է փոփոխական, բայց կան որոշ տարբերություններ:
 
-There are subtle differences between `let` and `var`, but they do not matter to us yet. We'll cover them in detail in the chapter <info:var>.
+`let`-ի և `var`-ի մեջ կան փոքր տարբերություններ, որոնք մենք դեռ չեն դիտարկի: Այդ տարբերությունների մասին մանրամասն կխոսենք <info:var> բաժնում:
 ````
 
 ## A real-life analogy
 
-We can easily grasp the concept of a "variable" if we imagine it as a "box" for data, with a uniquely-named sticker on it.
+Հեշտությամբ կարելի է հասկանալ «փոփոխական»-ի գաղափարը, եթե պատկերացնենք այն որպես տվյալների «արկղ», որն իրեն առանձնահատուկ պիտակ ունի:
 
-For instance, the variable `message` can be imagined as a box labelled `"message"` with the value `"Hello!"` in it:
+Օրինակ՝ `message` փոփոխականը կարելի է պատկերացնել որպես `"message"` պիտակով արկղ, որի մեջ պահվում է `"Hello!"` արժեքը:
 
 ![](variable.svg)
 
-We can put any value in the box.
+Արկղի մեջ կարող ենք դնել ցանկացած արժեք:
 
-We can also change it as many times as we want:
+Այդ արժեքները կարող ենք փոխել ըստ անհրաժեշտության.
 
 ```js run
 let message;
 
 message = 'Hello!';
 
-message = 'World!'; // value changed
+message = 'World!'; // արժեքը փոխված է
 
 alert(message);
 ```
 
-When the value is changed, the old data is removed from the variable:
+Երբ արժեքը փոխվում է, հին տվյալները դառնում են անհասանելի.
 
 ![](variable-change.svg)
 
-We can also declare two variables and copy data from one into the other.
+Մենք նաև կարող ենք սահմանել երկու փոփոխական և պատճենել դրանցից մեկի տվյալները մյուսի մեջ:
 
 ```js run
 let hello = 'Hello world!';
@@ -127,113 +127,113 @@ let hello = 'Hello world!';
 let message;
 
 *!*
-// copy 'Hello world' from hello into message
+// պատճենել 'Hello world'-ը hello-ից message
 message = hello;
 */!*
 
-// now two variables hold the same data
+// այժմ երկու փոփոխականները պարունակում են նույն տվյալները
 alert(hello); // Hello world!
 alert(message); // Hello world!
 ```
 
-````warn header="Declaring twice triggers an error"
-A variable should be declared only once.
+````warn header="Նույն փոփոխականը մեկից ավել անգամ սահմանելը սխալ է առաջացնում"
+Փոփոխականը կարող է սահմանվել միայն մեկ անգամ:
 
-A repeated declaration of the same variable is an error:
+Փոփոխականի հայտարարման կրկնությունը սխալ է.
 
 ```js run
 let message = "This";
 
-// repeated 'let' leads to an error
+// կրկնվող 'let' հայտարարությունները առաջացնում են սխալներ
 let message = "That"; // SyntaxError: 'message' has already been declared
 ```
-So, we should declare a variable once and then refer to it without `let`.
+Այսպիսով՝ մենք պետք է փոփոխականները հայտարարենք մեկ անգամ, այնուհետև օգտագործենք առանց `let` հիմնաբառի:
 ````
 
-```smart header="Functional languages"
-It's interesting to note that there exist so-called [pure functional](https://en.wikipedia.org/wiki/Purely_functional_programming) programming languages, such as [Haskell](https://en.wikipedia.org/wiki/Haskell), that forbid changing variable values.
+```smart header="Ֆունկցիոնալ լեզուներ"
+Հետաքրքիր է իմանալ, որ գոյություն ունեն [ֆունկցիոնալ](https://hy.wikipedia.org/wiki/%D5%96%D5%B8%D6%82%D5%B6%D5%AF%D6%81%D5%AB%D5%B8%D5%B6%D5%A1%D5%AC_%D5%AE%D6%80%D5%A1%D5%A3%D6%80%D5%A1%D5%BE%D5%B8%D6%80%D5%B8%D6%82%D5%B4) ծրագրավորման լեզուներ, օրինակ՝ [Haskell](https://en.wikipedia.org/wiki/Haskell), որոնք արգելում են փոփոխականների արժեքների փոփոխությունները:
 
-In such languages, once the value is stored "in the box", it's there forever. If we need to store something else, the language forces us to create a new box (declare a new variable). We can't reuse the old one.
+Նման լեզուներում, երբ արժեքները տեղադրվում են «արկղների» դրանք այլևս փոխել հնարավոր չէ: Եթե անհրաժեշտ է պահել այլ արժեք, լեզուն ստիպում է ստեղծել նոր արկղ (հայտարարել նոր փոփոխական):
 
-Though it may seem a little odd at first sight, these languages are quite capable of serious development. More than that, there are areas like parallel computations where this limitation confers certain benefits.
+Չնայած առաջին հայացքից այդ պահվածքը կարող է տարօրինակ թվալ, այս լեզուները իրոք օգտագործվում են լուրջ նախագծեր մշակելու համար: Ավելին, կան ոլորտներ (օր.՝ զուգահեռ հաշվարկներ), որտեղ այս սահմանափակումները շահավետ են:
 ```
 
-## Variable naming [#variable-naming]
+## Փոփոխականների անվանումը [#variable-naming]
 
-There are two limitations on variable names in JavaScript:
+JavaScript-ում փոփոխականների անունների հետ կապված կա երկու սահմանափակում.
 
-1. The name must contain only letters, digits, or the symbols `$` and `_`.
-2. The first character must not be a digit.
+1. Անունը պետք է պարունակի միայն տառեր, թվեր, կամ `$` և `_` նշանները:
+2. Փոփոխականի անվան առաջին նշանը չպետք է լինի թիվ:
 
-Examples of valid names:
+Ստորև բերված են վավեր անունների օրինակներ.
 
 ```js
 let userName;
 let test123;
 ```
 
-When the name contains multiple words, [camelCase](https://en.wikipedia.org/wiki/CamelCase) is commonly used. That is: words go one after another, each word except first starting with a capital letter: `myVeryLongName`.
+Երբ փոփոխականի անունը պարունակում է մի քանի բառեր, սովորաբար օգտագործվում է [camelCase](https://en.wikipedia.org/wiki/CamelCase): camelCase-ի օգինակ է հետևյալ անունը՝ `myVeryLongName`:
 
-What's interesting -- the dollar sign `'$'` and the underscore `'_'` can also be used in names. They are regular symbols, just like letters, without any special meaning.
+Ինչպես նշեցինք `'$'` և `'_'` նշանները ևս կարող են օգտագործվել փոփոխականների անուններում, սակայն դրանք որոշակի հատուկ իմաստ չունեն:
 
-These names are valid:
+Հետևյալ անունները վավեր են.
 
 ```js run untrusted
-let $ = 1; // declared a variable with the name "$"
-let _ = 2; // and now a variable with the name "_"
+let $ = 1; // հայտարարել փոփոխական "$" անունով
+let _ = 2; // և "_" անունով
 
 alert($ + _); // 3
 ```
 
-Examples of incorrect variable names:
+Սրանք անվավեր անունների օրինակներ են.
 
 ```js no-beautify
-let 1a; // cannot start with a digit
+let 1a; // փոփոխականի անունը չի կարող սկսել թվով
 
-let my-name; // hyphens '-' aren't allowed in the name
+let my-name; // գծիկները թույլատրված չեն անուններում
 ```
 
-```smart header="Case matters"
-Variables named `apple` and `APPLE` are two different variables.
+```smart header="Case-ը կարևոր է"
+`apple` և `AppLE` անուններով փոփոխականները երկու տարբեր փոփոխականներ են:
 ```
 
-````smart header="Non-Latin letters are allowed, but not recommended"
-It is possible to use any language, including Cyrillic letters, Chinese logograms and so on, like this:
+````smart header="Ոչ լատիներեն տառերը թույլատրված են, բայց խորհուրդ չի տրվում դրանք օգտագործել"
+Հնարավոր է օգտագործել ցանկացած լեզվի տառեր, ներառյալ կիրիլյան տառեր, չինական լոգոգրամներ, և այլն, օրինակ՝
 
 ```js
 let имя = '...';
 let 我 = '...';
 ```
 
-Technically, there is no error here. Such names are allowed, but there is an international convention to use English in variable names. Even if we're writing a small script, it may have a long life ahead. People from other countries may need to read it sometime.
+Այստեղ սխալ չկա։ Նման անունները վավեր են, սակայն ամենուր ընդունված է օգտագործել անգլերենը: Նույնիսկ եթե փոքր սկրիպտ եք գրում, այն հնարավոր է կարդան նաև այլազգի ծրագրավորողները:
 ````
 
-````warn header="Reserved names"
-There is a [list of reserved words](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), which cannot be used as variable names because they are used by the language itself.
+````warn header="Վերապահված անուններ (reserved names)"
+Գոյություն ունի [վերապահված բառերի ցանկ](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Keywords), որոնք չի կարելի օգտագործել որպես փոփոխականի անուն, քանի որ դրանք օգտագործվում են հենց լեզվի կողմից:
 
-For example: `let`, `class`, `return`, and `function` are reserved.
+Օրինակ՝ `let`, `class`, `return`, և `function` հիմնաբառերը վերապահված են:
 
-The code below gives a syntax error:
+Ստորև բերված կոդը սկալ է պարունակում.
 
 ```js run no-beautify
-let let = 5; // can't name a variable "let", error!
-let return = 5; // also can't name it "return", error!
+let let = 5; // փոփոխականի անունը չի կարող լինել "let"
+let return = 5; // ինչպես նաև "return"
 ```
 ````
 
-````warn header="An assignment without `use strict`"
+````warn header="Փոփոխականի վերագրումն առանց `use strict`-ի"
 
-Normally, we need to define a variable before using it. But in the old times, it was technically possible to create a variable by a mere assignment of the value without using `let`. This still works now if we don't put `use strict` in our scripts to maintain compatibility with old scripts.
+Սովորաբար փոփոխականներն օգտագործելուց առաջ պետք է դրանք հայտարարել: Նախկինում հնարավոր էր ստեղծել փոփոխական միայն վերագրման միջոցով՝ առանց օգտագործելու `let`-ը: Դա այժմ ևս հնարավոր է, եթե սկրիպտում չլինի `use strict`-ը:
 
 ```js run no-strict
-// note: no "use strict" in this example
+// ուշադրություն դրաձրեք, որ այս սկրիպտում "use strict" չկա
 
-num = 5; // the variable "num" is created if it didn't exist
+num = 5; // "num" փոփոխականը ստեղծվում է, եթե այն գոյություն չուներ
 
 alert(num); // 5
 ```
 
-This is a bad practice and would cause an error in strict mode:
+Սա սխալ է առաջացնում «strict mode»-ում.
 
 ```js
 "use strict";
@@ -244,15 +244,15 @@ num = 5; // error: num is not defined
 ```
 ````
 
-## Constants
+## Հաստատուններ
 
-To declare a constant (unchanging) variable, use `const` instead of `let`:
+Հաստատուն սահմանելու համար `let`-ի փոխարեն օգտագործեք `const`.
 
 ```js
 const myBirthday = '18.04.1982';
 ```
 
-Variables declared using `const` are called "constants". They cannot be reassigned. An attempt to do so would cause an error:
+`const`-ով սահմանված փոփոխականները կոչվում են «հաստատուններ». դրանց չի կարելի նոր արժեք վերագրել: Նման փորձը սխալի կհանգեցնի.
 
 ```js run
 const myBirthday = '18.04.1982';
@@ -260,15 +260,15 @@ const myBirthday = '18.04.1982';
 myBirthday = '01.01.2001'; // error, can't reassign the constant!
 ```
 
-When a programmer is sure that a variable will never change, they can declare it with `const` to guarantee and communicate that fact to everyone.
+Եթե վստահ եք, որ փոփոխականի արժեքը երբեր չի փոխվի, սահմանեք այն որպես `const` դա ապահովելու և բոլորին այդ փաստն ակնհայտ դարձնելու համար:
 
-### Uppercase constants
+### Մեծատառ հաստատուններ
 
-There is a widespread practice to use constants as aliases for difficult-to-remember values that are known before execution.
+Ընդունված է հաստատունները օգտագործել դժվար հիշվող արժեքների համար, որոնք հայտնի են նախօրոք:
 
-Such constants are named using capital letters and underscores.
+Նման հաստատունները գրվում են մեծատառ և ընդգծիկներով (underscores):
 
-For instance, let's make constants for colors in so-called "web" (hexadecimal) format:
+Օրինակ՝ սահմանենք հաստատուններ որոշ գույների համար.
 
 ```js run
 const COLOR_RED = "#F00";
@@ -276,70 +276,70 @@ const COLOR_GREEN = "#0F0";
 const COLOR_BLUE = "#00F";
 const COLOR_ORANGE = "#FF7F00";
 
-// ...when we need to pick a color
+// ...գույնն օգտագործելու համար
 let color = COLOR_ORANGE;
 alert(color); // #FF7F00
 ```
 
-Benefits:
+Առավելությունները.
 
-- `COLOR_ORANGE` is much easier to remember than `"#FF7F00"`.
-- It is much easier to mistype `"#FF7F00"` than `COLOR_ORANGE`.
-- When reading the code, `COLOR_ORANGE` is much more meaningful than `#FF7F00`.
+- `COLOR_ORANGE`-ը շատ ավելի հեշտ է մտապահել, քան `"#FF7F00"`-ը,
+- ավելի հեշտ է սխալ գրել `"#FF7F00"`-ը, քան `COLOR_ORANGE`-ը,
+- կոդը կարդալիս `COLOR_ORANGE`-ն ավելի շատ իմաստ է արտահայտում, քան `#FF7F00`-ը:
 
-When should we use capitals for a constant and when should we name it normally? Let's make that clear.
+Եկեք հասկանանք երբ է պետք հաստատունները գրել մեծատառերով, իսկ երբ ոչ:
 
-Being a "constant" just means that a variable's value never changes. But some constants are known before execution (like a hexadecimal value for red) and some constants are *calculated* in run-time, during the execution, but do not change after their initial assignment.
+«Հաստատունն» ուղղակի փոփոխական է, որի արժեքը չի փոխվում: Կան հաստատուններ, որոնց արժեքը հայտնի է մինչև սկրիպտը գործարկելը (ինչպես, օրինակ, վերոնշյալ գույները) և կան հաստատուններ, որոնց արժեքը հայտնի է դառնում միայն սկրիպտի աշխատանքի ընթացքում և այն չի փոխվում սկզբնական վերագրումից հետո:
 
-For instance:
+Օրինակ՝
 
 ```js
 const pageLoadTime = /* time taken by a webpage to load */;
 ```
 
-The value of `pageLoadTime` is not known before the page load, so it's named normally. But it's still a constant because it doesn't change after the assignment.
+`pageLoadTime`-ի արժեքը հայտնի չէ, քանի դեռ էջն ամբողջությամբ չի բեռնվել, այդ իսկ պատճառով այն մեծատառ չէ։ Սակայն այն հաստատուն է, քանի որ վերագրելուց հետո արժեքը չի փոխվում:
 
-In other words, capital-named constants are only used as aliases for "hard-coded" values.
+Այլ կերպ ասած՝ մեծատառերով գրված հաստատունները օգտագործվում են միայն որպես «կոշտ կոդավորված» արժեքների փոխանուններ:
 
-## Name things right
+## Ճիշտ անունների ընտրությունը կարևոր է
 
-Talking about variables, there's one more extremely important thing.
+Երբ խոսում ենք փոփոխականների մասին մի կարևոր բան կա, որը պետք է միշտ հիշել:
 
-A variable name should have a clean, obvious meaning, describing the data that it stores.
+Փոփոխականը պետք է ունենա պարզ, միարժեք հասկանալի, և պարունակող արժեքը բնութագրող անուն:
 
-Variable naming is one of the most important and complex skills in programming. A glance at variable names can reveal which code was written by a beginner versus an experienced developer.
+Փոփոխականները անվանելը կարևորագույն և դժվար ունակություններից է ծրագրավորման մեջ: Արագ նայելով փոփոխականնրի անուններին կարելի է կարծիք կազվել կոդը գրած ծրագրավորողի ունակությունների մասին:
 
-In a real project, most of the time is spent modifying and extending an existing code base rather than writing something completely separate from scratch. When we return to some code after doing something else for a while, it's much easier to find information that is well-labelled. Or, in other words, when the variables have good names.
+Իրական նախագծերում հիմնական ժամանակը ծախսվում է գոյություն ունեցող կոդը փոփոխելու և զարգացնելու վրա: Երբ վերադառնում ենք մեր գրած կոդին որոշ ժամանակ հետո շատ ավելի հեշտ է վերհիշել այն, երբ փոփոխականներն իմաստավոր անուններ ունեն:
 
-Please spend time thinking about the right name for a variable before declaring it. Doing so will repay you handsomely.
+Հորդորում ենք ծախսել որոշ ժամանակ մտածելու ճիշտ անուններ փոփոխականների համար մինչև դրանք հայտարարելը: Հավատացեք, դա Ձեզ հետագայում միայն կօգնի:
 
-Some good-to-follow rules are:
+Ահա որոշ կանոններ, որոնց արժի հետևել.
 
-- Use human-readable names like `userName` or `shoppingCart`.
-- Stay away from abbreviations or short names like `a`, `b`, and `c`, unless you know what you're doing.
-- Make names maximally descriptive and concise. Examples of bad names are `data` and `value`. Such names say nothing. It's only okay to use them if the context of the code makes it exceptionally obvious which data or value the variable is referencing.
-- Agree on terms within your team and in your mind. If a site visitor is called a "user" then we should name related variables `currentUser` or `newUser` instead of `currentVisitor` or `newManInTown`.
+- օգտագործեք հեշտ ընթեռնելի անուններ, օրինակ՝ `userName`, կամ `shoppingCart`,
+- մի օգտագործեք հապավումներ կամ նմանատիպ կարճ անուններ՝ `a`, `b`, `c`, եթե, իհարկե, գիտեք ինչ եք ունում,
+- անուններն ընտրեք հնարավորինս նկարագրող և հակիրճ: `data`-ն և `value`-ն վատ անունների օրինակներ են, քանի որ նման անունները ոչինչ չեն ասում: Նման անունները կարելի է միայն օգտագործել այն դեպքերում, երբ կոդի համատեքստը (context) միանշանակ հասկանալի է դարձնում, թե ինչ արժեքներ են այդ փոփոխականները պարունակում,
+- եկեք համաձայնության Ձեր թիմով, կամ ինքներդ Ձեզ հետ: Եթե Ձեր կայքի հաճախորդին անվանում եք «user», ապա նրա հետ կապված փոփոխականները պետք է ունենան նմանատիպ անուններ՝ `currentUser`, կամ `newUser` և ոչ թե `currentVisitor`, կամ `newManInTown`:
 
-Sounds simple? Indeed it is, but creating descriptive and concise variable names in practice is not. Go for it.
+Այս ամենը պարզ է հնչում, սակայն գործնականում հասկանալի և հակիրճ փոփոխականների անուններ մտածելն այնքան էլ հեշտ չէ: Ինքներդ փորձեք և կհամոզվեք:
 
-```smart header="Reuse or create?"
-And the last note. There are some lazy programmers who, instead of declaring new variables, tend to reuse existing ones.
+```smart header="Օգտագործե՞լ եղած փոփոխականը, թե՞ նորը մտածել"
+Որոշ ծույլ ծրագրավորողներ փորձում են կրկին օգտագործել հայտարարած փոփոխականները՝ նորերը սահմանելու փոխարեն:
 
-As a result, their variables are like boxes into which people throw different things without changing their stickers. What's inside the box now? Who knows? We need to come closer and check.
+Արդյունքում նրանց փոփոխականները նմանվում են արկղերի, որոնց մեջ տարբեր տիպի իրեր են նետվում, առանց արկի պիտակը փոխելու: Այպես դժվարանում է հասկանալ, թե ինչ է պահվում այդ արկղում:
 
-Such programmers save a little bit on variable declaration but lose ten times more on debugging.
+Նման դեպքերում ծրագրավորողները մի փոքր խնայում են փոփոխականները հայտարարելիս, սակայն ավելի շատ ժամանակ են ծախսում, երբ խնդիրներ են առաջանում:
 
-An extra variable is good, not evil.
+Այսպիսով՝ ավել փոփոխականը վատ բան չէ:
 
-Modern JavaScript minifiers and browsers optimize code well enough, so it won't create performance issues. Using different variables for different values can even help the engine optimize your code.
+Ժամանակակից JavaScript-ում կան գործիքներ, որոնք փոքրացնում և լավարկում (optimize) են կոդն այն աստիճան, որ ավել փոփոխականներ ունենալը խնդիրներ չի առաջացնի: Նույնիսկ հակառակը. տարբեր արժեքները տարբեր փոփոխականներում պահելը կարող է օգնել շարժիչին այս գործը կատարելիս:
 ```
 
-## Summary
+## Ամփոփում
 
-We can declare variables to store data by using the `var`, `let`, or `const` keywords.
+Տվյալները պահելու համար կարող ենք հայտարարել փոփոխականներ, օգտագործելով `var`, `let`, կամ `const` հիմնաբառերը:
 
-- `let` -- is a modern variable declaration.
-- `var` -- is an old-school variable declaration. Normally we don't use it at all, but we'll cover subtle differences from `let` in the chapter <info:var>, just in case you need them.
-- `const` -- is like `let`, but the value of the variable can't be changed.
+- `let` -- ներկայումս փոփոխականները հայտարարվում են այս հիմնաբառով:
+- `var` -- նախկինում օգտագործվում էր փոփոխականներ հայտարարելու համար: Այժմ այն չենք օգտագործում, իսկ սրա և `let`-ի տարբերությունները կքննարկենք <info:var> բաժնում:
+- `const` -- նման է `let`-ին, սակայն այս հիմնաբառով հայտարարված փոփոխականի արժեքը չի փոխվում:
 
-Variables should be named in a way that allows us to easily understand what's inside them.
+Փոփոխականների անունները պետք է պարզ հուշեն, թե ինչ արժեք է պարունակում տվյալ փոփոխականը։
diff --git a/1-js/02-first-steps/05-types/1-string-quotes/solution.md b/1-js/02-first-steps/05-types/1-string-quotes/solution.md
index 68a13c15b..90f3892a7 100644
--- a/1-js/02-first-steps/05-types/1-string-quotes/solution.md
+++ b/1-js/02-first-steps/05-types/1-string-quotes/solution.md
@@ -1,15 +1,15 @@
 
-Backticks embed the expression inside `${...}` into the string.
+Թեք չակերտները ներառում են `${...}`-ի մեջ գրված արտահայտության արդյունքը տողի մեջ։
 
 ```js run
-let name = "Ilya";
+let name = "David";
 
-// the expression is a number 1
+// արտահայտությունը 1 թիվն է
 alert( `hello ${1}` ); // hello 1
 
-// the expression is a string "name"
+// արտահայտությունը "name" տողն է
 alert( `hello ${"name"}` ); // hello name
 
-// the expression is a variable, embed it
-alert( `hello ${name}` ); // hello Ilya
+// արտահայտությունը փոփոխական, ներդնենք այն
+alert( `hello ${name}` ); // hello David
 ```
diff --git a/1-js/02-first-steps/05-types/1-string-quotes/task.md b/1-js/02-first-steps/05-types/1-string-quotes/task.md
index 14ea6b4d6..07005f96c 100644
--- a/1-js/02-first-steps/05-types/1-string-quotes/task.md
+++ b/1-js/02-first-steps/05-types/1-string-quotes/task.md
@@ -2,16 +2,16 @@ importance: 5
 
 ---
 
-# String quotes
+# Տողի չակերտները
 
-What is the output of the script?
+Ինչպիսի՞ն կլինի սկրիպտի արտաբերած արդյունքը։
 
 ```js
-let name = "Ilya";
+let name = "David";
 
 alert( `hello ${1}` ); // ?
 
 alert( `hello ${"name"}` ); // ?
 
 alert( `hello ${name}` ); // ?
-```
\ No newline at end of file
+```
diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md
index 04e8b2450..723a83f0f 100644
--- a/1-js/02-first-steps/05-types/article.md
+++ b/1-js/02-first-steps/05-types/article.md
@@ -1,225 +1,237 @@
-# Data types
+# Տվյալների տիպերը
 
-A value in JavaScript is always of a certain type. For example, a string or a number.
+JavaScript-ում արժեքը միշտ պատկանում է տվյալների որոշակի տիպի։ Օրինակ՝ տող (string) կամ թիվ (number)։
 
-There are eight basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+JavaScript-ում կան տվյալների ութ հիմնական տիպեր։ Այս գլխում մենք կանրադառնանք դրանց մասնակիորեն, իսկ հաջորդ գլուխներում կխոսենք դրանցից յուրաքանչյուրի մասին ավելի մանրամասն։
 
-We can put any type in a variable. For example, a variable can at one moment be a string and then store a number:
+Փոփոխականը կարող է պարունակել ցանկացած տիպի տվյալ։ Օրինակ՝ սկզբում այն կարող է պարունակել տող (string), իսկ հետո՝ փոխարինվել թվով (number)․
 
 ```js
-// no error
-let message = "hello";
+// Սխալ չկա
+let message = "բարև";
 message = 123456;
 ```
 
-Programming languages that allow such things, such as JavaScript, are called "dynamically typed", meaning that there exist data types, but variables are not bound to any of them.
+Այն լեզուները, որոնք թույլ են տալիս նման պահվածք, կոչվում են «դինամիկ տիպավորված»։ Դա նշանակում է, որ տիպերը գոյություն ունեն, բայց փոփոխականները կապված չեն դրանցից ոչ մեկի հետ։
 
-## Number
+## Թիվ (Number)
 
 ```js
 let n = 123;
 n = 12.345;
 ```
 
-The *number* type represents both integer and floating point numbers.
+*number* տիպը ներկայացնում է ինչպես ամբողջ թվերը, այնպես էլ տասնորդական թվերը։
 
-There are many operations for numbers, e.g. multiplication `*`, division `/`, addition `+`, subtraction `-`, and so on.
+Թվերի համար գոյություն ունեն բազմաթիվ գործողություններ, օրինակ՝ բազմապատկում `*`, բաժանաում `/`, գումարում `+`, հանում `-` և այլն.
 
-Besides regular numbers, there are so-called "special numeric values" which also belong to this data type: `Infinity`, `-Infinity` and `NaN`.
+Բացի սովորական թվերից կան նաև այսպես կոչված «հատուկ թվային արժեքներ», որոնք նույնպես պատկանում են այս տվյալների տիպին․ `Infinity`, `-Infinity` և `NaN`։
 
-- `Infinity` represents the mathematical [Infinity](https://en.wikipedia.org/wiki/Infinity) ∞. It is a special value that's greater than any number.
+- `Infinity`-ն ներկայացնում է մաթեմատիկական [անվերջությունը](https://hy.wikipedia.org/wiki/%D4%B1%D5%B6%D5%BE%D5%A5%D6%80%D5%BB%D5%B8%D6%82%D5%A9%D5%B5%D5%B8%D6%82%D5%B6_(%D5%B4%D5%A1%D5%A9%D5%A5%D5%B4%D5%A1%D5%BF%D5%AB%D5%AF%D5%A1)) ∞։ Այն հատուկ արժեք է, որը մեծ է ցանկացած թվից։
 
-    We can get it as a result of division by zero:
+    Մենք կարող ենք ստանալ այն որպես զրոյի վրա բաժանման արդյունք,
 
     ```js run
     alert( 1 / 0 ); // Infinity
     ```
 
-    Or just reference it directly:
+    կամ վերցնելով այն ակնհայտ կերպով։
 
     ```js run
     alert( Infinity ); // Infinity
     ```
-- `NaN` represents a computational error. It is a result of an incorrect or an undefined mathematical operation, for instance:
+- `NaN`-ը նշանակում է հաշվողական սխալ։ Այն սխալ կամ անորոշ մաթեմատիկական գործողույան արդյունք է, օրինակ․
 
     ```js run
-    alert( "not a number" / 2 ); // NaN, such division is erroneous
+    alert( "ոչ թվային արժեք" / 2 ); // NaN, բաժանումը հնարավոր չէ
     ```
 
-    `NaN` is sticky. Any further mathematical operation on `NaN` returns `NaN`:
+    `NaN`-ը անփոփոխ արժեք է։ Ցանկացած գործողություն `NaN`-ի հետ վերադարձնում է `NaN`:
 
     ```js run
     alert( NaN + 1 ); // NaN
     alert( 3 * NaN ); // NaN
-    alert( "not a number" / 2 - 1 ); // NaN
+    alert( "ոչ թվային արժեք" / 2 - 1 ); // NaN
     ```
 
-    So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result (there's only one exception to that: `NaN ** 0` is `1`).
+    Եթե մաթեմատիկական արտահայտության որևէ անդամ `NaN` է, ապա ամբողջ արտահայտության արդյունքը կլինի `NaN`։ Միակ բացառությունը `NaN ** 0` = `1` է։
 
-```smart header="Mathematical operations are safe"
-Doing maths is "safe" in JavaScript. We can do anything: divide by zero, treat non-numeric strings as numbers, etc.
+```smart header="Մաթեմատիկական գործողությունները անվտանգ են"
+Մաթեմատիկական գործողությունները JavaScript-ում «անվտանգ» են։ Մենք կարող ենք կատարել ցանկացած գործողություն՝ բաժանել զրոյի, ոչ թվային տողերի հետ վարվել ինչպես թվերի հետ։
 
-The script will never stop with a fatal error ("die"). At worst, we'll get `NaN` as the result.
+Սկրիպտը երբեք կանգ չի առնի՝ շպրտելով սխալ։ Վատագույն դեպքում, որպես արդյունք, մենք կստանանք `NaN`։
 ```
 
-Special numeric values formally belong to the "number" type. Of course they are not numbers in the common sense of this word.
+Հատուկ թվային արժեքները պատկանում են «թիվ» (number) տիպին։ Իրականում դրանք թվեր չեն բառի ուղիղ իմաստով:
 
-We'll see more about working with numbers in the chapter <info:number>.
+Թվերի հետ աշխատանքին ավելի մանրամասն կծանոթանանք <info:number> գլխում։
 
 ## BigInt [#bigint-type]
 
-In JavaScript, the "number" type cannot safely represent integer values larger than <code>(2<sup>53</sup>-1)</code> (that's `9007199254740991`), or less than <code>-(2<sup>53</sup>-1)</code> for negatives.
+JavaScript-ում «number» տիպը չի կարող ներկայացնել թվային արժեքներ, որոնք մեծ են <code>(2<sup>53</sup>-1)</code>-ից (նույնն է, ինչ `9007199254740991`), կամ փոքր են <code>-(2<sup>53</sup>-1)</code>-ից՝ բացասական թվերի դեպքում։
 
-To be really precise, the "number" type can store larger integers (up to <code>1.7976931348623157 * 10<sup>308</sup></code>), but outside of the safe integer range <code>±(2<sup>53</sup>-1)</code> there'll be a precision error, because not all digits fit into the fixed 64-bit storage. So an "approximate" value may be stored.
+Իսկապես ճշգրիտ լինելու համար, «number» տիպը կարող է պահել ավելի մեծ ամբողջ թվեր (մինչև <code>1.7976931348623157 * 10<sup>308</sup></code>), բայց անվտանգ ամբողջ թվերի միջակայքից դուրս <code>±(2): <sup>53</sup>-1)</code> ճշգրտության սխալ կլինի, քանի որ ոչ բոլոր թվանշաններն են տեղավորվում ֆիքսված 64-բիթանոց պահեստում: Այնպես որ, «մոտավոր» արժեք կարող է պահվել:
 
-For example, these two numbers (right above the safe range) are the same:
+Օրինակ, այս երկու թվերը (անվտանգ տիրույթից անմիջապես վերև) նույնն են.
 
 ```js
 console.log(9007199254740991 + 1); // 9007199254740992
 console.log(9007199254740991 + 2); // 9007199254740992
 ```
 
-So to say, all odd integers greater than <code>(2<sup>53</sup>-1)</code> can't be stored at all in the "number" type.
+Այսպես ասած՝ <code>(2<sup>53</sup>-1)</code>-ից մեծ բոլոր կենտ ամբողջ թվերն ընդհանրապես չեն կարող պահվել «number» տիպում։
 
-For most purposes <code>±(2<sup>53</sup>-1)</code> range is quite enough, but sometimes we need the entire range of really big integers, e.g. for cryptography or microsecond-precision timestamps.
+Շատ նպատակների համար <code>±(2<sup>53</sup>-1)</code> միջակայքը բավական է, բայց երբեմն մեզ անհրաժեշտ է իսկապես մեծ ամբողջ թվերի ամբողջ միջակայքը, օրինակ. գաղտնագրության կամ միկրովայրկյանային ճշգրտությամբ ժամանակի համար:
 
-`BigInt` type was recently added to the language to represent integers of arbitrary length.
+`BigInt`-ը վերջերս է ավելացվել լեզվում՝ կամայական մեծության թվեր նեկայացնելու նպատակով։
 
-A `BigInt` value is created by appending `n` to the end of an integer:
+`BigInt` արժեք ստեղծվում է թվին վերջից կցելով `n`․
 
 ```js
-// the "n" at the end means it's a BigInt
+// «n»-ը վերջում նշանակում է, որ արժեքը BigInt տիպի է
 const bigInt = 1234567890123456789012345678901234567890n;
 ```
 
-As `BigInt` numbers are rarely needed, we don't cover them here, but devoted them a separate chapter <info:bigint>. Read it when you need such big numbers.
+Քանի որ `BigInt` թվերը հազվադեպ են օգտագործվում, դրանց այստեղ չենք անդրադառնա, այլ կդիտարկենք առանձին՝ <info:bigint> գլխում։ Կարդացե՛ք այն, եթե նման մեծ թվերի օգտագոծման կարիք կունենաք։
 
+<<<<<<< HEAD
+
+```smart header="Համատեղելիության խնդիրներ"
+Այս պահին `BigInt`-ը համատեղելի է Firefox/Chrome/Edge/Safari զննիչների հետ, բայց ոչ IE-ի։
+```
+
+Կարող եք ստուգել [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) հոդվածը, հասկանալու համար, թե զննիչների որ տարբերակների հետ է այն համատեղելի։
+
+## Տող (String)
+=======
 ## String
+>>>>>>> 51bc6d3cdc16b6eb79cb88820a58c4f037f3bf19
 
-A string in JavaScript must be surrounded by quotes.
+JavaScript-ում տողը պետք է շրջապատված լինի չակերտներով։
 
 ```js
-let str = "Hello";
-let str2 = 'Single quotes are ok too';
-let phrase = `can embed another ${str}`;
+let str = "Բարև";
+let str2 = 'Եզակի չակերտները նույպես թույլատրելի են';
+let phrase = `թեք չակերտները կարող են ներառել փոփոխականներ ${str}`;
 ```
 
-In JavaScript, there are 3 types of quotes.
+JavaScript-ում գոյություն ոնեն 3 տեսակի չակերտներ.
 
-1. Double quotes: `"Hello"`.
-2. Single quotes: `'Hello'`.
-3. Backticks: <code>&#96;Hello&#96;</code>.
+1. Կրկնակի չակերտներ․ `"Բարև"`։
+2. Եզակի չակերտներ․ `'Բարև'`։
+3. Թեք չակերտներ․ <code>&#96;Բարև&#96;</code>։
 
-Double and single quotes are "simple" quotes. There's practically no difference between them in JavaScript.
+Կրկնակի և եզակի չակերտները «պարզ» չակերտներ են։ JavaScript-ում դրանց միջև տարբերություններ չկան։
 
-Backticks are "extended functionality" quotes. They allow us to embed variables and expressions into a string by wrapping them in `${…}`, for example:
+Թեք չակերտները ունեն «ընդլայնված ֆունկցիոնալություն»։ Դրանք թույլ են տալիս ներդնել փոփոխականներ և արտահայտություններ տողի մեջ՝ դրանք `${…}`-ի մեջ պարփակելու միջոցով, օրինակ․
 
 ```js run
-let name = "John";
+let name = "Դավիթ";
 
-// embed a variable
-alert( `Hello, *!*${name}*/!*!` ); // Hello, John!
+// ներդնենք փոփոխականը
+alert( `Բարև, *!*${name}*/!*!` ); // Բարև, Դավիթ!
 
-// embed an expression
-alert( `the result is *!*${1 + 2}*/!*` ); // the result is 3
+// ներդնենք արտահայտություն
+alert( `արդյունքը կլինի *!*${1 + 2}*/!*` ); // արդյունքը կլինի 3
 ```
 
-The expression inside `${…}` is evaluated and the result becomes a part of the string. We can put anything in there: a variable like `name` or an arithmetical expression like `1 + 2` or something more complex.
+`${…}`-ի մեջ ներդրված արտահայտությունը գնահատվում է, և արդյունքը դառնում է տողի մի մասը։ Մենք կարող ենք տեղադրել այնտեղ ամեն ինչ՝ փոփոխական (`name`) կամ թվաբանական արտահայտություն՝ `1 + 2`-ի նման կամ ավելի բարդ։
+
+Ուշադրություն դարձրեք այն փաստին, որ սա հնարավոր է միայն թեք չակերտների դեպքում։ Մյուս չակերտները չունեն այսպիսի ներդրման ֆունկցիոնալություն։
 
-Please note that this can only be done in backticks. Other quotes don't have this embedding functionality!
 ```js run
-alert( "the result is ${1 + 2}" ); // the result is ${1 + 2} (double quotes do nothing)
+alert( "արդյունքը կլինի ${1 + 2}" ); // արդյունքը կլինի ${1 + 2} (կրկնակի չակերտները ոչինչ չեն անում)
 ```
 
-We'll cover strings more thoroughly in the chapter <info:string>.
+Մենք կանրադառնանք տողերին ավելի մանրամասն <info:string> գլխում։
 
-```smart header="There is no *character* type."
-In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is called "char".
+```smart header="Գոյություն չունի *character* տիպ։"
+Որոշ լեզուներում գոյություն ունի հատուկ "character" տիպ եզակի սիմվոլների համար։ Օրինակ՝ C և Java լեզուներում այն կոչվում է «char»։
 
-In JavaScript, there is no such type. There's only one type: `string`. A string may consist of zero characters (be empty), one character or many of them.
+JavaScript-ում չկա նման տիպ։ Կա միայն մեկ տիպ՝ `string`։ string-ը կարող է լինել դատարկ, ունենալ մեկ կամ բազմաթիվ նիշեր։
 ```
 
-## Boolean (logical type)
+## Boolean (տրամաբանական տիպ)
 
-The boolean type has only two values: `true` and `false`.
+Boolean տիպը ունի երկու արժեք․ `true` և `false`։
 
-This type is commonly used to store yes/no values: `true` means "yes, correct", and `false` means "no, incorrect".
+Այս տիպը հիմնականում օգտագործվում է այո/ոչ արժեքներ պահելու համար․ `true` նշանակում է «այո, ճիշտ է», իսկ `false` նշանակում է «ոչ, սխալ է»։
 
-For instance:
+Օրինակ՝
 
 ```js
-let nameFieldChecked = true; // yes, name field is checked
-let ageFieldChecked = false; // no, age field is not checked
+let nameFieldChecked = true; // այո, անվանական դաշտը ստուգված է
+let ageFieldChecked = false; // ոչ, տարիքային դաշտը ստուգված չէ
 ```
 
-Boolean values also come as a result of comparisons:
+Boolean արժեքները ստացվում են նաև որպես համեմատությունների արդյունք․
 
 ```js run
 let isGreater = 4 > 1;
 
-alert( isGreater ); // true (the comparison result is "yes")
+alert( isGreater ); // true (համեմատության արդյունքն է «այո»)
 ```
 
-We'll cover booleans more deeply in the chapter <info:logical-operators>.
+Մենք կանրադառնանք boolean տիպին ավելի մանրամասն <info:logical-operators> գլխում։
 
-## The "null" value
+## «null» արժեքը
 
-The special `null` value does not belong to any of the types described above.
+`null` հատուկ արժեքը չի պատկանում վերոնշյալ տիպերից ոչ մեկին։
 
-It forms a separate type of its own which contains only the `null` value:
+Այն ձևավորում է առանձին տիպ, որը պարունակում է `null` արժեքը:
 
 ```js
 let age = null;
 ```
 
-In JavaScript, `null` is not a "reference to a non-existing object" or a "null pointer" like in some other languages.
+JavaScript-ում `null`-ը «գոյություն չունեցող օբյեկտի հղում» կամ «զրոյական ցուցիչ» չէ, ինչպես որոշ այլ լեզուներում։
 
-It's just a special value which represents "nothing", "empty" or "value unknown".
+Այն պարզապես հատուկ արժեք է, որը նշանակում է «ոչինչ», «դատարկություն» կամ «անհայտ արժեք»։
 
-The code above states that `age` is unknown.
+Վերոնշյալ կոդը պնդում է, որ `age` փոփոխականի արժեքը անհայտ է։
 
-## The "undefined" value
+## «undefined» արժեքը
 
-The special value `undefined` also stands apart. It makes a type of its own, just like `null`.
+`undefined` հատուկ արժեքը նույնպես ուրույն է։ Այն ձևավորում է իր սեփական տիպը, ճիշտ ինչպես `null`-ը։
 
-The meaning of `undefined` is "value is not assigned".
+`undefined` նշանակում է, որ «արժեք չի վերագրվել»։
 
-If a variable is declared, but not assigned, then its value is `undefined`:
+Եթե փոփոխականը հայտարարված է, բայց նրան արժեք չի վերագրվել, ապա նրա արժեքը կլինի `undefined`․
 
 ```js run
 let age;
 
-alert(age); // shows "undefined"
+alert(age); // ցույց կտա «undefined»
 ```
 
-Technically, it is possible to explicitly assign `undefined` to a variable:
+Տեխնիկապես փոփոխականին հնարավոր է ակնհայտ կերպով վերագրել `undefined` արժեքը․
 
 ```js run
 let age = 100;
 
-// change the value to undefined
+// արժեքը դարձնել «undefined»
 age = undefined;
 
-alert(age); // "undefined"
+alert(age); // «undefined»
 ```
 
-...But we don't recommend doing that. Normally, one uses `null` to assign an "empty" or "unknown" value to a variable, while `undefined` is reserved as a default initial value for unassigned things.
+...Բայց խորհուրդ չի տրվում այդպես անել։ Սովորաբար `null`-ը օգտագործվում է փոփոխականին «դատարկ» կամ «անհայտ» արժեք վերագրելու համար, մինչդեռ `undefined`-ը  իրենից ենթադրում է նախնական լռելյայն (default) արժեք՝ չվերագրված փոփոխականների համար։
 
-## Objects and Symbols
+## Օբյեկտներ և սիմվոլներ
 
-The `object` type is special.
+`object` տիպը յուրահատուկ է։
 
-All other types are called "primitive" because their values can contain only a single thing (be it a string or a number or whatever). In contrast, objects are used to store collections of data and more complex entities.
+Մնացած բոլոր տիպերը կոչվում են «պրիմիտիվ» տիպեր, քանի որ նրանց արժեքները պարզ արժեքներ են (լինի այն տող, թիվ կամ այլ արժեք)։ Օբյեկտները, իրենց հերթին, օգտագործվում են տվյալների համախումբ և ավելի բարդ կառուցվածքներ պահեստավորելու նպատակով։
 
-Being that important, objects deserve a special treatment. We'll deal with them later in the chapter <info:object>, after we learn more about primitives.
+Օբյեկտները լեզվում կարևոր տեղ են զբաղեցնում և հատուկ ուշադրության են արժանի։ Մենք կզբաղվենք դրանցով ավելի ուշ՝ <info:object> գլխում՝ պրիմիտիվ տիպերը ավելի խորը ուսումնասիրելուց հետո։
 
-The `symbol` type is used to create unique identifiers for objects. We have to mention it here for the sake of completeness, but also postpone the details till we know objects.
+`symbol` տիպը օգտագործվում է օբյեկտներում չկրկնվող նույնացուցիչներ ստեղծելու համար։ Մենք այստեղ նշում ենք դրա գոյության փաստը՝ տիպերի նկարագիրը լիարժեք դարձնելու համար, բայց թողնում ենք դրա ուսումնասիրությունը հետագայի համար, երբ արդեն ուսումնասիրած կլինենք օբյեկտները։
 
-## The typeof operator [#type-typeof]
+## typeof օպերատորը [#type-typeof]
 
-The `typeof` operator returns the type of the operand. It's useful when we want to process values of different types differently or just want to do a quick check.
+`typeof` օպերատորը վերադարձնում է իր արգումենտի տիպը։ Այն օգտակար է, երբ մենք ուզում ենք մշակել տարբեր տիպերի արժեքները տարբեր կերպով, կամ պարզապես արագ ստուգում անել
 
-A call to `typeof x` returns a string with the type name:
+`typeof x`-ի կանչը վերադարձնում է տող, որը պարունակում է տիպի անվանումը․
 
 ```js
 typeof undefined // "undefined"
@@ -247,11 +259,11 @@ typeof alert // "function"  (3)
 */!*
 ```
 
-The last three lines may need additional explanation:
+Վերջին երեք տողերը ունեն հավելյալ պարզաբանման կարիք․
 
-1. `Math` is a built-in object that provides mathematical operations. We will learn it in the chapter <info:number>. Here, it serves just as an example of an object.
-2. The result of `typeof null` is `"object"`. That's an officially recognized error in `typeof`, coming from very early days of JavaScript and kept for compatibility. Definitely, `null` is not an object. It is a special value with a separate type of its own. The behavior of `typeof` is wrong here.
-3. The result of `typeof alert` is `"function"`, because `alert` is a function. We'll study functions in the next chapters where we'll also see that there's no special "function" type in JavaScript. Functions belong to the object type. But `typeof` treats them differently, returning `"function"`. That also comes from the early days of JavaScript. Technically, such behavior isn't correct, but can be convenient in practice.
+1. `Math`-ը ներկառուցված օբյեկտ է, որը տրամադրում է մաթեմատիկական տարբեր գործողություններ և հաստատուններ։ Մենք կուսումնասիրենք այն <info:number> գլխում։ Այստեղ այն պարզապես ծառայում է որպես օբյեկտի օրինակ։
+2. `typeof null`-ի արդյունքը `"object"` է։ Այն `typeof` օպերատորի վարքագծի պաշտոնապես ընդունված սխալ է, որը եկել է JavaScript-ի ստեղծման վաղ ժամանակներից և մնացել է լեզվում համատեղելիության նպատակով։ Անշուշտ, `null`-ը օբյեկտ չէ։ Այն հատուկ արժեք է, որը ունի իր սեփական տիպը։
+3. `typeof alert`-ի արդյունքը `"function"` է, քանի որ `alert`-ը ֆունկցիա է։ Մենք կուսումնասիրենք ֆունկցիաները հաջորդ գլուխներում, որտեղ կիմանանք, որ JavaScript-ը չունի առանձին function տիպ։ Ֆունկցիաները պատկանում են object տիպին։ Բայց `typeof`-ը մշակում է դրանք հատուկ ձևով՝ վերադարձնելով `"function"` արժեքը։ Դա նույնպես գալիս է JavaScript-ի պատմության վաղ ժամանակներից։ Տեխնիկապես վարքագիծը ճիշտ չէ, բայց պրակտիկայում կարող է հարմար լինել։
 
 ```smart header="The `typeof(x)` syntax"
 You may also come across another syntax: `typeof(x)`. It's the same as `typeof x`.
@@ -263,25 +275,26 @@ Usually, such parentheses contain a mathematical expression, such as `(2 + 2)`,
 Some people prefer `typeof(x)`, although the `typeof x` syntax is much more common.
 ```
 
-## Summary
+## Ամփոփում
 
-There are 8 basic data types in JavaScript.
+JavaScript-ում գոյություն ունեն տվյալների 8 տիպեր։
 
-- Seven primitive data types:
-    - `number` for numbers of any kind: integer or floating-point, integers are limited by <code>±(2<sup>53</sup>-1)</code>.
-    - `bigint` for integer numbers of arbitrary length.
-    - `string` for strings. A string may have zero or more characters, there's no separate single-character type.
-    - `boolean` for `true`/`false`.
-    - `null` for unknown values -- a standalone type that has a single value `null`.
-    - `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
-    - `symbol` for unique identifiers.
-- And one non-primitive data type:
-    - `object` for more complex data structures.
+- Տվյալների յոթ պրիմիտիվ տիպեր՝
+    - `number` բոլոր տեսակի թվերի համար․ ամբողջ և տասնորդական, ամբողջ թվերը սահմանափակված են <code>±(2<sup>53</sup>-1)</code> միջակայքում։
+    - `bigint` կամայական մեծության ամբողջ թվերի համար։
+    - `string` տողերի համար։ Տողը կարող է պարունակել զրո կամ ավել նիշեր, չկա նիշի համար նախատեսված առանձին տիպ։
+    - `boolean` `true`/`false` արժեքների համար։
+    - `null` անհայտ արժեքների համար․ առանձին տիպ է, որը ունի մեկ արժեք՝ `null`։
+    - `undefined` չվերագրված արժեքների համար․ առանձին տիպ է, որը ունի մեկ արժեք՝ `undefined`։
+    - `object` ավելի բարդ տվյալների կառուցվածքների համար։
+    - `symbol` չկրկնվող նույնացուցիչների համար։
+- Եվ տվյալների ոչ պրիմիտիվ մեկ տիպ՝
+    - `object` տվյալների բարդ կառուցվածքների համար։
 
-The `typeof` operator allows us to see which type is stored in a variable.
+`typeof`-ը թույլ է տալիս ստուգել, թե ինչ տիպի արժեք է պահված փոփոխականում։
 
-- Usually used as `typeof x`, but `typeof(x)` is also possible.
-- Returns a string with the name of the type, like `"string"`.
-- For `null` returns `"object"` -- this is an error in the language, it's not actually an object.
+- Ունի երկու ձև․ `typeof x` կամ `typeof(x)`։
+- Վերադարձնում է տող, որը պարունակում է տիպի անվանումը, օրինակ՝ `"string"`։
+- `null`-ի դեպքում վերադարձնում է `"object"`․ սա լեզվի սխալ է, այն իրականում օբյեկտ չէ։
 
-In the next chapters, we'll concentrate on primitive values and once we're familiar with them, we'll move on to objects.
+Հաջորդ գլուխներում մենք կկենտրոնանանք պրիմիտիվ արժեքների վրա և երբ ծանոթանանք դրանց հետ, կանցնենք օբյեկտների ուսումնասիրությանը։
diff --git a/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md b/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md
index 903ee7ff3..8f9b064c3 100644
--- a/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md
+++ b/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/solution.md
@@ -1,11 +1,11 @@
-JavaScript-code:
+JavaScript կոդը․
 
 ```js demo run
-let name = prompt("What is your name?", "");
+let name = prompt("Ի՞նչ է Ձեր անունը։", "");
 alert(name);
 ```
 
-The full page:
+Ամբողջական էջը․
 
 ```html
 <!DOCTYPE html>
@@ -15,7 +15,7 @@ The full page:
   <script>
     'use strict';
 
-    let name = prompt("What is your name?", "");
+    let name = prompt("Ի՞նչ է Ձեր անունը։", "");
     alert(name);
   </script>
 
diff --git a/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md b/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md
index a65a654e0..e398ce6d0 100644
--- a/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md
+++ b/1-js/02-first-steps/06-alert-prompt-confirm/1-simple-page/task.md
@@ -2,8 +2,8 @@ importance: 4
 
 ---
 
-# A simple page
+# Պարզ էջ
 
-Create a web-page that asks for a name and outputs it.
+Կառուցե՛ք էջ, որը օգտատիրոջից կհարցնի իր անունը և կպատկերի այն։
 
 [demo]
diff --git a/1-js/02-first-steps/06-alert-prompt-confirm/article.md b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
index ef0f333cb..1ab9f8a1a 100644
--- a/1-js/02-first-steps/06-alert-prompt-confirm/article.md
+++ b/1-js/02-first-steps/06-alert-prompt-confirm/article.md
@@ -1,105 +1,105 @@
-# Interaction: alert, prompt, confirm
+# Փոխազդեցություն: alert, prompt, confirm
 
-As we'll be using the browser as our demo environment, let's see a couple of functions to interact with the user: `alert`, `prompt` and `confirm`.
+Քանի որ մենք օգտագործելու ենք զննիչները որպես ներկայացման տիրույթ, եկեք ուսումնասիրենք մի քանի ֆունկցիաներ՝ նախատեսված օգտատիրոջ հետ փոխազդեցության համար․ `alert`, `prompt` և `confirm`։
 
 ## alert
 
-This one we've seen already. It shows a message and waits for the user to press "OK".
+Այս ֆունկցիայի հետ մենք արդեն առնչվել ենք։ Այն ցույց է տալիս հաղորդագրություն և սպասում է օգտատիրոջ՝ «OK» կոճակը սեղմելուն։
 
-For example:
+Օրինակ․
 
 ```js run
-alert("Hello");
+alert("Բարև");
 ```
 
-The mini-window with the message is called a *modal window*. The word "modal" means that the visitor can't interact with the rest of the page, press other buttons, etc, until they have dealt with the window. In this case -- until they press "OK".
+Հաղորդագրությունը պարունակող փոքր պատուհանը կոչվում է *մոդալ պատուհան* (modal window)։ «Մոդալը» նշանակում է, որ օգտատերը չի կարող փոխազդել էջի մնացած մասի հետ, սեղմել այլ կոճակներ և այլն, քանի դեռ նա փոխազդում է պատուհանի հետ։ Այս պարագայում՝ քանի դեռ չի սեղմել «OK» կոճակը։
 
 ## prompt
 
-The function `prompt` accepts two arguments:
+`prompt` ֆունկցիան ընդունում է երկու արգումենտ․
 
 ```js no-beautify
 result = prompt(title, [default]);
 ```
 
-It shows a modal window with a text message, an input field for the visitor, and the buttons OK/Cancel.
+Այն կպատկերի տեքստային հաղորդագրություն պարունակող մոդալ պատուհան, տեքստի մուտքագրման դաշտ և OK/Cancel կոճակներ։
 
 `title`
-: The text to show the visitor.
+։ Տեքստը, որը կպատկերվի պատուհանում։
 
 `default`
-: An optional second parameter, the initial value for the input field.
+: Ոչ պարտադիր երկրորդ արգումենտ՝ մուտքագրման դաշտի նախնական արժեքի համար։
 
-```smart header="The square brackets in syntax `[...]`"
-The square brackets around `default` in the syntax above denote that the parameter is optional, not required.
+```smart header="Քառակուսի փակագծերը `[...]` շարահյուսությունում"
+Վերոնշյալ շարահյուսությունում `default`-ը շրջապատող քառակուսի փակագծերը նշանակում են, որ պարամետրի առկայությունը պարտադիր չէ։
 ```
 
-The visitor can type something in the prompt input field and press OK. Then we get that text in the `result`. Or they can cancel the input by pressing Cancel or hitting the `key:Esc` key, then we get `null` as the `result`.
+Օգտատերը կարող է մուտքագրման դաշտում լրացնել ինչ-որ բան և սեղմել OK։ Մուտքագրված տեքստը կվերագրվի `result` փոփոխականին։ Օգտատերը նաև կարող է չեղարկել մուտքագրումը՝ սեղմելով Cancel կամ ստեղնաշարի `key:Esc` կոճակները։ Այդ դեպքում `result`-ին կվերագրվի `null` արժեքը։
 
-The call to `prompt` returns the text from the input field or `null` if the input was canceled.
+`prompt`-ի կանչը վերադարձնում է մուտքագրման դաշտում նշված տեքստը կամ `null`, եթե մուտքագրումը չեղարկվել է։
 
-For instance:
+Օրինակ․
 
 ```js run
-let age = prompt('How old are you?', 100);
+let age = prompt('Քանի՞ տարեկան ես։', 100);
 
-alert(`You are ${age} years old!`); // You are 100 years old!
+alert(`Դու ${age} տարեկան ես։`); // Դու 100 տարեկան ես։
 ```
 
-````warn header="In IE: always supply a `default`"
-The second parameter is optional, but if we don't supply it, Internet Explorer will insert the text `"undefined"` into the prompt.
+````warn header="IE-ի համար միշտ սահմանեք լռելյայն (`default`) արժեք"
+Երկրորդ պարամետրը պարտադիր չէ, բայց, եթե չսահմանենք այն, Internet Explorer-ը կտեղադրի `"undefined"` տեքստը prompt-ի մուտքագրման դաշտում։
 
-Run this code in Internet Explorer to see:
+Աշխատեցրեք կոդը Internet Explorer-ում՝ արդյունքը տեսնելու համար․
 
 ```js run
-let test = prompt("Test");
+let test = prompt("Թեստ");
 ```
 
-So, for prompts to look good in IE, we recommend always providing the second argument:
+Այսպիսով, որպեսզի prompt-ը ունենա նորմալ տեսք IE-ում, խորհուրդ է տրվում միշտ սահմանել երկրորդ արգումենտը․
 
 ```js run
-let test = prompt("Test", ''); // <-- for IE
+let test = prompt("Թեստ", ''); // <-- IE-ի համար
 ```
 ````
 
 ## confirm
 
-The syntax:
+Շարահյուսությունը (syntax)․
 
 ```js
 result = confirm(question);
 ```
 
-The function `confirm` shows a modal window with a `question` and two buttons: OK and Cancel.
+`confirm` ֆունկցիան պատկերում է մոդալ պատուհան `question` հարցման տեքստով և երկու կոճակով՝ OK և Cancel։
 
-The result is `true` if OK is pressed and `false` otherwise.
+Արդյունքը կլինի `true`, եթե սեղմվի OK կոճակը, և `false`՝ հակառակ դեպքում։
 
-For example:
+Օրինակ․
 
 ```js run
-let isBoss = confirm("Are you the boss?");
+let isBoss = confirm("Դու՞ք եք այստեղ գլխավորը։");
 
-alert( isBoss ); // true if OK is pressed
+alert( isBoss ); // true, եթե սեղմվի OK կոճակը
 ```
 
-## Summary
+## Ամփոփում
 
-We covered 3 browser-specific functions to interact with visitors:
+Մենք ուսումնասիրեցինք 3 զննիչային (browser-specific) ֆունկցիաներ, որոնք փոխազդում են օգտատիրոջ հետ․
 
 `alert`
-: shows a message.
+: պատկերում է հաղորդագրություն։
 
 `prompt`
-: shows a message asking the user to input text. It returns the text or, if Cancel button or `key:Esc` is clicked, `null`.
+: պատկերում է հաղորդագրություն, սպասելով օգտատիրոջ կողմից տեքստի մուտքագրմանը։ Այն վերադարձնում է տեքստը, կամ, եթե սեղմվել է Cancel կամ `key:Esc` կոճակը, ապա վերադարձնում է `null`։
 
 `confirm`
-: shows a message and waits for the user to press "OK" or "Cancel". It returns `true` for OK and `false` for Cancel/`key:Esc`.
+: պատկերում է հաղորդագրություն և սպասում է օգտատիրոջ «OK» կամ «Cancel» սեղմելուն։ OK-ի դեպքում վերադարձնում է `true`, իսկ Cancel/`key:Esc`-ի դեպքում՝ `false`։
 
-All these methods are modal: they pause script execution and don't allow the visitor to interact with the rest of the page until the window has been dismissed.
+Այս բոլոր մեթոդները մոդալային են․ դրանք կանգնեցնում են սկրիպտի իրականցումը և թույլ չեն տալիս օգտատիրոջը փոխազդել էջի մնացած մասի հետ, քանի դեռ պատուհանը չի փակվել։
 
-There are two limitations shared by all the methods above:
+Վերոնշյալ մեթոդները ունեն երկու սահմանափակում․
 
-1. The exact location of the modal window is determined by the browser. Usually, it's in the center.
-2. The exact look of the window also depends on the browser. We can't modify it.
+1. Մոդալ պատուհանի դիրքը որոշվում է զննիչի կողմից։ Սովորաբար այն լինում է կենտրոնում։
+2. Պատուհանի տեսքը նույնպես որոշվում է զննիչի կողմից։ Մենք չենք կարող այն փոփոխել։
 
-That is the price for simplicity. There are other ways to show nicer windows and richer interaction with the visitor, but if "bells and whistles" do not matter much, these methods work just fine.
+Այսպիսին է պարզության գինը։ Կան շատ այլ եղանակներ՝ ավելի գեղեցիկ պատուհաններ պատկերելու և օգտատիրոջ հետ ավելի լայն փոխազդեցություն ապահովելու համար, բայց եթե «ճոխությունը» կարևոր չէ, այս մեթոդները հիանալի լուծում են։
diff --git a/1-js/02-first-steps/07-type-conversions/article.md b/1-js/02-first-steps/07-type-conversions/article.md
index 329556141..501a9849f 100644
--- a/1-js/02-first-steps/07-type-conversions/article.md
+++ b/1-js/02-first-steps/07-type-conversions/article.md
@@ -1,150 +1,150 @@
-# Type Conversions
+# Տիպերի փոխարկումներ (Type Conversions)
 
-Most of the time, operators and functions automatically convert the values given to them to the right type.
+Հաճախ օպերատորները և ֆունկցիաները ինքնաբերաբար փոխարկում են իրենց տրված արժեքները անհրաժեշտ տիպի։
 
-For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers.
+Օրինակ՝ `alert`-ը ինքնաբերաբար փոխարկում է ցանկացած արժեք տողի (string)՝ այն պատկերելու համար։ Մաթեմատիկական գործողությունները փոխարկում են արժեքները թվերի։
 
-There are also cases when we need to explicitly convert a value to the expected type.
+Նաև լինում են դեպքեր, երբ մենք կարիք ենք ունենում բացահայտորեն փոխարկել արժեքը անհրաժեշ տիպի։
 
-```smart header="Not talking about objects yet"
-In this chapter, we won't cover objects. For now, we'll just be talking about primitives.
+```smart header="Դեռևս չենք խոսում օբյեկտների մասին"
+Այս գլխում մենք չենք լուսաբանի օբյեկտները։ Առայժմ կխոսենք միայն պրիմիտիվների մասին։
 
-Later, after we learn about objects, in the chapter <info:object-toprimitive> we'll see how objects fit in.
+Հետագայում, երբ կծանոթանանք օբյեկտների հետ <info:object-toprimitive> գլխում, կտեսնենք, թե ինչպես են փոխարկվում օբյեկտները։
 ```
 
-## String Conversion
+## Տողային փոխարկում (String Conversion)
 
-String conversion happens when we need the string form of a value.
+Տողի փոխարկումը տեղի է ունենում, երբ կարիք է լինում ներկայացնել արժեքի տողային տեսքը։
 
-For example, `alert(value)` does it to show the value.
+Օրինակ՝ `alert(value)`-ն կատարում է փոխարկում՝ արժեքը պատկերելու համար։ 
 
-We can also call the `String(value)` function to convert a value to a string:
+Մենք կարող ենք կանչել `String(value)` ֆունկցիան՝ արժեքը տողի փոխարկելու համար․
 
 ```js run
 let value = true;
 alert(typeof value); // boolean
 
 *!*
-value = String(value); // now value is a string "true"
+value = String(value); // այստեղ value-ին վերագրվեց "true" տողը
 alert(typeof value); // string
 */!*
 ```
 
-String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc.
+Տողի փոխարկման արդյունքը հիմնականում ակնհայտ է։ `false`-ը դառնում է `"false"`, `null`-ը դառնում է `"null"` և այլն։
 
-## Numeric Conversion
+## Թվային փոխարկում (Numeric Conversion)
 
-Numeric conversion in mathematical functions and expressions happens automatically.
+Մաթեմատիկական ֆունկցիաներում և արտահայտություններում այլ արժեքներիից թվին փոխարկումը տեղի է ունենում ավտոմատ։
 
-For example, when division `/` is applied to non-numbers:
+Օրինակ՝ երբ բաժանումը `/` կիրառվում է ոչ թվային արժեքների վրա․
 
 ```js run
-alert( "6" / "2" ); // 3, strings are converted to numbers
+alert( "6" / "2" ); // 3, տողերը փոխարկվում են թվերի
 ```
 
-We can use the `Number(value)` function to explicitly convert a `value` to a number:
+Մենք կարող ենք կիրառել `Number(value)` ֆունկցիան՝ `value`-ն բացահայտ կերպով թվի փոխարկելու համար․
 
 ```js run
 let str = "123";
 alert(typeof str); // string
 
-let num = Number(str); // becomes a number 123
+let num = Number(str); // դառնում է թիվ 123
 
 alert(typeof num); // number
 ```
 
-Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered.
+Բացահայտ փոխարկումը հաճախ նախընտրելի է, երբ որևէ թվի մուտքագրում ակնկալող տեքստային դաշտից արժեք վերցնելու կարիք կա։
 
-If the string is not a valid number, the result of such a conversion is `NaN`. For instance:
+Երբ տողից թվի փոխարկումը վավեր չէ, այդ փոխարկման արդյունքը կլինի `NaN`։ Օրինակ․
 
 ```js run
-let age = Number("an arbitrary string instead of a number");
+let age = Number("կամայական տող, թվի փոխարեն");
 
-alert(age); // NaN, conversion failed
+alert(age); // NaN, փոխարկումը ձախողվել է
 ```
 
-Numeric conversion rules:
+Թվային փոխարկումների կանոնները․
 
-| Value |  Becomes... |
+| Արժեքը |  Փոխարկվում է... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
-|<code>true&nbsp;and&nbsp;false</code> | `1` and `0` |
-| `string` | Whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. |
+|<code>true&nbsp;և&nbsp;false</code> | `1` և `0` |
+| `string` | Սկզբում և վերջում եղած բացատները (ներառյալ space-ներ, թաբեր `\t`, նոր տողեր `\n`, և այլն) հեռացվում են։ Եթե ստացված տողը դատարկ է, արդյունքը դառնում է `0`։ Հակառակ դեպքում, ոչ դատարկ տողից «կարդացվում է» թիվը։ Ձախողման դեպքում արդյունքը դառնում է `NaN`։ |
 
-Examples:
+Օրինակներ․
 
 ```js run
 alert( Number("   123   ") ); // 123
-alert( Number("123z") );      // NaN (error reading a number at "z")
+alert( Number("123z") );      // NaN (փոխարկումը ձախողվել է "z"-ի առկայության պատճառով)
 alert( Number(true) );        // 1
 alert( Number(false) );       // 0
 ```
 
-Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`.
+Նշենք, որ `null`-ը և `undefined`-ը իրենց տարբեր կերպ են դրսևորում՝ `null`-ը դառնում է զրո, մինչդեռ `undefined`-ը դառնում է `NaN`։
 
-Most mathematical operators also perform such conversion, we'll see that in the next chapter.
+Մաթեմատիկական օպերատորների գերակշիռ մասը նույնպես իրականացնում է նման փոխարկում։ Մենք կուսումնասիրենք դրանք հաջորդ գլխում։
 
-## Boolean Conversion
+## Տրամաբանական փոխարկում (Boolean Conversion)
 
-Boolean conversion is the simplest one.
+Տրամաբանական փոխարկումը ամենապարզն է։
 
-It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`.
+Այն տեղի է ունենում տրամաբանական գործողություններում (ավելի ուշ կծանոթանանք պայմանական ստուգումների և նման այլ կառուցվածքների հետ), բայց նաև կարող է իրականացվել բացահայտ կերպով՝ `Boolean(value)` ֆունկցիայի միջոցով։
 
-The conversion rule:
+Փոխարկման կանոնները․
 
-- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`.
-- Other values become `true`.
+- Արժեքները, որոնք ենթադրում են «դատարկություն», ինչպես `0`-ն, դատարկ տողը, `null`-ը, `undefined`-ը և `NaN`-ը, դառնում են `false`։
+- Մնացած արժեքները դառնում են `true`։
 
-For instance:
+Օրինակ՝
 
 ```js run
 alert( Boolean(1) ); // true
 alert( Boolean(0) ); // false
 
-alert( Boolean("hello") ); // true
+alert( Boolean("բարև") ); // true
 alert( Boolean("") ); // false
 ```
 
-````warn header="Please note: the string with zero `\"0\"` is `true`"
-Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`.
+````warn header="Հիշե՛ք, զրո պարունակող տողը `\"0\"` `true` է"
+Որոշ լեզուներ (օրինակ՝ PHP-ն) ընկալում են `"0"` տողը որպես `false`։ Բայց JavaScript-ում ոչ դատարկ տողը միշտ `true` է։
 
 ```js run
 alert( Boolean("0") ); // true
-alert( Boolean(" ") ); // spaces, also true (any non-empty string is true)
+alert( Boolean(" ") ); // բացատը նույնպես true է (ցանկացած ոչ դատարկ տող true է)
 ```
 ````
 
-## Summary
+## Ամփոփում
 
-The three most widely used type conversions are to string, to number, and to boolean.
+Առավել հաճախ կիրառվող տիպային փոխարկումները տողային, թվային և տրամաբանական փոխարկումներն են։
 
-**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values.
+**`Տողային փոխարկում`** -- Տեղի է ունենում ինչ-որ բանի պատկերման դեպքում։ Կարող է իրականացվել `String(value)`-ի միջոցով։ Տողային փոխարկումը պրիմիտիվ արժեքների դեպքում կանխատեսելի է։
 
-**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`.
+**`Թվային փոխարկում`** -- Տեղի է ունենում մաթեմատիկական գործողություններում։ Կարող է իրականացվել `Number(value)`-ի միջոցով։
 
-The conversion follows the rules:
+Փոխարկումը ենթարկվում է հետևյալ կանոններին․
 
-| Value |  Becomes... |
+| Արժեքը |  Փոխարկվում է... |
 |-------|-------------|
 |`undefined`|`NaN`|
 |`null`|`0`|
 |<code>true&nbsp;/&nbsp;false</code> | `1 / 0` |
-| `string` | The string is read "as is", whitespaces (includes spaces, tabs `\t`, newlines `\n` etc.) from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. |
+| `string` | Տողերը կարդացվում են ինչպես կան, եզրերում եղած բացատները (ներառյալ space-ներ, թաբեր `\t`, նոր տողեր `\n`, և այլն) անտեսվում են։ Դատարկ տողը դառնում է `0`։ Ձախողման դեպքում ստացվում է `NaN`։ |
 
-**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`.
+**`Տրամաբանական փոխարկում`** -- Տեղի է ունենում տրամաբանական գործողություններում։ Կարող է իրականացվել `Boolean(value)`-ի միջոցով։
 
-Follows the rules:
+Ենթարկվում է հետևյալ կանոններին․
 
-| Value |  Becomes... |
+| Արժեքը |  Փոխարկվում է... |
 |-------|-------------|
 |`0`, `null`, `undefined`, `NaN`, `""` |`false`|
-|any other value| `true` |
+|ցանկացած այլ արժեք| `true` |
 
 
-Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are:
+Այս կանոնների մեծ մասը հեշտ է հասկանալ և հիշել։ Բացառություն են կազմում հետևյալ դեպքերը, որտեղ մարդիկ հաճախակի են սխալվում․
 
-- `undefined` is `NaN` as a number, not `0`.
-- `"0"` and space-only strings like `"   "` are true as a boolean.
+- `undefined`-ը որպես թիվ `NaN` է, ոչ թե `0`։
+- `"0"`-ն և միայն բացատներից կազմված տողը՝ ինչպես `"   "`, true են։
 
-Objects aren't covered here. We'll return to them later in the chapter <info:object-toprimitive> that is devoted exclusively to objects after we learn more basic things about JavaScript.
+Այս գլխում չխոսվեց օբյեկտների մասին։ Մենք կվերադառնանք դրանց ավելի ուշ՝ ամբողջությամբ օբյեկտներին նվիրված <info:object-toprimitive> գլխում, JavaScript-ի տարրական գաղափարները ավելի հիմնովին ուսումնասիրելուց հետո։
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 d52c37a17..1bfccc7df 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,51 +17,51 @@ 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, the remainder of 5 divided by 2
-alert( 8 % 3 ); // 2, the remainder of 8 divided by 3
-alert( 8 % 4 ); // 0, the remainder of 8 divided by 4
+alert( 5 % 2 ); // 1, 5-ը բաժանած 2-ի մնացորդը
+alert( 8 % 3 ); // 2, 8-ը բաժանած 3-ի մնացորդը
+alert( 8 % 4 ); // 0, 8-ը բաժանած 4-ի մնացորդը
 ```
 
-### Exponentiation **
+### Աստիճան բարձրացնել  **
 
-The exponentiation operator `a ** b` raises `a` to the power of `b`.
+Աստիճան բարձրացնելու օպերատորը `a ** b` բարձրացնում է `a`-ն `b`-ի աստիճան.
 
-In school maths, we write that as a<sup>b</sup>.
+Դպրոցական մաթեմատիկայում այն գրում ենք հետևյալ տեսքով a<sup>b</sup>։
 
-For instance:
+Օրինակ՝
 
 ```js run
 alert( 2 ** 2 ); // 2² = 4
@@ -69,9 +69,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)
@@ -79,62 +79,62 @@ alert( 8 ** (1/3) ); // 2 (power of 1/3 is the same as a cubic root)
 ```
 
 
-## String concatenation with binary +
+## Տողերի միավորումը երկուական +-ով
 
-Let's meet the 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
 
@@ -142,77 +142,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 |
+| Առաջնահերթություն | Անվանում | Նշան |
 |------------|------|------|
 | ... | ... | ... |
-| 14 | unary plus | `+` |
-| 14 | unary negation | `-` |
-| 13 | exponentiation | `**` |
-| 12 | multiplication | `*` |
-| 12 | division | `/` |
-| 11 | addition | `+` |
-| 11 | subtraction | `-` |
+| 14 | ունար պլյուս | `+` |
+| 14 | ունար ժխտում | `-` |
+| 13 | աստիճան բարձրացում | `**` |
+| 12 | բազմապատկում | `*` |
+| 12 | բաժանում | `/` |
+| 11 | գումարում | `+` |
+| 11 | հանում | `-` |
 | ... | ... | ... |
-| 2 | assignment | `=` |
+| 2 | վերագրում | `=` |
 | ... | ... | ... |
 
-As we can see, the "unary plus" has a priority of `14` which is higher than the `11` of "addition" (binary plus). That's why, in the expression `"+apples + +oranges"`, unary pluses work before the addition.
+Կարող ենք տեսնել, "ունար պլյուս"-ը ունի `14` գերակայությունը, որը մեծ է քան `11`-ը "գումարում" (երկուական պլյուս)։ Ահա թե ինչու է `"+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 `2`.
+Պետք է նշել այն, որ վերագրումը `=` նույնպես օպերատոոր է։ Այն գերակայության աղյուսակում ունի շատ ցածր դիրք՝ `2`։
 
-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;
@@ -220,15 +220,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;
@@ -242,15 +242,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;
@@ -264,22 +264,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;
@@ -287,19 +287,19 @@ 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;
@@ -309,45 +309,45 @@ n *= 3 + 5; // right part evaluated first, same as n *= 8
 alert( n ); // 16
 ```
 
-## Increment/decrement
+## Ինկրեմենտ/դեկրեմենտ
 
 <!-- Can't use -- in title, because the built-in parser turns it into a 'long dash' – -->
 
-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;
@@ -356,36 +356,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;
@@ -393,27 +393,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;
@@ -422,59 +422,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_operators) 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-ի մի շարք ֆրեյմվորկներում։ Ահա թե ինչում մենք դիտարկեցինք դրանք։ Բայց երբեմն դրանք չեն բարելավում կոդի ընթեռնելիությունը, ուստի դրանք օգտագործելուց առաջ պետք է լավ մտածել։
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
index 632b1cf4e..7712f06bf 100644
--- a/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
+++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/solution.md
@@ -10,12 +10,12 @@ null == "\n0\n" → false
 null === +"\n0\n" → false
 ```
 
-Some of the reasons:
+Պատճառներից որոշները.
 
-1. Obviously, true.
-2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
-3. Again, dictionary comparison, first char `"2"` is greater than the first char `"1"`.
-4. Values `null` and `undefined` equal each other only.
-5. Strict equality is strict. Different types from both sides lead to false.
-6. Similar to `(4)`, `null` only equals `undefined`.
-7. Strict equality of different types.
+1. Միանշանակ, true.
+2. Բառարանային համեմատություն, հետևաբար՝ false: `"a"`-ն ավելի փոքր է, քան `"p"`-ն։
+3. Կրկին բառարանային համեմատություն, առաջին նշան `"2"`-ը ավելի մեծ է, քան առաջինը նշան `"1"`-ը։
+4. `null` և `undefined` արժեքները հավասար են միայն իրար։
+5. Տարբեր տիպերի խիստ հավասարության ստուգման արդյունքը false է։
+6. Նման է `(4)`-ին, `null`-ը միայն հավասար է `undefined`-ին։
+7․ Տարբեր տիպերի խիստ հավասարության ստուգում:
\ No newline at end of file
diff --git a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
index be7f75ddd..68f05da54 100644
--- a/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
+++ b/1-js/02-first-steps/09-comparison/1-comparison-questions/task.md
@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# Comparisons
+# Համեմատություններ
 
-What will be the result for these expressions?
+Ի՞նչ են հետևյալ արտահայտությունների արժեքները:
 
 ```js no-beautify
 5 > 4
@@ -15,4 +15,3 @@ undefined === null
 null == "\n0\n"
 null === +"\n0\n"
 ```
-
diff --git a/1-js/02-first-steps/09-comparison/article.md b/1-js/02-first-steps/09-comparison/article.md
index a69317fee..06c46b1ef 100644
--- a/1-js/02-first-steps/09-comparison/article.md
+++ b/1-js/02-first-steps/09-comparison/article.md
@@ -1,47 +1,47 @@
-# Comparisons
+# Համեմատություններ
 
-We know many comparison operators from maths.
+Մենք գիտենք համեմատության բազմաթիվ գործողություններ մաթեմատիկայից։
 
-In JavaScript they are written like this:
+JavaScript-ում դրանք գրվում են հետևյալ տեսքով․
 
-- Greater/less than: <code>a &gt; b</code>, <code>a &lt; b</code>.
-- Greater/less than or equals: <code>a &gt;= b</code>, <code>a &lt;= b</code>.
-- Equals: `a == b`, please note the double equality sign `==` means the equality test, while a single one `a = b` means an assignment.
-- Not equals: In maths the notation is <code>&ne;</code>, but in JavaScript it's written as <code>a != b</code>.
+- Մեծ/փոքր։ <code>a &gt; b</code>, <code>a &lt; b</code>։
+- Մեծ/փոքր կամ հավասար։ <code>a &gt;= b</code>, <code>a &lt;= b</code>։
+- Հավասար՝ `a == b`: Ուշադրություն դարձրեք, որ `==` գործողությունով ստուգվում է հավասարությունը, մինչդեռ `a = b` նշանակում է վերագրում։
+- Ոչ հավասար։ Մաթեմատիկայում այս նշանը հետևյալն է՝ <code>&ne;</code>, բայց JavaScript-ում այն ներկայացվում է հետևյալ տեսքով՝ <code>a != b</code>։
 
-In this article we'll learn more about different types of comparisons, how JavaScript makes them, including important peculiarities.
+Այս հոդվածում մենք կսովորենք համեմատության տարբեր գործողությունները, թե ինչպես է JavaScript-ը կատարում դրանք, ներառյալ կարևոր առանձնահատկությունները։
 
-At the end you'll find a good recipe to avoid "JavaScript quirks"-related issues.
+Վերջում դուք կիմանաք, թե ինչպես խուսափել «JavaScript-ի տարօրիանկություններ»-ի հետ կապված խնդիրներից։
 
-## Boolean is the result
+## Արդյունքը տրամաբանական տիպի է
 
-All comparison operators return a boolean value:
+Համեմատության բոլոր գործողությունները վերադարձնում են տրամաբանական տիպի արժեք․
 
-- `true` -- means "yes", "correct" or "the truth".
-- `false` -- means "no", "wrong" or "not the truth".
+- `true` - նշանակում է "այո", "ճիշտ" կամ "իրական".
+- `false` - նշանակում է "ոչ", "սխալ" կամ "ոչ իրական/կեղծ". Օրինակ․
 
-For example:
+Օրինակ՝
 
 ```js run
-alert( 2 > 1 );  // true (correct)
-alert( 2 == 1 ); // false (wrong)
-alert( 2 != 1 ); // true (correct)
+alert( 2 > 1 );  // true (ճիշտ)
+alert( 2 == 1 ); // false (սխալ)
+alert( 2 != 1 ); // true (ճիշտ)
 ```
 
-A comparison result can be assigned to a variable, just like any value:
+Համեմատության արդյունքը կարելի է վերագրել փոփոխականի, ինչպես ցանկացած արժեք․
 
 ```js run
-let result = 5 > 4; // assign the result of the comparison
-alert( result ); // true
+let result = 5 > 4; // վերագրել համեմատության արդյունքը
+alert(result); // true (ճիշտ)
 ```
 
-## String comparison
+## Տողերի համեմատություն
 
-To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order.
+Եթե ցանկանում ենք ստուգել թե որ տողային փոփոխականն է մեծ, JavaScript-ը օգտագործում է այսպես կոչված "բառարան" (անգլ․՝ dictionary) կամ "բառարանային" (անգլ․՝ lexicographical) հերթականություն։
 
-In other words, strings are compared letter-by-letter.
+Այլ կերպ ասած՝ տողերը համեմատվում են տառ առ տառ։
 
-For example:
+Օրինակ՝
 
 ```js run
 alert( 'Z' > 'A' ); // true
@@ -49,55 +49,55 @@ alert( 'Glow' > 'Glee' ); // true
 alert( 'Bee' > 'Be' ); // true
 ```
 
-The algorithm to compare two strings is simple:
+Երկու տողային փոփոխականների համեմատման ալգորիթմը շատ պարզ է․
 
-1. Compare the first character of both strings.
-2. If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done.
-3. Otherwise, if both strings' first characters are the same, compare the second characters the same way.
-4. Repeat until the end of either string.
-5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater.
+1. Համեմատել երկու տողերի առաջին նշանները:
+2․ Եթե առաջին տողի առաջին նշանը մեծ (կամ փոքր) է, քան մյուս տողինը, ապա առաջին տողը մեծ (կամ փոքր) է երկրորդից:
+3. Հակառակ դեպքում, եթե տողերի առաջին նշանները հավասար են, ապա նույն ձևով համեմատվում են երկրորդ նշանները:
+4. Գործողությունը կրկնվում է մինչև տողերից որևէ մեկի ավարտը։
+5. Եթե տողերն ունեն նույն երկարությունը, ապա դրանք հավասար են։ Հակառակ դեպքում, մեծ երկարություն ունեցող տողը համարվում է ավելի մեծ:
 
-In the first example above, the comparison `'Z' > 'A'` gets to a result at the first step.
+Առաջին օրինակում `'Z' > 'A'` համեմատության արդյունքը կստացվի առաջին քայլից։
 
-The second comparison `'Glow'` and `'Glee'` needs more steps as strings are compared character-by-character:
+Երկրորդ համեմատությունը `'Glow'` և `'Glee'`, պահանջում է ավել քայլեր, քանի որ տողերը համեմատվում են նիշ առ նիշ․
 
-1. `G` is the same as `G`.
-2. `l` is the same as `l`.
-3. `o` is greater than `e`. Stop here. The first string is greater.
+1. `G`-ն նույնն է ինչ `G`-ն։
+2. `l`-ը նույնն է ինչ `l`-ը։
+3. `o`-ն մեծ է քան `e`-ն։ Այստեղ համեմատթույունն ավարտվում է, քանի որ առաջին տողը ավելի մեծ է, քան երկրորդը։
 
-```smart header="Not a real dictionary, but Unicode order"
-The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same.
+```smart header="Ոչ իրական բառարան, այլ Unicode-ային հերթականություն"
+Վերևում բերված համեմատության ալգորիթմը մոտավորապես համարժեք է բառարաններում կամ հեռախոսագրքերում օգտագործվողին, բայց նույնը չէ:
 
-For instance, case matters. A capital letter `"A"` is not equal to the lowercase `"a"`. Which one is greater? The lowercase `"a"`. Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter <info:string>.
+Օրինակ՝ մեծատառ `"A"`-ն հավասար չէ փոքրատառ `"a"`-ին։ Ո՞ր մեկն է մեծ. փոքրատառ `"a"`-ն։ Ինչու՞, քանի որ փոքրատառ նշանը ունի ավելի մեծ ինդեքս կոդավորման աղյուսակում, որն օգտագործում է JavaScript-ը (Unicode)։ Մենք կվերադառնանք սրա մանրամասներին, և բխող հետևանքներին <info:string> բաժնում։
 ```
 
-## Comparison of different types
+## Տարբեր տիպերի համեմատությունը
 
-When comparing values of different types, JavaScript converts the values to numbers.
+Երբ համեմատությունը կատարվում է տարբեր տիպերի միջև, JavaScript-ը դրանք ձևափոխում է թվի:
 
-For example:
+Օրինակ՝
 
 ```js run
-alert( '2' > 1 ); // true, string '2' becomes a number 2
-alert( '01' == 1 ); // true, string '01' becomes a number 1
+alert( '2' > 1 ); // true, տողային '2' փոփոխականը ձևափոխվում է թվային 2-ի
+alert( '01' == 1 ); // true, տողային '01' փոփոխականը ձևափոխվում է թվային 1-ի
 ```
 
-For boolean values, `true` becomes `1` and `false` becomes `0`.
+Տրամաբանական արժեքների դեպքում `true`-ն ձևափոխվում է `1`-ի, իսկ `false`-ը՝ `0`-ի։ 
 
-For example:
+Օրինակ՝
 
 ```js run
 alert( true == 1 ); // true
 alert( false == 0 ); // true
 ```
 
-````smart header="A funny consequence"
-It is possible that at the same time:
+````smart header="Հետաքրքիր հետևանք"
+Միաժամանակ հնարավոր է․
 
-- Two values are equal.
-- One of them is `true` as a boolean and the other one is `false` as a boolean.
+  - Երկու արժեքներ նույնն են։
+  - Նրանցից մեկը տրամաբանական `true`-է, իսկ մյուսը տրամաբանական `false`-է։
 
-For example:
+Օրինակ՝
 
 ```js run
 let a = 0;
@@ -109,67 +109,67 @@ alert( Boolean(b) ); // true
 alert(a == b); // true!
 ```
 
-From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"` becomes `0`), while the explicit `Boolean` conversion uses another set of rules.
+JavaScript-ի տեսանկյունից, այս արդյունքները համարվում են ճիշտ։ Տողային արժեքը ձևափոխվում է թվային տիպի (ուստի `"0"`-ն ձևափոխվում է `0`-ի), մինչդեռ բացահայտ `Boolean`-փոխակերպումը կիրառում է մեկ այլ կանոն։
 ````
 
-## Strict equality
+## Խիստ հավասարություն
 
-A regular equality check `==` has a problem. It cannot differentiate `0` from `false`:
+Սովորական հավասարության ստուգումը `==` խնդրահարույց է։ Այն չի կարող տարբերակել `0`-ն `false`-ից։
 
 ```js run
 alert( 0 == false ); // true
 ```
 
-The same thing happens with an empty string:
+Նույն բանը կատարվում է դատարկ տողի հետ։
 
 ```js run
 alert( '' == false ); // true
 ```
 
-This happens because operands of different types are converted to numbers by the equality operator `==`. An empty string, just like `false`, becomes a zero.
+Սա պատահում է, քանի որ `==` գործողությանը տարբեր տիպերի համեմատման ժամանակ արժեքները ձևափոխում է թվերի։ Դատարկ տողը, ինչպես `false`-ը, դառնում է զրո։
 
-What to do if we'd like to differentiate `0` from `false`?
+Ի՞նչ պետք է անել, եթե ցանկանում ենք տարբերակել `0`-ն `false`-ից։
 
-**A strict equality operator `===` checks the equality without type conversion.**
+**Խիստ համեմատության գործողությունը `===` ստուգում է հավասարությունը առանց տիպային կերպափոխումների:**
 
-In other words, if `a` and `b` are of different types, then `a === b` immediately returns `false` without an attempt to convert them.
+Այլ կերպ ասած, եթե `a`-ն և `b`-ն տարբերի տիպերի են, ապա `a === b`-ն անմիջապես կվերադարձնի `false`, առանց տիպերի կերպափոխման։
 
-Let's try it:
+Եկեք փորձենք դա․
 
 ```js run
-alert( 0 === false ); // false, because the types are different
+alert(0 === false); // false, քանի որ արժեքները ունեն տարբեր տիպեր
 ```
 
-There is also a "strict non-equality" operator `!==` analogous to `!=`.
+Գոյություն ունի "խիստ ոչ հավասար" գործողության նշանը `!==`, որը նման է `!=`-ին։ 
 
-The strict equality operator is a bit longer to write, but makes it obvious what's going on and leaves less room for errors.
+Խիստ հավասարության օպերատորը մի փոքր ավելի երկար է գրվում, բայց ակնհայտ է դառնում այն, որ դա ավելի քիչ է սխալներ առաջացնում։
 
-## Comparison with null and undefined
+## Համեմատություն null-ի և undefined-ի հետ
 
-There's a non-intuitive behavior when `null` or `undefined` are compared to other values.
+Գոյություն ունի ոչ ինտուիտիվ պահվածք, երբ `null`-ը կամ `undefined`-ը համեմատվում են այլ արժեքների հետ։ 
 
-For a strict equality check `===`
-: These values are different, because each of them is a different type.
+Խիստ համեմատության `===` դեպքում․
+այս արժեքները տարբեր են, քանի որ նրանցից մեկը ունի այլ տիպ
 
     ```js run
     alert( null === undefined ); // false
     ```
 
-For a non-strict check `==`
-: There's a special rule. These two are a "sweet couple": they equal each other (in the sense of `==`), but not any other value.
+Ոչ խիստ համեմատության `==` դեպքում․
+Գոյություն ունի հատուկ կանոն։ Այս երկուսը համահունչ են, դրանք հավասար են իրար հետ, բայց հավասար չեն ոչ արժեքներով։
 
     ```js run
     alert( null == undefined ); // true
     ```
 
-For maths and other comparisons `< > <= >=`
-: `null/undefined` are converted to numbers: `null` becomes `0`, while `undefined` becomes `NaN`.
+Մաթեմատիկական և այլհամեմատություններում `< > <= >=`․
+`null/undefined`-ը ձևափոխվում են թվերի, `null`-ը ձևափոխվում է `0`-ի, մինչդեռ `undefined`-ը ձևափոխվում է `NaN`-ի։
 
-Now let's see some funny things that happen when we apply these rules. And, what's more important, how to not fall into a trap with them.
+Այժմ եկեք դիտարկենք մի քանի հետաքրքիր բաներ, որոնք տեղի են ունենում, երբ կիրառում ենք այս կանոնները: Եվ, որ ավելի կարևոր է, ինչպես չնկնել այդ ծուղակը։
 
-### Strange result: null vs 0
+### Տարօրինակ արդյունք․ null vs 0
 
-Let's compare `null` with a zero:
+Եկեք համեմատենք `null`-ը զրոյի հետ․
 
 ```js run
 alert( null > 0 );  // (1) false
@@ -177,15 +177,15 @@ alert( null == 0 ); // (2) false
 alert( null >= 0 ); // (3) *!*true*/!*
 ```
 
-Mathematically, that's strange. The last result states that "`null` is greater than or equal to zero", so in one of the comparisons above it must be `true`, but they are both false.
+Մաթեմատիկորեն, դա տարօրինակ է։ Վերջին արդյունքը, որ «`null`-ը մեծ կամ հավասար է զրոյի», համեմատություններից գոնե մեկը պետք է լինի `true`, բայց երկուսն էլ սխալ են։
 
-The reason is that an equality check `==` and comparisons `> < >= <=` work differently. Comparisons convert `null` to a number, treating it as `0`. That's why (3) `null >= 0` is true and (1) `null > 0` is false.
+Դրա պատճառըն այն է, որ `==` և `> < >= <=` գործողությունները գործում են տարբեր։ Հավասարության ստուգումը կերպափոխում է `null`-ը թվի, այսինքն՝ 0-ի։ Ահա թե ինչու `null >= 0`-ն ճիշտ է, իսկ `null > 0`-ը սխալ։
 
-On the other hand, the equality check `==` for `undefined` and `null` is defined such that, without any conversions, they equal each other and don't equal anything else. That's why (2) `null == 0` is false.
+Մյուս կողմից, `==`-ը ստուգում է `undefined`-ը և `null`-ը առանց ձևափոխման, դրանք հավասար են միմյանց, բայց հավասար չեն այլ փոփոխականի, ահա թե ինչու `null == 0` արտահայտությունը արժեքը `false` է:
 
-### An incomparable undefined
+### Անհամեմատելի undefined-ը
 
-The value `undefined` shouldn't be compared to other values:
+`undefined` արժեքը չի կարող համեմատվել այլ արժեքների հետ․
 
 ```js run
 alert( undefined > 0 ); // false (1)
@@ -193,24 +193,24 @@ alert( undefined < 0 ); // false (2)
 alert( undefined == 0 ); // false (3)
 ```
 
-Why does it dislike zero so much? Always false!
+Ինչու՞ այն նման չէ զրոյին, համեմատության արդյունքը միշտ կեղծ է:
 
-We get these results because:
+Մենք ստանում ենք այս արդյունքը, քանի որ․
 
-- Comparisons `(1)` and `(2)` return `false` because `undefined` gets converted to `NaN` and `NaN` is a special numeric value which returns `false` for all comparisons.
-- The equality check `(3)` returns `false` because `undefined` only equals `null`, `undefined`, and no other value.
+- Համեմատություններ `(1)`-ը և `(2)`-ը վերադարձնում են `false`, քանի որ `undefined`-ը ձևափոխվում է `NaN`-ի, իսկ `NaN`-ը հատուկ թվային արժեք է, որը բոլոր համեմատությունների դեպքում վերադարձնում է `false`։
+- Համեմատություն `(3)`-ը վերադարձնում է `false`, քանի որ `undefined`-ը հավասար է միայն `null`-ին և `undefined`-ին, և ոչ մի այլ արժեքի:
 
-### Avoid problems
+### Խուսափեք խնդիրներից
 
-Why did we go over these examples? Should we remember these peculiarities all the time? Well, not really. Actually, these tricky things will gradually become familiar over time, but there's a solid way to avoid problems with them:
+Ինչու՞ դիտարկեցինք այս օրինակները: Պե՞տք է անընդհատ հիշել այս առանձնահատկությունները: Դե, իրականում ոչ: Փաստորեն, նմանատիպ բարդությունները ժամանակի ընթացքում աստիճանաբար հայտնի կդառնան, բայց այդ խնդիրներից խուսափելու հնարավոր միջոցներ կան.
 
-- Treat any comparison with `undefined/null` except the strict equality `===` with exceptional care.
-- Don't use comparisons `>= > < <=` with a variable which may be `null/undefined`, unless you're really sure of what you're doing. If a variable can have these values, check for them separately.
+- Ցանկացած համեմատությանը `undefined/null`-ի հետ, բացի խիստ հավասարությունից, հարկավոր է հատուկ ուշադրություն։
+- Մի օգտագործեք `>= > < <=` համեմատությունները այն արժեքների հետ, որոնք կարող են լինել `null/undefined`, եթե իսկապես վստահ չեք, թե ինչ եք անում։ Եթե փոփոխականը կարող է ունենալ այս արժեքները, ստուգեք դրանք առանձին:
 
-## Summary
+## Ամփոփում
 
-- Comparison operators return a boolean value.
-- Strings are compared letter-by-letter in the "dictionary" order.
-- When values of different types are compared, they get converted to numbers (with the exclusion of a strict equality check).
-- The values `null` and `undefined` equal `==` each other and do not equal any other value.
-- Be careful when using comparisons like `>` or `<` with variables that can occasionally be `null/undefined`. Checking for `null/undefined` separately is a good idea.
+- Համեմատման գործողությունները վերադարձնում են տրամաբանական արժեք:
+- Տողերը համեմատվում են տառ առ տառ, բառարանային հերթականությամբ:
+- Երբ տարբեր տիպեր ունեցող արժեքները համեմատվում են, դրանք ձևափոխվում են թվերի (բացառությամբ խիստ հավասարության համեմատության):
+- `null` և `undefined` արժեքները հավասար են (`==`) մեկը մյուսին և հավասար չեն որևէ այլ արժեքի:
+- Զգուշացեք օգտագործել այնպիսի համեմատություններ ինչպիսիք են `>`, կամ `<` այն փոփոխականների հետ, որոնք կարող են լինել `null/undefined`։ Լավ գաղափար է `null/undefined`-ը ստուգել առանձին։
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
index 51f1d4680..406ff73c0 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/solution.md
@@ -1,12 +1,12 @@
-**Yes, it will.**
+**Այո, կցուցադրվի:**
 
-Any string except an empty one (and `"0"` is not empty) becomes `true` in the logical context.
+Ցանկացած տող, բացի դատարկից (իսկ `"0"`-ն դատարկ չէ) տրամաբանական համատեքստում դառնում է `true`:
 
-We can run and check:
+Մենք կարող ենք գործարկել և ստուգել.
 
 ```js run
 if ("0") {
-  alert( 'Hello' );
+  alert( 'Ողջույն' );
 }
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
index 5f16cda85..88820ffa5 100644
--- a/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
+++ b/1-js/02-first-steps/10-ifelse/1-if-zero-string/task.md
@@ -1,14 +1,14 @@
-importance: 5
+կարևորությունը՝ 5
 
 ---
 
-# if (a string with zero)
+# if (զրոյով տող)
 
-Will `alert` be shown?
+Կցուցադրվի՞ արդյոք `alert`-ը:
 
 ```js
 if ("0") {
-  alert( 'Hello' );
+  alert( 'Ողջույն' );
 }
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
index 47b020aab..422be45cc 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="500" height="264" viewBox="0 0 500 264"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="ifelse_task2.svg"><path id="Path-1218-Copy" fill="#C06334" fill-rule="nonzero" d="M425.5 133.5v54h8l-9.5 19-9.5-19h8v-51h-82v-3h85z"/><g id="Rectangle-1-+-Корень" transform="translate(213 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="14"/><text id="Begin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21" y="19">Begin</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-2" transform="translate(8 206)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="You-don't-know?-“ECM" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="12.937" y="20">You don&apos;t know?</tspan> <tspan x="22.107" y="39">“ECMAScript”!</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-3" transform="translate(354 206)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Right!" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="47.93" y="28">Right!</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M255 34v23.049l8 .001-9.5 19-9.5-19 8-.001V34h3z"/><path id="Path-1218" fill="#C06334" fill-rule="nonzero" d="M139.5 133.5v3h-59v51h8l-9.5 19-9.5-19h8v-54h62z"/><path id="Rectangle-356" fill="#FFF" d="M47 152h60v20H47z"/><g id="Rectangle-354-+-Каково-“официальное”" transform="translate(137 76)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M116.5 1.123L230.801 59.5 116.5 117.877 2.199 59.5 116.5 1.123z"/><text id="What's-the-“official" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="80.958" y="43">What&apos;s the</tspan> <tspan x="60.214" y="62">“official” name of</tspan> <tspan x="80.77" y="81">JavaScript?</tspan></text></g><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="57" y="166">Other</tspan></text><path id="Rectangle-356-Copy" fill="#FFF" d="M387 152h60v20h-60z"/><text id="ECMAScript" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="383" y="165">ECMAScript</tspan></text></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" width="500" height="264" viewBox="0 0 500 264"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="ifelse_task2.svg"><path id="Path-1218-Copy" fill="#C06334" fill-rule="nonzero" d="M425.5 133.5v54h8l-9.5 19-9.5-19h8v-51h-82v-3h85z"/><g id="Rectangle-1-+-Корень" transform="translate(213 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="14"/><text id="Begin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21" y="19">Begin</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-2" transform="translate(8 206)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="You-don't-know?-“ECM" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="12.937" y="20">You don&apos;t know?</tspan> <tspan x="22.107" y="39">“ECMAScript”!</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-3" transform="translate(354 206)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Right!" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="47.93" y="28">Right!</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M255 34v23.049l8 .001-9.5 19-9.5-19 8-.001V34h3z"/><path id="Path-1218" fill="#C06334" fill-rule="nonzero" d="M139.5 133.5v3h-59v51h8l-9.5 19-9.5-19h8v-54h62z"/><path id="Rectangle-356" fill="#FFF" d="M47 152h60v20H47z"/><g id="Rectangle-354-+-Каково-“официальное”" transform="translate(137 76)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M116.5 1.123L230.801 59.5 116.5 117.877 2.199 59.5 116.5 1.123z"/><text id="What's-the-“official" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="80.958" y="43">What&apos;s the</tspan> <tspan x="60.214" y="62">“official” name of</tspan> <tspan x="80.77" y="81">JavaScript?</tspan></text></g><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="57" y="166">Other</tspan></text><path id="Rectangle-356-Copy" fill="#FFF" d="M387 152h60v20h-60z"/><text id="ECMAScript" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="383" y="165">ECMAScript</tspan></text></g></g></svg>
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
index ea9966653..e9cda3bf3 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/ifelse_task2/index.html
@@ -5,12 +5,12 @@
   <script>
     'use strict';
 
-    let value = prompt('What is the "official" name of JavaScript?', '');
+    let value = prompt('Ո՞րն է JavaScript-ի «պաշտոնական» անվանումը:', '');
 
     if (value == 'ECMAScript') {
-      alert('Right!');
+      alert('Ճիշտ է:');
     } else {
-      alert("You don't know? ECMAScript!");
+      alert("Դուք չգիտե՞ք. ECMAScript:");
     }
   </script>
 
diff --git a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
index 4305584fa..ce72e7cce 100644
--- a/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
+++ b/1-js/02-first-steps/10-ifelse/2-check-standard/task.md
@@ -1,12 +1,12 @@
-importance: 2
+կարևորությունը՝ 2
 
 ---
 
-# The name of JavaScript
+# JavaScript-ի անվանումը
 
-Using the `if..else` construct, write the code which asks: 'What is the "official" name of JavaScript?'
+Օգտագործելով `if..else` կառուցվածքը, գրեք կոդ, որը կհարցնի. «Ո՞րն է JavaScript-ի «պաշտոնական» անվանումը:»։
 
-If the visitor enters "ECMAScript", then output "Right!", otherwise -- output: "You don't know? ECMAScript!"
+Եթե այցելուն մուտքագրում է «ECMAScript», ապա արտատպեք «Ճիշտ է:», հակառակ դեպքում՝ արտատպեք «Դուք չգիտե՞ք. ECMAScript:»:
 
 ![](ifelse_task2.svg)
 
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
index f168360dd..3a7684e0b 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
+++ b/1-js/02-first-steps/10-ifelse/3-sign/if_sign/index.html
@@ -6,7 +6,7 @@
   <script>
     'use strict';
 
-    let value = prompt('Type a number', 0);
+    let value = prompt('Մուտքագրեք թիվ', 0);
 
     if (value > 0) {
       alert(1);
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/solution.md b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
index 262a605c2..ae1051d45 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/solution.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/solution.md
@@ -1,7 +1,7 @@
 
 
 ```js run
-let value = prompt('Type a number', 0);
+let value = prompt('Մուտքագրեք թիվ', 0);
 
 if (value > 0) {
   alert( 1 );
diff --git a/1-js/02-first-steps/10-ifelse/3-sign/task.md b/1-js/02-first-steps/10-ifelse/3-sign/task.md
index 0c5d0e008..26aad41a3 100644
--- a/1-js/02-first-steps/10-ifelse/3-sign/task.md
+++ b/1-js/02-first-steps/10-ifelse/3-sign/task.md
@@ -1,15 +1,15 @@
-importance: 2
+կարևորությունը՝ 2
 
 ---
 
-# Show the sign
+# Ցույց տալ նշանը
 
-Using `if..else`, write the code which gets a number via `prompt` and then shows in `alert`:
+Օգտագործելով `if..else`՝ գրեք այնպիսի կոդ, որը `prompt`-ի միջոցով ստանում է թիվ և այնուհետև `alert`-ով ցուցադրում է.
 
-- `1`, if the value is greater than zero,
-- `-1`, if less than zero,
-- `0`, if equals zero.
+- `1`, եթե արժեքը մեծ է զրոյից,
+- `-1`, եթե փոքր է զրոյից,
+- `0`, եթե հավասար է զրոյի։
 
-In this task we assume that the input is always a number.
+Այս առաջադրանքում մենք ենթադրում ենք, որ մուտքագրվածը միշտ թիվ է:
 
 [demo src="if_sign"]
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
index ff32354fa..acbcdb4f3 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/solution.md
@@ -1,6 +1,6 @@
 
 
 ```js
-let result = (a + b < 4) ? 'Below' : 'Over';
+let result = (a + b < 4) ? 'Ցածր' : 'Բարձր';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
index 6bdf8453e..a76a904d1 100644
--- a/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/5-rewrite-if-question/task.md
@@ -1,17 +1,17 @@
-importance: 5
+կարևորությունը՝ 5
 
 ---
 
-# Rewrite 'if' into '?'
+# «if»-ը փոխարինեք «?»-ով
 
-Rewrite this `if` using the conditional operator `'?'`:
+Վերագրեք այս `if`-ը՝ օգտագործելով `'?'` պայմանական օպերատորը.
 
 ```js
 let result;
 
 if (a + b < 4) {
-  result = 'Below';
+  result = 'Ցածր';
 } else {
-  result = 'Over';
+  result = 'Բարձր';
 }
 ```
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
index 6d68e29d7..2be229e6f 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/solution.md
@@ -1,9 +1,9 @@
 
 
 ```js
-let message = (login == 'Employee') ? 'Hello' :
-  (login == 'Director') ? 'Greetings' :
-  (login == '') ? 'No login' :
+let message = (login == 'Աշխատակից') ? 'Ողջույն' :
+  (login == 'Տնօրեն') ? 'Ողջույններ' :
+  (login == '') ? 'Մուտք չկա' :
   '';
 ```
 
diff --git a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
index 4f7d994a2..1eb3aae9a 100644
--- a/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
+++ b/1-js/02-first-steps/10-ifelse/6-rewrite-if-else-question/task.md
@@ -1,22 +1,22 @@
-importance: 5
+կարևորությունը՝ 5
 
 ---
 
-# Rewrite 'if..else' into '?'
+# «if..else»-ը փոխարինեք «?»-ով:
 
-Rewrite `if..else` using multiple ternary operators `'?'`.
+Վերաշարադրեք `if..else`-ը՝ օգտագործելով մի քանի «եռակի» օպերատորներ `?`:
 
-For readability, it's recommended to split the code into multiple lines.
+Ընթեռնելիության համար խորհուրդ է տրվում կոդը բաժանել մի քանի տողերի:
 
 ```js
 let message;
 
-if (login == 'Employee') {
-  message = 'Hello';
-} else if (login == 'Director') {
-  message = 'Greetings';
+if (login == 'Աշխատակից') {
+  message = 'Ողջույն';
+} else if (login == 'Տնօրեն') {
+  message = 'Ողջույններ';
 } else if (login == '') {
-  message = 'No login';
+  message = 'Մուտք չկա';
 } else {
   message = '';
 }
diff --git a/1-js/02-first-steps/10-ifelse/article.md b/1-js/02-first-steps/10-ifelse/article.md
index 82e8800b9..f3d0165f1 100644
--- a/1-js/02-first-steps/10-ifelse/article.md
+++ b/1-js/02-first-steps/10-ifelse/article.md
@@ -1,117 +1,117 @@
-# Conditional branching: if, '?'
+# Պայմանական ճյուղավորում. if, ?
 
-Sometimes, we need to perform different actions based on different conditions.
+Երբեմն, մենք կարիք ենք ունենում կատարել տարբեր գործողություններ՝ կախված տարբեր պայմաններից։
 
-To do that, we can use the `if` statement and the conditional operator `?`, that's also called a "question mark" operator.
+Դա անելու համար մենք կարող ենք օգտագործել `if` դրույթը և `?` պայմանական օպերատորը: Վերջինս նաև կոչվում է «հարցական նշան»-ի օպերատոր։
 
-## The "if" statement
+## «if» դրույթը
 
-The `if(...)` statement evaluates a condition in parentheses and, if the result is `true`, executes a block of code.
+`if(...)` դրույթը արժևորում է փակագծերում նշված պայմանը և, եթե արդյունքը `true` է, ապա կատարում է կոդի բլոկը:
 
-For example:
+Օրինակ.
 
 ```js run
-let year = prompt('In which year was ECMAScript-2015 specification published?', '');
+let year = prompt('Ո՞ր թվականին է թողարկվել ECMAScript-2015 ստանդարտը:', '');
 
 *!*
-if (year == 2015) alert( 'You are right!' );
+if (year == 2015) alert( 'Դուք ճիշտ եք:' );
 */!*
 ```
 
-In the example above, the condition is a simple equality check (`year == 2015`), but it can be much more complex.
+Վերոնշյալ օրինակում պայմանը ստուգում է պարզ հավասարություն (`year == 2015`), բայց այն կարող է շատ ավելի բարդ լինել:
 
-If we want to execute more than one statement, we have to wrap our code block inside curly braces:
+Եթե մենք ցանկանում ենք կատարել մեկից ավել դրույթներ, ապա մեր կոդի հատվածը պետք է վերցնենք ձևավոր փակագծերի մեջ:
 
 ```js
 if (year == 2015) {
-  alert( "That's correct!" );
-  alert( "You're so smart!" );
+  alert( "Ճիշտ է:" );
+  alert( "Դուք այնքան խելացի եք․․․" );
 }
 ```
 
-We recommend wrapping your code block with curly braces `{}` every time you use an `if` statement, even if there is only one statement to execute. Doing so improves readability.
+Մենք խորհուրդ ենք տալիս պատել կոդի հատվածը `{}` ձևավոր փակագծերով ամեն անգամ, երբ օգտագործում եք `if` դրույթը, նույնիսկ եթե կատարման համար առկա է միայն մեկ դրույթ։ Այդպես բարելավվում է ընթեռնելիությունը:
 
-## Boolean conversion
+## Բուլյան փոխակերպում
 
-The `if (…)` statement evaluates the expression in its parentheses and converts the result to a boolean.
+`if (…)` դրույթը գնահատում է իր փակագծերում առկա արտահայտությունը և արդյունքը դարձնում բուլյան:
 
-Let's recall the conversion rules from the chapter <info:type-conversions>:
+Եկեք հիշենք փոխակերպման կանոնները <info:type-conversions> գլխից.
 
-- A number `0`, an empty string `""`, `null`, `undefined`, and `NaN` all become `false`. Because of that they are called "falsy" values.
-- Other values become `true`, so they are called "truthy".
+- `0` թիվը, դատարկ տողը `""`, `null`, `undefined` և `NaN`՝ սրանք բոլորը դառնում են `false`: Այդ պատճառով կոչվում են «կեղծ» արժեքներ։
+- Մյուս արժեքները դառնում են `true`, ուստի դրանք կոչվում են «ճշմարիտ»:
 
-So, the code under this condition would never execute:
+Այսպիսով, այս պայմանի ներսում կոդը երբեք չի գործարկվի.
 
 ```js
-if (0) { // 0 is falsy
+if (0) { // 0-ն կեղծ է
   ...
 }
 ```
 
-...and inside this condition -- it always will:
+...և այս պայմանի ներսում միշտ կգործարկվի.
 
 ```js
-if (1) { // 1 is truthy
+if (1) { // 1-ը ճշմարիտ է
   ...
 }
 ```
 
-We can also pass a pre-evaluated boolean value to `if`, like this:
+Մենք կարող ենք նաև նախապես գնահատված բուլյան արժեք փոխանցել `if`-ին, այսպես.
 
 ```js
-let cond = (year == 2015); // equality evaluates to true or false
+let cond = (year == 2015); // հավասարությունը գնահատվում է ճշմարիտ կամ կեղծ
 
 if (cond) {
   ...
 }
 ```
 
-## The "else" clause
+## «else» դրույթը
 
-The `if` statement may contain an optional `else` block. It executes when the condition is falsy.
+`if` դրույթը կարող է պարունակել կամընտրական, ոչ պարտադիր «else» բլոկ: Այն գործարկվում է, երբ պայմանը կեղծ է:
 
-For example:
+Օրինակ.
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('Ո՞ր թվականին է հրապարակվել ECMAScript-2015 դասակարգումը:', '');
 
 if (year == 2015) {
-  alert( 'You guessed it right!' );
+  alert( 'Դուք ճիշտ գուշակեցիք:' );
 } else {
-  alert( 'How can you be so wrong?' ); // any value except 2015
+  alert( 'Ինչպե՞ս կարող եք այդքան սխալվել:' ); // ցանկացած արժեք, բացի 2015-ից
 }
 ```
 
-## Several conditions: "else if"
+## Մի քանի պայմաններ. «else if»
 
-Sometimes, we'd like to test several variants of a condition. The `else if` clause lets us do that.
+Երբեմն մենք ցանկանում ենք փորձարկել պայմանի մի քանի տարբերակներ: `else if` դրույթը մեզ թույլ է տալիս անել դա:
 
-For example:
+Օրինակ.
 
 ```js run
-let year = prompt('In which year was the ECMAScript-2015 specification published?', '');
+let year = prompt('Ո՞ր թվականին է հրապարակվել ECMAScript-2015 դասակարգումը:', '');
 
 if (year < 2015) {
-  alert( 'Too early...' );
+  alert( 'Շատ վաղ է...' );
 } else if (year > 2015) {
-  alert( 'Too late' );
+  alert( 'Շատ ուշ է' );
 } else {
-  alert( 'Exactly!' );
+  alert( 'Ճիշտ այդպես:' );
 }
 ```
 
-In the code above, JavaScript first checks `year < 2015`. If that is falsy, it goes to the next condition `year > 2015`. If that is also falsy, it shows the last `alert`.
+Վերևի կոդում JavaScript-ը նախ ստուգում է `year < 2015`-ը: Եթե դա կեղծ է, անցում է կատարում հաջորդ պայմանին՝ `year > 2015`: Եթե դա նույնպես կեղծ է, ցույց է տալիս վերջին `alert`-ը:
 
-There can be more `else if` blocks. The final `else` is optional.
+Կարող են լինել ավելի շատ `else if` բլոկներ: Վերջին `else`-ը կամընտիր է:
 
-## Conditional operator '?'
+## Պայմանական օպերատոր «?»
 
-Sometimes, we need to assign a variable depending on a condition.
+Երբեմն մեզ պետք է լինում փոփոխական նշանակել՝ կախված պայմանից:
 
-For instance:
+Օրինակ.
 
 ```js run no-beautify
 let accessAllowed;
-let age = prompt('How old are you?', '');
+let age = prompt('Քանի՞ տարեկան եք:', '');
 
 *!*
 if (age > 18) {
@@ -124,116 +124,116 @@ if (age > 18) {
 alert(accessAllowed);
 ```
 
-The so-called "conditional" or "question mark" operator lets us do that in a shorter and simpler way.
+Այսպես կոչված «պայմանական» կամ «հարցական նշանի» օպերատորը թույլ է տալիս դա անել ավելի կարճ և ավելի պարզ ձևով:
 
-The operator is represented by a question mark `?`. Sometimes it's called "ternary", because the operator has three operands. It is actually the one and only operator in JavaScript which has that many.
+Օպերատորը ներկայացված է `?` հարցական նշանով: Երբեմն այն կոչվում է «եռակի», քանի որ օպերատորն ունի երեք օպերանդ։ Այն իրականում միակ օպերատորն է JavaScript-ում, որն այդքան օպերանդ ունի:
 
-The syntax is:
+Շարահյուսությունը հետևյալն է.
 ```js
 let result = condition ? value1 : value2;
 ```
 
-The `condition` is evaluated: if it's truthy then `value1` is returned, otherwise -- `value2`.
+Գնահատվում է `condition`-ը. եթե այն ճշմարիտ է, ապա `value1`-ն է վերադարձվում, հակառակ դեպքում՝ `value2`-ը:
 
-For example:
+Օրինակ.
 
 ```js
 let accessAllowed = (age > 18) ? true : false;
 ```
 
-Technically, we can omit the parentheses around `age > 18`. The question mark operator has a low precedence, so it executes after the comparison `>`.
+Տեխնիկապես մենք կարող ենք բաց թողնել փակագծերը `age > 18`-ի շուրջ: Հարցական նշանի օպերատորն ունի ցածր գերակայություն, ուստի այն գործարկվում է `>` համեմատությունից հետո:
 
-This example will do the same thing as the previous one:
+Այս օրինակը կանի նույն բանը, ինչ նախորդը.
 
 ```js
-// the comparison operator "age > 18" executes first anyway
-// (no need to wrap it into parentheses)
+// համեմատության «age > 18» օպերատորը ամեն դեպքում առաջինն է կատարվում
+// (կարիք չկա փակագծերի մեջ վերցնել այն)
 let accessAllowed = age > 18 ? true : false;
 ```
 
-But parentheses make the code more readable, so we recommend using them.
+Բայց փակագծերը կոդն ավելի ընթեռնելի են դարձնում, ուստի խորհուրդ ենք տալիս օգտագործել դրանք:
 
 ````smart
-In the example above, you can avoid using the question mark operator because the comparison itself returns `true/false`:
+Վերևի օրինակում դուք կարող եք խուսափել հարցական նշանի օպերատորի օգտագործումից, քանի որ համեմատությունն ինքնին վերադարձնում է `true/false`.
 
 ```js
-// the same
+// նույնը
 let accessAllowed = age > 18;
 ```
 ````
 
-## Multiple '?'
+## Բազմաթիվ «?»
 
-A sequence of question mark operators `?` can return a value that depends on more than one condition.
+Հարցական նշանի օպերատորների `?` հաջորդականությունը կարող է վերադարձնել արժեք, որը կախված է մեկից ավելի պայմաններից:
 
-For instance:
+Օրինակ.
 ```js run
-let age = prompt('age?', 18);
+let age = prompt('տարի՞քը', 18);
 
-let message = (age < 3) ? 'Hi, baby!' :
-  (age < 18) ? 'Hello!' :
-  (age < 100) ? 'Greetings!' :
-  'What an unusual age!';
+let message = (age < 3) ? 'Ողջույն փոքրիկ' :
+  (age < 18) ? 'Ողջույն' :
+  (age < 100) ? 'Ողջույններ' :
+  'Ի՜նչ անսովոր տարիք է։';
 
 alert( message );
 ```
 
-It may be difficult at first to grasp what's going on. But after a closer look, we can see that it's just an ordinary sequence of tests:
+Սկզբում կարող է դժվար լինել հասկանալը, թե ինչ է կատարվում: Բայց ավելի ուշադիր նայելուց հետո մենք կարող ենք տեսնել, որ դա ընդամենը թեստերի սովորական հաջորդականություն է.
 
-1. The first question mark checks whether `age < 3`.
-2. If true -- it returns `'Hi, baby!'`. Otherwise, it continues to the expression after the colon ":", checking `age < 18`.
-3. If that's true -- it returns `'Hello!'`. Otherwise, it continues to the expression after the next colon ":", checking `age < 100`.
-4. If that's true -- it returns `'Greetings!'`. Otherwise, it continues to the expression after the last colon ":", returning `'What an unusual age!'`.
+1. Առաջին հարցական նշանը ստուգում է, թե արդյո՞ք `age < 3`:
+2. Եթե ճիշտ է, այն վերադարձնում է `'Ողջույն փոքրիկ'`: Հակառակ դեպքում, այն շարունակում է `:` կրկնակետից հետո արտահայտությունը՝ ստուգելով `age < 18`:
+3. Եթե դա ճիշտ է, այն վերադարձնում է `'Ողջույն'`: Հակառակ դեպքում, այն շարունակում է հաջորդ `:` կրկնակետից հետո արտահայտությունը՝ ստուգելով `age < 100`:
+4. Եթե դա ճիշտ է, այն վերադարձնում է `'Ողջույններ!'`: Հակառակ դեպքում, այն շարունակում է վերջին `:` կրկնակետից հետո արտահայտությունը՝ վերադարձնելով `'Ի՜նչ անսովոր տարիք է։'`:
 
-Here's how this looks using `if..else`:
+Ահա, թե ինչպես է սա երևում `if..else`-ի միջոցով.
 
 ```js
 if (age < 3) {
-  message = 'Hi, baby!';
+  message = 'Ողջույն փոքրիկ';
 } else if (age < 18) {
-  message = 'Hello!';
+  message = 'Ողջույն';
 } else if (age < 100) {
-  message = 'Greetings!';
+  message = 'Ողջույններ';
 } else {
-  message = 'What an unusual age!';
+  message = 'Ի՜նչ անսովոր տարիք է։';
 }
 ```
 
-## Non-traditional use of '?'
+## «?»-ի ոչ ավանդական օգտագործումը
 
-Sometimes the question mark `?` is used as a replacement for `if`:
+Երբեմն `?` հարցական նշանն օգտագործվում է որպես `if`-ին փոխարինող.
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Ո՞ր ընկերությունն է ստեղծել JavaScript-ը:', '');
 
 *!*
 (company == 'Netscape') ?
-   alert('Right!') : alert('Wrong.');
+   alert('Ճիշտ է:') : alert('Սխալ է:');
 */!*
 ```
 
-Depending on the condition `company == 'Netscape'`, either the first or the second expression after the `?` gets executed and shows an alert.
+Կախված `company == 'Netscape'` պայմանից, գործարկվում է առաջին կամ երկրորդ արտահայտությունը `?`-ից հետո և ցույց է տալիս alert-ը:
 
-We don't assign a result to a variable here. Instead, we execute different code depending on the condition.
+Մենք այստեղ արդյունքը չենք վերագրում փոփոխականի: Փոխարենը մենք գործարկում ենք տարբեր կոդեր՝ կախված պայմանից։
 
-**It's not recommended to use the question mark operator in this way.**
+**Խորհուրդ չի տրվում այս եղանակով օգտագործել հարցական նշանի օպերատորը։**
 
-The notation is shorter than the equivalent `if` statement, which appeals to some programmers. But it is less readable.
+Նշանագրությունն ավելի կրճատ է, քան համարժեք `if` դրույթի դեպքում, ինչը գրավիչ է որոշ ծրագրավորողների համար: Բայց դա ավելի քիչ ընթեռնելի է։
 
-Here is the same code using `if` for comparison:
+Ահա նույն կոդը, որտեղ համեմատության համար օգտագործված է `if`.
 
 ```js run no-beautify
-let company = prompt('Which company created JavaScript?', '');
+let company = prompt('Ո՞ր ընկերությունն է ստեղծել JavaScript-ը:', '');
 
 *!*
 if (company == 'Netscape') {
-  alert('Right!');
+  alert('Ճիշտ է:');
 } else {
-  alert('Wrong.');
+  alert('Սխալ է:');
 }
 */!*
 ```
 
-Our eyes scan the code vertically. Code blocks which span several lines are easier to understand than a long, horizontal instruction set.
+Մեր աչքերը ուղղահայաց են սքանավորում կոդը: Կոդի բլոկները, որոնք ընդգրկում են մի քանի տող, ավելի հասկանալի են, քան երկար, հորիզոնական հրահանգների հավաքածուն:
 
-The purpose of the question mark operator `?` is to return one value or another depending on its condition. Please use it for exactly that. Use `if` when you need to execute different branches of code.
+Հարցական նշանի օպերատորի `?` նպատակն է վերադարձնել այս կամ այն արժեքը՝ կախված իր պայմանից: Օգտագործեք այն հենց դրա համար: Օգտագործեք `if`, երբ անհրաժեշտ է գործարկել կոդի տարբեր ճյուղեր:
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
index 8869d32e6..99bc1d5e2 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/solution.md
@@ -1,6 +1,5 @@
-The answer is `2`, that's the first truthy value.
+Պատասխանը `2` է, քանի որ այն առաջին ճշմարիտ արժեքն է։
 
 ```js run
 alert( null || 2 || undefined );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
index a7c9addfc..27e56f58b 100644
--- a/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
+++ b/1-js/02-first-steps/11-logical-operators/1-alert-null-2-undefined/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# What's the result of OR?
+# Ի՞նչ է հետևյալ ԿԱՄ-ով արտահայտության արդյունքը
 
-What is the code below going to output?
+Ի՞նչ կտպի ներքևում գրված ծրագիրը։
 
 ```js
 alert( null || 2 || undefined );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
index f85b56366..a06dd4d88 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/solution.md
@@ -1,13 +1,13 @@
-The answer: first `1`, then `2`.
+Այն կտպի `1`, այնուհետև `2`։
 
 ```js run
 alert( alert(1) || 2 || alert(3) );
 ```
 
-The call to `alert` does not return a value. Or, in other words, it returns `undefined`.
+`alert`֊ի կանչը չի վերադարձնում ոչ մի արժեք։ Կամ այլ կերպ ասած վերադարձնում է `undefined`։
 
-1. The first OR `||` evaluates its left operand `alert(1)`. That shows the first message with `1`.
-2. The `alert` returns `undefined`, so OR goes on to the second operand searching for a truthy value.
-3. The second operand `2` is truthy, so the execution is halted, `2` is returned and then shown by the outer alert.
+1. Սկզբում ԿԱՄ `||`֊ը հաշվում (evaluates) է իր ձախ կողմի օպերանդը՝ `alert(1)`, որն էլ էկրանին ցույց է տալիս `1` արժեքը։
+2. `alert`֊ը վերադարձնում է `undefined`։ ԿԱՄ֊ը անցնում է երկրորդ օպերանդին՝ որոնելով ճշմարիտ արժեք։
+3. Երկրորդ օպերանդը `2` է, որը ճշմարիտ է, և ԿԱՄ֊ը դադարեցնում է իր հաշվարկները։ `2`֊ը վերադարձվում է և ցուցադրվում էկրանին դրսի `alert`֊ի միջոցով։
 
-There will be no `3`, because the evaluation does not reach `alert(3)`.
+`3`֊ը չի երևա էկրանին, քանի որ ԿԱՄ֊ը կանգ է առնում երկրորդ օպերանդի վրա և չի հասնում `alert(3)`֊ին։
diff --git a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
index 3908fa2ec..3bcfcea8b 100644
--- a/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/2-alert-or/task.md
@@ -2,11 +2,10 @@ importance: 3
 
 ---
 
-# What's the result of OR'ed alerts?
+# Ի՞նչ է հետևյալ ԿԱՄ-ով արտահայտության արդյունքը
 
-What will the code below output?
+Ի՞նչ կտպի ներքևում գրված ծրագիրը։
 
 ```js
 alert( alert(1) || 2 || alert(3) );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
index 368b59409..1fbca8c1a 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/solution.md
@@ -1,4 +1,4 @@
-The answer: `null`, because it's the first falsy value from the list.
+Պատասխանը `null` է, քանի որ այն առաջին սխալական արժեքն է։
 
 ```js run
 alert(1 && null && 2);
diff --git a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
index 043d431e4..e46adfb69 100644
--- a/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
+++ b/1-js/02-first-steps/11-logical-operators/3-alert-1-null-2/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# What is the result of AND?
+# Ի՞նչ է հետևյալ ԵՎ-ով արտահայտության արդյունքը:
 
-What is this code going to show?
+Ի՞նչ կտպի ներքևում գրված ծրագիրը։
 
 ```js
 alert( 1 && null && 2 );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
index b6fb10d72..ac1846ec0 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/solution.md
@@ -1,10 +1,10 @@
-The answer: `1`, and then `undefined`.
+Այն կտպի `1`, այնուհետև `undefined`։
 
 ```js run
 alert( alert(1) && alert(2) );
 ```
 
-The call to `alert` returns `undefined` (it just shows a message, so there's no meaningful return).
+`alert`֊ի կանչը տպում է էկրանին և վերադարձնում `undefined`։
 
-Because of that, `&&` evaluates the left operand (outputs `1`), and immediately stops, because `undefined` is a falsy value. And `&&` looks for a falsy value and returns it, so it's done.
+Այդ պատճառով, երբ `&&`֊ը ավարտում է ձախ օպերանդի հաշվարկը (էկրանին ցուցադրում է `1`), անմիջապես կանգ է առնում, քանի որ `undefined`֊ը սխալական արժեք է։ `&&`֊ը փնտրում է առաջին սխալական արժեքը և վերադարձնում այն։
 
diff --git a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
index 69f877b95..7b758dbe5 100644
--- a/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
+++ b/1-js/02-first-steps/11-logical-operators/4-alert-and/task.md
@@ -2,11 +2,10 @@ importance: 3
 
 ---
 
-# What is the result of AND'ed alerts?
+# Ի՞նչ է հետևյալ ԵՎ-ով արտահայտության արդյունքը
 
-What will this code show?
+Ի՞նչ կտպի ներքևում գրված ծրագիրը։
 
 ```js
 alert( alert(1) && alert(2) );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
index 25e3568f8..b5f064b66 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/solution.md
@@ -1,16 +1,16 @@
-The answer: `3`.
+Պատասխանը `3` է։
 
 ```js run
 alert( null || 2 && 3 || 4 );
 ```
 
-The precedence of AND `&&` is higher than `||`, so it executes first.
+ԵՎ `&&`֊ի նախապատվությունը ավելի բարձր է քան `||`֊ինը, հետևաբար այն ավելի շուտ կկատարվի։
 
-The result of `2 && 3 = 3`, so the expression becomes:
+Քանի որ `2 && 3 = 3`, ապա կստանանք հետևյալ արտահայտությունը․
 
 ```
 null || 3 || 4
 ```
 
-Now the result is the first truthy value: `3`.
+Եվ կստանանք պատասխանը առաջին ճշմարիտ արժեքը՝ `3`։
 
diff --git a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
index b18bb9c51..3ce663f1f 100644
--- a/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
+++ b/1-js/02-first-steps/11-logical-operators/5-alert-and-or/task.md
@@ -2,11 +2,10 @@ importance: 5
 
 ---
 
-# The result of OR AND OR
+# Ի՞նչ է հետևյալ ԵՎ-ով և ԿԱՄ֊ով արտահայտության արդյունքը
 
-What will the result be?
+Ի՞նչ կտպի ներքևում գրված ծրագիրը։
 
 ```js
 alert( null || 2 && 3 || 4 );
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
index fc9e336c1..2ca505d31 100644
--- a/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/6-check-if-in-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range between
+# Միջակայքի ստուգում
 
-Write an `if` condition to check that `age` is between `14` and `90` inclusively.
+Գրեք `if` պայման, որը կստուգի արդյոք `age` փոփոխականը ընկած է `14` և `90` թվերի միջակայքում, այդ թվերը ներառյալ։
 
-"Inclusively" means that `age` can reach the edges `14` or `90`.
+"Ներառյալ" նշանակում է, որ `age`֊ը կարող է ընդունել `14` կամ `90` արժեքները նույնպես։
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
index d1946a967..11e9b2a9d 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/solution.md
@@ -1,10 +1,10 @@
-The first variant:
+Առաջին եղանակը․
 
 ```js
 if (!(age >= 14 && age <= 90))
 ```
 
-The second variant:
+Երկրորդ եղանակը․
 
 ```js
 if (age < 14 || age > 90)
diff --git a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
index 9b947d00f..86aca175f 100644
--- a/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
+++ b/1-js/02-first-steps/11-logical-operators/7-check-if-out-range/task.md
@@ -2,8 +2,8 @@ importance: 3
 
 ---
 
-# Check the range outside
+# Միջակայքից դուրս ստուգում
 
-Write an `if` condition to check that `age` is NOT between `14` and `90` inclusively.
+Գրեք `if` պայման, որը կստուգի արդյոք `age` փոփոխականը ընկած ՉԷ `14` և `90` թվերի միջակայքում, այդ թվերը ներառյալ։
 
-Create two variants: the first one using NOT `!`, the second one -- without it.
+Խնդրիը լուծեք երկու եղանակով․ առաջինը օգտագործելով ՈՉ `!` օպերատորը, երկրորդը առանց ՈՉ֊ի։
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
index 210509758..e57f03e99 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/solution.md
@@ -1,20 +1,20 @@
-The answer: the first and the third will execute.
+Պատասխան՝ առաջին և երրորդ `alert`֊ները կկանչվեն։
 
-Details:
+Մանրամասներ․
 
 ```js run
-// Runs.
-// The result of -1 || 0 = -1, truthy
-if (-1 || 0) alert( 'first' );
+// Կանչվում է,
+// քանի որ -1 || 0 = -1 ճշմարիտ է
+if (-1 || 0) alert('առաջին')
 
-// Doesn't run
-// -1 && 0 = 0, falsy
-if (-1 && 0) alert( 'second' );
+// Չի կանչվում,
+// քանի որ -1 && 0 = 0 սխալական է
+if (-1 && 0) alert('երկրորդ')
 
-// Executes
-// Operator && has a higher precedence than ||
-// so -1 && 1 executes first, giving us the chain:
+// Կնչվում է, քանի որ
+// && օպերատորի նախապատվությունը ավելի բարձր է, քան ||֊ինը,
+// այսպիսով -1 && 1 հաշվվում է առաջինը։ Ստանում ենք հետևյալ շղթան․
 // null || -1 && 1  ->  null || 1  ->  1
-if (null || -1 && 1) alert( 'third' );
+if (null || -1 && 1) alert('երրորդ')
 ```
 
diff --git a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
index 55987121b..24dc9d396 100644
--- a/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
+++ b/1-js/02-first-steps/11-logical-operators/8-if-question/task.md
@@ -2,15 +2,14 @@ importance: 5
 
 ---
 
-# A question about "if"
+# Հարց "if"֊ի մասին
 
-Which of these `alert`s are going to execute?
+Այս `alert`֊ներից որո՞նք կաշխատեն։
 
-What will the results of the expressions be inside `if(...)`?
+Ի՞նչ կլինի `if(...)`֊երի ներսում գրված արտահայտությունների արժեքները։
 
 ```js
-if (-1 || 0) alert( 'first' );
-if (-1 && 0) alert( 'second' );
-if (null || -1 && 1) alert( 'third' );
+if (-1 || 0) alert('առաջին')
+if (-1 && 0) alert('երկրորդ')
+if (null || -1 && 1) alert('երրորդ')
 ```
-
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.svg b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.svg
index d22b518a9..5ae954374 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.svg
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.svg
@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="599" height="493" viewBox="0 0 599 493"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="ifelse_task.svg"><path id="Path-1218-Copy" fill="#C06334" fill-rule="nonzero" d="M529.5 326.5v93h8l-9.5 19-9.5-19h8v-90h-82v-3h85zM372.5 131.5v126h8l-9.5 19-9.5-19h8v-123h-82v-3h85z"/><g id="Rectangle-1-+-Корень" transform="translate(180 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="14"/><text id="Begin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21" y="20">Begin</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-2" transform="translate(0 243)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Canceled" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="36.647" y="29">Canceled</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-5" transform="translate(150 438)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Canceled" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="36.647" y="29">Canceled</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-6" transform="translate(458 438)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Welcome!" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="34.953" y="29">Welcome!</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-4" transform="translate(154 243)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="I-don't-know-you" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="12.564" y="28">I don&apos;t know you</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-7" transform="translate(296 438)"><rect id="Rectangle-1" width="147" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Wrong-password" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="17.803" y="29">Wrong password</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M222 35v23.049l8 .001-9.5 19-9.5-19 8-.001V35h3z"/><path id="Path-1218" fill="#C06334" fill-rule="nonzero" d="M131.691 131.367v3l-59.302-.001v85.181h8l-9.5 19-9.5-19h8v-88.18h62.302z"/><path id="Path-1218-Copy-2" fill="#C06334" fill-rule="nonzero" d="M281.691 326.367v3l-59.307-.001-.319 90.139 8 .029-9.567 18.966-9.433-19.033 8 .027.324-91.633.005-1.494h62.297z"/><g id="Rectangle-354-+-Каково-“официальное”" transform="translate(127 81)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M93.61 1.144L185.161 52l-91.55 50.856L2.058 52 93.61 1.144z"/><text id="Who's-there?" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="51.305" y="55">Who&apos;s there?</tspan></text></g><g id="Rectangle-354-+-Каково-“официальное”-Copy" transform="translate(277 276)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M93.61 1.144L185.161 52l-91.55 50.856L2.058 52 93.61 1.144z"/><text id="Password?" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="58.89" y="55">Password?</tspan></text></g><g id="Rectangle-356-+-Отмена" transform="translate(39 191)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="Cancel" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.5" y="15">Cancel</tspan></text></g><g id="Rectangle-356-+-Отмена-Copy" transform="translate(189 384)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="Cancel" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.5" y="15">Cancel</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”" transform="translate(341 191)"><path id="Rectangle-356-Copy" fill="#FFF" d="M0 2h60v20H0z"/><text id="Admin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.703" y="15">Admin</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”-Copy" transform="translate(493 384)"><path id="Rectangle-356-Copy" fill="#FFF" d="M7 2h60v20H7z"/><text id="TheMaster" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x=".096" y="15">TheMaster</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M223 182v42.56h8l-9.5 19-9.5-19h8V182h3z"/><path id="Line-Copy-2" fill="#C06334" fill-rule="nonzero" d="M373 377v42.56h8l-9.5 19-9.5-19h8V377h3z"/><g id="Rectangle-356-Copy-2-+-“Админ”-Copy" transform="translate(191 191)"><path id="Rectangle-356-Copy-2" fill="#FFF" d="M0 2h60v20H0z"/><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="9.996" y="15">Other</tspan></text></g><g id="Rectangle-356-Copy-2-+-“Админ”-Copy-Copy" transform="translate(341 384)"><path id="Rectangle-356-Copy-2" fill="#FFF" d="M0 2h60v20H0z"/><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="9.996" y="15">Other</tspan></text></g></g></g></svg>
\ No newline at end of file
+<svg xmlns="http://www.w3.org/2000/svg" width="599" height="493" viewBox="0 0 599 493"><defs><style>@import url(https://fonts.googleapis.com/css?family=Open+Sans:bold,italic,bolditalic%7CPT+Mono);@font-face{font-family:&apos;PT Mono&apos;;font-weight:700;font-style:normal;src:local(&apos;PT MonoBold&apos;),url(/font/PTMonoBold.woff2) format(&apos;woff2&apos;),url(/font/PTMonoBold.woff) format(&apos;woff&apos;),url(/font/PTMonoBold.ttf) format(&apos;truetype&apos;)}</style></defs><g id="combined" fill="none" fill-rule="evenodd" stroke="none" stroke-width="1"><g id="ifelse_task.svg"><path id="Path-1218-Copy" fill="#C06334" fill-rule="nonzero" d="M529.5 326.5v93h8l-9.5 19-9.5-19h8v-90h-82v-3h85zM372.5 131.5v126h8l-9.5 19-9.5-19h8v-123h-82v-3h85z"/><g id="Rectangle-1-+-Корень" transform="translate(180 4)"><rect id="Rectangle-1" width="78" height="28" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="14"/><text id="Begin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="20" y="20">Սկիզբ</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-2" transform="translate(0 243)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Canceled" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="25.647" y="29">Չեղարկված է</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-5" transform="translate(150 438)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Canceled" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="25.647" y="29">Չեղարկված է</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-6" transform="translate(458 438)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Welcome!" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="21.453000000000003" y="29">Բարի գալուստ</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-4" transform="translate(154 243)"><rect id="Rectangle-1" width="131" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="I-don't-know-you" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="7.064" y="28">Չեմ ճանաչում քեզ</tspan></text></g><g id="Rectangle-1-+-Корень-Copy-7" transform="translate(296 438)"><rect id="Rectangle-1" width="147" height="49" x="1" y="1" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" rx="24.5"/><text id="Wrong-password" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="20.303" y="29">Սխալ գաղտնաբառ</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M222 35v23.049l8 .001-9.5 19-9.5-19 8-.001V35h3z"/><path id="Path-1218" fill="#C06334" fill-rule="nonzero" d="M131.691 131.367v3l-59.302-.001v85.181h8l-9.5 19-9.5-19h8v-88.18h62.302z"/><path id="Path-1218-Copy-2" fill="#C06334" fill-rule="nonzero" d="M281.691 326.367v3l-59.307-.001-.319 90.139 8 .029-9.567 18.966-9.433-19.033 8 .027.324-91.633.005-1.494h62.297z"/><g id="Rectangle-354-+-Каково-“официальное”" transform="translate(127 81)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M93.61 1.144L185.161 52l-91.55 50.856L2.058 52 93.61 1.144z"/><text id="Who's-there?" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="76.305" y="55">Ո՞վ է</tspan></text></g><g id="Rectangle-354-+-Каково-“официальное”-Copy" transform="translate(277 276)"><path id="Rectangle-354" fill="#FBF2EC" stroke="#DBAF88" stroke-width="2" d="M93.61 1.144L185.161 52l-91.55 50.856L2.058 52 93.61 1.144z"/><text id="Password?" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="49.89" y="55">Գաղտնաբա՞ռը</tspan></text></g><g id="Rectangle-356-+-Отмена" transform="translate(39 191)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="Cancel" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="-2" y="15">Չեղարկել</tspan></text></g><g id="Rectangle-356-+-Отмена-Copy" transform="translate(189 384)"><path id="Rectangle-356" fill="#FFF" d="M0 2h60v20H0z"/><text id="Cancel" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="-2" y="15">Չեղարկել</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”" transform="translate(341 191)"><path id="Rectangle-356-Copy" fill="#FFF" d="M0 2h60v20H0z"/><text id="Admin" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="9.703" y="15">Ադմին</tspan></text></g><g id="Rectangle-356-Copy-+-“Админ”-Copy" transform="translate(493 384)"><path id="Rectangle-356-Copy" fill="#FFF" d="M7 2h60v20H7z"/><text id="TheMaster" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="8.096" y="15">Գլխավոր</tspan></text></g><path id="Line" fill="#C06334" fill-rule="nonzero" d="M223 182v42.56h8l-9.5 19-9.5-19h8V182h3z"/><path id="Line-Copy-2" fill="#C06334" fill-rule="nonzero" d="M373 377v42.56h8l-9.5 19-9.5-19h8V377h3z"/><g id="Rectangle-356-Copy-2-+-“Админ”-Copy" transform="translate(191 191)"><path id="Rectangle-356-Copy-2" fill="#FFF" d="M0 2h60v20H0z"/><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="9.496" y="15">Ուրիշ</tspan></text></g><g id="Rectangle-356-Copy-2-+-“Админ”-Copy-Copy" transform="translate(341 384)"><path id="Rectangle-356-Copy-2" fill="#FFF" d="M0 2h60v20H0z"/><text id="Other" fill="#AF6E24" font-family="OpenSans-Regular, Open Sans" font-size="14" font-weight="normal"><tspan x="9.496" y="15">Ուրիշ</tspan></text></g></g></g></svg>
\ No newline at end of file
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
index 604606259..26c628d12 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/solution.md
@@ -1,25 +1,25 @@
 
 
 ```js run demo
-let userName = prompt("Who's there?", '');
+let userName = prompt("Ո՞վ է", '');
 
-if (userName === 'Admin') {
+if (userName === 'Ադմին') {
 
-  let pass = prompt('Password?', '');
+  let pass = prompt('Գաղտնաբառը՞', '');
 
-  if (pass === 'TheMaster') {
-    alert( 'Welcome!' );
+  if (pass === 'Գլխավոր') {
+    alert( 'Բարի գալուստ' );
   } else if (pass === '' || pass === null) {
-    alert( 'Canceled' );
+    alert( 'Չեղարկված է' );
   } else {
-    alert( 'Wrong password' );
+    alert( 'Սխալ գաղտնաբառ' );
   }
 
 } else if (userName === '' || userName === null) {
-  alert( 'Canceled' );
+  alert( 'Չեղարկված է' );
 } else {
-  alert( "I don't know you" );
+  alert( "Չեմ ճանաչում քեզ" );
 }
 ```
 
-Note the vertical indents inside the `if` blocks. They are technically not required, but make the code more readable.
+Ուշադրություն դարձրեք ուղղահայաց խորություններին (indents) `if` բլոկների ներսում։ Դրանք պարտադիր չեն, բայց դարձնում են ծրագիրը ավելի ընթեռնելի։
diff --git a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
index 290a52642..a02b60d84 100644
--- a/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
+++ b/1-js/02-first-steps/11-logical-operators/9-check-login/task.md
@@ -2,24 +2,24 @@ importance: 3
 
 ---
 
-# Check the login
+# Մուտքի ստուգում (login)
 
-Write the code which asks for a login with `prompt`.
+Գրեք ծրագիր, որը կպահանջի մուտք գործել, օգտագործելով `prompt`֊ը։
 
-If the visitor enters `"Admin"`, then `prompt` for a password, if the input is an empty line or `key:Esc` -- show "Canceled", if it's another string -- then show "I don't know you".
+Եթե օգտատերը կմուտքագրի `"Ադմին"`, ապա կբացվի `prompt` գաղտնաբառի համար, եթե ոչինչ չմուտքագրի կամ սեղմի `Esc` ստեղնը  -- կցուցադրվի "Չեղարկված է", եթե մեկ այլ տողային արժեք մուտքագրվի, ապա կցուցադրվի "Չեմ ճանաչում քեզ"։
 
-The password is checked as follows:
+Գաղտնաբառը ստուգվում է հետևյալ կերպ․
 
-- If it equals "TheMaster", then show "Welcome!",
-- Another string -- show "Wrong password",
-- For an empty string or cancelled input, show "Canceled"
+- Եթե այն "Գլխավոր" է, ապա ցուցադրվում է "Բարի գալուստ",
+- Ուրիշ տողային արժեքի դեպքում ցուցադրվում է "Սխալ գաղտնաբառ",
+- Դատարկ տողի և չեղարկված (cancelled) դեպքերում ցուցադրվում է "Չեղարկված է"
 
-The schema:
+Գծապատկերը․
 
 ![](ifelse_task.svg)
 
-Please use nested `if` blocks. Mind the overall readability of the code.
+Օգտագործել ներդրված `if` բլոկներ։ Հիշեք նաև ծրագրի ընթեռնելիության մասին։
 
-Hint:  passing an empty input to a prompt returns an empty string `''`. Pressing `key:ESC` during a prompt returns `null`.
+Հուշում․ prompt֊ին դատարկ տողային արժեք փոխանցելիս այն վերադարձնում է `''`։ `Esc` ստեղնը սեղմելիս prompt֊ի վրա, այն վերադարձնում է `null`։
 
 [demo]
diff --git a/1-js/02-first-steps/11-logical-operators/article.md b/1-js/02-first-steps/11-logical-operators/article.md
index 78c4fd2f1..eb8440510 100644
--- a/1-js/02-first-steps/11-logical-operators/article.md
+++ b/1-js/02-first-steps/11-logical-operators/article.md
@@ -1,24 +1,24 @@
-# Logical operators
+# Տրամաբանական օպերատորներ (Logical operators)
 
-There are four logical operators in JavaScript: `||` (OR), `&&` (AND), `!` (NOT), `??` (Nullish Coalescing). Here we cover the first three, the `??` operator is in the next article.
+JavaScript-ում կան չորս տրամաբանական օպերատորներ՝ `||` (ԿԱՄ), `&&` (ԵՎ), `!` (ՈՉ), `??` (Nullish Coalescing). Այստեղ մենք կծանոթանանք առաջին երեքին։ `??` օպերատորին կարող եք ծանոթանալ հաջորդ հոդվածում։
 
-Although they are called "logical", they can be applied to values of any type, not only boolean. Their result can also be of any type.
+Չնայած նրանք անվանվում են "տրամաբանական", նրանք կարող են կիրառվել կամայական (տարբերվող տրամաբանական տիպից) տիպի վրա։ Նրանց արդյունքը նույպես կարող է լինել կամայական տիպի։
 
-Let's see the details.
+Եկեք դիտարկենք ավելի մանրամասն։
 
-## || (OR)
+## || (ԿԱՄ) (OR)
 
-The "OR" operator is represented with two vertical line symbols:
+"ԿԱՄ" օպերատորը ներկայացվում է երկու ուղղահայաց գիծ նշանների միջոցով։
 
 ```js
 result = a || b;
 ```
 
-In classical programming, the logical OR is meant to manipulate boolean values only. If any of its arguments are `true`, it returns `true`, otherwise it returns `false`.
+Դասական ծրագրավորման մեջ տրամաբանական ԿԱՄ օպերատորը կիրառվում է միայն տրամաբանական արժեքների վրա։ Եթե նրա արգումենտներից մեկը ճշմարիտ `true` է, ապա այն վերադարձնում է `true`, հակառակ դեպքում՝ `false`։
 
-In JavaScript, the operator is a little bit trickier and more powerful. But first, let's see what happens with boolean values.
+JavaScript֊ում այս օպերատորը ավելի ճկուն և հզոր է։ Բայց սկզում եկեք տեսնենք, թե ինչ է կատարվում տրամաբանական տիպերի հետ։
 
-There are four possible logical combinations:
+Կան չորս տրամաբանական կոմբինայիաներ․
 
 ```js run
 alert( true || true );   // true
@@ -27,21 +27,21 @@ alert( true || false );  // true
 alert( false || false ); // false
 ```
 
-As we can see, the result is always `true` except for the case when both operands are `false`.
+Ինչպես տեսնում ենք արդյունքը միշտ ճիշտ (`true`) է, բացի այն դեպքից, երբ երկու օպերանդներն էլ սխալ (`false`) են։
 
-If an operand is not a boolean, it's converted to a boolean for the evaluation.
+Եթե օպերանդը տրամաբանական տիպ չի, ապա այն փոխակերպվում (convert) է տրամաբանական տիպի։
 
-For instance, the number `1` is treated as `true`, the number `0` as `false`:
+Օրինակ `1`֊ը մշակվում է որպես `true`, `0`֊ն՝ `false`․
 
 ```js run
-if (1 || 0) { // works just like if( true || false )
-  alert( 'truthy!' );
+if (1 || 0) { // աշխատում է ինչպես if( true || false )
+  alert('Ճշմարիտ է!')
 }
 ```
 
-Most of the time, OR `||` is used in an `if` statement to test if *any* of the given conditions is `true`.
+Շատ հաճախ ԿԱՄ `||` օպերատորը օգտագործվում է `if` պայմանի օպերատորի հետ՝ ստուգելու համար արդյոք ճիշտ (`true`) է տրված պայմաններից _գոնե մեկը_։
 
-For example:
+Օրինակ․
 
 ```js run
 let hour = 9;
@@ -49,61 +49,61 @@ let hour = 9;
 *!*
 if (hour < 10 || hour > 18) {
 */!*
-  alert( 'The office is closed.' );
+  alert('Գրասենյակը փակ է։');
 }
 ```
 
-We can pass more conditions:
+Մենք կարող ենք ստուգել ավելի շատ պայմաններ․
 
 ```js run
-let hour = 12;
-let isWeekend = true;
+let hour = 12
+let isWeekend = true
 
 if (hour < 10 || hour > 18 || isWeekend) {
-  alert( 'The office is closed.' ); // it is the weekend
+  alert('Գրասենյակը փակ է։') // քանի որ շաբաթ կամ կիրակի է (weekend)
 }
 ```
 
-## OR "||" finds the first truthy value [#or-finds-the-first-truthy-value]
+## ԿԱՄ "||"֊ը գտնում է առաջին ճշմարիտ արժեքը [#or-finds-the-first-truthy-value]
 
-The logic described above is somewhat classical. Now, let's bring in the "extra" features of JavaScript.
+Վերոնշյալ տրամաբանությունը ստանդարտ է ԿԱՄ֊ի համար։ Հիմա եկեք դիտարկենք JavaScript֊ի "հավելյալ" հատկությունները։
 
-The extended algorithm works as follows.
+Ընդլայնված ալգորիթմը աշխատում է հետևյալ կերպ։
 
-Given multiple OR'ed values:
+Տրված են մի քանի ԿԱՄ֊ով կապված արժեքներ․
 
 ```js
-result = value1 || value2 || value3;
+result = value1 || value2 || value3
 ```
 
-The OR `||` operator does the following:
+ԿԱՄ `||` օպերատորը կատարում է հետևյալ քայլերը․
 
-- Evaluates operands from left to right.
-- For each operand, converts it to boolean. If the result is `true`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were `false`), returns the last operand.
+- Հաշվում է օպերանդների արժեքները ձախից աջ։
+- Ամեն օպերանդի արժեք փոխակերպում է տրամաբանական տիպի։ Եթե արդյունքը `true` է այն կանգ է առնում և վերադարձնում այդ օպերանդի օրիգինալ արժեքը։
+- Եթե բոլոր օպերանդները հաշվվում են, և բոլորի արժեքը `false` է լինում, ապա վերադարձնում է վերջին օպերանդի արժեքը։
 
-A value is returned in its original form, without the conversion.
+Արժեքը վերադարձվում է իր օրիգինալ վիճակում, առանց փոխարկման (conversion)։
 
-In other words, a chain of OR `||` returns the first truthy value or the last one if no truthy value is found.
+Այլ կերպ ասած, ԿԱՄ `||`֊երից կազմված շղթան վերադարձնում է առաջին ճշմարիտ արժեքը, կամ վերջինը, եթե չկան ճշմարիտ արժեքներ։
 
-For instance:
+Օրինակ․
 
 ```js run
-alert( 1 || 0 ); // 1 (1 is truthy)
+alert(1 || 0) // 1 (1֊ը ճշմարիտ է)
 
-alert( null || 1 ); // 1 (1 is the first truthy value)
-alert( null || 0 || 1 ); // 1 (the first truthy value)
+alert(null || 1) // 1 (1֊ը առաջին ճշմարիտ արժեքն է)
+alert(null || 0 || 1) // 1 (առաջին ճշմարիտ արժեքը)
 
-alert( undefined || null || 0 ); // 0 (all falsy, returns the last value)
+alert(undefined || null || 0) // 0 (քանի որ բոլորը սխալական (falsy) են, վերադարձնում է վերջինը)
 ```
 
-This leads to some interesting usage compared to a "pure, classical, boolean-only OR".
+Սա հնարավորություն է տալիս կիրառել օպերատորը "մաքուր, ստանդարտ, միայն տրամաբանական ԿԱՄ"֊ի շրջանակներից դուրս։
 
-1. **Getting the first truthy value from a list of variables or expressions.**
+1. **Առաջին ճշմարիտ արժեքի ստացումը փոփոխականների կամ արտահայտությունների ցուցակից։**
 
-    For instance, we have `firstName`, `lastName` and `nickName` variables, all optional (i.e. can be undefined or have falsy values).
+    Օրինակ ունենք `firstName`, `lastName` և `nickName` փոփոխականները, բոլորը ըստ ցանկության կարող են ստանալ սխալական կամ `undefined` արժեքներ։
 
-    Let's use OR `||` to choose the one that has the data and show it (or `"Anonymous"` if nothing set):
+    Եկեք օգտագործենք ԿԱՄ `||`֊ը ընտրելու համար մեկը որը ունի արժեք (ճշմարիտ) և ցույց տանք այն (կամ `"Anonymous"` եթե այդպիսի արժեք չի գտնվել)։
 
     ```js run
     let firstName = "";
@@ -115,36 +115,36 @@ This leads to some interesting usage compared to a "pure, classical, boolean-onl
     */!*
     ```
 
-    If all variables were falsy, `"Anonymous"` would show up.
+    Եթե բոլոր փոփոխականները լինեին սխալական, ապա կտեսնեինք `"Anonymous"`։
 
-2. **Short-circuit evaluation.**
+2. **Կրճատ հաշվարկ (Short-circuit evaluation)։**
 
-    Another feature of OR `||` operator is the so-called "short-circuit" evaluation.
+    ԿԱՄ `||`֊ի մեկ այլ հատկությունը այսպես կոչված "կրճատ հաշվարկ"֊ի հատկությունն է։
 
-    It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument.
+    Դա նշանակում է, որ `||`֊ը կատարում է իր արգումենտների հաշվարկը և փոխակերպումը տրամաբանական տիպի մինչև առաջին ճշմարիտ արժեքին հանդիպելը, ապա այդ արժեքը միանգամից վերադարձվում է, առանց նույնիսկ հաջորդ արգումենտներին նայելու։
 
-    The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.
+    Այս հատկության կարևորությունն ակնհայտ է դառնում, եթե օպերանդը պարզապես արժեք չէ, այլ ինչ֊որ արտահայտություն՝ կողմնակի ազդեցությամբ, օրինակ փոփոխականի վերագրում կամ ֆունկցիայի կանչ։
 
-    In the example below, only the second message is printed:
+    Ներքևի օրինակում միայն երկրորդ նամակը կերևա էկրանին․
 
     ```js run no-beautify
-    *!*true*/!* || alert("not printed");
-    *!*false*/!* || alert("printed");
+    *!*true*/!* || alert("չի երևա");
+    *!*false*/!* || alert("կերևա");
     ```
 
-    In the first line, the OR `||` operator stops the evaluation immediately upon seeing `true`, so the `alert` isn't run.
+    Առաջին տողում ԿԱՄ `||` օպերատորը անմիջապես դադարեցնում է հաշվարկը հենց հանդիպում է `true` արժեքին, այդ պատճառով `alert`֊ը չի կանչվում։
 
-    Sometimes, people use this feature to execute commands only if the condition on the left part is falsy.
+    Հաճախ ծրագրավորողները օգտագործում են այս հատկությունը այն դեպքում, երբ անհրաժեշտ է կատարել հրամանները (execute commands) այն և միայն այն դեպքում, երբ ձախ կողմի գրված պայմանը սխալական է։
 
-## && (AND)
+## && (ԵՎ) (AND)
 
-The AND operator is represented with two ampersands `&&`:
+ԵՎ օպերատորը ներկայացվում է երկու ամպերսանդի նշանների միջոցով `&&`։
 
 ```js
-result = a && b;
+result = a && b
 ```
 
-In classical programming, AND returns `true` if both operands are truthy and `false` otherwise:
+Դասական ծրագրավորման մեջ ԵՎ օպերատորը վերադարձնում է `true`, եթե իր երկու օպերանդների արժեքները ճշմերիտ են, հակառակ դեպքում՝ `false`։
 
 ```js run
 alert( true && true );   // true
@@ -153,137 +153,137 @@ alert( true && false );  // false
 alert( false && false ); // false
 ```
 
-An example with `if`:
+Օրինակ `if`֊ի հետ։
 
 ```js run
 let hour = 12;
 let minute = 30;
 
 if (hour == 12 && minute == 30) {
-  alert( 'The time is 12:30' );
+  alert('Ժամը 12։30֊ն է');
 }
 ```
 
-Just as with OR, any value is allowed as an operand of AND:
+Ինչպես ԿԱՄ֊ի դեպքում, ԵՎ֊ի օպերանդները նույնպես կարող են ունենալ կամայական արժեք․
 
 ```js run
-if (1 && 0) { // evaluated as true && false
-  alert( "won't work, because the result is falsy" );
+if (1 && 0) { // հաշվվում է ինչպես true && false
+  alert('չի երևա, որովհետև արժեքը սխալական է');
 }
 ```
 
 
-## AND "&&" finds the first falsy value
+## ԵՎ "&&"֊ը գտնում է առաջին սխալական արժեքը
 
-Given multiple AND'ed values:
+Տրված է մի քանի արժեքներ կապակցված ԵՎ֊ով․
 
 ```js
-result = value1 && value2 && value3;
+result = value1 && value2 && value3
 ```
 
-The AND `&&` operator does the following:
+ԵՎ `&&` օպերատորը կատարում է հետևյալ գործողություննեը․
 
-- Evaluates operands from left to right.
-- For each operand, converts it to a boolean. If the result is `false`, stops and returns the original value of that operand.
-- If all operands have been evaluated (i.e. all were truthy), returns the last operand.
+- Հաշվում է օպերանդների արժեքները ձախից աջ։
+- Ամեն օպերանդի արժեք փոխակերպում է տրամաբանական տիպի։ Եթե արդյունքը `false` է այն կանգ է առնում և վերադարձնում այդ օպերանդի օրիգինալ արժեքը։
+- Եթե բոլոր օպերանդները հաշվվում են, և բոլորի արժեքը `true` է լինում, ապա վերադարձնում է վերջին օպերանդի արժեքը։
 
-In other words, AND returns the first falsy value or the last value if none were found.
+Այլ կերպ ասած, ԵՎ֊ը վերադարձնում է առաջին սխալական արժեքը, կամ վերջին արժեքը, եթե ոչ մի սխալական արժեք չի գտնվել։
 
-The rules above are similar to OR. The difference is that AND returns the first *falsy* value while OR returns the first *truthy* one.
+Վերոնշյալ կանոնները նման են ԿԱՄ֊ին։ Տարբերությունն այն է, որ ԵՎ֊ը վերադարձնում է առաջին _սխալական_ արժեքը, իսկ ԿԱՄ֊ը՝ առաջին _ճշմարիտ_ արժեքը։
 
-Examples:
+Օրինակներ․
 
 ```js run
-// if the first operand is truthy,
-// AND returns the second operand:
+// Եթե առաջին օպերանդը ճշմարիտ է,
+// ապա ԵՎ֊ը վերադարձնում է երկրոդ օպերանդը։
 alert( 1 && 0 ); // 0
 alert( 1 && 5 ); // 5
 
-// if the first operand is falsy,
-// AND returns it. The second operand is ignored
+// Եթե առաջին օպերանդը սխալական է,
+// ապա ԵՎ֊ը վերադարձնում է այն։ Երկրորդ օպերանդը անտեսվում է։
 alert( null && 5 ); // null
-alert( 0 && "no matter what" ); // 0
+alert( 0 && "կապ չունի ինչ" ); // 0
 ```
 
-We can also pass several values in a row. See how the first falsy one is returned:
+Կարող ենք նաև մի քանի արժեք միաժամանակ փոխանցել։ Տեսնենք թե ինչպես է ԵՎ֊ը վերադարձնում առաջին սխալական արժեքը․
 
 ```js run
-alert( 1 && 2 && null && 3 ); // null
+alert(1 && 2 && null && 3) // null
 ```
 
-When all values are truthy, the last value is returned:
+Երբ բոլոր արժեքնորը ճշմարիտ են, ապա վերադարձվում է վերջին արժեքը․
 
 ```js run
-alert( 1 && 2 && 3 ); // 3, the last one
+alert(1 && 2 && 3) // 3, վերջինը
 ```
 
-````smart header="Precedence of AND `&&` is higher than OR `||`"
-The precedence of AND `&&` operator is higher than OR `||`.
+````smart header="ԵՎ `&&`֊ի նախապատվությունը (precedence) ավելի բարձր է քան ԿԱՄ `||`֊ինը"
+ԵՎ `&&`֊ի նախապատվությունը (precedence) ավելի բարձր է քան ԿԱՄ `||`֊ինը:
 
-So the code `a && b || c && d` is essentially the same as if the `&&` expressions were in parentheses: `(a && b) || (c && d)`.
+Այսպիսով `a && b || c && d` արտահայտությունը համարժեք է հետևյալ արտահայտությանը՝ `(a && b) || (c && d)`, որտեղ `&&`֊երը փակագծերի մեջ են։
 ````
 
-````warn header="Don't replace `if` with `||` or `&&`"
-Sometimes, people use the AND `&&` operator as a "shorter way to write `if`".
+````warn header="Մի փոխարինեք `if`֊ը `||`֊ով կամ `&&`֊ով"
+Հաճախ ծրագրավորողները օգտագործում են ԵՎ `&&` օպերատորը, որպես "`if`֊ի կարճ գրելաձև"։
 
-For instance:
+Օրինակ․
 
 ```js run
 let x = 1;
 
-(x > 0) && alert( 'Greater than zero!' );
+(x > 0) && alert('Մեծ է զրոից');
 ```
 
-The action in the right part of `&&` would execute only if the evaluation reaches it. That is, only if `(x > 0)` is true.
+Աջ կողմի գործողությունը կկատարվի այն ժամանակ, երբ ձախից աջ արժեքավորումը հասնի իրեն (այսինքն ձախ կողմի բոլոր արժեքները ճշմարիտ են)։ Դա տեղի կունենա, եթե `(x > 0)` արտահայտությունը ճիշտ լինի։
 
-So we basically have an analogue for:
+Դա ստացվում է հետևյալի անալոգը․
 
 ```js run
 let x = 1;
 
-if (x > 0) alert( 'Greater than zero!' );
+if (x > 0) alert('Մեծ է զրոից');
 ```
 
-Although, the variant with `&&` appears shorter, `if` is more obvious and tends to be a little bit more readable. So we recommend using every construct for its purpose: use `if` if we want `if` and use `&&` if we want AND.
+Թեև `&&`֊ով տարբերակն ավելի կարճ է, `if`֊ը ավելի հասկանալի է և ավելի ընթեռնելի։ Այսպիսով, մենք խորհուրդ ենք տալիս օգտագործել յուրաքանչյուր գրելաձև իր նշանակությանը համապատասխան՝ օգտագործեք `if` եթե ցանկանում եք պայման ստուգել, և `&&`, եթե ցանկանում եք կատարել ԵՎ տրամաբանական գործողությունը։
 ````
 
 
-## ! (NOT)
+## ! (ՈՉ) (NOT)
 
-The boolean NOT operator is represented with an exclamation sign `!`.
+Տրամաբանական ՈՉ օպերատորը ներկայացվում է բացականչական նշանի միջոցով՝ `!`։
 
-The syntax is pretty simple:
+Նրա շարահյուսությունը (syntax) շատ պարզ է․
 
 ```js
-result = !value;
+result = !value
 ```
 
-The operator accepts a single argument and does the following:
+Օպերատորը ընդունում է մեկ արգումենտ և կատարում հետևյալ քայլերը․
 
-1. Converts the operand to boolean type: `true/false`.
-2. Returns the inverse value.
+1. Փոխակերպում է օպերանդը տրամաբանական տիպի՝ `true/false`.
+2. Վերադարձնում է հակադարձ արժեքը։
 
-For instance:
+Օրինակ․
 
 ```js run
 alert( !true ); // false
 alert( !0 ); // true
 ```
 
-A double NOT `!!` is sometimes used for converting a value to boolean type:
+Երբեմն կրկնակի ՈՉ `!!`֊ը օգտագործվում է արժեքը տրամաբանական տիպի փոխակերպելու համար․
 
 ```js run
-alert( !!"non-empty string" ); // true
-alert( !!null ); // false
+alert(!!'ոչ դատարկ տողային արժեք') // true
+alert(!!null) // false
 ```
 
-That is, the first NOT converts the value to boolean and returns the inverse, and the second NOT inverses it again. In the end, we have a plain value-to-boolean conversion.
+Այսինքն՝ առաջին ՈՉ֊ը փոխակերպում է արժեքը տրամաբանական տիպի, և վերադարձնում դրա հակադարձը, իսկ երկրորդ ՈՉ֊ը կրկին հակադարձում է այն։ Վերջնարդյունքում ունենում ենք տրամաբանական տիպի փոխակերպում (value-to-boolean conversion)։
 
-There's a little more verbose way to do the same thing -- a built-in `Boolean` function:
+Այս գործողության ավելի տեսանելի տարբերակը ներկառուցված `Boolean` ֆունկցիայի կիրառմամբ է․
 
 ```js run
-alert( Boolean("non-empty string") ); // true
-alert( Boolean(null) ); // false
+alert(Boolean('ոչ դատարկ տողային արժեք')) // true
+alert(Boolean(null)) // false
 ```
 
-The precedence of NOT `!` is the highest of all logical operators, so it always executes first, before `&&` or `||`.
+ՈՉ `!` օպերատորի նախապատվությունը ամենաբարձրն է բոլոր տրամաբանական օպերատորների մեջ, այսինքն արտահայտության մեջ միշտ առաջինը կատարվում է `!` գործողությունը, և այնուհետև `&&` և `||` գործողությունները։
diff --git a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
index 0b2f092ab..74898d969 100644
--- a/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
+++ b/1-js/02-first-steps/12-nullish-coalescing-operator/article.md
@@ -1,94 +1,94 @@
-# Nullish coalescing operator '??'
+# Null֊ի միավորման (Nullish coalescing) օպերատոր '??'
 
 [recent browser="new"]
 
-The nullish coalescing operator is written as two question marks `??`.
+Null֊ի միավորման օպերատորը գրվում է երկու հարցականի նշանի միջոցով՝ `??`։
 
-As it treats `null` and `undefined` similarly, we'll use a special term here, in this article. For brevity, we'll say that a value is "defined" when it's neither `null` nor `undefined`.
+Քանի որ այն վերաբերվում է `null` և `undefined` արժեքներին նույն կերպ, մենք կօգտագործենք հատուկ տերմին այս հոդվածում։ Կասենք, որ արժեքը «հատկանշված» է, եթե դա ո՛չ `null` է, ո՛չ `undefined`։
 
-The result of `a ?? b` is:
-- if `a` is defined, then `a`,
-- if `a` isn't defined, then `b`.
+`a ?? b` արտահայտության արժեքը կլինի՝
+- եթե `a`֊ն որոշված է, ապա `a`,
+- եթե `a`֊ն որոշված չէ, ապա `b`։
 
-In other words, `??` returns the first argument if it's not `null/undefined`. Otherwise, the second one.
+Այլ կերպ ասած, `??` օպերատորը վերադարձնում է առաջին արգումենտը, եթե դրա արժեքը `null/undefined` չէ։ Հակառակ դեպքում՝ երկրորդը։
 
-The nullish coalescing operator isn't anything completely new. It's just a nice syntax to get the first "defined" value of the two.
+Null֊ի միավորման օպերատորը ամենևին նոր բան չէ, այն ուղղակի սիրուն գրելաձև է՝ երկու արժեքներից առաջին "որոշված" արժեքը ստանալու։
 
-We can rewrite `result = a ?? b` using the operators that we already know, like this:
+Կարող ենք գրել `result = a ?? b` արտահայտությունը օգտագործելով մեզ արդեն հայտնի օպերատորները․
 
 ```js
 result = (a !== null && a !== undefined) ? a : b;
 ```
 
-Now it should be absolutely clear what `??` does. Let's see where it helps.
+Հիմա արդեն պետք է պարզ լինի, թե ինչ է անում `??`֊ը։ Տեսնենք, թե որտեղ կարող է այն օգտակար լինել։
 
-The common use case for `??` is to provide a default value.
+Ընդհանուր առմամբ `??` օգտագործվում է կանխադրված (default) արժեք տալու համար:
 
-For example, here we show `user` if its value isn't `null/undefined`, otherwise `Anonymous`:
+Օրինակ՝ այստեղ մենք ցուցադրում ենք `user`, եթե դրա արժեքը `null/undefined` չէ, հակառակ դեպքում՝ `Anonymous` (Անանուն)․
 
 ```js run
 let user;
 
-alert(user ?? "Anonymous"); // Anonymous (user is undefined)
+alert(user ?? "Անանուն"); // Անանուն (user֊ը undefined է)
 ```
 
-Here's the example with `user` assigned to a name:
+Ահա օրինակ, երբ `user`֊ին վերագրված է անուն․
 
 ```js run
-let user = "John";
+let user = "Ջոն";
 
-alert(user ?? "Anonymous"); // John (user is not null/undefined)
+alert(user ?? "Անանուն"); // Ջոն (user֊ը null/undefined չէ)
 ```
 
-We can also use a sequence of `??` to select the first value from a list that isn't `null/undefined`.
+Մենք կարող ենք նաև օգտագործել `??`֊ից կազմված շարան, առաջին ոչ `null/undefined` արժեքը վերցնելու համար։
 
-Let's say we have a user's data in variables `firstName`, `lastName` or `nickName`. All of them may be not defined, if the user decided not to fill in the corresponding values.
+Ենթադրենք ունենք օգտատիրոջ տվյալները հետևյալ փոփոխականների մեջ՝ `firstName`, `lastName` կամ `nickName`։ Դրանք բոլորը կարող են որոշված չլինել, եթե օգտատերը որոշել է չմուտքագրել համապատասխան արժեքները։
 
-We'd like to display the user name using one of these variables, or show "Anonymous" if all of them are `null/undefined`.
+Մենք ցանկանում ենք ցուցադրել օգտատիրոջ անունը՝ օգտագործելով այս փոփոխականներից մեկը, կամ ցուցադրել «Անանուն», եթե դրանք բոլորը `null/undefined` են։
 
-Let's use the `??` operator for that:
+Օգտագործենք `??` օպերատորը․
 
 ```js run
 let firstName = null;
 let lastName = null;
-let nickName = "Supercoder";
+let nickName = "Սուպերկոդեռ";
 
-// shows the first defined value:
+// ցուցադրում է առաջին որոշված արժեքը․
 *!*
-alert(firstName ?? lastName ?? nickName ?? "Anonymous"); // Supercoder
+alert(firstName ?? lastName ?? nickName ?? "Անանուն"); // Սուպերկոդեռ
 */!*
 ```
 
-## Comparison with ||
+## Համեմատում ||֊ի հետ
 
-The OR `||` operator can be used in the same way as `??`, as it was described in the [previous chapter](info:logical-operators#or-finds-the-first-truthy-value).
+ԿԱՄ `||` օպերատորը կարող է օգտագործվել նույն կերպ ինչ `??`, որը նկարագրված է [նախորդ հոդվածում](info:logical-operators#or-finds-the-first-truthy-value)։
 
-For example, in the code above we could replace `??` with `||` and still get the same result:
+Օրինակ վերևի ծրագրում կարող ենք `??`֊ը փոխարինել `||`֊ով և ստանալ նույն արդյունքը․
 
 ```js run
 let firstName = null;
 let lastName = null;
-let nickName = "Supercoder";
+let nickName = "Սուպերկոդեռ";
 
-// shows the first truthy value:
+// ցուցադրում է առաջին որոշված արժեքը․
 *!*
-alert(firstName || lastName || nickName || "Anonymous"); // Supercoder
+alert(firstName || lastName || nickName || "Անանուն"); // Սուպերկոդեռ
 */!*
 ```
 
-Historically, the OR `||` operator was there first. It's been there since the beginning of JavaScript, so developers were using it for such purposes for a long time.
+ԿԱՄ `||` օպերատորը կա JavaScript֊ի ստեղծման պահից ի վեր, և ծրագրավորողները օգտագործում էին այն այսպիսի դեպքերի համար շատ երկար ժամանակ։
 
-On the other hand, the nullish coalescing operator `??` was added to JavaScript only recently, and the reason for that was that people weren't quite happy with `||`.
+Իսկ null֊ի միավորման օպերատորը `??` ավելացվել է JavaScript֊ում վերջերս, և դրա պատճառը այն է, որ ծրագրավորողները այնքան էլ գոհ չէին `||`֊ից։
 
-The important difference between them is that:
-- `||` returns the first *truthy* value.
-- `??` returns the first *defined* value.
+Կարևոր տարբերությունը դրանց միջև․
+- `||`֊ը վերադարձնում է առաջին *ճշմարիտ* արժեքը։
+- `??`֊ը վերադարձնում է առաջին *որոշված* արժեքը։
 
-In other words, `||` doesn't distinguish between `false`, `0`, an empty string `""` and `null/undefined`. They are all the same -- falsy values. If any of these is the first argument of `||`, then we'll get the second argument as the result.
+Այլ կերպ ասած, `||`֊ը  չի տարբերակում `false`, `0`, դատարկ տող `""` և `null/undefined` արժեքները։ Դրանք բոլորը նույնն են -- սխալական արժեքներ։ Եթե սրանցից ինչ֊որ մեկը լինի առաջին արգումենտ `||`֊ի համար, ապա մենք կստանանք երկրորդ արգումենտը արդյունքում։
 
-In practice though, we may want to use default value only when the variable is `null/undefined`. That is, when the value is really unknown/not set.
+Բայց պրակտիկայում լինում են դեպքեր երբ, մենք կարիք ենք ունենում օգտագործել լռելյայն արժեք միայն այն դեպքում, երբ փոփոխականը `null/undefined` է։ Դա այն դեպքն է, երբ արժեքը իրոք անհայտ է, կամ ոչ վերագրված։
 
-For example, consider this:
+Դիտարկենք հետևյալ օրինակը․
 
 ```js run
 let height = 0;
@@ -97,73 +97,74 @@ alert(height || 100); // 100
 alert(height ?? 100); // 0
 ```
 
-- The `height || 100` checks `height` for being a falsy value, and it's `0`, falsy indeed.
-    - so the result of `||` is the second argument, `100`.
-- The `height ?? 100` checks `height` for being `null/undefined`, and it's not,
-    - so the result is `height` "as is", that is `0`.
+- `height || 100` արտահայտությունը ստուգում է, արդյոք `height`֊ը սխալական է, թե ոչ։ Այն `0` է, որն էլ սխալական է,
+    - այսպիսով `||`֊ի արդյունքը կլինի երկրորդ արգումենտը՝ `100`։
+- `height ?? 100` արտահայտությունը ստուգում է, արդյոք `height`֊ը `null/undefined` է, թե ոչ, որն էլ այդպիսին չէ,
+    - այսպիսով արդյունքը կլինի `height`, այսինքն `0`։
 
-In practice, the zero height is often a valid value, that shouldn't be replaced with the default. So `??` does just the right thing.
+Պրակտիկայում զրոն վավեր (valid) արժեք է, որը չպետք է փոխարինվի լռելյայն արժեքով։ Այսինքն `??`֊ը անում է այն ինչ մեզ պետք է։
 
-## Precedence
+## Նախապատվություն
 
-The precedence of the `??` operator is the same as `||`. They both equal `3` in the [MDN table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table).
+`??`֊ի նախապատվությունը նույնն է ինչ `||`֊ինը՝։ [MDN աղյուսակում](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table) երկուսն էլ `3` են։
 
-That means that, just like `||`, the nullish coalescing operator `??` is evaluated before `=` and `?`, but after most other operations, such as `+`, `*`.
+Դա նշանակում է, որ ինչպես `||`֊ի դեպքում, null֊ի միավորման օպերատոր `??`֊ը կատարվում է `=` և `?` օպերատորներից առաջ, բայց շատ այլ օպերատորնեից հետո, ինչպիսիք են `+`, `*`։
 
-So we may need to add parentheses in expressions like this:
+Այսպիսով, եթե մենք օգտագործում ենք `??`֊ը այլ օպերատորների հետ միասին մեկ արտահայտությունում՝ արժեք ընտրելու համար, պետք է նաև ավելացնել փակագծեր․
+Այսպիսով, մեզ գուցե անհրաժեշտ լինի փակագծեր ավելացնել այսպիսի արտահայտություններում.
 
 ```js run
 let height = null;
 let width = null;
 
-// important: use parentheses
+// կարևոր է օգտագործել փակագծեր
 let area = (height ?? 100) * (width ?? 50);
 
 alert(area); // 5000
 ```
 
-Otherwise, if we omit parentheses, then as `*` has the higher precedence than `??`, it would execute first, leading to incorrect results.
+Հակառակ դեպքում, եթե չդնենք փակագծերը, ապա, քանի որ `*`֊ի նախապատվությունը ավելի բարձր է, քան `??`֊ինը, այն կաշխատի առաջինը, որի արդյունքում էլ կստանանք սխալ պատասխան։
 
 ```js
-// without parentheses
+// առանց փակագծեր
 let area = height ?? 100 * width ?? 50;
 
-// ...works this way (not what we want):
+// ...աշխատում է այս եղանակով (այն չէ ինչ մենք ուզում ենք)․
 let area = height ?? (100 * width) ?? 50;
 ```
 
-### Using ?? with && or ||
+### ??֊ի օգտագործումը &&-ի և ||֊ի հետ
 
-Due to safety reasons, JavaScript forbids using `??` together with `&&` and `||` operators, unless the precedence is explicitly specified with parentheses.
+Անվտանգության նկատառումներից ելնելով JavaScript֊ը արգելում է օգտագործել `??`֊ը `&&` և `||` օպերատորների հետ, բացառությամբ այն դեպքերի, երբ հստակ փակագծերով նշված է հերթականությունը։
 
-The code below triggers a syntax error:
+Ներքևում գրված ծրագիրը կաշխատի սինտաքսի սխալով (syntax error)․
 
 ```js run
-let x = 1 && 2 ?? 3; // Syntax error
+let x = 1 && 2 ?? 3; // Սինտաքսի սխալ
 ```
 
-The limitation is surely debatable, it was added to the language specification with the purpose to avoid programming mistakes, when people start to switch from `||` to `??`.
+Այս սահմանափակումը ախոս քննարկման ենթակա է, այն ավելացվել է լեզվում, որպեսզի խուսափվեն ծրագրային սխալները, երբ ծրագրավորողը սկսում է անցում կատարել `||`֊ից `??`֊ին։
 
-Use explicit parentheses to work around it:
+Օգտագործեք փակագծեր, որպեսզի այն աշխատի․
 
 ```js run
 *!*
-let x = (1 && 2) ?? 3; // Works
+let x = (1 && 2) ?? 3; // Աշխատում է
 */!*
 
 alert(x); // 2
 ```
 
-## Summary
+## Ամփոփում
 
-- The nullish coalescing operator `??` provides a short way to choose the first "defined" value from a list.
+- Null֊ի միավորման օպերատոր `??`֊ը տրամադրում է կարճ ձև ընտրելու առաջին "որոշված" արժեքը շարքից։
 
-    It's used to assign default values to variables:
+    Օգտագործվում է փոփոխականին լռելյայն արժեք վերագրելու համար․
 
     ```js
-    // set height=100, if height is null or undefined
+    // դնում ենք height֊ի արժեքը 100, եթե height֊ը null կամ undefined է
     height = height ?? 100;
     ```
 
-- The operator `??` has a very low precedence, only a bit higher than `?` and `=`, so consider adding parentheses when using it in an expression.
-- It's forbidden to use it with `||` or `&&` without explicit parentheses.
+- `??` օպերատորը ունի շատ ցածր նախապատվության աստիճան, այն մի քիչ բարձր է, քան `?` և `=`֊ինը, այդ պատճառով կարևոր է հիշել ավելացնել փակագծեր, երբ այն օգտագործում ենք ինչ֊որ արտահայտության մեջ։
+- Արգելված է օգտագործել այն `||` կամ `&&` օպերատորների հետ առանց փակագծերի։
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
index 43ee4aad3..11a87cff2 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/solution.md
@@ -1,4 +1,4 @@
-The answer: `1`.
+Պատասխան՝ `1`։
 
 ```js run
 let i = 3;
@@ -8,18 +8,18 @@ while (i) {
 }
 ```
 
-Every loop iteration decreases `i` by `1`. The check `while(i)` stops the loop when `i = 0`.
+Ցիկլի ամեն իտերացիա `i`֊ն նվազեցնում է `1`֊ով։ `while(i)` ստուգումը կանգ կառնի, երբ `i = 0`։
 
-Hence, the steps of the loop form the following sequence ("loop unrolled"):
+Հետևաբար ցիկլը բաղկացած կլինի հետևյալ քայլերից ("բացենք ցիկլը")․
 
 ```js
 let i = 3;
 
-alert(i--); // shows 3, decreases i to 2
+alert(i--); // ցույց կտա 3, կնվազեցնի i֊ն 1֊ով՝ դարձնելով 2
 
-alert(i--) // shows 2, decreases i to 1
+alert(i--) // ցույց կտա 2, կնվազեցնի i֊ն 1֊ով՝ դարձնելով 1
 
-alert(i--) // shows 1, decreases i to 0
+alert(i--) // ցույց կտա 1, կնվազեցնի i֊ն 1֊ով՝ դարձնելով 0
 
-// done, while(i) check stops the loop
+// վերջ, while(i) ստուգումը կդադարեցնի ցիկլը
 ```
diff --git a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
index 3b847dfa2..6254eb49e 100644
--- a/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
+++ b/1-js/02-first-steps/13-while-for/1-loop-last-value/task.md
@@ -2,9 +2,9 @@ importance: 3
 
 ---
 
-# Last loop value
+# Ցիկլի վերջին արժեքը
 
-What is the last value alerted by this code? Why?
+Ի՞նչ արժեք ցույց կտա այս ծրագիրը ամենավերջում և ինչու՞։
 
 ```js
 let i = 3;
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
index 495359876..4e7016d58 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/solution.md
@@ -1,30 +1,30 @@
-The task demonstrates how postfix/prefix forms can lead to different results when used in comparisons.
+Այս առաջադրանքը ցուց է տալիս, թե ինչպես նախածանցի/վերջածանցի կիրառումը կարող է բերել տարբեր արդյունքների, երբ դրանք օգտագործվում են համեմատության մեջ։
 
-1. **From 1 to 4**
+1. **1֊ից մինչև 4**
 
     ```js run
     let i = 0;
     while (++i < 5) alert( i );
     ```
 
-    The first value is `i = 1`, because `++i` first increments `i` and then returns the new value. So the first comparison is `1 < 5` and the `alert` shows `1`.
+    Առաջին արժեքը `i = 1`, քանի որ `++i`֊ն սկզբում աճեցնում է `i`֊ի արժեքը, և հետո նոր վերադարձնում ստացված նոր աժեքը։ Այսպիսով առաջին համեմատությունը կլինի `1 < 5` և `alert`֊ը ցույց կտա `1`։
 
-    Then follow `2, 3, 4…` -- the values show up one after another. The comparison always uses the incremented value, because `++` is before the variable.
+    Ապա կհաջորդի `2, 3, 4…` -- արժեքները կցուցադրվեն մեկը մյուսի հետևից։ Համեմատումը միշտ օգտագործում է ավելացված արժեքը, քանի որ `++`֊ը գրված է փոփոխականից առաջ։
 
-    Finally, `i = 4` is incremented to `5`, the comparison `while(5 < 5)` fails, and the loop stops. So `5` is not shown.
-2. **From 1 to 5**
+    Եվ վերջապես `i = 4` ավելացվում է դառնալով `5`, `while(5 < 5)` համեմատումը կլինի սխալ, և ցիկլը կավարտվի։ Այսպիսով `5`֊ը չի երևա էկրանին։
+2. **1֊ից մինչև 5**
 
     ```js run
     let i = 0;
     while (i++ < 5) alert( i );
     ```
 
-    The first value is again `i = 1`. The postfix form of `i++` increments `i` and then returns the *old* value, so the comparison `i++ < 5` will use `i = 0` (contrary to `++i < 5`).
+    Առաջին արժեքը կրկին `i = 1` է։ `i++`֊ը աճեցնում է `i`֊ն, և ապա վերադարձնում *հին* արժեքը, այսպիսով `i++ < 5` համեմատության մեջ `i = 0` (ի տարբերություն `++i < 5`֊ի)։
 
-    But the `alert` call is separate. It's another statement which executes after the increment and the comparison. So it gets the current `i = 1`.
+    Բայց `alert`֊ի կանչը առանձին է։ Այն առանձին հատված է, որը կատարվում է փոփոխականի աճից և համեմատումից հետո։ Այսպիսով այն ստանում է ընթացիկ `i = 1`։
 
-    Then follow `2, 3, 4…`
+    Ապա հետևում են `2, 3, 4…`։
 
-    Let's stop on `i = 4`. The prefix form `++i` would increment it and use `5` in the comparison. But here we have the postfix form `i++`. So it increments `i` to `5`, but returns the old value. Hence the comparison is actually `while(4 < 5)` -- true, and the control goes on to `alert`.
+    Կանգ առնենք `i = 4` դեպքի վրա։ `++i`֊ն կաճեցներ `i`֊ն և կօգտագործեր `5` արժեքը համեմատման համար։ Բայց այստեղ օգտագործվում է `i++`, որը աճեցնում է `i`֊ն՝ դանձնելով `5`, և վերադարձնում հին արժեքը։ Հետևաբար համեմատումը կլինի `while(4 < 5)` -- որն էլ ճիշտ է, և `alert`֊ը ցույց կտա `5` արժեքը։
 
-    The value `i = 5` is the last one, because on the next step `while(5 < 5)` is false.
+    `i = 5` արժեքի դեպքում հաջորդ քայլում կունենանք `while(5 < 5)`, որն էլ սխալ է։
diff --git a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
index 298213237..21374d7fa 100644
--- a/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
+++ b/1-js/02-first-steps/13-while-for/2-which-value-while/task.md
@@ -2,19 +2,19 @@ importance: 4
 
 ---
 
-# Which values does the while loop show?
+# Ինչպիսի՞ արժեքներ ցույց կտա while ցիկլը
 
-For every loop iteration, write down which value it outputs and then compare it with the solution.
+Ամեն իտերացիայի համար գրառեք, թե ինչպիսի արժեքներ ցույց կտա ցիկլը, և համեմատեք ձեր պատասխանները լուծման հետ։
 
-Both loops `alert` the same values, or not?
+Արդյո՞ք երկու ցիկլերն էլ ցույց `alert` կանեն նույն արժեքները, թե ոչ։
 
-1. The prefix form `++i`:
+1. `++i` նախածանցով (prefix).
 
     ```js
     let i = 0;
     while (++i < 5) alert( i );
     ```
-2. The postfix form `i++`
+2. `i++` վերջածանցով (postfix).
 
     ```js
     let i = 0;
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
index e2e28e75b..7bc9ef467 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/solution.md
@@ -1,4 +1,4 @@
-**The answer: from `0` to `4` in both cases.**
+**Պատասխան՝ `0`֊ից մինչև `4`, երկու դեպքում էլ։**
 
 ```js run
 for (let i = 0; i < 5; ++i) alert( i );
@@ -6,12 +6,12 @@ for (let i = 0; i < 5; ++i) alert( i );
 for (let i = 0; i < 5; i++) alert( i );
 ```
 
-That can be easily deducted from the algorithm of `for`:
+Այս պատասխանին կարող ենք հասնել դիտարկելով `for`֊ի աշխատելու ալգորիթմը․
 
-1. Execute once `i = 0` before everything (begin).
-2. Check the condition `i < 5`
-3. If `true` -- execute the loop body `alert(i)`, and then `i++`
+1. Կատարում է մի անգամ `i = 0`, ամեն ինչից առաջ (սկիզբ)։
+2. Ստուգում է պայմանը `i < 5`։
+3. Եթե ճիշտ է (`true`) -- կատարում է ցիկլի մարմինը՝ `alert(i)`, և ապա `i++`
 
-The increment `i++` is separated from the condition check (2). That's just another statement.
+`i++` աճը բաժանված է պայմանի ստուգման գործողությունից (2)։ Այն կոդի ուրիշ անկախ հատված է։
 
-The value returned by the increment is not used here, so there's no difference between `i++` and `++i`.
+Աճեցումից հետո վերադարձված արժեքը այստեղ չի օգտագործվում, այսպիսով տարբերություն չկա `i++`֊ի և `++i`֊ի միջև։
diff --git a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
index bfefa63f5..4b00882b9 100644
--- a/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
+++ b/1-js/02-first-steps/13-while-for/3-which-value-for/task.md
@@ -2,18 +2,18 @@ importance: 4
 
 ---
 
-# Which values get shown by the "for" loop?
+# Ո՞ր արժեքները կցուցադրվեն "for" ցիկլի միջոցով
 
-For each loop write down which values it is going to show. Then compare with the answer.
+Ամեն ցիկլի համար գրառեք, թե ինչպիսի արժեքներ ցույց կտա ցիկլը, և համեմատեք ձեր պատասխանները լուծման հետ։
 
-Both loops `alert` same values or not?
+Արդյո՞ք երկու ցիկլերն էլ ցույց `alert` կանեն նույն արժեքները, թե ոչ։
 
-1. The postfix form:
+1. Վերջածանցով (postfix).
 
     ```js
     for (let i = 0; i < 5; i++) alert( i );
     ```
-2. The prefix form:
+2. Նախածանցով (prefix).
 
     ```js
     for (let i = 0; i < 5; ++i) alert( i );
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/solution.md b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
index e8e66bb47..c3c9d199c 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/solution.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/solution.md
@@ -8,4 +8,4 @@ for (let i = 2; i <= 10; i++) {
 }
 ```
 
-We use the "modulo" operator `%` to get the remainder and check for the evenness here.
+Մենք օգտագործում ենք "մնացորդի" օպերատոր `%`֊ը մնացորդը ստանալու համար, և ստուգում ենք թվի զույգությունը։
diff --git a/1-js/02-first-steps/13-while-for/4-for-even/task.md b/1-js/02-first-steps/13-while-for/4-for-even/task.md
index ff34e7e40..b4d8bfa20 100644
--- a/1-js/02-first-steps/13-while-for/4-for-even/task.md
+++ b/1-js/02-first-steps/13-while-for/4-for-even/task.md
@@ -2,8 +2,8 @@ importance: 5
 
 ---
 
-# Output even numbers in the loop
+# Ցուցադրել զույգ թվերը ցիկլի միջոցով
 
-Use the `for` loop to output even numbers from `2` to `10`.
+Օգտագործեք `for` ցիկլը ցուցադրելու զույգ թվերը `2`֊ից մինչև `10`։
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
index 612cf559c..1d918d3d0 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/solution.md
@@ -3,7 +3,7 @@
 ```js run
 let i = 0;
 while (i < 3) {
-  alert( `number ${i}!` );
+  alert( `Համար ${i}!` );
   i++;
 }
 ```
diff --git a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
index 0c69d9c2d..924ca648d 100644
--- a/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
+++ b/1-js/02-first-steps/13-while-for/5-replace-for-while/task.md
@@ -2,13 +2,13 @@ importance: 5
 
 ---
 
-# Replace "for" with "while"
+# Փոխարինեք "for"֊ը "while"֊ով
 
-Rewrite the code changing the `for` loop to `while` without altering its behavior (the output should stay same).
+Վերաշարադրեք կոդը, փոխելով `for` ցիկլը `while`֊ով, առանց նրա կատարման արդյունքը փոխելու (ցուցադրվող արժեքները պետք է մնան նույնը)։
 
 ```js run
 for (let i = 0; i < 3; i++) {
-  alert( `number ${i}!` );
+  alert( `Համար ${i}!` );
 }
 ```
 
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
index c7de5f09b..061e91102 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/solution.md
@@ -3,13 +3,13 @@
 let num;
 
 do {
-  num = prompt("Enter a number greater than 100?", 0);
+  num = prompt("Ներմուծեք 100֊ից բարձր թիվ", 0);
 } while (num <= 100 && num);
 ```
 
-The loop `do..while` repeats while both checks are truthy:
+`do..while` ցիկլը կրկնում է քանի դեռ երկու պայմաններն էլ ճշմարիտ են․
 
-1. The check for `num <= 100` -- that is, the entered value is still not greater than `100`.
-2. The check `&& num` is false when `num` is `null` or an empty string. Then the `while` loop stops too.
+1. `num <= 100` ստուգումը նշանակում է, որ ներմուծված թիվը դեռ մեծ չէ `100`֊ից։
+2. `&& num` ստուգումը սխալ է, երբ `num`֊ը `null` է կամ դատարկ տող։ Այդ դեպքում `while`֊ը կանգ է առնում։
 
-P.S. If `num` is `null` then `num <= 100` is `true`, so without the 2nd check the loop wouldn't stop if the user clicks CANCEL. Both checks are required.
+Եթե `num`֊ը `null` է, ապա `num <= 100` համեմատումը `true` է, այսինքն առանց երկրորդ պայմանի ցիկլը կանգ չէր առնի, եթե օգտատերը սեղմեր ՉԵՂԱՐԿԵԼ (CANCEL): Երկու պայմանն էլ պարտադիր են։
diff --git a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
index 0788ee76e..ca3b03c69 100644
--- a/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
+++ b/1-js/02-first-steps/13-while-for/6-repeat-until-correct/task.md
@@ -2,12 +2,12 @@ importance: 5
 
 ---
 
-# Repeat until the input is correct
+# Կրկնել քանի դեռ ներմուծված արժեքը ճիշտ չէ
 
-Write a loop which prompts for a number greater than `100`. If the visitor enters another number -- ask them to input again.
+Գրել ցիկլ, որը կհարցնի (prompt) թիվ, որը պետք է լինի մեծ `100`֊ից։ Եթե օգտատերը ներմուծի ուրիշ թիվ (պայմանին չբավարարող) -- տալ նրան ներմուծել կրկին։
 
-The loop must ask for a number until either the visitor enters a number greater than `100` or cancels the input/enters an empty line.
+Ցիկլը պետք է ուզի թիվ օգտատերից, մինչև մուտքագրվի `100`֊ից մեծ թիվ կամ չեղարկվի (cancel) ներմուծումը (մուտքագրվի դատարկ տող)։
 
-Here we can assume that the visitor only inputs numbers. There's no need to implement a special handling for a non-numeric input in this task.
+Ենթադրվում է, որ օգտատերը ներմուծում է միայն թվային արժեքներ։ Լրացուցիչ դեպքեր պետք չէ դիտարկել ոչ թվային արժեքների համար։
 
 [demo]
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
index b4b64b6fa..73aae6486 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/solution.md
@@ -1,29 +1,29 @@
-There are many algorithms for this task.
+Կան շատ տարբեր ալգորիթմներ այս խնդրիը լուծելու համար։
 
-Let's use a nested loop:
+Եկեք օգտագործենք ներդրված ցիկլեր․
 
 ```js
-For each i in the interval {
-  check if i has a divisor from 1..i
-  if yes => the value is not a prime
-  if no => the value is a prime, show it
+Բոլոր i֊երի համար հատվածից {
+  ստուգում է, արդյոք i֊ն բաժանվում է ինչ֊որ թվի միչև ինքը
+  եթե այո => արժեքը պարզ չէ
+  եթե ոչ => արժեքը պարզ է և պետք է ցույց տալ այն
 }
 ```
 
-The code using a label:
+Ծրագիրը օգտագործում է պիտակ (label)․
 
 ```js run
 let n = 10;
 
 nextPrime:
-for (let i = 2; i <= n; i++) { // for each i...
+for (let i = 2; i <= n; i++) { // ամեն i֊ի համար...
 
-  for (let j = 2; j < i; j++) { // look for a divisor..
-    if (i % j == 0) continue nextPrime; // not a prime, go next i
+  for (let j = 2; j < i; j++) { // փնտրում է բաժանարար..
+    if (i % j == 0) continue nextPrime; // պարզ չէ, անցնում է հաջորդ i֊ին
   }
 
-  alert( i ); // a prime
+  alert( i ); // պարզ թիվ
 }
 ```
 
-There's a lot of space to optimize it. For instance, we could look for the divisors from `2` to square root of `i`. But anyway, if we want to be really efficient for large intervals, we need to change the approach and rely on advanced maths and complex algorithms like [Quadratic sieve](https://en.wikipedia.org/wiki/Quadratic_sieve), [General number field sieve](https://en.wikipedia.org/wiki/General_number_field_sieve) etc.
+Այս օրինակում կան շատ տեղեր, որ կարելի է ավելի օպտիմալ գրել։ Օրինակ մենք կարող ենք փնտրել բաժանարարները `2`֊ից մինչև արմատ `i`֊ն։ Մեծ ինտերվալների դեպքում մենք պետք է լավացնենք (այսինքն փոքրացնենք) փնտրման սահմանները, ավելի արդյունավետ ծրագիր ստանալու համար։ Դրա համար պետք է ծանոթ լինենք խորացված մաթեմատիկայի տարրերին և կոմպլեքս ալգորիթմներին, ինչպիսիք են [Քառակուսային մաղ (Quadratic sieve)](https://en.wikipedia.org/wiki/Quadratic_sieve), [Ընդհանուր թվերի դաշտային մաղ (General number field sieve)](https://en.wikipedia.org/wiki/General_number_field_sieve) և այլն։
diff --git a/1-js/02-first-steps/13-while-for/7-list-primes/task.md b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
index 6344b9f6f..0c0c56b83 100644
--- a/1-js/02-first-steps/13-while-for/7-list-primes/task.md
+++ b/1-js/02-first-steps/13-while-for/7-list-primes/task.md
@@ -2,16 +2,16 @@ importance: 3
 
 ---
 
-# Output prime numbers
+# Տպել պարզ թվերը
 
-An integer number greater than `1` is called a [prime](https://en.wikipedia.org/wiki/Prime_number) if it cannot be divided without a remainder by anything except `1` and itself.
+`1`֊ից մեծ ամբողջ թիվը կոչվում է [պարզ](https://hy.wikipedia.org/wiki/Պարզ_թիվ), եթե ունի միայն երկու բաժանարար, դրանք են՝ `1`֊ը և հենց ինքը։
 
-In other words, `n > 1` is a prime if it can't be evenly divided by anything except `1` and `n`.
+Այլ կերպ ասած, `n > 1` պայմանին բավարարող `n`֊ը պարզ է, եթե այն հնարավոր չէ անմնացորդ բաժանել կամայական ամբողջ թվի վրա, բացի `1`֊ից և `n`֊ից։
 
-For example, `5` is a prime, because it cannot be divided without a remainder by `2`, `3` and `4`.
+Օրինակ, `5`֊ը պարզ է, քանի որ այն չի բաժանվում `2`֊ի, `3`֊ի և `4`֊ի։
 
-**Write the code which outputs prime numbers in the interval from `2` to `n`.**
+**Գրել ծրագիր, որը կտպի բոլոր պարզ թվերը `2`֊ից մինչև `n` հատվածում:**
 
-For `n = 10` the result will be `2,3,5,7`.
+`n = 10` դեպքի համար արդյունքը պետք է լինի `2,3,5,7`։
 
-P.S. The code should work for any `n`, not be hard-tuned for any fixed value.
+Հ․Գ․ Ծրագիրը պետք է աշխատի կամայական `n`֊ի համար, այսինքն `n`֊ը պետք է հեշտ մոդիֆիկացվի։
diff --git a/1-js/02-first-steps/13-while-for/article.md b/1-js/02-first-steps/13-while-for/article.md
index d1b749888..b952dac0a 100644
--- a/1-js/02-first-steps/13-while-for/article.md
+++ b/1-js/02-first-steps/13-while-for/article.md
@@ -1,10 +1,10 @@
-# Loops: while and for
+# Ցիկլեր․ while և for
 
-We often need to repeat actions.
+Հաճախ մենք կարիք ենք ունենում կրկնել ինչ֊որ գործողությունների հերթականություն։
 
-For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10.
+Օրինակ․ տպել իրար հետևից ցուցակի մեջ գտնվող ապրանքները, կամ ուղղակի աշխատեցնել նույն կոդը 1֊ից 10 բոլոր թվերի համար։
 
-*Loops* are a way to repeat the same code multiple times.
+*Ցիկլերը* նույն կոդը մի քանի անգամ կրկնելու հնարավորություն են տալիս։
 
 ```smart header="The for..of and for..in loops"
 A small announcement for advanced readers.
@@ -21,47 +21,47 @@ Otherwise, please read on.
 
 ## The "while" loop
 
-The `while` loop has the following syntax:
+`while` ցիկլը ունի հետևյալ գրելաձևը․
 
 ```js
 while (condition) {
-  // code
-  // so-called "loop body"
+  // կոդը
+  // որին նաև ասում են "ցիկլի մարմին" ("loop body")
 }
 ```
 
-While the `condition` is truthy, the `code` from the loop body is executed.
+Քանի դեռ `condition`֊ը (պայմանը) ճշմարիտ է, `կոդը` ցիկլի մարմնի ներսում կկատարվի։
 
-For instance, the loop below outputs `i` while `i < 3`:
+Օրինակի համար, ներքևի ցիկլը կարտածի `i`, քանի դեռ `i < 3`․
 
 ```js run
 let i = 0;
-while (i < 3) { // shows 0, then 1, then 2
+while (i < 3) { // ցույց կտա 0, հետո 1, հետո 2
   alert( i );
   i++;
 }
 ```
 
-A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations.
+Ցիկլի մարմնի մի կատարումը անվանում են *իտերացիա* (*an iteration*): Ցիկլը վերևի օրինակում կատարում է երեք իտերացիա։
 
-If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process.
+Եթե չլիներ `i++` գործողությունը վերևի օրինակում, ապա ցիկլը կկրկնվեր (տեսականորեն) անվերջ։ Պրակտիկայում, դիտարկիչը (browser) կտրամադրի տարբեր գործիքներ, որոնց միջոցով կկարողանանք կանգնեցնել այդպիսի ցիկլկերը, և սերվերում (server-side) կիրառվող JavaScript֊ում կարող ենք սպանել (kill) այդ պրոցեսը։
 
-Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`.
+Կամայական արտահայտություն կամ փոփոխական կարող է լինել ցիկլի պայման։ Պայմանը հաշվվում և ձևափոխվում է տրամաբանական տիպի `while`֊ի կողմից։
 
-For instance, a shorter way to write `while (i != 0)` is `while (i)`:
+Օրինակի համար, `while (i != 0)` արտահայտության կարճ գրելաձևը կլինի `while (i)`:
 
 ```js run
 let i = 3;
 *!*
-while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops
+while (i) { // երբ i֊ն դառնա 0, պայմանը կդառնա սխալական, և ցիկլը կանգ կառնի
 */!*
   alert( i );
   i--;
 }
 ```
 
-````smart header="Curly braces are not required for a single-line body"
-If the loop body has a single statement, we can omit the curly braces `{…}`:
+````smart header="Ձևավոր փակագծերը պարտադիր չեն մեկ տողանի մարմնի համար"
+Եթե ցիկլի մարմինը ունի ընդամենը մեկ արտահայտություն (statement), ապա կարող ենք բաց թողնել ձևավոր փակագծերը `{…}`․
 
 ```js run
 let i = 3;
@@ -71,19 +71,19 @@ while (i) alert(i--);
 ```
 ````
 
-## The "do..while" loop
+## "do..while" ցիկլը
 
-The condition check can be moved *below* the loop body using the `do..while` syntax:
+Պայմանի ստուգումը կարելի է տեղափոխել ցիկլի մարմնի *ներքևը* օգտագործելով `do..while` գերլաձևը․
 
 ```js
 do {
-  // loop body
+  // ցիկլի մարմին
 } while (condition);
 ```
 
-The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.
+Ցիկլը սկզբում կաշխատացնի մարմինը, ապա կստուգի պայմանը, և քանի դեռ այն ճշմարիտ է, այն կաշխատացնի մարմինը նորից ու նորից։
 
-For example:
+Օրինակ․
 
 ```js run
 let i = 0;
@@ -93,107 +93,107 @@ do {
 } while (i < 3);
 ```
 
-This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.
+Այս գրելաձևը պետք է օգտագործվի միայն այն դեպքում, երբ ցանկանում եք, որ ցիկլի մարմինը աշխատի **առնվազն մեկ անգամ** անկախ պայմանի ճշմարիտ կամ սխալական լինելու փաստից։ Սովորաբար մյուս տեսքը ավելի նախընտրելի է․ `while(…) {…}`։
 
-## The "for" loop
+## "for" ցիկլը
 
-The `for` loop is more complex, but it's also the most commonly used loop.
+`for` ցիլկը ավելի բարդ է, բայց այն ամենից շատ կիրառվող ցիկլն է։
 
-It looks like this:
+Այն ունի հետևյալ տեսքը․
 
 ```js
 for (begin; condition; step) {
-  // ... loop body ...
+  // ... ցիկլի մարմին ...
 }
 ```
 
-Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`:
+Եկեք ուսումնասիրենք այդ մասերը օրինակի վրա։ Ներքևի ցիկլը կատարում է `alert(i)` հրամանը `i`֊ն `0`֊ից մինչև `3`֊ը ոչ ներառյալ:
 
 ```js run
-for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2
+for (let i = 0; i < 3; i++) { // ցույց կտա 0, հետո 1, հետո 2
   alert(i);
 }
 ```
 
-Let's examine the `for` statement part-by-part:
+Դիտարկենք `for`֊ը մաս առ մաս․
 
-| part  |          |                                                                            |
+| մաս  |          |                                                                            |
 |-------|----------|----------------------------------------------------------------------------|
-| begin | `let i = 0`    | Executes once upon entering the loop.                                      |
-| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
-| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
-| step| `i++`      | Executes after the body on each iteration. |
+| սկիզբ | `i = 0`    | Կատարվում է, երբ մտնում ենք ցիկլ։                                      |
+| պայման | `i < 3`| Ստուգվում է ցիկլի ամեն իտերացիայից առաջ։ Եթե այն սխալ է, ապա ցիկլը կանգնեցվում է։              |
+| մարմին | `alert(i)`| Աշխատում է այնքան ժամանակ, քանի դեռ պայմանը ճշմարիտ է։                         |
+| քայլ| `i++`      | Կատարվում է մարմնի կատարումից հետո, ամեն իտերացիայի ժամանակ։ |
 
-The general loop algorithm works like this:
+Ընդհանուր դեպքում ալգորիթմը աշխատում է հետևյալ կերպ․
 
 ```
-Run begin
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
+Աշխատացնել *սկիզբ*
+→ (եթե *պայման* → կատարել *մարմին* և աշխատացնել *քայլ*)
+→ (եթե *պայման* → կատարել *մարմին* և աշխատացնել *քայլ*)
+→ (եթե *պայման* → կատարել *մարմին* և աշխատացնել *քայլ*)
 → ...
 ```
 
-That is, `begin` executes once, and then it iterates: after each `condition` test, `body` and `step` are executed.
+Այսինքն՝ `սկիզբ`֊ը կատարվում է մեկ անգամ, և հետո սկսվում են իտերացիաները․ ամեն `պայման`֊ի ստուգումից հետո, `մարմին`֊ը և `քայլ`֊ը կատարվում են։
 
-If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper.
+Եթե ցիկլերի թեման նոր է ձեր համար, ապա օգտակար կլինի հետ գնալ օրինակներին և քայլ առ քայլ գրառել դրանց կատարման ընթացքները թղթի վրա։
 
-Here's exactly what happens in our case:
+Ահա թե ինչ է տեղի ունենում կոնկրետ մեր օրինակի դեպքում․
 
 ```js
 // for (let i = 0; i < 3; i++) alert(i)
 
-// run begin
+// աշխատացնել սկիզբը
 let i = 0
-// if condition → run body and run step
+// եթե պայման → կատարել մարմինը և աշխատացնել քայլը
 if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
+// եթե պայման → կատարել մարմինը և աշխատացնել քայլը
 if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
+// եթե պայման → կատարել մարմինը և աշխատացնել քայլը
 if (i < 3) { alert(i); i++ }
-// ...finish, because now i == 3
+// ...ավարտ, քանի որ i == 3
 ```
 
-````smart header="Inline variable declaration"
-Here, the "counter" variable `i` is declared right in the loop. This is called an "inline" variable declaration. Such variables are visible only inside the loop.
+````smart header="Փոփոխականի ներկառուցված հայտարարում"
+Այստեղ "հաշվիչ" փոփոխական `i`֊ն հայտարարված է հենց ցիկլի վրա։ Այն կոչվում է "ներկառուցված" փոփոխականի հայտարարում։ Այսպիսի փոփոխականները տեսանելի են միայն ցիկլի ներսում։
 
 ```js run
 for (*!*let*/!* i = 0; i < 3; i++) {
   alert(i); // 0, 1, 2
 }
-alert(i); // error, no such variable
+alert(i); // սխալ է, չկա այդպիսի փոփոխական
 ```
 
-Instead of defining a variable, we could use an existing one:
+Փոփոխական հայտարարելու փոխարեն մենք կարող ենք օգտագործել արդեն գոյություն ունեցողը։
 
 ```js run
 let i = 0;
 
-for (i = 0; i < 3; i++) { // use an existing variable
+for (i = 0; i < 3; i++) { // օգտագործվում է գոյություն ունեցող փոփոխական
   alert(i); // 0, 1, 2
 }
 
-alert(i); // 3, visible, because declared outside of the loop
+alert(i); // 3, տեսանելի է, քանի որ հայտարարված է ցիկլից դուրս
 ```
 ````
 
-### Skipping parts
+### Մասերի բաց թողում
 
-Any part of `for` can be skipped.
+`for` ցիկլի ամեն մաս կաող է բաց թողնվել։
 
-For example, we can omit `begin` if we don't need to do anything at the loop start.
+Օրինակ, կարող ենք բաց թողնել `սկիզբ`֊ը, եթե ցիկլի սկզբում գործողություն չունենք անելու։
 
-Like here:
+Ինչպես այստեղ․
 
 ```js run
-let i = 0; // we have i already declared and assigned
+let i = 0; // i֊ն արդեն հայտարարված և արժեք ստացած է
 
-for (; i < 3; i++) { // no need for "begin"
+for (; i < 3; i++) { // կարիք չկա "սկիզբ"֊ի
   alert( i ); // 0, 1, 2
 }
 ```
 
-We can also remove the `step` part:
+Մենք կարող ենք նաև հեռացնել `քայլ`֊ի հատվածը․
 
 ```js run
 let i = 0;
@@ -203,32 +203,32 @@ for (; i < 3;) {
 }
 ```
 
-This makes the loop identical to `while (i < 3)`.
+Այն դառնում է նույնաբար `while (i < 3)` ցիկլը։
 
-We can actually remove everything, creating an infinite loop:
+Մենք կարող ենք հեռացնել ամեն բան, և կստանանք անվերջ ցիկլ․
 
 ```js
 for (;;) {
-  // repeats without limits
+  // կրկնվում է անվերջ
 }
 ```
 
-Please note that the two `for` semicolons `;` must be present. Otherwise, there would be a syntax error.
+Նկատի ունեցեք, որ `for`֊ի երկու կետ ստորակետները `;` պարտադիր պետք է գրված լինեն, հակառակ դեպքում տեղի կունենա սինտաքսի սխալ (syntax error)։
 
-## Breaking the loop
+## Ցիկլի ընդհատում (break)
 
-Normally, a loop exits when its condition becomes falsy.
+Սովորական դեպքերում ցիկլը դուրս է գալիս (ավարտվում է) այն ժամանակ, երբ նրա պայմանը դառնում է սխալական։
 
-But we can force the exit at any time using the special `break` directive.
+Բայց մենք կարող ենք հարկադրաբար (force) դուրս գալ ցիկլից, ամեն պահի, օգտագործելով հատուկ դիրեկտիվ `break`֊ը։
 
-For example, the loop below asks the user for a series of numbers, "breaking" when no number is entered:
+Օրինակ՝ ներքևի ցիկլը օգտատիրոջից անընդհատ թվային մուտք է ուզում, "ընդհատվում" է, երբ ոչ թվային արժեք է մուտքագրվում․
 
 ```js run
 let sum = 0;
 
 while (true) {
 
-  let value = +prompt("Enter a number", '');
+  let value = +prompt("Մուտքագրեք թիվ", '');
 
 *!*
   if (!value) break; // (*)
@@ -237,35 +237,35 @@ while (true) {
   sum += value;
 
 }
-alert( 'Sum: ' + sum );
+alert( 'Գումարը՝ ' + sum );
 ```
 
-The `break` directive is activated at the line `(*)` if the user enters an empty line or cancels the input. It stops the loop immediately, passing control to the first line after the loop. Namely, `alert`.
+`break` դիրեկտիվը կատարվում է `(*)` տողում, եթե օգտատերը մուտքագրում է դատարկ տող կամ չեղարկում է ներմուծման դաշտը։ Այն անմիջապես դադարեցնում է ցիկլը, և փոխանցում կատարումը ցիկլի անմիջապես հաջորդող տողին։ Մեր դեպքում՝ `alert`։
 
-The combination "infinite loop + `break` as needed" is great for situations when a loop's condition must be checked not in the beginning or end of the loop, but in the middle or even in several places of its body.
+"Անվերջ ցիկլ + `break`" կոմբինացիան հիանալի լուծում է այն դեպքերի համար, երբ ցիկլի պայմանը պետք է ստուգվի ոչ թե սկզբում կամ վերջում, այլ ցիկլի մարմնի մեջ, նույնիսկ կարող է ստուգվել մի քանի տեղ։
 
-## Continue to the next iteration [#continue]
+## Շարունակել հաջորդ իտերացիայից [#continue]
 
-The `continue` directive is a "lighter version" of `break`. It doesn't stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows).
+`continue` դիրեկտիվը `break`֊ի ավելի "թեթև տարբերակն" է։ Այն չի կանգնեցնում ամբողջ ցիկլը, այլ կանգնեցնում է միայն ընթացիկ իտերացիան, և հարկադրում ցիկլին անցնել հաջորդին (եթե պայմանը ճշմարիտ է)։
 
-We can use it if we're done with the current iteration and would like to move on to the next one.
+Մենք կարող ենք օգտագործել այն, եթե այլևս կարիք չկա շարունակել այդ պահի իտերացիան և ցանկանում ենք անցնել հաջորդին։
 
-The loop below uses `continue` to output only odd values:
+Ներքևի ցիկլը օգտագործում է `continue`֊ն՝ ցուցադրելու միայն կենտ արժեքները․
 
 ```js run no-beautify
 for (let i = 0; i < 10; i++) {
 
-  // if true, skip the remaining part of the body
+  // եթե ճիշտ է, բաց է թողնում ցիկլի մարմնի ներքևի հատվածը
   *!*if (i % 2 == 0) continue;*/!*
 
-  alert(i); // 1, then 3, 5, 7, 9
+  alert(i); // 1, հետո 3, 5, 7, 9
 }
 ```
 
-For even values of `i`, the `continue` directive stops executing the body and passes control to the next iteration of `for` (with the next number). So the `alert` is only called for odd values.
+`i`֊ի զույգ արժեքների համար `continue` դիրեկտիվը կանգնեցնում է մարմնի կատարումը և կատարումը փոխանցում `for`֊ի հաջորդ իտերացիային (հաջորդ թվով)։ Այսպիսով, `alert`֊ը կանչվում է միայն կենտ արժեքների համար։
 
-````smart header="The `continue` directive helps decrease nesting"
-A loop that shows odd values could look like this:
+````smart header="`continue` դիրեկտիվը օգնում է քչացնել ներդրվածությունները"
+Ցիկլը, որը ցույց է տալիս միայն կենտ արժեքները կարող էր ունենալ հետևյալ տեսքը․
 
 ```js run
 for (let i = 0; i < 10; i++) {
@@ -277,15 +277,15 @@ for (let i = 0; i < 10; i++) {
 }
 ```
 
-From a technical point of view, this is identical to the example above. Surely, we can just wrap the code in an `if` block instead of using `continue`.
+Տեխնիկական տեսանկյունից վերևում բերված երկու օրինակները ամբողջովին նույնն են։ Իհարկե, մենք կարող ենք շրջապատել մեր կոդի այդ հատվածը `if` բլոկով, `continue`֊ի փոխարեն։
 
-But as a side effect, this created one more level of nesting (the `alert` call inside the curly braces). If the code inside of `if` is longer than a few lines, that may decrease the overall readability.
+Բայց որպես կողմնակի ազդեցություն, սա ստեղծեց բնադրման ևս մեկ մակարդակ (`alert`֊ի կանչը ձևավոր փակագծերի ներսում)։ Եթե `if`֊ի ներսում կոդը մի քանի տողից երկար է, ապա այն կարող է նվազեցնել ընդհանուր ընթեռնելիությունը։
 ````
 
-````warn header="No `break/continue` to the right side of '?'"
-Please note that syntax constructs that are not expressions cannot be used with the ternary operator `?`. In particular, directives such as `break/continue` aren't allowed there.
+````warn header="Ոչ մի `break/continue` '?'֊ի աջ կողմում"
+Ուշադրություն դարձրեք, որ սինտաքսիկ կոնդտրուկցիաները (syntax constructs) չեն հանդիսանում արտահայտություններ (expressions) և չեն կարող օգտագործվել `?` օպերատորի հետ։ Մասնավոր դեպքում, `break/continue` և նմանատիպ դիրեկտիվները թույլատրված չեն '?'֊ի հետ։
 
-For example, if we take this code:
+Օրինակի համար, եթե դիտարկենք այս ծրագիրը․
 
 ```js
 if (i > 5) {
@@ -295,42 +295,42 @@ if (i > 5) {
 }
 ```
 
-...and rewrite it using a question mark:
+...և ձևափոխենք այն օգտագործելով հարցականի նշանը․
 
 ```js no-beautify
-(i > 5) ? alert(i) : *!*continue*/!*; // continue isn't allowed here
+(i > 5) ? alert(i) : *!*continue*/!*; // continue֊ն թույլատրված չէ այստեղ
 ```
 
-...it stops working: there's a syntax error.
+...այն կդադարի աշխատել, քանի որ կա սինտաքսի սխալ։
 
-This is just another reason not to use the question mark operator `?` instead of `if`.
+Սա մեկ այլ պատճառ է, որպեսզի չօգտագործենք `?`֊ը `if`֊ի փոխարեն։
 ````
 
-## Labels for break/continue
+## Պիտակներ (labels) break֊ի և continue֊ի համար
 
-Sometimes we need to break out from multiple nested loops at once.
+Կան դեպքեր, երբ մենք ցանկանում ենք դուրս գալ միանգամից մի քանի դերդրված ցիկլերից միանգամից։
 
-For example, in the code below we loop over `i` and `j`, prompting for the coordinates `(i, j)` from `(0,0)` to `(2,2)`:
+Օրինակ, ներքևի ծրագրում մենք անցնում ենք ցիկլ `i` և `j` փոփոխականներով, `prompt`-ի օգնությամբ հարցնում `(i, j)` կոորդինատների համար արժեք, սկսած `(0,0)` մինչև `(2,2)`․
 
 ```js run no-beautify
 for (let i = 0; i < 3; i++) {
 
   for (let j = 0; j < 3; j++) {
 
-    let input = prompt(`Value at coords (${i},${j})`, '');
+    let input = prompt(`Արժեքը (${i},${j}) կոորդինատում`, '');
 
-    // what if we want to exit from here to Done (below)?
+    // ի՞նչ եթե ցանկանում ենք դուրս գալ այստեղից, և անցնել Պատրաստ է (ներքև) տողին
   }
 }
 
-alert('Done!');
+alert('Պատրաստ է!');
 ```
 
-We need a way to stop the process if the user cancels the input.
+Մեզ պետք է ինչ֊որ ձև կանգնեցնել պրոցեսը, եթե օգտատերը չեղարկել է ներմուծման դաշտը։
 
-The ordinary `break` after `input` would only break the inner loop. That's not sufficient -- labels, come to the rescue!
+Ստանդարտ `break`֊ը `input`֊ից հետո կկանգնեցնի միայն ներսի ցիկլը։ Դա բավարար չէ, և այստեղ է, որ պիտակները գալիս են օգնության։
 
-A *label* is an identifier with a colon before a loop:
+*Պիտակը* դա նույնականացուցիչ (identifier) է վերջակետով ցիկլից առաջ․
 
 ```js
 labelName: for (...) {
@@ -338,74 +338,74 @@ labelName: for (...) {
 }
 ```
 
-The `break <labelName>` statement in the loop below breaks out to the label:
+`break <labelName>` հրամանը ներքևի ցիկլում կանգնեցնում է դրսի ցիկլը և անցնում պիտակի ցիկլի վերջը․
 
 ```js run no-beautify
 *!*outer:*/!* for (let i = 0; i < 3; i++) {
 
   for (let j = 0; j < 3; j++) {
 
-    let input = prompt(`Value at coords (${i},${j})`, '');
+    let input = prompt(`Արժեքը (${i},${j}) կոորդինատում`, '');
 
-    // if an empty string or canceled, then break out of both loops
+    // եթե դատարկ տող է կամ չեղարկված, ապա երկու ցիկլերն էլ կանգնեցվում են
     if (!input) *!*break outer*/!*; // (*)
 
-    // do something with the value...
+    // արժեքի հետ ինչ֊որ գործողություն...
   }
 }
 
-alert('Done!');
+alert('Պատրաստ է!');
 ```
 
-In the code above, `break outer` looks upwards for the label named `outer` and breaks out of that loop.
+Վերևի ծրագրում `break outer`֊ը փնտրում է իրեն ընդգրկող դրսի ցիկլը, որի պիտակը `outer` է, և կանգնեցնում այն։
 
-So the control goes straight from `(*)` to `alert('Done!')`.
+Այդպիսով կատարումը `(*)`֊ից անցնում է միանգամից `alert('Done!')`։
 
-We can also move the label onto a separate line:
+Մենք նաև կարող ենք պիտակները տեղադրել ուրիշ տողում․
 
 ```js no-beautify
 outer:
 for (let i = 0; i < 3; i++) { ... }
 ```
 
-The `continue` directive can also be used with a label. In this case, code execution jumps to the next iteration of the labeled loop.
+`continue` դիրեկտիվը նույնպես կարող է կիրառվել պիտակների հետ։ Այս դեպքում, ծրագրի կատարումը անցնում է նշված պիտակով ցիկլի հաջորդ իտերացիային։
 
-````warn header="Labels do not allow to \"jump\" anywhere"
-Labels do not allow us to jump into an arbitrary place in the code.
+````warn header="Պիտակները թույլ չեն տալիս \"ցատկել\" կամայական տեղ"
+Պիտակները թույլ չեն տալիս մեզ ցատկել ծրագրի լրիվ այլ հատված։
 
-For example, it is impossible to do this:
+Օրինակ, անհնար է անել այսպիրի հնարք․
 
 ```js
-break label; // jump to the label below (doesn't work)
+break label; // ցատկ ներքևի պիտակին (չի աշխատի)
 
 label: for (...)
 ```
 
-A `break` directive must be inside a code block. Technically, any labelled code block will do, e.g.:
+`break` դիրեկտիվը պետք է լինի պիտակը պարունակող բլոկի ներսում։ Տեխնիկապես կամայական պիտակավորված բլոկի համար կարող ենք անել հետևյալը․
 
 ```js
 label: {
   // ...
-  break label; // works
+  break label; // կաշխատի
   // ...
 }
 ```
 
-...Although, 99.9% of the time `break` is used inside loops, as we've seen in the examples above.
+...Չնայած դրան, 99.9% դեպքերում `break`֊ը օգտագործվում է ցիկլերի ներսում, ինչպես տեսանք վերևի օրինակում։
 
-A `continue` is only possible from inside a loop.
+`continue`֊ն միայն հնարավոր է կիրառել ցիկլի ներսում։
 ````
 
-## Summary
+## Ամփոփում
 
-We covered 3 types of loops:
+Մենք դիտարկեցինք ցիկլերի 3 տիպ․
 
-- `while` -- The condition is checked before each iteration.
-- `do..while` -- The condition is checked after each iteration.
-- `for (;;)` -- The condition is checked before each iteration, additional settings available.
+- `while` -- Ստուգվում է պայմանը ամեն իտերացիայից առաջ։
+- `do..while` -- Ստուգվում է պայմանը ամեն իտերացիայից հետո։
+- `for (;;)` -- Ստուգվում է պայմանը ամեն իտերացիայից առաջ, և տալիս լրացուցիչ կարգավորումների հնարավորություն
 
-To make an "infinite" loop, usually the `while(true)` construct is used. Such a loop, just like any other, can be stopped with the `break` directive.
+"Անվերջ" ցիկլ ստանալու համար սովորաբար օգտագործում են `while(true)`։ Այս ցիկլը, ինչպես նաև կամայական այլ ցիկլ, կարող է կանգնեցվել `break` դիրեկտիվի միջոցով։
 
-If we don't want to do anything in the current iteration and would like to forward to the next one, we can use the `continue` directive.
+Եթե մենք չենք ուզում, որ աշխատի ընթացիկ իտերացիան, այլ ցանկանում ենք անցնել հաջորդին, ապա կարող ենք օգտագործել `continue` դիրեկտիվը։
 
-`break/continue` support labels before the loop. A label is the only way for `break/continue` to escape a nested loop to go to an outer one.
+`break/continue` կարող են կիրառվել ցիկլերից առաջ գրված պիտակների վրա։ Պիտակը միակ ձևն է `break/continue`֊ի միջոցով ներդրված ցիկլերից դրսի ցիկլը կանգնեցնելու կամ դրա հաջորդ իտերացիային անցնելու համար։
diff --git a/1-js/02-first-steps/16-function-expressions/article.md b/1-js/02-first-steps/16-function-expressions/article.md
index c6dd891bd..cd69d8b08 100644
--- a/1-js/02-first-steps/16-function-expressions/article.md
+++ b/1-js/02-first-steps/16-function-expressions/article.md
@@ -1,96 +1,96 @@
-# Function expressions
+# Ֆունկցիոնալ արտահայտություններ
 
-In JavaScript, a function is not a "magical language structure", but a special kind of value.
+JavaScript-ում ֆունկցիան «լեզվի կախարդական կառուցվածք» չէ, բայց արժեքի հատուկ տեսակ է:
 
-The syntax that we used before is called a *Function Declaration*:
+Այն շարահյուսությունը, որ մինչ այս օգտագործել ենք, կոչվում է *Function Declaration* (Ֆունկցիոնալ Հռչակագիր):
 
 ```js
 function sayHi() {
-  alert( "Hello" );
+  alert( "Ողջույն" );
 }
 ```
 
-There is another syntax for creating a function that is called a *Function Expression*.
+Կա նաև այլ շարահյուսություն ֆունկցիա ստեղծելու համար, որը կոչվում է *Function Expression* (Ֆունկցիոնալ Արտահայտություն):
 
-It allows us to create a new function in the middle of any expression.
+Դա մեզ թույլ է տալիս ստեղծել նոր ֆունկցիա ցանկացած արտահայտության մեջտեղում:
 
-For example:
+Օրինակ.
 
 ```js
 let sayHi = function() {
-  alert( "Hello" );
+  alert( "Ողջույն" );
 };
 ```
 
-Here we can see a variable `sayHi` getting a value, the new function, created as `function() { alert("Hello"); }`.
+Այստեղ մենք կարող ենք տեսնել, որ `sayHi` փոփոխականը ստանում է արժեք՝ նոր ֆունկցիա, որը ստեղծվել է այսպես՝ `function() { alert("Ողջույն"); }`:
 
-As the function creation happens in the context of the assignment expression (to the right side of `=`), this is a *Function Expression*.
+Քանի որ ֆունկցիայի ստեղծումը տեղի է ունենում վերագրման արտահայտության համատեքստում (`=` նշանի աջ կողմում), ապա սա *Function Expression* (Ֆունկցիոնալ Արտահայտություն) է:
 
-Please note, there's no name after the `function` keyword. Omitting a name is allowed for Function Expressions.
+Նկատի ունեցեք, որ `function` հիմնաբառից հետո չկա անվանում: Անվան բացթողումը թույլատրելի է Ֆունկցիոնալ Արտահայտությունների համար:
 
-Here we immediately assign it to the variable, so the meaning of these code samples is the same: "create a function and put it into the variable `sayHi`".
+Այստեղ մենք անմիջապես վերագրում ենք այն փոփոխականի, ուստի այս կոդի նմուշների իմաստը նույնն է. «ստեղծել ֆունկցիա և տեղադրել այն `sayHi` փոփոխականում»:
 
-In more advanced situations, that we'll come across later, a function may be created and immediately called or scheduled for a later execution, not stored anywhere, thus remaining anonymous.
+Ավելի առաջադեմ իրավիճակներում, որոնց մենք ավելի ուշ կառնչվենք, ֆունկցիան կարող է ստեղծվել և անմիջապես կանչվել կամ պլանավորվել հետագա գործարկման համար, ոչ մի տեղ չպահվել, այդպիսով մնալ անանուն:
 
-## Function is a value
+## Ֆունկցիան արժեք է
 
-Let's reiterate: no matter how the function is created, a function is a value. Both examples above store a function in the `sayHi` variable.
+Եկեք կրկնենք. անկախ նրանից, թե ինչպես է ստեղծվում ֆունկցիան, այն արժեք է: Վերոնշյալ երկու օրինակներն էլ `sayHi` փոփոխականում պահում են ֆունկցիա:
 
-We can even print out that value using `alert`:
+Մենք կարող ենք նույնիսկ տպել այդ արժեքը՝ օգտագործելով `alert`.
 
 ```js run
 function sayHi() {
-  alert( "Hello" );
+  alert( "Ողջույն" );
 }
 
 *!*
-alert( sayHi ); // shows the function code
+alert( sayHi ); // ցուցադրում է ֆունկցիայի կոդը
 */!*
 ```
 
-Please note that the last line does not run the function, because there are no parentheses after `sayHi`. There are programming languages where any mention of a function name causes its execution, but JavaScript is not like that.
+Նկատի ունեցեք, որ վերջին տողը չի գործարկում ֆունկցիան, որովհետև `sayHi`-ից հետո չկան փակագծեր: Կան ծրագրավորման լեզուներ, որտեղ ֆունկցիայի անվան ցանկացած հիշատակում հանգեցնում է դրա գործարկմանը, բայց JavaScript-ը այդպիսին չէ։
 
-In JavaScript, a function is a value, so we can deal with it as a value. The code above shows its string representation, which is the source code.
+JavaScript-ում ֆունկցիան արժեք է, այնպես որ մենք կարող ենք դրան վերաբերվել որպես արժեքի: Վերոնշյալ կոդը ցույց է տալիս իր տողային ներկայացումը, որը սկզբնական կոդ է:
 
-Surely, a function is a special value, in the sense that we can call it like `sayHi()`.
+Անշուշտ, ֆունկցիան հատուկ արժեք է, այն իմաստով, որ մենք կարող ենք այն կանչել որպես `sayHi()`:
 
-But it's still a value. So we can work with it like with other kinds of values.
+Բայց դա դեռևս արժեք է: Այսպիսով, մենք կարող ենք աշխատել դրա հետ այնպես, ինչպես այլ տեսակի արժեքների հետ:
 
-We can copy a function to another variable:
+Մենք կարող ենք պատճենել ֆունկցիան մեկ այլ փոփոխականում.
 
 ```js run no-beautify
-function sayHi() {   // (1) create
-  alert( "Hello" );
+function sayHi() {     // (1) ստեղծել
+  alert( "Ողջույն" );
 }
 
-let func = sayHi;    // (2) copy
+let func = sayHi;      // (2) պատճենել
 
-func(); // Hello     // (3) run the copy (it works)!
-sayHi(); // Hello    //     this still works too (why wouldn't it)
+func(); // Ողջույն     // (3) գործարկել կրկնօրինակը (սա աշխատում է)
+sayHi(); // Ողջույն    //     սա նույնպես դեռ աշխատում է (ինչու ոչ)
 ```
 
-Here's what happens above in detail:
+Ահա մանրամասն, թե ինչ է տեղի ունենում վերևում.
 
-1. The Function Declaration `(1)` creates the function and puts it into the variable named `sayHi`.
-2. Line `(2)` copies it into the variable `func`. Please note again: there are no parentheses after `sayHi`. If there were, then `func = sayHi()` would write  *the result of the call* `sayHi()` into `func`, not *the function* `sayHi` itself.
-3. Now the function can be called as both `sayHi()` and `func()`.
+1. Ֆունկցիոնալ Հռչակագիրը `(1)` ստեղծում է ֆունկցիա և տեղադրում այն `sayHi` անվանումով փոփոխականում:
+2. Տող `(2)`-ը պատճենում է այն `func` փոփոխականում: Կրկին նկատի ունեցեք. `sayHi`-ից հետո չկան փակագծեր: Եթե լինեին, ապա `func = sayHi()` կվերագրեր `sayHi()`-ի *կանչվելու արդյունքը* `func`-ին, այլ ոչ հենց `sayHi` *ֆունկցիան*:
+3. Այժմ երկու եղանակով էլ ֆունկցիան կարող է կանչվել՝ `sayHi()` և `func()`:
 
-We could also have used a Function Expression to declare `sayHi`, in the first line:
+Մենք `sayHi` հռչակելու համար կարող էինք օգտագործել նաև Ֆունկցիոնալ Արտահայտություն առաջին տողում.
 
 ```js
-let sayHi = function() { // (1) create
-  alert( "Hello" );
+let sayHi = function() { // (1) ստեղծել
+  alert( "Ողջույն" );
 };
 
 let func = sayHi;  //(2)
 // ...
 ```
 
-Everything would work the same.
+Ամեն ինչ նույն կերպ կաշխատի:
 
 
-````smart header="Why is there a semicolon at the end?"
-You might wonder, why do Function Expressions have a semicolon `;` at the end, but Function Declarations do not:
+````smart header="Ինչո՞ւ վերջում կա կետ-ստորակետ:"
+Կարող եք զարմանալ, թե ինչո՞ւ Ֆունկցիոնալ Արտահայտություններն ունեն կետ-ստորակետ `;` վերջում, իսկ Ֆունկցիոնալ Հռչակագրերը չունեն.
 
 ```js
 function sayHi() {
@@ -102,27 +102,27 @@ let sayHi = function() {
 }*!*;*/!*
 ```
 
-The answer is simple: a Function Expression is created here as `function(…) {…}` inside the assignment statement: `let sayHi = …;`. The semicolon `;` is recommended at the end of the statement, it's not a part of the function syntax.
+Պատասխանը պարզ է. Ֆունկցիոնալ Արտահայտությունն այստեղ որպես `function(…) {…}` ստեղծվել է վերագրման դրույթի ներսում. `let sayHi = …;` (statement): Կետ-ստորակետը `;` խորհուրդ է տրվում դնել դրույթի վերջում, դա ֆունկցիայի շարահյուսության մաս չէ:
 
-The semicolon would be there for a simpler assignment, such as `let sayHi = 5;`, and it's also there for a function assignment.
+Կետ-ստորակետը կարող է լինել այդտեղ ավելի պարզ վերագրման համար, ինչպիսին է `let sayHi = 5;`, այն այդտեղ է նաև ֆունկցիա վերագրելու համար:
 ````
 
-## Callback functions
+## Հետկանչ ֆունկցիաներ
 
-Let's look at more examples of passing functions as values and using function expressions.
+Դիտարկենք ֆունկցիաները որպես արժեքներ փոխանցելու և ֆունկցիոնալ արտահայտություններ օգտագործելու ավելի շատ օրինակներ:
 
-We'll write a function `ask(question, yes, no)` with three parameters:
+Մենք կգրենք ֆունկցիա `ask(question, yes, no)` երեք պարամետրերով:
 
 `question`
-: Text of the question
+: Հարցի տեքստը
 
 `yes`
-: Function to run if the answer is "Yes"
+: Գործարկման համար ֆունկցիա, եթե պատասխանը «Դրական» է
 
 `no`
-: Function to run if the answer is "No"
+: Գործարկման համար ֆունկցիա, եթե պատասխանը «Բացասական» է
 
-The function should ask the `question` and, depending on the user's answer, call `yes()` or `no()`:
+Ֆունկցիան պետք է հարց տա `question` այնուհետև, կախված օգտատիրոջ պատասխանից, կանչի `yes()` կամ `no()`.
 
 ```js run
 *!*
@@ -133,24 +133,24 @@ function ask(question, yes, no) {
 */!*
 
 function showOk() {
-  alert( "You agreed." );
+  alert( "Դուք համաձայնեցիք:" );
 }
 
 function showCancel() {
-  alert( "You canceled the execution." );
+  alert( "Դուք չեղարկեցիք գործարկումը։" );
 }
 
-// usage: functions showOk, showCancel are passed as arguments to ask
-ask("Do you agree?", showOk, showCancel);
+// օգտագործումը. showOk և showCancel ֆունկցիաները փոխանցվում են ask ֆունկցիային որպես արգումենտներ
+ask("Դուք համաձա՞յն եք:", showOk, showCancel);
 ```
 
-In practice, such functions are quite useful. The major difference between a real-life `ask` and the example above is that real-life functions use more complex ways to interact with the user than a simple `confirm`. In the browser, such functions usually draw a nice-looking question window. But that's another story.
+Գործնականում նման ֆունկցիաները բավականին օգտակար են: Հիմնական տարբերությունը «իրական կյանքով» `ask`-ի և վերոնշյալ օրինակի միջև այն է, որ «իրական կյանքով» ֆունկցիաները օգտագործում են ավելի բարդ ուղիներ օգտատիրոջ հետ փոխազդելու համար, քան պարզ `confirm`-ը: Բրաուզերում նման ֆունկցիաները սովորաբար նկարում են գեղեցիկ տեսք ունեցող հարցերի պատուհան: Բայց դա այլ պատմություն է:
 
-**The arguments `showOk` and `showCancel` of `ask` are called *callback functions* or just *callbacks*.**
+**`ask` ֆունկցիայի `showOk` և `showCancel` արգումենտները կոչվում են *callback functions* (հետկանչ ֆունկցիաներ) կամ պարզապես *callbacks* (հետկանչեր):**
 
-The idea is that we pass a function and expect it to be "called back" later if necessary. In our case, `showOk` becomes the callback for "yes" answer, and `showCancel` for "no" answer.
+Գաղափարն այն է, որ մենք փոխանցում ենք ֆունկցիա և ակնկալում, որ այն հետագայում «հետ կկանչվի» անհրաժեշտության դեպքում: Մեր պարագայում `showOk`-ը դառնում է հետկանչ «դրական» պատասխանի համար, իսկ `showCancel`-ը՝ «բացասական» պատասխանի համար:
 
-We can use Function Expressions to write an equivalent, shorter function:
+Մենք կարող ենք օգտագործել Ֆունկցիոնալ Արտահայտություններ՝ նույն ֆունկցիան ավելի հակիրճ գրելու համար.
 
 ```js run no-beautify
 function ask(question, yes, no) {
@@ -160,221 +160,221 @@ function ask(question, yes, no) {
 
 *!*
 ask(
-  "Do you agree?",
-  function() { alert("You agreed."); },
-  function() { alert("You canceled the execution."); }
+  "Դուք համաձա՞յն եք:",
+  function() { alert("Դուք համաձայնեցիք:"); },
+  function() { alert("Դուք չեղարկեցիք գործարկումը։"); }
 );
 */!*
 ```
 
-Here, functions are declared right inside the `ask(...)` call. They have no name, and so are called *anonymous*. Such functions are not accessible outside of `ask` (because they are not assigned to variables), but that's just what we want here.
+Այստեղ ֆունկցիաները ճշգրիտ են հռչակված `ask(...)` կանչի ներսում: Նրանք չունեն անվանում, ուստի կոչվում են *anonymous* (անանուն): Նման ֆունկցիաները հասանելի չեն `ask`-ից դուրս (քանի որ դրանք վերագրված չեն փոփոխականների), բայց դա հենց այն է, ինչ մենք ուզում ենք այստեղ:
 
-Such code appears in our scripts very naturally, it's in the spirit of JavaScript.
+Շատ բնական է, որ նմանատիպ կոդ է հայտնվում մեր սքրիփթներում, այն JavaScript-ի ոգով է:
 
-```smart header="A function is a value representing an \"action\""
-Regular values like strings or numbers represent the *data*.
+```smart header="Ֆունկցիան «գործողություն» ներկայացնող արժեք է"
+Սովորական արժեքները, ինչպիսիք են տողերը կամ թվերը, ներկայացնում են *տվյալներ*:
 
-A function can be perceived as an *action*.
+Ֆունկցիան կարող է ընկալվել որպես *գործողություն*։
 
-We can pass it between variables and run when we want.
+Մենք կարող ենք այն փոխանցել փոփոխականների միջև և գործարկել` երբ կցանկանանք:
 ```
 
 
-## Function Expression vs Function Declaration
+## Ֆունկցիոնալ Արտահայտությունն ընդդեմ Ֆունկցիոնալ Հռչակագրի
 
-Let's formulate the key differences between Function Declarations and Expressions.
+Եկեք ձևակերպենք Ֆունկցիոնալ Հռչակագրի և Արտահայտության միջև հիմնական տարբերությունները:
 
-First, the syntax: how to differentiate between them in the code.
+Առաջինը՝ շարահյությություն. ինչպես տարանջատել դրանք կոդում:
 
-- *Function Declaration:* a function, declared as a separate statement, in the main code flow:
+- *Ֆունկցիոնալ Հռչակագիր (Function Declaration)*. ֆունկցիա՝ հայտարարված որպես առանձին դրույթ (statement) հիմնական կոդի հոսքում:
 
     ```js
-    // Function Declaration
+    // Ֆունկցիոնալ Հռչակագիր
     function sum(a, b) {
       return a + b;
     }
     ```
-- *Function Expression:* a function, created inside an expression or inside another syntax construct. Here, the function is created on the right side of the "assignment expression" `=`:
+- *Ֆունկցիոնալ Արտահայտություն (Function Expression)*. ֆունկցիա՝ ստեղծված արտահայտության կամ մեկ այլ շարահյուսական կառուցվածքի ներսում: Այստեղ ֆունկցիան ստեղծվում է «վերագրման արտահայտության» `=` աջ կողմում.
 
     ```js
-    // Function Expression
+    // Ֆունկցիոնալ Արտահայտություն
     let sum = function(a, b) {
       return a + b;
     };
     ```
 
-The more subtle difference is *when* a function is created by the JavaScript engine.
+Ավելի նուրբ տարբերությունն այն է, թե *երբ* է ֆունկցիան ստեղծվում JavaScript շարժիչի կողմից:
 
-**A Function Expression is created when the execution reaches it and is usable only from that moment.**
+**Ֆունկցիոնալ Արտահայտությունը ստեղծվում է, երբ կատարումը հասնում է դրան և կիրառելի է միայն այդ պահից:**
 
-Once the execution flow passes to the right side of the assignment `let sum = function…` -- here we go, the function is created and can be used (assigned, called, etc. ) from now on.
+Երբ կատարման հոսքն անցնում է վերագրման աջ կողմ `let sum = function…`, այդ պահից սկսած ֆունկցիան համարվում է ստեղծված և կարող է օգտագործվել (վերագրվել, կանչվել, և այլն․․․):
 
-Function Declarations are different.
+Ֆունկցիոնալ Հռչակագրերը տարբեր են:
 
-**A Function Declaration can be called earlier than it is defined.**
+**Ֆունկցիոնալ Հռչակագիրը կարող է կանչվել ավելի վաղ, քան այն սահմանվել է:**
 
-For example, a global Function Declaration is visible in the whole script, no matter where it is.
+Օրինակ՝ գլոբալ Ֆունկցիոնալ Հռչակագիրը հասանելի է ամբողջ սքրիփթում, անկախ նրանից, թե որտեղ է այն գտնվում:
 
-That's due to internal algorithms. When JavaScript prepares to run the script, it first looks for global Function Declarations in it and creates the functions. We can think of it as an "initialization stage".
+Դա պայմանավորված է ներքին ալգորիթմներով: Երբ JavaScript-ը պատրաստվում է գործարկել սքրիփթը, այն նախ որոնում է գլոբալ Ֆունկցիոնալ Հռչակագրեր դրանում և ստեղծում ֆունկցիաներ: Մենք կարող ենք դա համարել որպես «նախաձեռնման փուլ»:
 
-And after all Function Declarations are processed, the code is executed. So it has access to these functions.
+ԵՎ այն բանից հետո, երբ բոլոր Ֆունկցիոնալ Հռչակագրերը մշակվել են, կոդը կատարվում է: Այսպիսով, այն ունի հասանելիություն այս ֆունկցիաներին:
 
-For example, this works:
+Օրինակի համար սա աշխատում է.
 
 ```js run refresh untrusted
 *!*
-sayHi("John"); // Hello, John
+sayHi("Պողոս"); // Ողջույն Պողոս
 */!*
 
 function sayHi(name) {
-  alert( `Hello, ${name}` );
+  alert( `Ողջույն ${name}` );
 }
 ```
 
-The Function Declaration `sayHi` is created when JavaScript is preparing to start the script and is visible everywhere in it.
+Ֆունկցիոնալ Հռչակագիրը `sayHi` ստեղծվում է, երբ JavaScript-ը պատրաստվում է սկսել սքրիփթը և դրա մեջ ամենուր տեսանելի է այդ ֆունկցիան:
 
-...If it were a Function Expression, then it wouldn't work:
+...Եթե դա լիներ Ֆունկցիոնալ Արտահայտություն, ապա այն չէր աշխատի.
 
 ```js run refresh untrusted
 *!*
-sayHi("John"); // error!
+sayHi("Պողոս"); // սխալ
 */!*
 
-let sayHi = function(name) {  // (*) no magic any more
-  alert( `Hello, ${name}` );
+let sayHi = function(name) {  // (*) այլևս ոչ մի կախարդանք
+  alert( `Ողջույն ${name}` );
 };
 ```
 
-Function Expressions are created when the execution reaches them. That would happen only in the line `(*)`. Too late.
+Ֆունկցիոնալ Արտահայտությունները ստեղծվում են, երբ կատարումը հասնում է դրանց: Դա տեղի կունենա միայն `(*)` տողում։ Չափազանց ուշ։
 
-Another special feature of Function Declarations is their block scope.
+Ֆունկցիոնալ Արտահայտությունների մեկ այլ առանձնահատկություն է դրանց բլոկային տեսադաշտը։
 
-**In strict mode, when a Function Declaration is within a code block, it's visible everywhere inside that block. But not outside of it.**
+**Խիստ ռեժիմում, երբ Ֆունկցիոնալ Հռչակագիրը գտնվում է կոդի բլոկի ներսում, այն տեսանելի է ամենուր՝ այդ բլոկի ներսում, բայց ոչ՝ դրանից դուրս:**
 
-For instance, let's imagine that we need to declare a function `welcome()` depending on the `age` variable that we get during runtime. And then we plan to use it some time later.
+Օրինակի համար եկեք պատկերացնենք, որ մենք պետք է հռչակենք `welcome()` ֆունկցիան՝ կախված `age` փոփոխականից, որը մենք ստանում ենք գործարկման ընթացքում: Եվ հետո մենք պլանավորում ենք օգտագործել այն որոշ ժամանակ անց:
 
-If we use Function Declaration, it won't work as intended:
+Եթե մենք օգտագործում ենք Ֆունկցիոնալ Հռչակագիր, այն չի աշխատի այնպես, ինչպես նախատեսված էր.
 
 ```js run
-let age = prompt("What is your age?", 18);
+let age = prompt("Քանի՞ տարեկան եք:", 18);
 
-// conditionally declare a function
+// պայմանականորեն հռչակել ֆունկցիա
 if (age < 18) {
 
   function welcome() {
-    alert("Hello!");
+    alert("Ողջույն");
   }
 
 } else {
 
   function welcome() {
-    alert("Greetings!");
+    alert("Ողջույններ");
   }
 
 }
 
-// ...use it later
+// ...օգտագործել ավելի ուշ
 *!*
-welcome(); // Error: welcome is not defined
+welcome(); // սխալ` welcome is not defined
 */!*
 ```
 
-That's because a Function Declaration is only visible inside the code block in which it resides.
+Դա պայմանավորված է նրանով, որ Ֆունկցիոնալ Հռչակագիրը տեսանելի է միայն այն կոդի բլոկի ներսում, որտեղ այն գտնվում է:
 
-Here's another example:
+Ահա ևս մեկ օրինակ.
 
 ```js run
-let age = 16; // take 16 as an example
+let age = 16; // օրինակի համար վերցրեք 16
 
 if (age < 18) {
 *!*
-  welcome();               // \   (runs)
+  welcome();                // \   (գործարկվում է)
 */!*
-                           //  |
-  function welcome() {     //  |
-    alert("Hello!");       //  |  Function Declaration is available
-  }                        //  |  everywhere in the block where it's declared
-                           //  |
+                            //  |
+  function welcome() {      //  |
+    alert("Ողջույն");       //  |  Ֆունկցիոնալ Հռչակագիրը հասանելի է
+  }                         //  |  ամենուր՝ բլոկում, որտեղ այն հայտարարված է
+                            //  |
 *!*
-  welcome();               // /   (runs)
+  welcome();                // /   (գործարկվում է)
 */!*
 
 } else {
 
-  function welcome() {
-    alert("Greetings!");
+  function welcome() {    
+    alert("Ողջույններ");
   }
 }
 
-// Here we're out of curly braces,
-// so we can not see Function Declarations made inside of them.
+// Այստեղ մենք ձևավոր փակագծերից դուրս ենք,
+// այնպես որ մենք չենք կարող տեսնել դրանց ներսում ստեղծված Ֆունկցիոնալ Հռչակագրերը:
 
 *!*
-welcome(); // Error: welcome is not defined
+welcome(); // սխալ՝ welcome is not defined
 */!*
 ```
 
-What can we do to make `welcome` visible outside of `if`?
+Ի՞նչ կարող ենք անել, որպեսզի `welcome`-ը դարձնենք տեսանելի `if`-ից դուրս:
 
-The correct approach would be to use a Function Expression and assign `welcome` to the variable that is declared outside of `if` and has the proper visibility.
+Ճիշտ մոտեցումը կլինի՝ օգտագործել Ֆունկցիոնալ Արտահայտություն և վերագրել `welcome`-ը փոփոխականի, որը հռչակված է `if`-ից դուրս և ունի համապատասխան տեսանելիություն:
 
-This code works as intended:
+Այս կոդը աշխատում է այնպես, ինչպես նախատեսված է.
 
 ```js run
-let age = prompt("What is your age?", 18);
+let age = prompt("Քանի՞ տարեկան եք:", 18);
 
 let welcome;
 
 if (age < 18) {
 
   welcome = function() {
-    alert("Hello!");
+    alert("Ողջույն");
   };
 
 } else {
 
   welcome = function() {
-    alert("Greetings!");
+    alert("Ողջույններ");
   };
 
 }
 
 *!*
-welcome(); // ok now
+welcome(); // այժմ նորմալ է
 */!*
 ```
 
-Or we could simplify it even further using a question mark operator `?`:
+Կամ մենք կարող ենք այն էլ ավելի պարզեցնել՝ օգտագործելով `?` հարցական նշանի օպերատոր.
 
 ```js run
-let age = prompt("What is your age?", 18);
+let age = prompt("Քանի՞ տարեկան եք:", 18);
 
 let welcome = (age < 18) ?
-  function() { alert("Hello!"); } :
-  function() { alert("Greetings!"); };
+  function() { alert("Ողջույն"); } :
+  function() { alert("Ողջույններ"); };
 
 *!*
-welcome(); // ok now
+welcome(); // այժմ նորմալ է
 */!*
 ```
 
 
-```smart header="When to choose Function Declaration versus Function Expression?"
-As a rule of thumb, when we need to declare a function, the first thing to consider is Function Declaration syntax. It gives more freedom in how to organize our code, because we can call such functions before they are declared.
+```smart header="Ե՞րբ օգտագործել Ֆունկցիոնալ Հռչակագիր, երբ՝ Ֆունկցիոնալ Արտահայտություն:"
+Որպես հիմնական կանոն, երբ մենք պետք է հայտարարենք ֆունկցիա, առաջին հերթին պետք է հաշվի առնել Ֆունկցիոնալ Հռչակագրի շարահուսությունը: Այն ավելի շատ ազատություն է տալիս այն հարցում, թի ինչպես կազմակերպենք մեր կոդը, քանի որ մենք կարող ենք կանչել այդպիսի ֆունկցիաները նախքան նրանց հռչակումը:
 
-That's also better for readability, as it's easier to look up `function f(…) {…}` in the code than `let f = function(…) {…};`. Function Declarations are more "eye-catching".
+Դա նաև ավելի ընթեռնելի է, քանի որ ավելի հեշտ է փնտրել `function f(…) {…}` կոդում, քան՝ `let f = function(…) {…};`: Ֆունկցիոնալ Հռչակագրերն ավելի «գրավիչ են աչքի համար»:
 
-...But if a Function Declaration does not suit us for some reason, or we need a conditional declaration (we've just seen an example), then Function Expression should be used.
+...Բայց եթե Ֆունկցիոնալ Հռչակագիրն ինչ-ինչ պատճառներով մեզ չի համապատասխանում, կամ մեզ անհրաժեշտ է պայմանական հայտարարագիր (մենք հենց նոր տեսանք օրինակը), ապա պետք է օգտագործվի Ֆունկցիոնալ Արտահայտություն:
 ```
 
-## Summary
+## Ամփոփում
 
-- Functions are values. They can be assigned, copied or declared in any place of the code.
-- If the function is declared as a separate statement in the main code flow, that's called a "Function Declaration".
-- If the function is created as a part of an expression, it's called a "Function Expression".
-- Function Declarations are processed before the code block is executed. They are visible everywhere in the block.
-- Function Expressions are created when the execution flow reaches them.
+- Ֆունկցիաներն արժեքներ են: Դրանք կարող են վերագրվել, պատճենվել կամ հռչակվել կոդի ցանկացած վայրում:
+- Եթե հիմնական կոդի հոսքում ֆունկցիան հռչակվում է որպես առանձին դրույթ, դա կոչվում է «Ֆունկցիոնալ Հռչակագիր» (Function Declaration):
+- Եթե ֆունկցիան ստեղծվում է որպես արտահայտության մաս, այն կոչվում է «Ֆունկցիոնալ Արտահայտություն» (Function Expression):
+- Ֆունկցիոնալ Հռչակագրերը մշակվում են նախքան կոդի բլոկի գործարկումը: Դրանք բլոկում տեսանելի են ամենուր:
+- Ֆունկցիոնալ Արտահայտությունները ստեղծվում են, երբ կատարողական հոսքը հասնում է դրանց:
 
-In most cases when we need to declare a function, a Function Declaration is preferable, because it is visible prior to the declaration itself. That gives us more flexibility in code organization, and is usually more readable.
+Շատ դեպքերում, երբ մենք պետք է հռչակենք ֆունկցիա, գերադասելի է Ֆունկցիոնալ Հռչակագիր, քանի որ այն տեսանելի է նախքան իր հռչակումը: Դա մեզ ավելի շատ ճկունություն է տալիս կոդի կազմակերպման հարցում և սովորաբար ավելի ընթեռնելի է:
 
-So we should use a Function Expression only when a Function Declaration is not fit for the task. We've seen a couple of examples of that in this chapter, and will see more in the future.
+Այսպիսով, մենք պետք է օգտագործենք Ֆունկցիոնալ Արտահայտություն միայն այն դեպքում, երբ Ֆունկցիոնալ Հռչակագիրը հարմար չէ առաջադրանքի համար: Մենք տեսել ենք դրա մի քանի օրինակ այս գլխում և ավելին կտեսնենք հետագայում:
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
index 041db18bc..a536e4b5f 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/solution.md
@@ -6,12 +6,12 @@ function ask(question, yes, no) {
 }
 
 ask(
-  "Do you agree?",
+  "Դուք համաձա՞յն եք:",
 *!*
-  () => alert("You agreed."),
-  () => alert("You canceled the execution.")
+  () => alert("Դուք համաձայնեցիք:"),
+  () => alert("Դուք չեղարկեցիք կատարումը:")
 */!*
 );
 ```
 
-Looks short and clean, right?
+Հակիրճ և պարզ տեսք ունի, այդպես չէ՞:
diff --git a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
index e18c08a83..af4dd3ce2 100644
--- a/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
+++ b/1-js/02-first-steps/17-arrow-functions-basics/1-rewrite-arrow/task.md
@@ -1,7 +1,7 @@
 
-# Rewrite with arrow functions
+# Դարձնել սլաքով ֆունկցիաներ
 
-Replace Function Expressions with arrow functions in the code below:
+Ստորև կոդում սովորական ֆունկցիաները (Function Expressions) փոխարինել՝ դարձնելով սլաքով ֆունկցիաներ․
 
 ```js run
 function ask(question, yes, no) {
@@ -10,8 +10,8 @@ function ask(question, yes, no) {
 }
 
 ask(
-  "Do you agree?",
-  function() { alert("You agreed."); },
-  function() { alert("You canceled the execution."); }
+  "Դուք համաձա՞յն եք:",
+  function() { alert("Դուք համաձայնեցիք:"); },
+  function() { alert("Դուք չեղարկեցիք կատարումը:"); }
 );
 ```
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 50c0d475d..2f51021da 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,16 +1,16 @@
-# Arrow functions, the basics
+# Սլաքով ֆունկցիաներ. հիմունքներ
 
-There's another very simple and concise syntax for creating functions, that's often better than Function Expressions.
+Կա ևս մեկ շատ պարզ ու հակիրճ շարահյուսություն ֆունկցիաներ ստեղծելու համար, որը հաճախ ավելի հարմար է, քան Ֆունկցիոնալ Արտահայտությունը (Function Expression):
 
-It's called "arrow functions", because it looks like this:
+Այն կոչվում է «սլաքով ֆունկցիաներ» (arrow functions), քանի որ ունի հետևյալ տեսքը.
 
 ```js
 let func = (arg1, arg2, ..., argN) => expression;
 ```
 
-This creates a function `func` that accepts arguments `arg1..argN`, then evaluates the `expression` on the right side with their use and returns its result.
+Սա ստեղծում է ֆունկցիա `func`, որն ընդունում է `arg1..argN` արգումենտները, այնուհետև դրանց կիրառմամբ աջ կողմում արժևորում է `expression`-ը և վերադարձնում արդյունք։
 
-In other words, it's the shorter version of:
+Այլ կերպ ասած՝ սա կրճատ տարբերակն է ստորև գրելաձևի.
 
 ```js
 let func = function(arg1, arg2, ..., argN) {
@@ -18,12 +18,12 @@ let func = function(arg1, arg2, ..., argN) {
 };
 ```
 
-Let's see a concrete example:
+Եկեք տեսնենք հստակ օրինակ:
 
 ```js run
 let sum = (a, b) => a + b;
 
-/* This arrow function is a shorter form of:
+/* Այս սլաքով ֆունկցիան ավելի կրճատ է, քան․
 
 let sum = function(a, b) {
   return a + b;
@@ -33,79 +33,79 @@ let sum = function(a, b) {
 alert( sum(1, 2) ); // 3
 ```
 
-As you can see, `(a, b) => a + b` means a function that accepts two arguments named `a` and `b`. Upon the execution, it evaluates the expression `a + b` and returns the result.
+Ինչպես տեսնում եք, `(a, b) => a + b` նշանակում է ֆունկցիա, որն ընդունում է երկու արգումենտ՝ `a` և `b` անվանումներով. Կատարման ժամանակ այն արժևորում է `a + b` արտահայտությունը և վերադարձնում արդյունք։
 
-- If we have only one argument, then parentheses around parameters can be omitted, making that even shorter.
+- Եթե ունենք միայն մեկ արգումենտ, ապա կոր փակագծերը արգումենտի շուրջ կարելի է չնշել՝ կրճատելով գրելաձևը․
 
-    For example:
+    Օրինակ.
 
     ```js run
     *!*
     let double = n => n * 2;
-    // roughly the same as: let double = function(n) { return n * 2 }
+    // նույնն է, ինչ․ let double = function(n) { return n * 2 }
     */!*
 
     alert( double(3) ); // 6
     ```
 
-- If there are no arguments, parentheses are empty, but they must be present:
+- Եթե արգումենտներ չկան, կոր փակագծերը դատարկ են, բայց դրանք պետք է առկա լինեն․
 
     ```js run
-    let sayHi = () => alert("Hello!");
+    let sayHi = () => alert("Ողջույն");
 
     sayHi();
     ```
 
-Arrow functions can be used in the same way as Function Expressions.
+Սլաքով ֆունկցիաները կարող են օգտագործվել նույն կերպ, ինչպես Ֆունկցիոնալ Արտահայտությունները։
 
-For instance, to dynamically create a function:
+Օրինակ՝ դինամիկ կերպով ֆունկցիա ստեղծելու համար․
 
 ```js run
-let age = prompt("What is your age?", 18);
+let age = prompt("Քանի՞ տարեկան եք:", 18);
 
 let welcome = (age < 18) ?
-  () => alert('Hello!') :
-  () => alert("Greetings!");
+  () => alert('Ողջույն') :
+  () => alert("Ողջույններ");
 
 welcome();
 ```
 
-Arrow functions may appear unfamiliar and not very readable at first, but that quickly changes as the eyes get used to the structure.
+Սլաքով ֆունկցիաները սկզբից կարող են անսովոր և ոչ այդքան հեշտ ընթերցվող թվալ, բայց դա արագ փոխվում է, երբ աչքերը սովորում են կառուցվածքին:
 
-They are very convenient for simple one-line actions, when we're just too lazy to write many words.
+Դրանք շատ հարմար են, պարզ՝ մի տողանի գործողությունների համար, երբ կզլանանք գրել ավելի շատ բառեր։
 
-## Multiline arrow functions
+## Բազմատողանի սլաքով ֆունկցիաներ
 
-The arrow functions that we've seen so far were very simple. They took arguments from the left of `=>`, evaluated and returned the right-side expression with them.
+Սլաքով ֆունկցիաները, որոնք մենք տեսանք մինչ այս, շատ պարզ էին։ Նրանք ստանում էին արգումենտներ `=>`-ի ձախ կողմում, արժևորում և դրանցով վերադարձնում էին արտահայտությունն աջ կողմում:
 
-Sometimes we need a more complex function, with multiple expressions and statements. In that case, we can enclose them in curly braces. The major difference is that curly braces require a `return` within them to return a value (just like a regular function does).
+Երբեմն մեզ պետք է լինում ավելի բարդ ֆունկցիա՝ մի քանի արտահայտություններով և դրույթներով։ Այդ դեպքում կարող ենք դրանք վերցնել ձևավոր փակագծերի մեջ: Հիմնական տարբերությունը նրանում է, որ ձևավոր փակագծերի ժամանակ պատասխան վերադարձնելու համար անհրաժեշտ է օգտագործել `return` դրանց ներսում (ինչպես սովորական ֆունկցիաներում)։
 
-Like this:
+Այսպես․
 
 ```js run
-let sum = (a, b) => {  // the curly brace opens a multiline function
+let sum = (a, b) => {  // ձևավոր փակագիծը բացում է բազմատողանի ֆունկցիան
   let result = a + b;
 *!*
-  return result; // if we use curly braces, then we need an explicit "return"
+  return result; // եթե օգտագործում ենք ձևավոր փակագծեր, ապա անհրաժեշտ է հստակ նշել «return»
 */!*
 };
 
 alert( sum(1, 2) ); // 3
 ```
 
-```smart header="More to come"
-Here we praised arrow functions for brevity. But that's not all!
+```smart header="Սպասվում է ավելին"
+Այստեղ գովեցինք սլաքով ֆունկցիաները հակիրճ լինելու համար։ Բայց սա դեռ ամենը չէ։
 
-Arrow functions have other interesting features.
+Սլաքով ֆունկցիաներն ունեն նաև այլ հետաքրքիր առանձնահատկություններ:
 
-To study them in-depth, we first need to get to know some other aspects of JavaScript, so we'll return to arrow functions later in the chapter <info:arrow-functions>.
+Դրանց խորը ուսումնասիրման համար մեզ առաջին հերթին պետք է ծանոթանալ JavaScript-ի որոշ այլ հայեցակետերի հետ, այնպես որ մենք կվերադառնանք սլաքով ֆունկցիաներին ավելի ուշ՝ <info:arrow-functions> գլխում:
 
-For now, we can already use arrow functions for one-line actions and callbacks.
+Առայժմ մենք կարող ենք օգտագործել սլաքով ֆունկցիաները մեկ տողանի գործողությունների և հետկանչերի (callback) համար:
 ```
 
-## Summary
+## Ամփոփում
 
-Arrow functions are handy for simple actions, especially for one-liners. They come in two flavors:
+Սլաքով ֆունկցիաները հարմար են պարզ գործողությունների համար, հատկապես՝ մեկ տողանի։ Դրանք լինում են երկու տեսակի.
 
-1. Without curly braces: `(...args) => expression` -- the right side is an expression: the function evaluates it and returns the result. Parentheses can be omitted, if there's only a single argument, e.g. `n => n*2`.
-2. With curly braces: `(...args) => { body }` -- brackets allow us to write multiple statements inside the function, but we need an explicit `return` to return something.
+1. Առանց ձևավոր փակագծերի՝ `(...args) => expression`, աջ կողմում արտահայտությունն է. ֆունկցիան արժեվորում է այն և վերադարձնում արդյունքը: Կոր փակագծերը կարելի է նաև չնշել, եթե առկա է միայն մեկ արգումենտ, օր․՝ `n => n*2`։
+2. Ձևավոր փակագծերով՝ `(...args) => { body }`, փակագծերը թույլ են տալիս գրել մի քանի դրույթ ֆունկցիայի ներսում, բայց պատասխան վերադարձնելու համար անհրաժեշտ է հստակ նշել `return`:
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 e7ddacac4..9646443c1 100644
--- a/1-js/02-first-steps/18-javascript-specials/article.md
+++ b/1-js/02-first-steps/18-javascript-specials/article.md
@@ -1,51 +1,51 @@
-# JavaScript specials
+# JavaScript-ի հատկանիշները
 
-This chapter briefly recaps the features of JavaScript that we've learned by now, paying special attention to subtle moments.
+Այս գլխում՝ հատուկ ուշադրություն դարձնելով նրբություններին, հակիրճ կամփոփենք JavaScript-ի այն առանձնահատկությունները, որոնք ուսումնասիրել ենք մինչ այս:
 
-## Code structure
+## Կոդի կառուցվածք
 
-Statements are delimited with a semicolon:
+Դրույթները տարանջատվում են կետ-ստորակետով.
 
 ```js run no-beautify
-alert('Hello'); alert('World');
+alert('Ողջույն'); alert('Աշխարհ');
 ```
 
-Usually, a line-break is also treated as a delimiter, so that would also work:
+Սովորաբար տողադարձը նույնպես դիտվում է որպես տարանջատիչ և սա նույնպես կաշխատի.
 
 ```js run no-beautify
-alert('Hello')
-alert('World')
+alert('Ողջույն')
+alert('Աշխարհ')
 ```
 
-That's called "automatic semicolon insertion". Sometimes it doesn't work, for instance:
+Դա կոչվում է «կետ-ստորակետի ավտոմատ տեղադրում»։ Երբեմն այն չի աշխատում, օրինակ.
 
 ```js run
-alert("There will be an error after this message")
+alert("Այս հաղորդագրությունից հետո սխալ կլինի:")
 
 [1, 2].forEach(alert)
 ```
 
-Most codestyle guides agree that we should put a semicolon after each statement.
+Կոդի գրելաձևին և ոճին վերաբերվող ուղեցույցների մեծ մասը խորհուրդ են տալիս, որ մենք պետք է կետ-ստորակետ դնենք յուրաքանչյուր դրույթից հետո:
 
-Semicolons are not required after code blocks `{...}` and syntax constructs with them like loops:
+Կոդի բլոկներից `{...}` և դրանցով կառուցված շարահյուսական կոնստրուկցիաներից հետո կետ-ստորակետեր չեն պահանջվում՝ ինչպես ցիկլում է.
 
 ```js
 function f() {
-  // no semicolon needed after function declaration
+  // կետ-ստորակետ պետք չէ ֆունկցիոնալ հռչակագրից հետո
 }
 
 for(;;) {
-  // no semicolon needed after the loop
+  // կետ-ստորակետ պետք չէ ցիկլից հետո
 }
 ```
 
-...But even if we can put an "extra" semicolon somewhere, that's not an error. It will be ignored.
+...Սակայն, եթե մենք «ավելորդ» կետ-ստորակետ դնենք, սխալ չի լինի։ Այն պարզապես կանտեսվի:
 
-More in: <info:structure>.
+Մանրամասն՝ <info:structure>.
 
-## Strict mode
+## Խիստ ռեժիմ
 
-To fully enable all features of modern JavaScript, we should start scripts with `"use strict"`.
+Ժամանակակից JavaScript-ի բոլոր առանձնահատկություններն ակտիվացնելու համար կոդի սկզբում հարկավոր է նշել `"use strict"`։
 
 ```js
 'use strict';
@@ -53,132 +53,132 @@ To fully enable all features of modern JavaScript, we should start scripts with
 ...
 ```
 
-The directive must be at the top of a script or at the beginning of a function body.
+Այդ ցուցումը պետք է լինի սքրիփթի սկզբում կամ ֆունկցիայի մարմնի սկզբում:
 
-Without `"use strict"`, everything still works, but some features behave in the old-fashioned, "compatible" way. We'd generally prefer the modern behavior.
+Առանց `"use strict"` օգտագործելու ամեն ինչ կաշխատի, բայց որոշ առանձնահատկությունների վարքագիծը կլինի հնաոճ ձևի հետ «համատեղելի» եղանակով։ Ընդհանուր առմամբ մենք նախընտրում ենք ժամանակակից վարքագիծը:
 
-Some modern features of the language (like classes that we'll study in the future) enable strict mode implicitly.
+Լեզվի որոշ ժամանակակից առանձնահատկություններ (օրինակ՝ կլասները, որոնք կսովորենք հետագայում) անուղղակիորեն ակտիվացնում են խիստ ռեժիմը։
 
-More in: <info:strict-mode>.
+Ավելին՝ <info:strict-mode>։
 
-## Variables
+## Փոփոխականներ
 
-Can be declared using:
+Կարող են հռչակվել՝ օգտագործելով․
 
 - `let`
-- `const` (constant, can't be changed)
-- `var` (old-style, will see later)
+- `const` (հաստատուն, չի կարող փոփոխվել)
+- `var` (հին ոճ, կդիտարկենք ավելի ուշ)
 
-A variable name can include:
-- Letters and digits, but the first character may not be a digit.
-- Characters `$` and `_` are normal, on par with letters.
-- Non-Latin alphabets and hieroglyphs are also allowed, but commonly not used.
+Փոփոխականի անվանումը կարող է պարունակել․
+- Տառեր և թվեր, բայց առաջին նիշը չի կարող լինել թիվ:
+- `$` և `_` նիշերը նորմալ են, համարժեք են տառերին։
+- Թույլատրվում են նաև ոչ լատինական այբուբեններ և հիերոգլիֆներ, բայց սովորաբար չեն օգտագործվում:
 
-Variables are dynamically typed. They can store any value:
+Փոփոխականները տիպավորվում են դինամիկ կերպով և կարող են պահել ցանկացած արժեք.
 
 ```js
 let x = 5;
-x = "John";
+x = "Պողոս";
 ```
 
-There are 8 data types:
+Տվյալների 8 տիպեր կան.
 
-- `number` for both floating-point and integer numbers,
-- `bigint` for integer numbers of arbitrary length,
-- `string` for strings,
-- `boolean` for logical values: `true/false`,
-- `null` -- a type with a single value `null`, meaning "empty" or "does not exist",
-- `undefined` -- a type with a single value `undefined`, meaning "not assigned",
-- `object` and `symbol` -- for complex data structures and unique identifiers, we haven't learnt them yet.
+- `number` ինչպես կոտորակային, այնպես էլ ամբողջ թվերի համար,
+- `bigint` կամայական երկարություն ունեցող ամբողջ թվերի համար,
+- `string` տողերի համար,
+- `boolean` տրամաբանական արժեքների համար՝ `true/false`,
+- `null` մեկ արժեք ունեցող տեսակ՝ `null`, նշանակում է «դատարկ» կամ «գոյություն չունեցող»,
+- `undefined` մեկ արժեք ունեցող տեսակ՝ `undefined`, նշանակում է «չսահմանված»,
+- `object` և `symbol` բարդ տվյալների կառուցվածքների և ունիկալ նույնականացուցիչների համար. մենք դեռ չենք սովորել դրանք։
 
-The `typeof` operator returns the type for a value, with two exceptions:
+`typeof` օպերատորը վերադարձնում է արժեքի տեսակը երկու բացառությամբ.
 ```js
-typeof null == "object" // error in the language
-typeof function(){} == "function" // functions are treated specially
+typeof null == "object" // սխալ լեզվում
+typeof function(){} == "function" // ֆունկցիաները մշակվում են առանձնահատուկ կերպով
 ```
 
-More in: <info:variables> and <info:types>.
+Ավելին՝ <info:variables> և <info:types>։
 
-## Interaction
+## Փոխազդեցություն
 
-We're using a browser as a working environment, so basic UI functions will be:
+Մենք բրաուզերն ենք օգտագործում որպես աշխատանքային միջավայր, ուստի UI-ի (օգտատիրոջ ինտերֆեյս) հիմնական ֆունկցիաները կլինեն.
 
 [`prompt(question, [default])`](https://developer.mozilla.org/en-US/docs/Web/API/Window/prompt)
-: Ask a `question`, and return either what the visitor entered or `null` if they clicked "cancel".
+: Հարց է տալիս `question`, այնուհետև վերադարձնում է այն, ինչ մուտքագրել է այցելուն կամ `null`, եթե այցելուն սեղմել է «Cancel»:
 
 [`confirm(question)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/confirm)
-: Ask a `question` and suggest to choose between Ok and Cancel. The choice is returned as `true/false`.
+: Հարց է տալիս `question` և առաջարկում ընտրություն կատարել՝ «Ok» կամ «Cancel». Ընտրությունը վերադարձվում է որպես `true/false`։
 
 [`alert(message)`](https://developer.mozilla.org/en-US/docs/Web/API/Window/alert)
-: Output a `message`.
+: Արտատպում է հաղորդագրություն `message`։
 
-All these functions are *modal*, they pause the code execution and prevent the visitor from interacting with the page until they answer.
+Բոլոր այս ֆունկցիաները *modal* են, նրանք դադարեցնում են կոդի գործարկումը և թույլ չեն տալիս այցելուներին փոխազդեցություն ունենալ էջի հետ, մինչև նրանք «չպատասխանեն»։
 
-For instance:
+Օրինակ.
 
 ```js run
-let userName = prompt("Your name?", "Alice");
-let isTeaWanted = confirm("Do you want some tea?");
+let userName = prompt("Ձեր անո՞ւնը:", "Ալիսա");
+let isTeaWanted = confirm("Թեյ կցանկանա՞ք:");
 
-alert( "Visitor: " + userName ); // Alice
-alert( "Tea wanted: " + isTeaWanted ); // true
+alert( "Այցելու՝ " + userName ); // Ալիսա
+alert( "Թեյ ուզեց՝ " + isTeaWanted ); // true
 ```
 
-More in: <info:alert-prompt-confirm>.
+Ավելին՝ <info:alert-prompt-confirm>։
 
-## Operators
+## Օպերատորներ
 
-JavaScript supports the following operators:
+JavaScript-ը սպասարկում է հետևյալ օպերատորները.
 
-Arithmetical
-: Regular: `* + - /`, also `%` for the remainder and `**` for power of a number.
+Թվաբանական
+: Կանոնավոր՝ `* + - /`, նաև `%` մնացորդի համար և `**` աստիճան բարձրացնելու համար։
 
-    The binary plus `+` concatenates strings. And if any of the operands is a string, the other one is converted to string too:
+    Բինար գումարումը `+` միացնում է տողերը։ ԵՎ եթե օպերանդներից մեկը տող է, մյուսը նույնպես փոխակերպվում է տողի․
 
     ```js run
-    alert( '1' + 2 ); // '12', string
-    alert( 1 + '2' ); // '12', string
+    alert( '1' + 2 ); // '12', տող
+    alert( 1 + '2' ); // '12', տող
     ```
 
-Assignments
-: There is a simple assignment: `a = b` and combined ones like `a *= 2`.
+Վերագրում
+: Կա պարզ վերագրում՝ `a = b`, և համակցված վերագրում՝ `a *= 2`։
 
-Bitwise
-: Bitwise operators work with 32-bit integers at the lowest, bit-level: see the [docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators) when they are needed.
+Բիթային
+: Բիթային օպերատորները աշխատում են 32-բիթ ամբողջ թվերի հետ ամենացածր՝ բիթային մակարդակում. տեսեք [դոկումենտացիան](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#bitwise_operators)-ում, երբ դրա կարիքը լինի:
 
-Conditional
-: The only operator with three parameters: `cond ? resultA : resultB`. If `cond` is truthy, returns `resultA`, otherwise `resultB`.
+Պայմանական
+: Միակ օպերատորը երեք պարամետրով՝ `cond ? resultA : resultB`։ Եթե `cond` պայմանը ճշմարիտ է, վերադարձվում է `resultA`, հակառակ դեպքում՝ `resultB`։
 
-Logical operators
-: Logical AND `&&` and OR `||` perform short-circuit evaluation and then return the value where it stopped (not necessary `true`/`false`). Logical NOT `!` converts the operand to boolean type and returns the inverse value.
+Տրամաբանական օպերատորներ
+: Տրամաբանական ԵՎ `&&` ու ԿԱՄ `||` օպերատորները իրականացնում են «կարճ միացման» արժեվորում, այնուհետև վերադարձնում են արժեք՝ որտեղ կանգ են առել (պարտադիր չէ `true`/`false`). Տրամաբանական ՈՉ `!` վերածում է օպերանդը տրամաբանական տեսակի և վերադարձնում հակառակ արժեքը։
 
-Nullish coalescing operator
-: The `??` operator provides a way to choose a defined value from a list of variables. The result of `a ?? b` is `a` unless it's `null/undefined`, then `b`.
+Զրոյական միավորման օպերատոր
+: `??` օպերատորը փոփոխականների ցանկից հատկանշված արժեքի ընտրության հնարավորություն է տալիս: `a ?? b`-ի արդյունքը կլինի `a`, եթե այն `null/undefined` չէ, հակառակ դեպքում՝ `b`:
 
-Comparisons
-: Equality check `==` for values of different types converts them to a number (except `null` and `undefined` that equal each other and nothing else), so these are equal:
+Համեմատություններ
+: հավասարության ստուգումը `==` տարբեր տիպերի արժեքների դեպքում նրանց փոխակերպում է թվի (բացի `null` և `undefined` տիպերից, որոնք միայն իրար կարող են հավասար լինել), այսպիսով սրանք հավասար են.
 
     ```js run
     alert( 0 == false ); // true
     alert( 0 == '' ); // true
     ```
 
-    Other comparisons convert to a number as well.
+    Այլ համեմատությունները նույնպես արժեքները փոխակերպում են թվի:
 
-    The strict equality operator `===` doesn't do the conversion: different types always mean different values for it.
+    Խիստ հավասարության օպերատորը `===` չի կատարում փոխակերպում․ նրա համար տարբեր տիպերը միշտ ունեն տարբեր արժեքների նշանակություն։
 
-    Values `null` and `undefined` are special: they equal `==` each other and don't equal anything else.
+    `null` և `undefined` արժեքները հատուկ են․ նրանք հավասար են `==` իրար և ուրիշ ոչինչի հավասար չեն։
 
-    Greater/less comparisons compare strings character-by-character, other types are converted to a number.
+    Մեծ/փոքր համեմատությունները տողերին համեմատում են նիշ-առ-շիշ, մյուս տիպերը փոխակերպվում են թվի։
 
-Other operators
-: There are few others, like a comma operator.
+Այլ օպերատորներ
+: Կա մի քանի ալյ օպերատոր, օր․՝ ստորակետի օպերատորը։
 
-More in: <info:operators>, <info:comparison>, <info:logical-operators>, <info:nullish-coalescing-operator>.
+Ավելին՝ <info:operators>, <info:comparison>, <info:logical-operators>, <info:nullish-coalescing-operator>։
 
-## Loops
+## Ցիկլներ
 
-- We covered 3 types of loops:
+- Մենք դիտարկել ենք 3 տեսակի ցիկլ․
 
     ```js
     // 1
@@ -197,43 +197,43 @@ More in: <info:operators>, <info:comparison>, <info:logical-operators>, <info:nu
     }
     ```
 
-- The variable declared in `for(let...)` loop is visible only inside the loop. But we can also omit `let` and reuse an existing variable.
-- Directives `break/continue` allow to exit the whole loop/current iteration. Use labels to break nested loops.
+- `for(let...)` ցիկլում հռչակված փոփոխականը հասանելի է միայն ցիկլի ներսում։ Բայց մենք կարող ենք նաև բաց թողնել `let`-ը և կրկին օգտագործել արդեն իսկ գոյություն ունեցող փոփոխականը:
+- `break/continue` հրահանգները թույլ են տալիս դուրս գալ ամբողջ ցիկլից/ընթացիկ կրկնությունից: Օգտագործեք պիտակներ ներդրված ցիկլները կանգնեցնելու համար։
 
-Details in: <info:while-for>.
+Մանրամասն՝ <info:while-for>։
 
-Later we'll study more types of loops to deal with objects.
+Ավելի ուշ, օբյեկտների հետ աշխատելու համար մենք կուսումնասիրենք ցիկլների ավելի շատ տեսակներ:
 
-## The "switch" construct
+## Կոնստրուկցիա «switch»
 
-The "switch" construct can replace multiple `if` checks. It uses `===` (strict equality) for comparisons.
+«switch» կոնստրուկցիան կարող է փոխարինել մի քանի `if` ստուգումների. Համեմատությունների ժամանակ այն օգտագործում է `===` խիստ հավասարման օպերատորը։
 
-For instance:
+Օրինակ՝
 
 ```js run
-let age = prompt('Your age?', 18);
+let age = prompt('Ձեր տարի՞քը:', 18);
 
 switch (age) {
   case 18:
-    alert("Won't work"); // the result of prompt is a string, not a number
+    alert("Չի աշխատի"); // prompt-ի վերադարձրած արդյունքը տող է, թիվ չէ
     break;
 
   case "18":
-    alert("This works!");
+    alert("Սա կաշխատի");
     break;
 
   default:
-    alert("Any value not equal to one above");
+    alert("Վերոնշյալներին ոչ հավասար ցանկացած արժեք");
 }
 ```
 
-Details in: <info:switch>.
+Մանրամասն՝ <info:switch>։
 
-## Functions
+## Ֆունկցիաներ
 
-We covered three ways to create a function in JavaScript:
+Մենք դիտարկեցինք JavaScript-ում ֆունկցիաներ ստեղծելու երեք տարբերակ․
 
-1. Function Declaration: the function in the main code flow
+1. Ֆունկցիոնալ Հռչակագիր (Function Declaration). ֆունկցիան հիմնական կոդի հոսքում․
 
     ```js
     function sum(a, b) {
@@ -243,7 +243,7 @@ We covered three ways to create a function in JavaScript:
     }
     ```
 
-2. Function Expression: the function in the context of an expression
+2. Ֆունկցիոնալ Արտահայտություն (Function Expression). ֆունկցիան արտահայտության համատեքստում․
 
     ```js
     let sum = function(a, b) {
@@ -253,32 +253,32 @@ We covered three ways to create a function in JavaScript:
     };
     ```
 
-3. Arrow functions:
+3. Սլաքով ֆունկցիաներ (arrow functions)․
 
     ```js
-    // expression on the right side
+    // արտահայտությունն աջ կողմում է
     let sum = (a, b) => a + b;
 
-    // or multi-line syntax with { ... }, need return here:
+    // կամ բազմատողանի շարահյուսություն ձևավոր փակագծերով { ... }, այստեղ return-ը անհրաժեշտ է
     let sum = (a, b) => {
       // ...
       return a + b;
     }
 
-    // without arguments
-    let sayHi = () => alert("Hello");
+    // առանց արգումենտների
+    let sayHi = () => alert("Ողջույն");
 
-    // with a single argument
+    // մեկ արգումենտով
     let double = n => n * 2;
     ```
 
 
-- Functions may have local variables: those declared inside its body or its parameter list. Such variables are only visible inside the function.
-- Parameters can have default values: `function sum(a = 1, b = 2) {...}`.
-- Functions always return something. If there's no `return` statement, then the result is `undefined`.
+- Ֆունկցիաները կարող են ունենալ տեղական (local) փոփոխականներ․ դրանք հայտարարվում են իրենց մարմնի ներսում կամ պարամետրերի ցանկում: Նման փոփոխականները հասանելի են միայն ֆունկցիայի ներսում:
+- Պարամետրերը կարող են ունենալ նախնական արժեք․ `function sum(a = 1, b = 2) {...}`։
+- Ֆունկցիաները միշտ ինչ-որ բան են վերադարձնում. եթե չկա `return` դրույթը, ապա արդյունքը `undefined` է։
 
-Details: see <info:function-basics>, <info:arrow-functions-basics>.
+Մանրամասն՝ <info:function-basics>, <info:arrow-functions-basics>։
 
-## More to come
+## Սպասվում է ավելին
 
-That was a brief list of JavaScript features. As of now we've studied only basics. Further in the tutorial you'll find more specials and advanced features of JavaScript.
+Սա JavaScript-ի առանձնահատկությունների համառոտ ցանկն էր: Այս պահի դրությամբ մենք ուսումնասիրել ենք միայն հիմունքները: Այս ձեռնարկում ավելի ուշ կգտնեք JavaScript-ի վերաբերյալ ավելի շատ հատկանիշներ և ընդլայնված առանձնահատկություններ։
diff --git a/README.md b/README.md
index 371793d6d..fd999bf65 100755
--- a/README.md
+++ b/README.md
@@ -1,16 +1,25 @@
-# The Modern JavaScript Tutorial
+# The Modern JavaScript Tutorial in Armenian
 
-This repository hosts the English content of the Modern JavaScript Tutorial, published at [https://javascript.info](https://javascript.info).
+This repository hosts the Armenian translation of the Modern JavaScript Tutorial, published in [https://javascript.info](https://javascript.info).
 
-## Translations
 
-We'd like to make the tutorial available in many languages. Please help us to translate.
+**That's how you can contribute:**
 
-See <https://javascript.info/translate> for the details.
+- See the [Armenian Translate Progress](https://github.com/javascript-tutorial/am.javascript.info/issues/1) issue.
+- Choose an unchecked article you'd like to translate.
+- Add a comment with the article title to the issue, e.g. `An Introduction to JavaScript`.
+    - Our bot will mark it in the issue, for everyone to know that you're translating it.
+    - Your comment should contain only the title.
+- Fork the repository, translate and send a PR when done.
+    - PR title should match article title, the bot will write it's number into the issue.
 
-## Contributions
+Please kindly allow maintainers to review and merge or request changes in your translation.
+   
+If maintainers do not respond, or if you'd like to become a maintainer, write us at the [main repo](https://github.com/javascript-tutorial/en.javascript.info/issues/new).
+    
+**Let others know what you're translating, in message boards or chats in your language. Invite them to join!**
 
-We'd also like to collaborate on the tutorial with other people.
+🎉 Thank you!
 
 Something's wrong? A topic is missing? Explain it to people, add it as PR 👏
 
@@ -24,16 +33,18 @@ Every chapter, article, or task has its folder.
 
 The folder is named like `N-url`, where `N` is a number for the sorting purposes and `URL` is the URL part with the title of the material.
 
-The type of the material is defined by the file inside the folder:
+The translated text is in `images.yml` file in the tutorial root.
 
-  - `index.md` stands for a chapter
-  - `article.md` stands for an article
-  - `task.md` stands for a task (solution must be provided in `solution.md` file as well)
+The file format is YAML:
+```yaml
+image.svg:        # image file
+  "hello world":  # English phrase
+    text: "Hola mundo"  # translation
+    position: "centre"  # "center" or "right", if needed to center or right-align the translation
+```
 
-Each of these files starts from the `# Main header`.
+## Running locally
 
-It's very easy to add something new.
+You can run the tutorial server locally to see how the translation looks.
 
----  
-♥  
-Ilya Kantor @iliakan
+The server and install instructions are at <https://github.com/javascript-tutorial/server>. 
diff --git a/images.yml b/images.yml
new file mode 100644
index 000000000..606cd628e
--- /dev/null
+++ b/images.yml
@@ -0,0 +1,15 @@
+# 1-js/02-first-steps/11-logical-operators/9-check-login/ifelse_task.svg
+ifelse_task.svg:
+  "_defaults":
+    position: "center"
+  "Begin": "Սկիզբ"
+  "Canceled": "Չեղարկված է"
+  "Welcome!": "Բարի գալուստ"
+  "I don't know you": "Չեմ ճանաչում քեզ"
+  "Wrong password": "Սխալ գաղտնաբառ"
+  "Who's there?": "Ո՞վ է"
+  "Password?": "Գաղտնաբա՞ռը"
+  "Cancel": "Չեղարկել"
+  "Admin": "Ադմին"
+  "TheMaster": "Գլխավոր"
+  "Other": "Ուրիշ"