From 2eb49e98414a75e5f2469c83fbfa781a3858c479 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Mon, 9 May 2022 03:36:18 +0400 Subject: [PATCH 01/12] Update article.md Part --- .../16-function-expressions/article.md | 116 +++++++++--------- 1 file changed, 58 insertions(+), 58 deletions(-) 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 74d094d3c..26543b562 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -182,179 +182,179 @@ ask( ## 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 at 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!"); + 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(); // այժմ նորմալ է */!* ``` From 75d347dd859c4044e87883f650190b0ed8953c3d Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Mon, 9 May 2022 05:24:46 +0400 Subject: [PATCH 02/12] Update article.md All --- .../16-function-expressions/article.md | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) 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 26543b562..4614391ad 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -359,22 +359,22 @@ 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 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. +Այսպիսով, մենք պետք է օգտագործենք Ֆունկցիայի Արտահայտություն միայն այն դեպքում, երբ Ֆունկցիայի Հայտարարությունը հարմար չէ առաջադրանքի համար: Մենք տեսել ենք դրա մի քանի օրինակ այս գլխում և ավելին կտեսնենք հետագայում: From 366b80a36924e7ff35398e074d9eff48a9c5fb6e Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Mon, 9 May 2022 05:34:25 +0400 Subject: [PATCH 03/12] Update article.md --- 1-js/02-first-steps/16-function-expressions/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 4614391ad..406c7501a 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -1,4 +1,4 @@ -# Function Expression +# Ֆունկցիայի Արտահայտություն Ֆունկցիան JavaScript-ում «լեզվի կախարդական կառուցվածք» չէ, բայց արժեքի հատուկ տեսակ է: From 1456fe58b5087f78301cce7e5c5dd3ba4e5a2df0 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Mon, 9 May 2022 05:39:36 +0400 Subject: [PATCH 04/12] Update article.md From 1f16f56ffbd463df79702fa655154ec099ffa43b Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 05:09:16 +0400 Subject: [PATCH 05/12] Update article.md --- .../16-function-expressions/article.md | 270 +++++++++--------- 1 file changed, 135 insertions(+), 135 deletions(-) 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 406c7501a..d502c9d27 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 -Ֆունկցիան JavaScript-ում «լեզվի կախարդական կառուցվածք» չէ, բայց արժեքի հատուկ տեսակ է: +In JavaScript, a function is not a "magical language structure", but a special kind of value. -Այն շարահյուսությունը, որ մինչ այս օգտագործել ենք, կոչվում է *Function Declaration* (Ֆունկցիայի Հայտարարություն): +The syntax that we used before is called a *Function Declaration*: ```js function sayHi() { - alert( "Ողջույն" ); + alert( "Hello" ); } ``` -Կա նաև այլ շարահյուսություն, որը կոչվում է *Function Expression* (Ֆունկցիայի Արտահայտություն): +There is another syntax for creating a function that is called a *Function Expression*. -Դա մեզ թույլ է տալիս ստեղծել նոր ֆունկցիա ցանկացած արտահայտության մեջտեղում: +It allows us to create a new function in the middle of any expression. -Օրինակ. +For example: ```js let sayHi = function() { - alert( "Ողջույն" ); + alert( "Hello" ); }; ``` -Այստեղ մենք կարող ենք տեսնել, որ `sayHi` փոփոխականը ստանում է արժեք՝ նոր ֆունկցիա, որը ստեղծվել է այսպես՝ `function() { alert("Ողջույն"); }`: +Here we can see a variable `sayHi` getting a value, the new function, created as `function() { alert("Hello"); }`. -Քանի որ ֆունկցիայի ստեղծումը տեղի է ունենում վերագրման արտահայտության համատեքստում (`=` նշանի աջ կողմում), ապա սա *Function Expression* է: +As the function creation happens in the context of the assignment expression (to the right side of `=`), this is a *Function Expression*. -Նկատի ունեցեք, որ `function` հիմնաբառից հետո չկա անվանում: Անվան բացթողումը թույլատրելի է Ֆունկցիայի Արտահայտությունների համար: +Please note, there's no name after the `function` keyword. Omitting a name is allowed for Function Expressions. -Այստեղ մենք անմիջապես վերագրում ենք այն փոփոխականին, ուստի այս կոդի նմուշների իմաստը նույնն է. «ստեղծել ֆունկցիա և տեղադրել այն `sayHi` փոփոխականում»: +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`". -Ավելի առաջադեմ իրավիճակներում, որոնց մենք հետո կհանդիպենք, ֆունկցիան կարող է ստեղծվել և անմիջապես կանչվել կամ պլանավորվել ավելի ուշ գործարկման համար, ոչ մի տեղ չպահվել, այդպիսով մնալով անանուն: +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 -Եկեք կրկնենք. անկախ նրանից, թե ինչպես է ստեղծվում ֆունկցիան, այն արժեք է: Վերոնշյալ երկու օրինակներն էլ պահում են ֆունկցիան `sayHi` փոփոխականում: +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. -Մենք կարող ենք նույնիսկ տպել այդ արժեքը՝ օգտագործելով `alert`. +We can even print out that value using `alert`: ```js run function sayHi() { - alert( "Ողջույն" ); + alert( "Hello" ); } *!* -alert( sayHi ); // ցուցադրում է ֆունկցիայի կոդը +alert( sayHi ); // shows the function code */!* ``` -Նկատի ունեցեք, որ վերջին տողը չի գործարկում ֆունկցիան, որովհետև `sayHi`-ից հետո չկան փակագծեր: Կան ծրագրավորման լեզուներ, որտեղ ֆունկցիայի անվան ցանկացած հիշատակում հանգեցնում է դրա գործարկմանը, բայց JavaScript-ը այդպիսին չէ։ +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. -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. -Անշուշտ, ֆունկցիան հատուկ արժեք է, այն իմաստով, որ մենք կարող ենք այն կանչել որպես `sayHi()`: +Surely, a function is a special value, in the sense that we can call it like `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) ստեղծել - alert( "Ողջույն" ); +function sayHi() { // (1) create + alert( "Hello" ); } -let func = sayHi; // (2) պատճենել +let func = sayHi; // (2) copy -func(); // Ողջույն // (3) գործարկել կրկնօրինակը (սա աշխատում է) -sayHi(); // Ողջույն // սա նույնպես դեռ աշխատում է (ինչու ոչ) +func(); // Hello // (3) run the copy (it works)! +sayHi(); // Hello // this still works too (why wouldn't it) ``` -Ահա մանրամասն, թե ինչ է տեղի ունենում վերևում. +Here's what happens above in detail: -1. Ֆունկցիայի Հայտարարությունը `(1)` ստեղծում է ֆունկցիա և տեղադրում այն `sayHi` փոփոխականում: -2. Տող `(2)`-ը պատճենում է այն `func` փոփոխականում: Կրկին նկատի ունեցեք. `sayHi`-ից հետո չկան փակագծեր: Եթե լինեին, ապա `func = sayHi()` կվերագրեր `sayHi()`-ի *կանչվելու արդյունքը* `func`-ին, այլ ոչ թե հենց `sayHi` *ֆունկցիան*: -3. Այժմ երկու եղանակով էլ ֆունկցիան կարող է կանչվել՝ `sayHi()` և `func()`: +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()`. -Մենք `sayHi` հայտարարելու համար կարող էինք նաև օգտագործել Ֆունկցիայի Արտահայտություն՝ առաջին տողում. +We could also have used a Function Expression to declare `sayHi`, in the first line: ```js -let sayHi = function() { // (1) ստեղծել - alert( "Ողջույն" ); +let sayHi = function() { // (1) create + alert( "Hello" ); }; let func = sayHi; // ... ``` -Ամեն ինչ նույն կերպ կաշխատի: +Everything would work the same. -````smart header="Ինչո՞ւ է վերջում կետ-ստորակետ:" -Կարող եք զարմանալ, թե ինչու Ֆունկցիայի Արտահայտությունը վերջում ունի կետ-ստորակետ `;`, բայց Ֆունկցիայի Հայտարարությունը չունի. +````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: ```js function sayHi() { @@ -102,27 +102,27 @@ let sayHi = function() { }*!*;*/!* ``` -Պատասխանը պարզ է. Ֆունկցիայի Արտահայտությունը ստեղծվել է այստեղ որպես `function(…) {…}` վերագրման հայտարարության ներսում. `let sayHi = …;` (statement): Կետ-ստորակետը `;` խորհուրդ է տրվում հայտարարության վերջում, դա ֆունկցիայի շարահյուսության մաս չէ: +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. -Կետ-ստորակետը կարող է լինել ավելի պարզ վերագրման դեպքում, ինչպիսին է `let sayHi = 5;`, այն առկա է նաև ֆունկցիա վերագրելու դեպքում: +The semicolon would be there for a simpler assignment, such as `let sayHi = 5;`, and it's also there for a function assignment. ```` -## Հետկանչ ֆունկցիաներ +## Callback functions -Դիտարկենք ֆունկցիաները որպես արժեքներ փոխանցելու և ֆունկցիաների արտահայտություններ օգտագործելու ավելի շատ օրինակներ: +Let's look at more examples of passing functions as values and using function expressions. -Մենք կգրենք ֆունկցիա `ask(question, yes, no)` երեք պարամետրով: +We'll write a function `ask(question, yes, no)` with three parameters: `question` -: Հարցի տեքստը +: Text of the question `yes` -: Գործարկման համար ֆունկցիա, եթե պատասխանը «Դրական» է +: Function to run if the answer is "Yes" `no` -: Գործարկման համար ֆունկցիա, եթե պատասխանը «Բացասական» է +: Function to run if the answer is "No" -Ֆունկցիան պետք է հարցնի `question` և, կախված օգտատիրոջ պատասխանից, կանչի `yes()` կամ `no()`. +The function should ask the `question` and, depending on the user's answer, call `yes()` or `no()`: ```js run *!* @@ -133,24 +133,24 @@ function ask(question, yes, no) { */!* function showOk() { - alert( "Դուք համաձայնեցիք:" ); + alert( "You agreed." ); } function showCancel() { - alert( "Դուք չեղարկեցիք գործարկումը։" ); + alert( "You canceled the execution." ); } -// օգտագործումը. showOk և showCancel ֆունկցիաները փոխանցվում են ask ֆունկցիային որպես արգումենտներ -ask("Դուք համաձա՞յն եք:", showOk, showCancel); +// usage: functions showOk, showCancel are passed as arguments to ask +ask("Do you agree?", showOk, showCancel); ``` -Գործնականում նման ֆունկցիաները բավականին օգտակար են: Հիմնական տարբերությունը «իրական կյանքով» `ask`-ի և վերոնշյալ օրինակի միջև այն է, որ «իրական կյանքով» ֆունկցիաները օգտագործում են ավելի բարդ ուղիներ օգտատիրոջ հետ փոխազդելու համար, քան պարզ `confirm`-ը: Բրաուզերում նման ֆունկցիաները սովորաբար նկարում են գեղեցիկ տեսք ունեցող հարցերի պատուհան: Բայց դա այլ պատմություն է: +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` ֆունկցիայի `showOk` և `showCancel` արգումենտները կոչվում են *callback functions* (հետկանչ ֆունկցիաներ) կամ պարզապես *callbacks* (հետկանչեր):** +**The arguments `showOk` and `showCancel` of `ask` are called *callback functions* or just *callbacks*.** -Գաղափարն այն է, որ մենք փոխանցում ենք ֆունկցիա և ակնկալում, որ այն հետագայում «հետ կկանչվի» անհրաժեշտության դեպքում: Մեր պարագայում `showOk`-ը դառնում է հետկանչ «դրական» պատասխանի համար, իսկ `showCancel`-ը՝ «բացասական» պատասխանի համար: +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. -Մենք կարող ենք օգտագործել Ֆունկցիայի Արտահայտություն՝ նույն ֆունկցիան շատ ավելի հակիրճ գրելու համար. +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( - "Դուք համաձա՞յն եք:", - function() { alert("Դուք համաձայնեցիք:"); }, - function() { alert("Դուք չեղարկեցիք գործարկումը։"); } + "Do you agree?", + function() { alert("You agreed."); }, + function() { alert("You canceled the execution."); } ); */!* ``` -Այստեղ ֆունկցիաները ճշգրիտ են հայտարարված `ask(...)` կանչի ներսում: Նրանք չունեն անվանում, ուստի կոչվում են *anonymous* (անանուն): Նման ֆունկցիաները հասանելի չեն `ask`-ից դուրս (քանի որ դրանք վերագրված չեն փոփոխականներին), բայց դա հենց այն է, ինչ մենք ուզում ենք այստեղ: +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. -Շատ բնական է, որ նմանատիպ կոդ է հայտնվում մեր սքրիփթներում, այն JavaScript-ի ոգով է: +Such code appears in our scripts very naturally, it's in the spirit of JavaScript. -```smart header="Ֆունկցիան արժեք է, որը ներկայացնում է «գործողություն»" -Սովորական արժեքները, ինչպիսիք են տողերը կամ թվերը, ներկայացնում են *տվյալներ*: +```smart header="A function is a value representing an \"action\"" +Regular values like strings or numbers represent the *data*. -Ֆունկցիան կարող է ընկալվել որպես *գործողություն*։ +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* - ֆունկցիա՝ հայտարարված որպես առանձին հայտարարություն (statement), հիմնական կոդի հոսքում: +- *Function Declaration:* a function, declared as a separate statement, in the main code flow: ```js - // Ֆունկցիայի Հայտարարություն + // Function Declaration function sum(a, b) { return a + b; } ``` -- *Function Expression* - ֆունկցիա՝ ստեղծված արտահայտության ներսում կամ մեկ այլ շարահյուսական կառուցվածքի ներսում: Այստեղ ֆունկցիան ստեղծվում է «վերագրման արտահայտության» `=` աջ կողմում. +- *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" `=`: ```js - // Ֆունկցիայի Արտահայտություն + // Function Expression let sum = function(a, b) { return a + b; }; ``` -Ավելի նուրբ տարբերությունն այն է, թե *երբ* է ֆունկցիան ստեղծվում JavaScript շարժիչի կողմից: +The more subtle difference is *when* a function is created by the JavaScript engine. -**Ֆունկցիայի Արտահայտությունը ստեղծվում է, երբ կատարումը հասնում է դրան և կարող է օգտագործվել միայն այդ պահից:** +**A Function Expression is created when the execution reaches it and is usable only from that moment.** -Երբ կատարման հոսքն անցնում է վերագրման աջ կողմ `let sum = function…`, այդ պահից սկսած ֆունկցիան համարվում է ստեղծված և կարող է օգտագործվել (վերագրվել, կանչվել, և այլն․․․): +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. -Ֆունկցիայի Հայտարարությունները տարբեր են: +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. -Դա պայմանավորված է ներքին ալգորիթմներով: Երբ JavaScript-ը պատրաստվում է գործարկել սքրիփթը, այն նախ որոնում է գլոբալ Ֆունկցիայի Հայտարարությունները և ստեղծում ֆունկցիաները: Մենք կարող ենք դա համարել որպես «նախաձեռնման փուլ»: +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". -ԵՎ այն բանից հետո, երբ բոլոր Ֆունկցիայի Հայտարարությունները մշակվել են, կոդը կատարվում է: Այսպիսով, այն ունի հասանելիություն այս ֆունկցիաներին: +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("Պողոս"); // Ողջույն Պողոս +sayHi("John"); // Hello, John */!* function sayHi(name) { - alert( `Ողջույն ${name}` ); + alert( `Hello, ${name}` ); } ``` -Ֆունկցիայի հայտարարությունը `sayHi` ստեղծվում է, երբ JavaScript-ը պատրաստվում է սկսել սքրիփթը և դրա մեջ ամենուր տեսանելի է: +The Function Declaration `sayHi` is created when JavaScript is preparing to start the script and is visible everywhere in it. -...Եթե դա լիներ Ֆունկցիայի Արտահայտություն, ապա այն չէր աշխատի. +...If it were a Function Expression, then it wouldn't work: ```js run refresh untrusted *!* -sayHi("Պողոս"); // սխալ +sayHi("John"); // error! */!* -let sayHi = function(name) { // (*) այլևս ոչ մի կախարդանք - alert( `Ողջույն ${name}` ); +let sayHi = function(name) { // (*) no magic any more + alert( `Hello, ${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.** -Օրինակ՝ եկեք պատկերացնենք, որ մենք պետք է հայտարարենք `welcome()` ֆունկցիան՝ կախված `age` փոփոխականից, որը մենք ստանում ենք գործարկման ընթացքում: Եվ հետո մենք նախատեսում ենք օգտագործել այն որոշ ժամանակ անց: +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. -Եթե մենք օգտագործում ենք Ֆունկցիայի Հայտարարություն, այն չի աշխատի այնպես, ինչպես նախատեսված էր. +If we use Function Declaration, it won't work as intended: ```js run -let age = prompt("Քանի՞ տարեկան եք:", 18); +let age = prompt("What is your age?", 18); // conditionally declare a function if (age < 18) { function welcome() { - alert("Ողջույն"); + alert("Hello!"); } } else { function welcome() { - alert("Ողջույններ"); + alert("Greetings!"); } } -// ...օգտագործել ավելի ուշ +// ...use it later *!* -welcome(); // սխալ` welcome is not defined +welcome(); // Error: 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; // օրինակի համար վերցրեք 16 +let age = 16; // take 16 as an example if (age < 18) { *!* - welcome(); // \ (գործարկվում է) + welcome(); // \ (runs) */!* - // | - function welcome() { // | - alert("Ողջույն"); // | Ֆունկցիայի Հայտարարությունը հասանելի է - } // | ամենուր՝ բլոկում, որտեղ այն հայտարարված է - // | + // | + function welcome() { // | + alert("Hello!"); // | Function Declaration is available + } // | everywhere in the block where it's declared + // | *!* - welcome(); // / (գործարկվում է) + welcome(); // / (runs) */!* } else { - function welcome() { - alert("Ողջույններ"); + function welcome() { + alert("Greetings!"); } } -// Այստեղ մենք ձևավոր փակագծերից դուրս ենք, -// այնպես որ մենք չենք կարող տեսնել դրանց ներսում ստեղծված Ֆունկցիայի Հայտարարությունները: +// Here we're out of curly braces, +// so we can not see Function Declarations made inside of them. *!* -welcome(); // սխալ՝ welcome is not defined +welcome(); // Error: welcome is not defined */!* ``` -Ի՞նչ կարող ենք անել, որպեսզի `welcome`-ը դարձնենք տեսանելի `if`-ից դուրս: +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. -Այս կոդը աշխատում է այնպես, ինչպես նախատեսված է. +This code works as intended: ```js run -let age = prompt("Քանի՞ տարեկան եք:", 18); +let age = prompt("What is your age?", 18); let welcome; if (age < 18) { welcome = function() { - alert("Ողջույն"); + alert("Hello!"); }; } else { welcome = function() { - alert("Ողջույններ"); + alert("Greetings!"); }; } *!* -welcome(); // այժմ նորմալ է +welcome(); // ok now */!* ``` -Կամ մենք կարող ենք այն էլ ավելի պարզեցնել՝ օգտագործելով `?` հարցական նշանի օպերատոր. +Or we could simplify it even further using a question mark operator `?`: ```js run -let age = prompt("Քանի՞ տարեկան եք:", 18); +let age = prompt("What is your age?", 18); let welcome = (age < 18) ? - function() { alert("Ողջույն"); } : - function() { alert("Ողջույններ"); }; + function() { alert("Hello!"); } : + function() { alert("Greetings!"); }; *!* -welcome(); // այժմ նորմալ է +welcome(); // ok now */!* ``` -```smart header="Ե՞րբ օգտագործել Ֆունկցիայի Հայտարարություն, երբ՝ Ֆունկցիայի Արտահայտություն:" -Որպես հիմնական կանոն, երբ մենք պետք է հայտարարենք ֆունկցիա, առաջին հերթին պետք է հաշվի առնել Ֆունկցիայի Հայտարարության շարահուսությունը: Այն ավելի շատ ազատություն է տալիս մեր կոդի դասավորության հարցում, քանի որ մենք կարող ենք կանչել այդպիսի ֆունկցիաները նախքան նրանց հայտարարումը: +```smart header="When to choose Function Declaration versus Function Expression?" +As a rule of thumb, when we need to declare a function, the first 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. -Դա նաև ավելի լավ է ընթեռնելիության համար, քանի որ կոդում ավելի հեշտ է փնտրել `function f(…) {…}`, քան՝ `let f = function(…) {…};`: Ֆունկցիայի Հայտարարություններն ավելի «աչք են գրավում»: +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". -...Բայց եթե Ֆունկցիայի Հայտարարությունն ինչ-ինչ պատճառներով մեզ չի համապատասխանում, կամ մեզ անհրաժեշտ է պայմանական հայտարարագիր (մենք հենց նոր տեսանք օրինակը), ապա պետք է օգտագործվի Ֆունկցիայի Արտահայտություն: +...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 -- Ֆունկցիաներն արժեքներ են: Դրանք կարող են նշանակվել, պատճենվել կամ հայտարարվել կոդի ցանկացած վայրում: -- Եթե հիմնական կոդի հոսքում ֆունկցիան հայտարարագրվում է որպես առանձին հայտարարություն, դա կոչվում է «Ֆունկցիայի Հայտարարություն» (Function Declaration): -- Եթե ֆունկցիան ստեղծվում է որպես արտահայտության մաս, այն կոչվում է «Ֆունկցիայի Արտահայտություն» (Function Expression): -- Ֆունկցիայի Հայտարարությունները մշակվում են նախքան կոդի բլոկի գործարկումը: Դրանք տեսանելի են բլոկում ամենուր: -- Ֆունկցիայի Արտահայտությունները ստեղծվում են, երբ կատարողական հոսքը հասնում է նրանց: +- 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. -Շատ դեպքերում, երբ մենք պետք է հայտարարագրենք ֆունկցիա, գերադասելի է Ֆունկցիայի Հայտարարությունը, քանի որ այն տեսանելի է նախքան հայտարարագրումը: Դա մեզ ավելի շատ ճկունություն է տալիս կոդի կազմակերպման մեջ և սովորաբար ավելի ընթեռնելի է: +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. From 79642ac0b65f22d4022741a855259fac1adcfb39 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 07:36:07 +0400 Subject: [PATCH 06/12] Function expressions /done --- .../16-function-expressions/article.md | 275 +++++++++--------- 1 file changed, 142 insertions(+), 133 deletions(-) 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 d502c9d27..368020edc 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()`. +Բայց դա դեռևս արժեք է: այնպես որ, մենք կարող ենք աշխատել դրա հետ այնպես, ինչպես այլ տեսակի արժեքների հետ: -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()`. +Ահա մանրամասն, թե ինչ է տեղի ունենում վերևում. We could also have used a Function Expression to declare `sayHi`, in the first line: +1. Ֆունկցիոնալ Հռչակագիրը `(1)` ստեղծում է ֆունկցիա և տեղադրում այն `sayHi` անվանումով փոփոխականում: +2. Տող `(2)`-ը պատճենում է այն `func` փոփոխականում: Կրկին նկատի ունեցեք. `sayHi`-ից հետո չկան փակագծեր: Եթե լինեին, ապա `func = sayHi()` կվերագրեր `sayHi()`-ի *կանչվելու արդյունքը* `func`-ին, այլ ոչ հենց `sayHi` *ֆունկցիան*: +3. Այժմ երկու եղանակով էլ ֆունկցիան կարող է կանչվել՝ `sayHi()` և `func()`: + +Մենք `sayHi` հռչակելու համար կարող էինք օգտագործել նաև Ֆունկցիոնալ Արտահայտություն՝ առաջին տողում. + ```js -let sayHi = function() { // (1) create - alert( "Hello" ); +let sayHi = function() { // (1) ստեղծել + alert( "Ողջույն" ); }; let func = sayHi; // ... ``` -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,201 +160,202 @@ 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(); // այժմ նորմալ է */!* ``` @@ -367,14 +368,22 @@ That's also better for readability, as it's easier to look up `function f(…) { ...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 +```smart header="Ե՞րբ օգտագործել Ֆունկցիոնալ Հռչակագիր, երբ՝ Ֆունկցիոնալ Արտահայտություն:" +Որպես հիմնական կանոն, երբ մենք պետք է հայտարարենք ֆունկցիա, առաջին հերթին պետք է հաշվի առնել Ֆունկցիոնալ Հռչակագրի շարահուսությունը: Այն ավելի շատ ազատություն է տալիս այն հարցում, թի ինչպես կազմակերպենք մեր կոդը, քանի որ մենք կարող ենք կանչել այդպիսի ֆունկցիաները նախքան նրանց հռչակումը: + +Դա նաև ավելի լավ է ընթեռնելիության համար, քանի որ ավելի հեշտ է փնտրել `function f(…) {…}` կոդում, քան՝ `let f = function(…) {…};`: Ֆունկցիոնալ Հռչակագրերն ավելի «գրավիչ են աչքի համար»: + +...Բայց եթե Ֆունկցիոնալ Հռչակագիրն ինչ-ինչ պատճառներով մեզ չի համապատասխանում, կամ մեզ անհրաժեշտ է պայմանական հռչակագիր (մենք հենց նոր տեսանք օրինակը), ապա պետք է օգտագործվի Ֆունկցիոնալ Արտահայտություն: +``` + +## Ամփոփում -- 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. +Այսպիսով, մենք պետք է օգտագործենք Ֆունկցիոնալ Արտահայտություն միայն այն դեպքում, երբ Ֆունկցիոնալ Հռչակագիրը հարմար չէ առաջադրանքի համար: Մենք տեսել ենք դրա մի քանի օրինակ այս գլխում և ավելին կտեսնենք հետագայում: From 6cb9c0cc3c9edd017cdbcb6c41bec5b9f70fbf70 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 07:38:09 +0400 Subject: [PATCH 07/12] Function expressions /done --- 1-js/02-first-steps/16-function-expressions/article.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 368020edc..1776b5cb6 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -189,7 +189,7 @@ ask( - *Ֆունկցիոնալ Հռչակագիր (Function Declaration)*. ֆունկցիա՝ հայտարարված որպես առանձին դրույթ (statement) հիմնական կոդի հոսքում: ```js - // Ֆունկցիայի Հայտարարություն + // Ֆունկցիոնալ Հռչակագիր function sum(a, b) { return a + b; } @@ -197,7 +197,7 @@ ask( - *Ֆունկցիոնալ Արտահայտություն (Function Expression)*. ֆունկցիա՝ ստեղծված արտահայտության կամ մեկ այլ շարահյուսական կառուցվածքի ներսում: Այստեղ ֆունկցիան ստեղծվում է «վերագրման արտահայտության» `=` աջ կողմում. ```js - // Ֆունկցիայի Արտահայտություն + // Ֆունկցիոնալ Արտահայտություն let sum = function(a, b) { return a + b; }; @@ -292,7 +292,7 @@ if (age < 18) { */!* // | function welcome() { // | - alert("Ողջույն"); // | Ֆունկցիայի Հայտարարությունը հասանելի է + alert("Ողջույն"); // | Ֆունկցիոնալ Հռչակագիրը հասանելի է } // | ամենուր՝ բլոկում, որտեղ այն հայտարարված է // | *!* From 23b6494533db52eb9b6e99db4b1a01200ca6c58e Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 07:43:27 +0400 Subject: [PATCH 08/12] Update article.md --- 1-js/02-first-steps/16-function-expressions/article.md | 9 --------- 1 file changed, 9 deletions(-) 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 1776b5cb6..5613e5474 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -344,7 +344,6 @@ welcome(); // այժմ նորմալ է */!* ``` -Or we could simplify it even further using a question mark operator `?`: Կամ մենք կարող ենք այն էլ ավելի պարզեցնել՝ օգտագործելով `?` հարցական նշանի օպերատոր. ```js run @@ -360,14 +359,6 @@ 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 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. - -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". - -...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. -``` - ```smart header="Ե՞րբ օգտագործել Ֆունկցիոնալ Հռչակագիր, երբ՝ Ֆունկցիոնալ Արտահայտություն:" Որպես հիմնական կանոն, երբ մենք պետք է հայտարարենք ֆունկցիա, առաջին հերթին պետք է հաշվի առնել Ֆունկցիոնալ Հռչակագրի շարահուսությունը: Այն ավելի շատ ազատություն է տալիս այն հարցում, թի ինչպես կազմակերպենք մեր կոդը, քանի որ մենք կարող ենք կանչել այդպիսի ֆունկցիաները նախքան նրանց հռչակումը: From 1dd380cec9b078c16e737c3cc12d85cf5958df76 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 08:14:19 +0400 Subject: [PATCH 09/12] Update article.md --- 1-js/02-first-steps/16-function-expressions/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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 5613e5474..e41ec930f 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -52,6 +52,8 @@ alert( sayHi ); // ցուցադրում է ֆունկցիայի կոդը JavaScript-ում ֆունկցիան արժեք է, այնպես որ մենք կարող ենք դրան վերաբերվել որպես արժեքի: Վերոնշյալ կոդը ցույց է տալիս իր տողային ներկայացումը, որը սկզբնական կոդը է: +Անշուշտ, ֆունկցիան հատուկ արժեք է, այն իմաստով, որ մենք կարող ենք այն կանչել որպես `sayHi()`: + Բայց դա դեռևս արժեք է: այնպես որ, մենք կարող ենք աշխատել դրա հետ այնպես, ինչպես այլ տեսակի արժեքների հետ: Մենք կարող ենք պատճենել ֆունկցիան մեկ այլ փոփոխականում. @@ -69,8 +71,6 @@ sayHi(); // Ողջույն // սա նույնպես դեռ աշխատու Ահա մանրամասն, թե ինչ է տեղի ունենում վերևում. -We could also have used a Function Expression to declare `sayHi`, in the first line: - 1. Ֆունկցիոնալ Հռչակագիրը `(1)` ստեղծում է ֆունկցիա և տեղադրում այն `sayHi` անվանումով փոփոխականում: 2. Տող `(2)`-ը պատճենում է այն `func` փոփոխականում: Կրկին նկատի ունեցեք. `sayHi`-ից հետո չկան փակագծեր: Եթե լինեին, ապա `func = sayHi()` կվերագրեր `sayHi()`-ի *կանչվելու արդյունքը* `func`-ին, այլ ոչ հենց `sayHi` *ֆունկցիան*: 3. Այժմ երկու եղանակով էլ ֆունկցիան կարող է կանչվել՝ `sayHi()` և `func()`: From abcffd4185618b6f6971e0faffec8e99ba434791 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 08:15:14 +0400 Subject: [PATCH 10/12] Update article.md --- 1-js/02-first-steps/16-function-expressions/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 e41ec930f..c8a713ebd 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -54,7 +54,7 @@ JavaScript-ում ֆունկցիան արժեք է, այնպես որ մենք Անշուշտ, ֆունկցիան հատուկ արժեք է, այն իմաստով, որ մենք կարող ենք այն կանչել որպես `sayHi()`: -Բայց դա դեռևս արժեք է: այնպես որ, մենք կարող ենք աշխատել դրա հետ այնպես, ինչպես այլ տեսակի արժեքների հետ: +Բայց դա դեռևս արժեք է: Այսպիսով, մենք կարող ենք աշխատել դրա հետ այնպես, ինչպես այլ տեսակի արժեքների հետ: Մենք կարող ենք պատճենել ֆունկցիան մեկ այլ փոփոխականում. From 573c1149f6ac5f451823488f4dab17825d6a7137 Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 08:30:53 +0400 Subject: [PATCH 11/12] Function expressions /done --- 1-js/02-first-steps/16-function-expressions/article.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 c8a713ebd..4e0e1b4c2 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -75,7 +75,7 @@ sayHi(); // Ողջույն // սա նույնպես դեռ աշխատու 2. Տող `(2)`-ը պատճենում է այն `func` փոփոխականում: Կրկին նկատի ունեցեք. `sayHi`-ից հետո չկան փակագծեր: Եթե լինեին, ապա `func = sayHi()` կվերագրեր `sayHi()`-ի *կանչվելու արդյունքը* `func`-ին, այլ ոչ հենց `sayHi` *ֆունկցիան*: 3. Այժմ երկու եղանակով էլ ֆունկցիան կարող է կանչվել՝ `sayHi()` և `func()`: -Մենք `sayHi` հռչակելու համար կարող էինք օգտագործել նաև Ֆունկցիոնալ Արտահայտություն՝ առաջին տողում. +Մենք `sayHi` հռչակելու համար կարող էինք օգտագործել նաև Ֆունկցիոնալ Արտահայտություն առաջին տողում. ```js let sayHi = function() { // (1) ստեղծել From 89315cb266889f56c4eea3638f69f868ff88777d Mon Sep 17 00:00:00 2001 From: Gaspar Galenteryan Date: Wed, 11 May 2022 20:17:50 +0400 Subject: [PATCH 12/12] Function expressions Updated. --- .../16-function-expressions/article.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) 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 8689a8778..344d91950 100644 --- a/1-js/02-first-steps/16-function-expressions/article.md +++ b/1-js/02-first-steps/16-function-expressions/article.md @@ -50,7 +50,7 @@ alert( sayHi ); // ցուցադրում է ֆունկցիայի կոդը Նկատի ունեցեք, որ վերջին տողը չի գործարկում ֆունկցիան, որովհետև `sayHi`-ից հետո չկան փակագծեր: Կան ծրագրավորման լեզուներ, որտեղ ֆունկցիայի անվան ցանկացած հիշատակում հանգեցնում է դրա գործարկմանը, բայց JavaScript-ը այդպիսին չէ։ -JavaScript-ում ֆունկցիան արժեք է, այնպես որ մենք կարող ենք դրան վերաբերվել որպես արժեքի: Վերոնշյալ կոդը ցույց է տալիս իր տողային ներկայացումը, որը սկզբնական կոդը է: +JavaScript-ում ֆունկցիան արժեք է, այնպես որ մենք կարող ենք դրան վերաբերվել որպես արժեքի: Վերոնշյալ կոդը ցույց է տալիս իր տողային ներկայացումը, որը սկզբնական կոդ է: Անշուշտ, ֆունկցիան հատուկ արժեք է, այն իմաստով, որ մենք կարող ենք այն կանչել որպես `sayHi()`: @@ -89,7 +89,7 @@ let func = sayHi; Ամեն ինչ նույն կերպ կաշխատի: -````smart header="Ինչո՞ւ է վերջում կետ-ստորակետ:" +````smart header="Ինչո՞ւ վերջում կա կետ-ստորակետ:" Կարող եք զարմանալ, թե ինչո՞ւ Ֆունկցիոնալ Արտահայտություններն ունեն կետ-ստորակետ `;` վերջում, իսկ Ֆունկցիոնալ Հռչակագրերը չունեն. ```js @@ -102,7 +102,7 @@ let sayHi = function() { }*!*;*/!* ``` -Պատասխանը պարզ է. Ֆունկցիոնալ Արտահայտությունն այստեղ որպես `function(…) {…}` ստեղծվել է վերագրման դրույթի ներսում. `let sayHi = …;` (statement): Կետ-ստորակետը `;` խորհուրդ է տրվում դրույթի վերջում, դա ֆունկցիայի շարահյուսության մաս չէ: +Պատասխանը պարզ է. Ֆունկցիոնալ Արտահայտությունն այստեղ որպես `function(…) {…}` ստեղծվել է վերագրման դրույթի ներսում. `let sayHi = …;` (statement): Կետ-ստորակետը `;` խորհուրդ է տրվում դնել դրույթի վերջում, դա ֆունկցիայի շարահյուսության մաս չէ: Կետ-ստորակետը կարող է լինել այդտեղ ավելի պարզ վերագրման համար, ինչպիսին է `let sayHi = 5;`, այն այդտեղ է նաև ֆունկցիա վերագրելու համար: ```` @@ -362,14 +362,14 @@ welcome(); // այժմ նորմալ է ```smart header="Ե՞րբ օգտագործել Ֆունկցիոնալ Հռչակագիր, երբ՝ Ֆունկցիոնալ Արտահայտություն:" Որպես հիմնական կանոն, երբ մենք պետք է հայտարարենք ֆունկցիա, առաջին հերթին պետք է հաշվի առնել Ֆունկցիոնալ Հռչակագրի շարահուսությունը: Այն ավելի շատ ազատություն է տալիս այն հարցում, թի ինչպես կազմակերպենք մեր կոդը, քանի որ մենք կարող ենք կանչել այդպիսի ֆունկցիաները նախքան նրանց հռչակումը: -Դա նաև ավելի լավ է ընթեռնելիության համար, քանի որ ավելի հեշտ է փնտրել `function f(…) {…}` կոդում, քան՝ `let f = function(…) {…};`: Ֆունկցիոնալ Հռչակագրերն ավելի «գրավիչ են աչքի համար»: +Դա նաև ավելի ընթեռնելի է, քանի որ ավելի հեշտ է փնտրել `function f(…) {…}` կոդում, քան՝ `let f = function(…) {…};`: Ֆունկցիոնալ Հռչակագրերն ավելի «գրավիչ են աչքի համար»: -...Բայց եթե Ֆունկցիոնալ Հռչակագիրն ինչ-ինչ պատճառներով մեզ չի համապատասխանում, կամ մեզ անհրաժեշտ է պայմանական հռչակագիր (մենք հենց նոր տեսանք օրինակը), ապա պետք է օգտագործվի Ֆունկցիոնալ Արտահայտություն: +...Բայց եթե Ֆունկցիոնալ Հռչակագիրն ինչ-ինչ պատճառներով մեզ չի համապատասխանում, կամ մեզ անհրաժեշտ է պայմանական հայտարարագիր (մենք հենց նոր տեսանք օրինակը), ապա պետք է օգտագործվի Ֆունկցիոնալ Արտահայտություն: ``` ## Ամփոփում -- Ֆունկցիաներն արժեքներ են: Դրանք կարող են վերագրվել, պատճենվել կամ կռչակվել կոդի ցանկացած վայրում: +- Ֆունկցիաներն արժեքներ են: Դրանք կարող են վերագրվել, պատճենվել կամ հռչակվել կոդի ցանկացած վայրում: - Եթե հիմնական կոդի հոսքում ֆունկցիան հռչակվում է որպես առանձին դրույթ, դա կոչվում է «Ֆունկցիոնալ Հռչակագիր» (Function Declaration): - Եթե ֆունկցիան ստեղծվում է որպես արտահայտության մաս, այն կոչվում է «Ֆունկցիոնալ Արտահայտություն» (Function Expression): - Ֆունկցիոնալ Հռչակագրերը մշակվում են նախքան կոդի բլոկի գործարկումը: Դրանք բլոկում տեսանելի են ամենուր: @@ -377,4 +377,4 @@ welcome(); // այժմ նորմալ է Շատ դեպքերում, երբ մենք պետք է հռչակենք ֆունկցիա, գերադասելի է Ֆունկցիոնալ Հռչակագիր, քանի որ այն տեսանելի է նախքան իր հռչակումը: Դա մեզ ավելի շատ ճկունություն է տալիս կոդի կազմակերպման հարցում և սովորաբար ավելի ընթեռնելի է: -Այսպիսով, մենք պետք է օգտագործենք Ֆունկցիոնալ Արտահայտություն միայն այն դեպքում, երբ Ֆունկցիոնալ Հռչակագիրը հարմար չէ առաջադրանքի համար: Մենք տեսել ենք դրա մի քանի օրինակ այս գլխում և ավելին կտեսնենք հետագայում: \ No newline at end of file +Այսպիսով, մենք պետք է օգտագործենք Ֆունկցիոնալ Արտահայտություն միայն այն դեպքում, երբ Ֆունկցիոնալ Հռչակագիրը հարմար չէ առաջադրանքի համար: Մենք տեսել ենք դրա մի քանի օրինակ այս գլխում և ավելին կտեսնենք հետագայում: