From 8207f16b3acf5d8fe487b335eae30fcce9e9e519 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sat, 10 Jul 2021 03:02:49 +0400 Subject: [PATCH 1/8] feat: translate article.md of data types section --- 1-js/02-first-steps/05-types/article.md | 251 +++++++++++++----------- 1 file changed, 140 insertions(+), 111 deletions(-) diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md index 661760005..10db2dfa1 100644 --- a/1-js/02-first-steps/05-types/article.md +++ b/1-js/02-first-steps/05-types/article.md @@ -1,226 +1,250 @@ -# 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://en.wikipedia.org/wiki/Infinity) ∞։ Այն հատուկ արժեք է, որը մեծ է + ցանկացած թվից։ - 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 operation on `NaN` returns `NaN`: + `NaN`-ը անփոփոխ արժեք է։ Ցանկացած գործողություն `NaN`-ի հետ վերադարձնում է `NaN`: ```js run - alert( "not a number" / 2 + 5 ); // NaN + alert( "ոչ թվային արժեք" / 2 + 5 ); // NaN ``` - So, if there's a `NaN` somewhere in a mathematical expression, it propagates to the whole result. + Եթե մաթեմատիկական արտահայտության որևէ անդամ `NaN` է, ապա ամբողջ արտահայտության արդյունքը կլինի `NaN`։ -```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 . +Թվերի հետ աշխատանքին ավելի մանրամասն կծանոթանանք գլխում։ ## BigInt -In JavaScript, the "number" type cannot represent integer values larger than (253-1) (that's `9007199254740991`), or less than -(253-1) for negatives. It's a technical limitation caused by their internal representation. +JavaScript-ում թվային (number) տիպը չի կարող ներկայացնել թվային արժեքներ, +որոնք մեծ են (253-1)-ից (նույնն է, ինչ +`9007199254740991`), +կամ փոքր են -(253-1)-ից՝ բացասական թվերի դեպքում։ Այս տեխիկական սահմանափակումը պայմանավորված է թվերի ներքին +ներկայացման յուրահատկություններով։ -For most purposes that's quite enough, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps. +Հիմնական դեպքերում սա ավելին քան բավական է, բայց երբեմն մենք կարիք ենք ունենում օգտագործելու իսկապես մեծ թվեր, օրինակ՝ գախտնագրման կամ +ժամանականիշի (timestamp) միկրովարկյաններով ներկայացման դեպքում։ -`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 . Read it when you need such big numbers. +Քանի որ `BigInt` թվերը հազվադեպ են օգտագործվում, դրանց այստեղ չենք անրադառնա, այլ կդիտարկենք առանձին՝ գլխում։ Կարդացե՛ք այն, +եթե նման մեծ թվերի օգտագոծման կարիք կունենաք։ -```smart header="Compatibility issues" -Right now, `BigInt` is supported in Firefox/Chrome/Edge/Safari, but not in IE. +```smart header="Համատեղելիության խնդիրներ" +Այս պահին `BigInt`-ը համատեղելի է Firefox/Chrome/Edge/Safari զննիչների հետ, բայց ոչ IE-ի։ ``` -You can check [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) to know which versions of a browser are supported. +Կարող եք ստուգել [*MDN* BigInt compatibility table](https://developer.mozilla. +org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) հոդվածը, հասկանալու համար, թե զննիչների որ +տարբերակների հետ է այն համատեղելի։ -## String +## Տող (String) -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: `Hello`. +1. Կրկնակի չակերտներ․ `"Բարև"`։ +2. Եզակի չակերտներ․ `'Բարև'`։ +3. Թեք չակերտներ․ `Բարև`։ -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 . +Մենք կանրադառնանք տողերին ավելի խորացված կերպեվ գլխում։ -```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) +## Բուլյան (տրամաբանական տիպ) -The boolean type has only two values: `true` and `false`. +Բուլյան տիպը ունի երկու արժեք․ `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: +Բուլյան արժեքները ստացվում են նաև որպես համեմատությունների արդյունք․ ```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 . +Մենք կանրադառնանք բուլյան տիպին ավելի խորացված կերպով գլխում։ -## 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`-ը իրենից ենթադրում է նախնական լռելյայն արժեք՝ չվերագրված փոփոխականների համար։ -## 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 , after we learn more about primitives. +Օբյեկտները լեզվում կարևոր տեղ են զբաղեցնում և հատուկ ուշադրության են արժանի։ Մենք կզբաղվենք դրանցով ավելի ուշ՝ գլխում՝ +պրիմիտիվ տիպերը ավելի խորը ուսումնասիրելուց հետո։ -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 argument. It's useful when we want to process values of different types differently or just want to do a quick check. +`typeof` օպերատորը վերադարձնում է իր արգումենտի տիպը։ Այն օգտակար է, երբ մենք ուզում ենք մշակել տարբեր տիպերի արժեքները տարբեր կերպով, կամ +պարզեպես արագ ստուգման կարիք կա։ -It supports two forms of syntax: +Այն ունի օգտագործման երկու սինտաքս․ -1. As an operator: `typeof x`. -2. As a function: `typeof(x)`. +1. Որպես օպերատոր՝ `typeof x`։ +2. Որպես ֆունկցիա `typeof(x)`։ -In other words, it works with parentheses or without them. The result is the same. +Այլ կերպ ասած, այն աշխատում է և՛ փակագծերով, և՛ առանց դրանց։ Արդյունքը նույնն է։ -The call to `typeof x` returns a string with the type name: +`typeof x`-ի կանչը վերադարձնում է տող, որը պարունակում է տիպի անվանումը․ ```js typeof undefined // "undefined" @@ -248,29 +272,34 @@ 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 . 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` behavior, coming from the 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. -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`-ը ներկառուցված օբեկտ է, որը տրամադրում է մաթեմատիկական տարբեր գործողություններ և հաստատուններ։ Մենք կուսումնասիրենք այն + գլխում։ Այստեղ այն պարզապես ծառայում է որպես օբյեկտի օրինակ։ +2. `typeof null`-ի արդյունքը `"object"` է։ Այն `typeof` օպերատորի վարքագծի պաշտոնապես ընդունված սխալ է, որը եկել է JavaScript-ի ստեղծման + վաղ ժամանակներից և մնացել է լեզվում համատեղելիության նպատակով։ Անշուշտ, `null`-ը օբյեկտ չէ։ Այն հատուկ արժեք է, որը ունի իր սեփական տիպը։ +3. `typeof alert`-ի արդյունքը `"function"` է, քանի որ `alert`-ը ֆունկցիա է։ Մենք կուսումնասիրենք ֆունկցիաները հաջորդ գլուխներում, որտեղ + կիմանանք, որ JavaScript-ը չունի առանձին «ֆունկցիա» տիպ։ Ֆունկցիաները պատկանում են օբյեկտ տիպին։ Բայց `typeof`-ը մշակում է դրանք + հատուկ ձևով՝ վերադարձնելով `"function"` արժեքը։ Դա նույնպես գալիս է JavaScript-ի պատմության վաղ ժամանակներից։ Տեխնիկապես վարքագիծը + ճիշտ չէ, բայց պրակտիկայում կարող է հարմար լինել։ -## Summary +## Ամփոփում -There are 8 basic data types in JavaScript. +JavaScript-ում գոյություն ունեն տվյալների 8 տիպեր։ -- `number` for numbers of any kind: integer or floating-point, integers are limited by ±(253-1). -- `bigint` is 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`. -- `object` for more complex data structures. -- `symbol` for unique identifiers. +- `number` բոլոր տեսակի թվերի համար․ ամբողջ և լողացող կետով, ամբողջ թվերը սահմանափակված են ±(253-1) միջակայքում։ +- `bigint` կամայական մեծության ամբողջ թվերի համար։ +- `string` տողերի համար։ Տողը կարող է պարունակել զրո կամ ավել նիշեր, չկա նիշի համար նախատեսված առանձին տիպ։ +- `boolean` `true`/`false` արժեքների համար։ +- `null` անհայտ արժեքների համար․ առանձին տիպ է, որը ունի մեկ արժեք՝ `null`։ +- `undefined` չվերագրված արժեքների համար․ առանձին տիպ է, որը ունի մեկ արժեք՝ `undefined`։ +- `object` ավելի բարդ տվյալների կառուցվածքների համար։ +- `symbol` չկրկնվող նույնացուցիչների համար։ -The `typeof` operator allows us to see which type is stored in a variable. +`typeof`-ը թույլ է տալիս ստուգել, թե ինչ տիպի արժեք է պահված փոփոխականում։ -- Two forms: `typeof x` or `typeof(x)`. -- 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. +Հաջորդ գլուխներում մենք կկենտրոնանանք պրիմիտիվ արժեքների վրա և երբ ծանոթանանք դրանց հետ, կանցնենք օբյեկտների ուսումնասիրությանը։ From 0915d031c56466c93f1192fcc2774648c2ec2705 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sat, 10 Jul 2021 03:03:22 +0400 Subject: [PATCH 2/8] feat: translate task.md of data types section --- 1-js/02-first-steps/05-types/1-string-quotes/task.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 +``` From 4e7b49fb493d90d75c07d7772f99042c6db0ea96 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sat, 10 Jul 2021 03:04:02 +0400 Subject: [PATCH 3/8] feat: translate solution.md of data types section --- .../05-types/1-string-quotes/solution.md | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) 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 ``` From e87963d6fe6691516f03aeeffdbb4922a56e741b Mon Sep 17 00:00:00 2001 From: Arthur Date: Sun, 11 Jul 2021 02:16:51 +0400 Subject: [PATCH 4/8] feat: translate article.md of interaction: alert, prompt, confirm section --- .../06-alert-prompt-confirm/article.md | 87 ++++++++++--------- 1 file changed, 47 insertions(+), 40 deletions(-) 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..c2be9b9e4 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,112 @@ -# 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"); +````js run +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: +Սինտաքսը․ ```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. +Այսպիսին է պարզության գինը։ Կան շատ այլ եղանակներ՝ ավելի գեղեցիկ պատուհաններ պատկերելու և օգտատիրոջ հետ ավելի լայն փոխազդեցություն +ապահովելու համար, բայց եթե «ճոխությունը» կարևոր չէ, այս մեթոդները հիանալի լուծում են։ From be2bf6874d16625a82f0691d3e9f87abcd655e95 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sun, 11 Jul 2021 02:17:22 +0400 Subject: [PATCH 5/8] feat: translate task.md of interaction: alert, prompt, confirm section --- .../06-alert-prompt-confirm/1-simple-page/task.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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] From a456830dc5fef29006ae60ed9137917d1e082c02 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sun, 11 Jul 2021 02:17:54 +0400 Subject: [PATCH 6/8] feat: translate solution.md of interaction: alert, prompt, confirm section --- .../06-alert-prompt-confirm/1-simple-page/solution.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 @@ -15,7 +15,7 @@ The full page: From f328760b9d831e09503b8d5ff10d3a9dee114ce8 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sun, 11 Jul 2021 16:58:04 +0400 Subject: [PATCH 7/8] fix: unnecessary new lines removed, typos fixed --- 1-js/02-first-steps/05-types/article.md | 94 +++++++++---------------- 1 file changed, 33 insertions(+), 61 deletions(-) diff --git a/1-js/02-first-steps/05-types/article.md b/1-js/02-first-steps/05-types/article.md index 10db2dfa1..885f7c459 100644 --- a/1-js/02-first-steps/05-types/article.md +++ b/1-js/02-first-steps/05-types/article.md @@ -2,8 +2,7 @@ JavaScript-ում արժեքը միշտ պատկանում է տվյալների որոշակի տիպի։ Օրինակ՝ տող (string) կամ թիվ (number)։ -JavaScript-ում կան տվյալների ութ հիմնական տիպեր։ Այս գլխում մենք կանրադառնանք դրանց մասնակիորեն, իսկ հաջորդ գլուխներում կխոսենք դրանցից -յուրաքանչյուրի մասին ավելի մանրամասն։ +JavaScript-ում կան տվյալների ութ հիմնական տիպեր։ Այս գլխում մենք կանրադառնանք դրանց մասնակիորեն, իսկ հաջորդ գլուխներում կխոսենք դրանցից յուրաքանչյուրի մասին ավելի մանրամասն։ Փոփոխականը կարող է պարունակել ցանկացած տիպի տվյալ։ Օրինակ՝ սկզբում այն կարող է պարունակել տող (string), իսկ հետո՝ փոխարինվել թվով (number)․ @@ -13,8 +12,7 @@ let message = "բարև"; message = 123456; ``` -Այն լեզուները, որոնք թույլ են տալիս նման պահվածք, կոչվում են «դինամիկ տիպավորված»։ Դա նշանակում է, որ տիպերը գոյություն ունեն, բայց -փոփոխականները կապված չեն դրանցից ոչ մեկի հետ։ +Այն լեզուները, որոնք թույլ են տալիս նման պահվածք, կոչվում են «դինամիկ տիպավորված»։ Դա նշանակում է, որ տիպերը գոյություն ունեն, բայց փոփոխականները կապված չեն դրանցից ոչ մեկի հետ։ ## Թիվ (Number) @@ -23,18 +21,15 @@ let n = 123; n = 12.345; ``` -*number* տիպը ներկայացնում է ինչպես ամբողջ թվերը, այնպես էլ լողացող կետով թվերը։ +*number* տիպը ներկայացնում է ինչպես ամբողջ թվերը, այնպես էլ տասնորդական թվերը։ Թվերի համար գոյություն ունեն բազմաթիվ գործողություններ, օրինակ՝ բազմապատկում `*`, բաժանաում `/`, գումարում `+`, հանում `-` և այլն. -Բացի սովորական թվերից կան նաև այսպես կոչված «հատուկ թվային արժեքներ», որոնք նույնպես պատկանում են այս տվյալների տիպին․ `Infinity`, -`-Infinity` -և `NaN`։ +Բացի սովորական թվերից կան նաև այսպես կոչված «հատուկ թվային արժեքներ», որոնք նույնպես պատկանում են այս տվյալների տիպին․ `Infinity`, `-Infinity` և `NaN`։ -- `Infinity`-ն ներկայացնում է մաթեմատիկական [անվերջությունը](https://en.wikipedia.org/wiki/Infinity) ∞։ Այն հատուկ արժեք է, որը մեծ է - ցանկացած թվից։ +- `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)) ∞։ Այն հատուկ արժեք է, որը մեծ է ցանկացած թվից։ - Մենք կարող ենք ստանալ այն որպես զրոի վրա բաժանման արդյունք, + Մենք կարող ենք ստանալ այն որպես զրոյի վրա բաժանման արդյունք, ```js run alert( 1 / 0 ); // Infinity @@ -60,8 +55,7 @@ n = 12.345; Եթե մաթեմատիկական արտահայտության որևէ անդամ `NaN` է, ապա ամբողջ արտահայտության արդյունքը կլինի `NaN`։ ```smart header="Մաթեմատիկական գործողությունները անվտանգ են" -Մաթեմատիկական գործողությունները JavaScript-ում «անվտանգ» են։ Մենք կարող ենք կատարել ցանկացած գործողություն՝ բաժանել զրոի, ոչ թվային տողերի -հետ վարվել ինչպես թվերի հետ։ +Մաթեմատիկական գործողությունները JavaScript-ում «անվտանգ» են։ Մենք կարող ենք կատարել ցանկացած գործողություն՝ բաժանել զրոյի, ոչ թվային տողերի հետ վարվել ինչպես թվերի հետ։ Սկրիպտը երբեք կանգ չի առնի՝ շպրտելով սխալ։ Վատագույն դեպքում, որպես արդյունք, մենք կստանանք `NaN`։ ``` @@ -72,16 +66,11 @@ n = 12.345; ## BigInt -JavaScript-ում թվային (number) տիպը չի կարող ներկայացնել թվային արժեքներ, -որոնք մեծ են (253-1)-ից (նույնն է, ինչ -`9007199254740991`), -կամ փոքր են -(253-1)-ից՝ բացասական թվերի դեպքում։ Այս տեխիկական սահմանափակումը պայմանավորված է թվերի ներքին -ներկայացման յուրահատկություններով։ +JavaScript-ում թվային (number) տիպը չի կարող ներկայացնել թվային արժեքներ, որոնք մեծ են (253-1)-ից (նույնն է, ինչ `9007199254740991`), կամ փոքր են -(253-1)-ից՝ բացասական թվերի դեպքում։ Այս տեխիկական սահմանափակումը պայմանավորված է թվերի ներքին ներկայացման յուրահատկություններով։ -Հիմնական դեպքերում սա ավելին քան բավական է, բայց երբեմն մենք կարիք ենք ունենում օգտագործելու իսկապես մեծ թվեր, օրինակ՝ գախտնագրման կամ -ժամանականիշի (timestamp) միկրովարկյաններով ներկայացման դեպքում։ +Հիմնական դեպքերում սա ավելի քան բավական է, բայց երբեմն մենք կարիք ենք ունենում օգտագործելու իսկապես մեծ թվեր, օրինակ՝ գաղտնագրման կամ ժամանականիշի (timestamp) միկրովարկյաններով ներկայացման դեպքում։ -`BigInt`-ը վերջերս ավելացվել է լեզվում՝ կամայական մեծության թվեր նեկայացնելու նպատակով։ +`BigInt`-ը վերջերս է ավելացվել լեզվում՝ կամայական մեծության թվեր նեկայացնելու նպատակով։ `BigInt` արժեք ստեղծվում է թվին վերջից կցելով `n`․ @@ -90,17 +79,14 @@ JavaScript-ում թվային (number) տիպը չի կարող ներկայա const bigInt = 1234567890123456789012345678901234567890n; ``` -Քանի որ `BigInt` թվերը հազվադեպ են օգտագործվում, դրանց այստեղ չենք անրադառնա, այլ կդիտարկենք առանձին՝ գլխում։ Կարդացե՛ք այն, -եթե նման մեծ թվերի օգտագոծման կարիք կունենաք։ +Քանի որ `BigInt` թվերը հազվադեպ են օգտագործվում, դրանց այստեղ չենք անդրադառնա, այլ կդիտարկենք առանձին՝ գլխում։ Կարդացե՛ք այն, եթե նման մեծ թվերի օգտագոծման կարիք կունենաք։ ```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) հոդվածը, հասկանալու համար, թե զննիչների որ -տարբերակների հետ է այն համատեղելի։ +Կարող եք ստուգել [*MDN* BigInt compatibility table](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#Browser_compatibility) հոդվածը, հասկանալու համար, թե զննիչների որ տարբերակների հետ է այն համատեղելի։ ## Տող (String) @@ -118,10 +104,9 @@ JavaScript-ում գոյություն ոնեն 3 տեսակի չակերտնե 2. Եզակի չակերտներ․ `'Բարև'`։ 3. Թեք չակերտներ․ `Բարև`։ -Կրկնակի և միակի չակերտները «պարզ» չակերտներ են։ JavaScript-ում դրանց միջև տարբերություններ չկան։ +Կրկնակի և եզակի չակերտները «պարզ» չակերտներ են։ JavaScript-ում դրանց միջև տարբերություններ չկան։ -Թեք չակերտները ունեն «ընդլայնված ֆունկցիոնալություն»։ Դրանք թույլ են տալիս ներդնել փոփոխականներ և արտահայտություններ տողի մեջ՝ դրանք -`${…}`-ի մեջ պարփակելու միջոցով, օրինակ․ +Թեք չակերտները ունեն «ընդլայնված ֆունկցիոնալություն»։ Դրանք թույլ են տալիս ներդնել փոփոխականներ և արտահայտություններ տողի մեջ՝ դրանք `${…}`-ի մեջ պարփակելու միջոցով, օրինակ․ ```js run let name = "Դավիթ"; @@ -133,17 +118,15 @@ alert( `Բարև, *!*${name}*/!*!` ); // Բարև, Դավիթ! alert( `արդյունքը կլինի *!*${1 + 2}*/!*` ); // արդյունքը կլինի 3 ``` -`${…}`-ի մեջ ներդրված արտահայտությունը գնահատվում է, և արդյունքը դառնում է տողի մի մասը։ Մենք կարող ենք տեղադրել այնեղ ամեն ինչ՝ -փոփոխական (`name`) կամ թվաբանական արտահայտություն՝ `1 + 2`-ի նման կամ ավելի բարդ։ +`${…}`-ի մեջ ներդրված արտահայտությունը գնահատվում է, և արդյունքը դառնում է տողի մի մասը։ Մենք կարող ենք տեղադրել այնտեղ ամեն ինչ՝ փոփոխական (`name`) կամ թվաբանական արտահայտություն՝ `1 + 2`-ի նման կամ ավելի բարդ։ -Ուշադրություն դարձրեք այն փաստին, որ սա հնարավոր է միյայն թեք չակերտների դեպքում։ Մյուս չակերտները չունեն այսպիսի ներդրման -ֆունկցիոնալություն։ +Ուշադրություն դարձրեք այն փաստին, որ սա հնարավոր է միայն թեք չակերտների դեպքում։ Մյուս չակերտները չունեն այսպիսի ներդրման ֆունկցիոնալություն։ ```js run alert( "արդյունքը կլինի ${1 + 2}" ); // արդյունքը կլինի ${1 + 2} (կրկնակի չակերտները ոչինչ չեն անում) ``` -Մենք կանրադառնանք տողերին ավելի խորացված կերպեվ գլխում։ +Մենք կանրադառնանք տողերին ավելի մանրամասն գլխում։ ```smart header="Գոյություն չունի *character* տիպ։" Որոշ լեզուներում գոյություն ունի հատուկ "character" տիպ եզակի սիմվոլների համար։ Օրինակ՝ C և Java լեզուներում այն կոչվում է «char»։ @@ -151,12 +134,11 @@ alert( "արդյունքը կլինի ${1 + 2}" ); // արդյունքը կլի JavaScript-ում չկա նման տիպ։ Կա միայն մեկ տիպ՝ `string`։ string-ը կարող է լինել դատարկ, ունենալ մեկ կամ բազմաթիվ նիշեր։ ``` -## Բուլյան (տրամաբանական տիպ) +## Boolean (տրամաբանական տիպ) -Բուլյան տիպը ունի երկու արժեք․ `true` և `false`։ +Boolean տիպը ունի երկու արժեք․ `true` և `false`։ -Այս տիպը հիմնականում օգտագործվում է այո/ոչ արժեքներ պահելու համար․ `true` նշանակում է «այո, ճիշտ է», իսկ `false` նշանակում է «ոչ, -սխալ է»։ +Այս տիպը հիմնականում օգտագործվում է այո/ոչ արժեքներ պահելու համար․ `true` նշանակում է «այո, ճիշտ է», իսկ `false` նշանակում է «ոչ, սխալ է»։ Օրինակ՝ @@ -165,7 +147,7 @@ let nameFieldChecked = true; // այո, անվանական դաշտը ստուգ let ageFieldChecked = false; // ոչ, տարիքային դաշտը ստուգված չէ ``` -Բուլյան արժեքները ստացվում են նաև որպես համեմատությունների արդյունք․ +Boolean արժեքները ստացվում են նաև որպես համեմատությունների արդյունք․ ```js run let isGreater = 4 > 1; @@ -173,7 +155,7 @@ let isGreater = 4 > 1; alert( isGreater ); // true (համեմատության արդյունքն է «այո») ``` -Մենք կանրադառնանք բուլյան տիպին ավելի խորացված կերպով գլխում։ +Մենք կանրադառնանք boolean տիպին ավելի մանրամասն գլխում։ ## «null» արժեքը @@ -185,7 +167,7 @@ alert( isGreater ); // true (համեմատության արդյունքն է « let age = null; ``` -JavaScript-ում `null`-ը «գոյություն չունեցող օբեկտի հղում» կամ «զրոյական ցուցիչ» չէ, ինչպես որոշ այլ լեզուներում։ +JavaScript-ում `null`-ը «գոյություն չունեցող օբյեկտի հղում» կամ «զրոյական ցուցիչ» չէ, ինչպես որոշ այլ լեզուներում։ Այն պարզապես հատուկ արժեք է, որը նշանակում է «ոչինչ», «դատարկություն» կամ «անհայտ արժեք»։ @@ -216,28 +198,23 @@ age = undefined; alert(age); // «undefined» ``` -...Բայց խորհուրդ չի տրվում այդպես անել։ Սովորաբար `null`-ը օգտագործվում է փոփոխականին «դատարկ» կամ «անհայտ» արժեք վերագրելու համար, -մինչդեռ `undefined`-ը իրենից ենթադրում է նախնական լռելյայն արժեք՝ չվերագրված փոփոխականների համար։ +...Բայց խորհուրդ չի տրվում այդպես անել։ Սովորաբար `null`-ը օգտագործվում է փոփոխականին «դատարկ» կամ «անհայտ» արժեք վերագրելու համար, մինչդեռ `undefined`-ը իրենից ենթադրում է նախնական լռելյայն (default) արժեք՝ չվերագրված փոփոխականների համար։ ## Օբյեկտներ և սիմվոլներ `object` տիպը յուրահատուկ է։ -Մնացած բոլոր տիպերը կոչվում են «պրիմիտիվ» տիպեր, քանի որ նրանց արժեքները պարզ արժեքներ են (լինի այն տող, թիվ կամ այլ արժեք)։ Օբյեկտները, -իրենց հերթին, օգտագործվում են տվյալների համախումբ և ավելի բարդ կառուցվածքներ պահեստավորելու նպատակով։ +Մնացած բոլոր տիպերը կոչվում են «պրիմիտիվ» տիպեր, քանի որ նրանց արժեքները պարզ արժեքներ են (լինի այն տող, թիվ կամ այլ արժեք)։ Օբյեկտները, իրենց հերթին, օգտագործվում են տվյալների համախումբ և ավելի բարդ կառուցվածքներ պահեստավորելու նպատակով։ -Օբյեկտները լեզվում կարևոր տեղ են զբաղեցնում և հատուկ ուշադրության են արժանի։ Մենք կզբաղվենք դրանցով ավելի ուշ՝ գլխում՝ -պրիմիտիվ տիպերը ավելի խորը ուսումնասիրելուց հետո։ +Օբյեկտները լեզվում կարևոր տեղ են զբաղեցնում և հատուկ ուշադրության են արժանի։ Մենք կզբաղվենք դրանցով ավելի ուշ՝ գլխում՝ պրիմիտիվ տիպերը ավելի խորը ուսումնասիրելուց հետո։ -`symbol` տիպը օգտագործվում է օբյեկտներում չկրկնվող նույնացուցիչներ ստեղծելու համար։ Մենք այստեղ նշում ենք դրա գոյության փաստը՝ տիպերի -նկարագիրը լիարժեք դարձնելու համար, բայց թողնում ենք դրա ուսումնասիրությունը հետագայի համար, երբ արդեն ուսումնասիրած կլինենք օբյեկտները։ +`symbol` տիպը օգտագործվում է օբյեկտներում չկրկնվող նույնացուցիչներ ստեղծելու համար։ Մենք այստեղ նշում ենք դրա գոյության փաստը՝ տիպերի նկարագիրը լիարժեք դարձնելու համար, բայց թողնում ենք դրա ուսումնասիրությունը հետագայի համար, երբ արդեն ուսումնասիրած կլինենք օբյեկտները։ ## typeof օպերատորը [#type-typeof] -`typeof` օպերատորը վերադարձնում է իր արգումենտի տիպը։ Այն օգտակար է, երբ մենք ուզում ենք մշակել տարբեր տիպերի արժեքները տարբեր կերպով, կամ -պարզեպես արագ ստուգման կարիք կա։ +`typeof` օպերատորը վերադարձնում է իր արգումենտի տիպը։ Այն օգտակար է, երբ մենք ուզում ենք մշակել տարբեր տիպերի արժեքները տարբեր կերպով, կամ պարզեպես արագ ստուգման կարիք կա։ -Այն ունի օգտագործման երկու սինտաքս․ +Այն ունի օգտագործման երկու շարահյուսություն (syntax)․ 1. Որպես օպերատոր՝ `typeof x`։ 2. Որպես ֆունկցիա `typeof(x)`։ @@ -274,20 +251,15 @@ typeof alert // "function" (3) Վերջին երեք տողերը ունեն հավելյալ պարզաբանման կարիք․ -1. `Math`-ը ներկառուցված օբեկտ է, որը տրամադրում է մաթեմատիկական տարբեր գործողություններ և հաստատուններ։ Մենք կուսումնասիրենք այն - գլխում։ Այստեղ այն պարզապես ծառայում է որպես օբյեկտի օրինակ։ -2. `typeof null`-ի արդյունքը `"object"` է։ Այն `typeof` օպերատորի վարքագծի պաշտոնապես ընդունված սխալ է, որը եկել է JavaScript-ի ստեղծման - վաղ ժամանակներից և մնացել է լեզվում համատեղելիության նպատակով։ Անշուշտ, `null`-ը օբյեկտ չէ։ Այն հատուկ արժեք է, որը ունի իր սեփական տիպը։ -3. `typeof alert`-ի արդյունքը `"function"` է, քանի որ `alert`-ը ֆունկցիա է։ Մենք կուսումնասիրենք ֆունկցիաները հաջորդ գլուխներում, որտեղ - կիմանանք, որ JavaScript-ը չունի առանձին «ֆունկցիա» տիպ։ Ֆունկցիաները պատկանում են օբյեկտ տիպին։ Բայց `typeof`-ը մշակում է դրանք - հատուկ ձևով՝ վերադարձնելով `"function"` արժեքը։ Դա նույնպես գալիս է JavaScript-ի պատմության վաղ ժամանակներից։ Տեխնիկապես վարքագիծը - ճիշտ չէ, բայց պրակտիկայում կարող է հարմար լինել։ +1. `Math`-ը ներկառուցված օբյեկտ է, որը տրամադրում է մաթեմատիկական տարբեր գործողություններ և հաստատուններ։ Մենք կուսումնասիրենք այն գլխում։ Այստեղ այն պարզապես ծառայում է որպես օբյեկտի օրինակ։ +2. `typeof null`-ի արդյունքը `"object"` է։ Այն `typeof` օպերատորի վարքագծի պաշտոնապես ընդունված սխալ է, որը եկել է JavaScript-ի ստեղծման վաղ ժամանակներից և մնացել է լեզվում համատեղելիության նպատակով։ Անշուշտ, `null`-ը օբյեկտ չէ։ Այն հատուկ արժեք է, որը ունի իր սեփական տիպը։ +3. `typeof alert`-ի արդյունքը `"function"` է, քանի որ `alert`-ը ֆունկցիա է։ Մենք կուսումնասիրենք ֆունկցիաները հաջորդ գլուխներում, որտեղ կիմանանք, որ JavaScript-ը չունի առանձին function տիպ։ Ֆունկցիաները պատկանում են object տիպին։ Բայց `typeof`-ը մշակում է դրանք հատուկ ձևով՝ վերադարձնելով `"function"` արժեքը։ Դա նույնպես գալիս է JavaScript-ի պատմության վաղ ժամանակներից։ Տեխնիկապես վարքագիծը ճիշտ չէ, բայց պրակտիկայում կարող է հարմար լինել։ ## Ամփոփում JavaScript-ում գոյություն ունեն տվյալների 8 տիպեր։ -- `number` բոլոր տեսակի թվերի համար․ ամբողջ և լողացող կետով, ամբողջ թվերը սահմանափակված են ±(253-1) միջակայքում։ +- `number` բոլոր տեսակի թվերի համար․ ամբողջ և տասնորդական, ամբողջ թվերը սահմանափակված են ±(253-1) միջակայքում։ - `bigint` կամայական մեծության ամբողջ թվերի համար։ - `string` տողերի համար։ Տողը կարող է պարունակել զրո կամ ավել նիշեր, չկա նիշի համար նախատեսված առանձին տիպ։ - `boolean` `true`/`false` արժեքների համար։ From 9ed10ee31b29c9b7e8f060649143aaba56727978 Mon Sep 17 00:00:00 2001 From: Arthur Date: Sun, 11 Jul 2021 17:22:08 +0400 Subject: [PATCH 8/8] fix: unnecessary new lines removed, typos fixed --- .../06-alert-prompt-confirm/article.md | 33 ++++++++----------- 1 file changed, 13 insertions(+), 20 deletions(-) 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 c2be9b9e4..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,11 +1,10 @@ # Փոխազդեցություն: alert, prompt, confirm -Քանի որ մենք օգտագործելու ենք զննիչները որպես ներկայացման տիրույթ, եկեք ուսումնասիրենք մի քանի ֆունկցիաներ՝ նախատեսված օգտատիրոջ հետ -փոխազդեցության համար․ `alert`, `prompt` և `confirm`։ +Քանի որ մենք օգտագործելու ենք զննիչները որպես ներկայացման տիրույթ, եկեք ուսումնասիրենք մի քանի ֆունկցիաներ՝ նախատեսված օգտատիրոջ հետ փոխազդեցության համար․ `alert`, `prompt` և `confirm`։ ## alert -Այս ֆունկցիայի հետ մենք արդեն առընչվել ենք։ Այն ցույց է տալիս հաղորդագրություն և սպասում է օգտատիրոջ՝ «OK» կոճակը սեղմելուն։ +Այս ֆունկցիայի հետ մենք արդեն առնչվել ենք։ Այն ցույց է տալիս հաղորդագրություն և սպասում է օգտատիրոջ՝ «OK» կոճակը սեղմելուն։ Օրինակ․ @@ -13,8 +12,7 @@ alert("Բարև"); ``` -Հաղորդագրությունը պարունակող փոքր պատուհանը կոչվում է *մոդալ պատուհան* (modal window)։ «Մոդալը» նշանակում է, որ օգտատերը չի կարող փոխազդել -էջի մնացած մասի հետ, սեղմել այլ կոճակներ և այլն, քանի դեռ նա փոխազդում է պատուհանի հետ։ Այս պարագայում՝ քանի դեռ չի սեղմել «OK» կոճակը։ +Հաղորդագրությունը պարունակող փոքր պատուհանը կոչվում է *մոդալ պատուհան* (modal window)։ «Մոդալը» նշանակում է, որ օգտատերը չի կարող փոխազդել էջի մնացած մասի հետ, սեղմել այլ կոճակներ և այլն, քանի դեռ նա փոխազդում է պատուհանի հետ։ Այս պարագայում՝ քանի դեռ չի սեղմել «OK» կոճակը։ ## prompt @@ -32,12 +30,11 @@ result = prompt(title, [default]); `default` : Ոչ պարտադիր երկրորդ արգումենտ՝ մուտքագրման դաշտի նախնական արժեքի համար։ -```smart header="Քառակուսի փակագծերը [...] սինտաքսում" -Վերոնշյալ սինտաքսւմ `default`-ը շրջապատող քառակուսի փակագծերը նշանակում են, որ պարամետրի առկայությունը պարտադիր չէ։ +```smart header="Քառակուսի փակագծերը `[...]` շարահյուսությունում" +Վերոնշյալ շարահյուսությունում `default`-ը շրջապատող քառակուսի փակագծերը նշանակում են, որ պարամետրի առկայությունը պարտադիր չէ։ ``` -Օգտատերը կարող է մուտքագրման դաշտում լրացնել ինչ որ բան և սեղմել OK։ Մուտքագրված տեքստը կվերագրվի `result` փոփոխականին։ Օգտատերը նաև -կարող է չեղարկել մուտքագրումը՝ սեղմելով Cancel կամ ստեղնաշարի `key:Esc` կոճակները։ Այդ դեպքում `result`-ին կվերագրվի `null` արժեքը։ +Օգտատերը կարող է մուտքագրման դաշտում լրացնել ինչ-որ բան և սեղմել OK։ Մուտքագրված տեքստը կվերագրվի `result` փոփոխականին։ Օգտատերը նաև կարող է չեղարկել մուտքագրումը՝ սեղմելով Cancel կամ ստեղնաշարի `key:Esc` կոճակները։ Այդ դեպքում `result`-ին կվերագրվի `null` արժեքը։ `prompt`-ի կանչը վերադարձնում է մուտքագրման դաշտում նշված տեքստը կամ `null`, եթե մուտքագրումը չեղարկվել է։ @@ -49,12 +46,12 @@ let age = prompt('Քանի՞ տարեկան ես։', 100); alert(`Դու ${age} տարեկան ես։`); // Դու 100 տարեկան ես։ ``` -````warn header="IE-ի համար միշտ սահմանեք լռելյայն (default) արժեք" +````warn header="IE-ի համար միշտ սահմանեք լռելյայն (`default`) արժեք" Երկրորդ պարամետրը պարտադիր չէ, բայց, եթե չսահմանենք այն, Internet Explorer-ը կտեղադրի `"undefined"` տեքստը prompt-ի մուտքագրման դաշտում։ Աշխատեցրեք կոդը Internet Explorer-ում՝ արդյունքը տեսնելու համար․ -````js run +```js run let test = prompt("Թեստ"); ``` @@ -67,7 +64,7 @@ let test = prompt("Թեստ", ''); // <-- IE-ի համար ## confirm -Սինտաքսը․ +Շարահյուսությունը (syntax)․ ```js result = confirm(question); @@ -93,20 +90,16 @@ alert( isBoss ); // true, եթե սեղմվի OK կոճակը : պատկերում է հաղորդագրություն։ `prompt` -: պատկերում է հաղորդագրություն, սպասելով օգտատիրոջ կողմից տեքստի մուտքագրմանը։ Այն վերադարձնում է տեքստը, կամ, եթե սեղմվել է Cancel կամ -`key:Esc` կոճակը, ապա վերադարձնում է `null`։ +: պատկերում է հաղորդագրություն, սպասելով օգտատիրոջ կողմից տեքստի մուտքագրմանը։ Այն վերադարձնում է տեքստը, կամ, եթե սեղմվել է Cancel կամ `key:Esc` կոճակը, ապա վերադարձնում է `null`։ `confirm` -: պատկերում է հաղորդագրություն և սպասում է օգտատիրոջ «OK» կամ «Cancel» սեղմելուն։ OK-ի դեպքում վերադարձնում է `true`, իսկ -Cancel/`key:Esc`-ի դեպքում՝ `false`։ +: պատկերում է հաղորդագրություն և սպասում է օգտատիրոջ «OK» կամ «Cancel» սեղմելուն։ OK-ի դեպքում վերադարձնում է `true`, իսկ Cancel/`key:Esc`-ի դեպքում՝ `false`։ -Այս բոլոր մեթոդները մոդալային են․ դրանք կանգնեցնում են սկրիպտի իրականցումը և թույլ չեն տալիս օգտատիրոջը փոխազդել էջի մնացած մասի հետ, -քանի դեռ պատուհանը չի փակվել։ +Այս բոլոր մեթոդները մոդալային են․ դրանք կանգնեցնում են սկրիպտի իրականցումը և թույլ չեն տալիս օգտատիրոջը փոխազդել էջի մնացած մասի հետ, քանի դեռ պատուհանը չի փակվել։ Վերոնշյալ մեթոդները ունեն երկու սահմանափակում․ 1. Մոդալ պատուհանի դիրքը որոշվում է զննիչի կողմից։ Սովորաբար այն լինում է կենտրոնում։ 2. Պատուհանի տեսքը նույնպես որոշվում է զննիչի կողմից։ Մենք չենք կարող այն փոփոխել։ -Այսպիսին է պարզության գինը։ Կան շատ այլ եղանակներ՝ ավելի գեղեցիկ պատուհաններ պատկերելու և օգտատիրոջ հետ ավելի լայն փոխազդեցություն -ապահովելու համար, բայց եթե «ճոխությունը» կարևոր չէ, այս մեթոդները հիանալի լուծում են։ +Այսպիսին է պարզության գինը։ Կան շատ այլ եղանակներ՝ ավելի գեղեցիկ պատուհաններ պատկերելու և օգտատիրոջ հետ ավելի լայն փոխազդեցություն ապահովելու համար, բայց եթե «ճոխությունը» կարևոր չէ, այս մեթոդները հիանալի լուծում են։