Merge pull request #11 from Netaly79/root_pages_2

Root pages 2

Author: OleksandrKucherenko

docs/classes.md

@@ -1,11 +1,10 @@
 ### Classes
-The reason why it's important to have classes in JavaScript as a first class item is that:
+Причина, чому важливо мати класи в JavaScript як елемент першого класу, полягає в тому, що:
+1. [Класи пропонують корисну структурну абстракцію](./tips/classesAreUseful.md)
+1. Забезпечують послідовний спосіб для розробників використовувати класи замість кожного фреймворку (emberjs, reactjs тощо), створюючи власну версію.
+1. Об'єктно-орієнтовані розробники вже розуміють класи
 
-1. [Classes offer a useful structural abstraction](./tips/classesAreUseful.md)
-1. Provides a consistent way for developers to use classes instead of every framework (emberjs,reactjs etc) coming up with their own version.
-1. Object Oriented Developers already understand classes.
-
-Finally JavaScript developers can *have `class`*. Here we have a basic class called Point:
+Нарешті розробники JavaScript можуть *мати `class`*. Як приклад, ми маємо базовий клас під назвою Point:
 ```ts
 class Point {
     x: number;
@@ -23,7 +22,7 @@ var p1 = new Point(0, 10);
 var p2 = new Point(10, 20);
 var p3 = p1.add(p2); // {x:10,y:30}
 ```
-This class generates the following JavaScript on ES5 emit:
+Цей клас генерує наступний JavaScript, грунтуючись на ES5:
 ```ts
 var Point = (function () {
     function Point(x, y) {
@@ -36,10 +35,12 @@ var Point = (function () {
     return Point;
 })();
 ```
-This is a fairly idiomatic traditional JavaScript class pattern now as a first class language construct.
+Це досить ідіоматичний традиційний шаблон класу JavaScript, який тепер є мовною конструкцією першого класу.
 
 ### Inheritance
-Classes in TypeScript (like other languages) support *single* inheritance using the `extends` keyword as shown below:
+Наслідування.
+
+Класи в TypeScript (як і в інших мовах) підтримують *single* наслудування (у класа може бути ліше один батьківський клас) за допомогою ключового слова `extends`, як показано нижче:
 
 ```ts
 class Point3D extends Point {
@@ -54,12 +55,13 @@ class Point3D extends Point {
     }
 }
 ```
-If you have a constructor in your class then you *must* call the parent constructor from your constructor (TypeScript will point this out to you). This ensures that the stuff that it needs to set on `this` gets set. Followed by the call to `super` you can add any additional stuff you want to do in your constructor (here we add another member `z`).
-
-Note that you override parent member functions easily (here we override `add`) and still use the functionality of the super class in your members (using `super.` syntax).
+Якщо у вашому класі є конструктор, ви *повинні* викликати батьківський конструктор із свого конструктора (TypeScript вкаже вам на це). Це гарантує, що все, що потрібно для існування класу та ініціалізації `this`, буде встановлено. Після виклику `super` ви можете додати будь-які додаткові речі, які ви хочете зробити у вашому конструкторі (тут ми додаємо ще один член `z`).
+Зауважте, що ви легко замінюєте батьківські функції-члени (тут ми перевизначаємо `add` ) і все ще використовуємо функціональність суперкласу у своїх членах (використовуючи синтаксис `super.` ).
 
 ### Statics
-TypeScript classes support `static` properties that are shared by all instances of the class. A natural place to put (and access) them is on the class itself and that is what TypeScript does:
+Статичні властивості класу.
+
+Класи TypeScript підтримують статичні властивості, які є спільними для всіх екземплярів класу. Природним місцем для їх розміщення (і доступу) є сам клас, і саме це робить TypeScript:
 
 ```ts
 class Something {
@@ -74,22 +76,23 @@ var s2 = new Something();
 console.log(Something.instances); // 2
 ```
 
-You can have static members as well as static functions.
+Ви можете мати як статичні члени, так і статичні функції.
 
 ### Access Modifiers
-TypeScript supports access modifiers `public`,`private` and `protected` which determine the accessibility of a `class` member as shown below:
+Модифікатори доступу.
 
-| accessible on   | `public` | `protected` | `private` |
-|-----------------|----------|-------------|-----------|
-| class           | yes      | yes         | yes       |
-| class children  | yes      | yes         | no        |
-| class instances | yes      | no          | no        |
+TypeScript підтримує модифікатори доступу `public` (публічний),`private` (приватний) та `protected` (захищений), які визначають доступність члена класу , як показано нижче:
 
+| доступні для    | `public` | `protected` | `private` |
+|-----------------|----------|-------------|-----------|
+| клас            | так      | ні          | так       |
+| дочерний клас   | так      | так         | ні        |
+| екземпляр класу | так      | ні          | ні        |
 
-If an access modifier is not specified it is implicitly `public` as that matches the *convenient* nature of JavaScript 🌹.
 
-Note that at runtime (in the generated JS) these have no significance but will give you compile time errors if you use them incorrectly. An example of each is shown below:
+Якщо модифікатор доступу не вказано, він неявно відкритий, оскільки це відповідає зручному характеру JavaScript 🌹.
 
+Зверніть увагу, що під час виконання (у згенерованому JS) вони не мають значення, але викличуть помилки під час компіляції, якщо ви використовуєте їх неправильно. Приклад кожного показаний нижче:
 ```ts
 class FooBase {
     public x: number;
@@ -114,31 +117,32 @@ class FooChild extends FooBase {
 }
 ```
 
-As always these modifiers work for both member properties and member functions.
+Як завжди, ці модифікатори працюють як для властивостей члена, так і для функцій члена.
 
 ### Abstract
-`abstract` can be thought of as an access modifier. We present it separately because opposed to the previously mentioned modifiers it can be on a `class` as well as any member of the class. Having an `abstract` modifier primarily means that such functionality *cannot be directly invoked* and a child class must provide the functionality.
+Абстрактний клас.
+
+`abstract` можна розглядати як модифікатор доступу. Ми представляємо його окремо, тому що, на відміну від згаданих раніше модифікаторів, він може бути як у `class`, так і в будь-якому члені класу. Наявність `abstract` модифікатора в першу чергу означає, що така функціональність *не може бути безпосередньо викликана* , і дочірній клас повинен надавати цю функціональність.
 
-* `abstract` **classes** cannot be directly instantiated. Instead the user must create some `class` that inherits from the `abstract class`.
+* Ми не можемо створити екземпляр `abstract` **classes**. Замість цього користувач повинен створити якийсь `class`, який наслідує від `abstract class` 
 
 ```ts
 abstract class FooCommand {}
 
 class BarCommand extends FooCommand {}
 
-const fooCommand: FooCommand = new FooCommand(); // Cannot create an instance of an abstract class.
-
-const barCommand = new BarCommand(); // You can create an instance of a class that inherits from an abstract class.
+const fooCommand: FooCommand = new FooCommand(); // Не можно створити екземпляр (instance) класу
+const barCommand = new BarCommand(); // Можно створити екземпляр класу, який є потомком абстрактного класу
 ```
 
-* `abstract` **members** cannot be directly accessed and a child class must provide the functionality.
+*  неможливо отримати прямий доступ до`abstract` **members**, тому дочірній клас повинен забезпечувати цю функціональність.
 
 ```ts
 abstract class FooCommand {
   abstract execute(): string;
 }
 
-class BarErrorCommand  extends FooCommand {} // 'BarErrorCommand' needs implement abstract member 'execute'.
+class BarErrorCommand  extends FooCommand {} // 'BarErrorCommand' повинен реалізувати'execute'.
 
 class BarCommand extends FooCommand {
   execute() {
@@ -152,17 +156,19 @@ barCommand.execute(); // Command Bar executed
 ```
 
 ### Constructor is optional
+Конструктор класу необов'язковий.
 
-The class does not need to have a constructor. e.g. the following is perfectly fine. 
+Клас не потребує наявності конструктора. наприклад, наступне цілком нормально. Якщо не створити конструктор власноруч, TypeScript зробить конструктор за замовчуванням
 
 ```ts
 class Foo {}
 var foo = new Foo();
 ```
 
 ### Define using constructor
+Визначення властивості за допомогою конструктора.
 
-Having a member in a class and initializing it like below:
+Наявність члена в класі та його ініціалізація, як показано нижче:
 
 ```ts
 class Foo {
@@ -172,8 +178,7 @@ class Foo {
     }
 }
 ```
-is such a common pattern that TypeScript provides a shorthand where you can prefix the member with an *access modifier* and it is automatically declared on the class and copied from the constructor. So the previous example can be re-written as (notice `public x:number`):
-
+є настільки поширеним шаблоном, що TypeScript надає скорочення, де ви можете додати до члена *access modifier*, і він автоматично оголошується в класі та копіюється з конструктора. Тож попередній приклад можна переписати таким чином (зверніть увагу на `public x:numbe`r ):
 ```ts
 class Foo {
     constructor(public x:number) {
@@ -182,8 +187,9 @@ class Foo {
 ```
 
 ### Property initializer
-This is a nifty feature supported by TypeScript (from ES7 actually). You can initialize any member of the class outside the class constructor, useful to provide default (notice `members = []`)
+Ініціалізатор властивості.
 
+Це чудова функція, яка підтримується TypeScript (з ES7). Ви можете ініціалізувати будь-який член класу поза конструктором класу, що корисно для встановлення значення за замовчуванням (зверніть увагу на `number = []` )
 ```ts
 class Foo {
     members = [];  // Initialize directly

docs/const.md

@@ -1,60 +1,67 @@
 ### const
+Константи.
 
-`const` is a very welcomed addition offered by ES6 / TypeScript. It allows you to be immutable with variables. This is good from a documentation as well as a runtime perspective. To use const just replace `var` with `const`:
+`const` є дуже бажаним доповненням, запропонованим ES6/TypeScript. Це дозволяє вам створювати змінні, значення которих не можно змінити. Це добре як з точки зору документації, так і з точки зору часу виконання. Щоб використовувати const, просто замініть `var` або `let` на `const`:
 
 ```ts
 const foo = 123;
 ```
 
-> The syntax is much better (IMHO) than other languages that force the user to type something like `let constant foo` i.e. a variable + behavior specifier.
+> Синтаксис TS набагато кращий (IMHO), ніж у інших мовах, які змушують користувача вводити щось на зразок `let constant foo` , тобто змінна + специфікатор поведінки.
 
-`const` is a good practice for both readability and maintainability and avoids using *magic literals* e.g.
+`const` є хорошою практикою як для зручності читання, так і для підтримки та уникає використання *magic literals* ("магічних" значень), наприклад
 
 ```ts
-// Low readability
+// Низька читабельність та не зрозуміло, чому саме 10?
 if (x > 10) {
 }
 
-// Better!
+// Краще!
 const maxRows = 10;
 if (x > maxRows) {
 }
 ```
 
 #### const declarations must be initialized
-The following is a compiler error:
+
+ВАЖЛИВО! Константа повинна отримати значення при створені.
+
+Нижче наведено помилку компілятора:
 
 ```ts
-const foo; // ERROR: const declarations must be initialized
+const foo; // ПОМИЛКА: необхідно ініціалізувати оголошення const
 ```
 
 #### Left hand side of assignment cannot be a constant
-Constants are immutable after creation, so if you try to assign them to a new value it is a compiler error:
+
+Константи є незмінними після створення, тому якщо ви спробуєте призначити їм нове значення, це буде помилкою компілятора:
 
 ```ts
 const foo = 123;
-foo = 456; // ERROR: Left-hand side of an assignment expression cannot be a constant
+foo = 456; // ПОМИЛКА
 ```
 
 #### Block Scoped
-A `const` is block scoped like we saw with [`let`](./let.md):
+
+`Const` має блочну область видимості , як ми бачили з  [`let`](./let.md):
 
 ```ts
 const foo = 123;
 if (true) {
-    const foo = 456; // Allowed as its a new variable limited to this `if` block
+    const foo = 456; // Можливо, тому що це інша знінна foo
 }
 ```
 
 #### Deep immutability
-A `const` works with object literals as well, as far as protecting the variable *reference* is concerned:
+
+`const` також працює з об’єктними літералами, в цьому припаді незмінною є *reference* (посилання) на змінну:
 
 ```ts
 const foo = { bar: 123 };
-foo = { bar: 456 }; // ERROR : Left hand side of an assignment expression cannot be a constant
+foo = { bar: 456 }; // // ПОМИЛКА: не можна присвоїти змінній інший обʼєкт
 ```
 
-However, it still allows sub properties of objects to be mutated, as shown below:
+Однак він все ще дозволяє змінювати властивості об’єктів, як показано нижче:
 
 ```ts
 const foo = { bar: 123 };
@@ -64,4 +71,4 @@ console.log(foo); // { bar: 456 }
 
 #### Prefer const
 
-Always use `const`, unless you plan to either lazily initialization of a variable, or do a reassignment (use `let` for those cases).
+Завжди використовуйте const , якщо ви не плануєте пізніше ініціалізувати змінну, або виконати перепризначення (використовуйте let для таких випадків).