From 37f6f848a6393a998d75e7b587f605422952f38b Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Mon, 2 Nov 2015 21:26:21 +0200
Subject: Rename ua-ua/javascript-ua.html.markdown to
 uk-ua/javascript-ua.html.markdown

Please, change lang to uk-ua.
---
 uk-ua/javascript-ua.html.markdown | 501 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 501 insertions(+)
 create mode 100644 uk-ua/javascript-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
new file mode 100644
index 00000000..fedbf5ac
--- /dev/null
+++ b/uk-ua/javascript-ua.html.markdown
@@ -0,0 +1,501 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+filename: javascript-ru.js
+translators:
+  - ["Alexey Gonchar", "http://github.com/finico"]
+  - ["Andre Polykanine", "https://github.com/Oire"]
+lang: ru-ru
+---
+
+JavaScript було створено в 1995 році Бренданом Айком, який працював у копаніх Netscape.
+Він був задуманий як проста мова сценаріїв для веб-сайтів, який би доповнював Java
+для більш складних веб-застосунків. Але тісна інтеграція з веб-сторінками і
+вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
+за власне Java.
+
+Зараз JavaScript не обмежується тільки веб-браузеорм. Наприклад, Node.js,
+програмна платформа, що дозволяє виконувати JavaScript код з використанням
+рушія V8 від браузера Google Chrome, стає все більш і більш популярною.
+
+```js
+// С-подібні коментарі. Однорядкові коментарі починаються з двох символів /(слеш)
+/* а багаторядкові коментарі починаються з послідовності слеша та зірочки і
+   закінчуються символами зірочка-слеш */
+
+Інструкції можуть закінчуватися крапкою з комою ;
+doStuff();
+
+// ... але не обов’язково, тому що крапка з комою автоматично вставляється на
+// місці символу нового рядка, крім деяких випадків.
+doStuff()
+
+// Ми завжди будемо використовувати крапку з комою в цьому посібнику, тому що ці
+// винятки можуть призвести до неочікуваних результатів
+
+///////////////////////////////////
+// 1. Числа, Рядки і Оператори
+
+// В JavaScript числа зберігаються тільки в одному форматі (64-bit IEEE 754 double)
+// Цей тип має 52-бітну мантису, якої достатньо для збереження чисел з
+// точністю до 9✕10¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Деякі прості арифметичні операції працють так, як ми очікуємо.
+1 + 1; // = 2
+0.1 + 0.2; // = 0.30000000000000004 (а деякі - ні)
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// В тому числі ділення з остачою
+5 / 2; // = 2.5
+
+// В JavaScript є побітові операції; коли ви виконуєте таку операцію,
+// число з плаваючою точкою переводиться в ціле зі знаком
+// довжиною *до* 32 розрядів.
+1 << 2; // = 4
+
+// Пріоритет у виразах можна задати явно круглими дужками
+(1 + 3) * 2; // = 8
+
+// Є три спеціальні значення, які не є реальними числами:
+Infinity; // "нескінченність", наприклад, як результат ділення на 0
+-Infinity; // "мінус нескінченність", як результат ділення від’ємного числа на 0
+NaN; // "не число", наприклад, ділення 0/0
+
+// Логічні типи
+true;
+false;
+
+// Рядки створюються за допомогою подвійних та одинарних лапок
+'абв';
+"Hello, world!";
+
+// Для логічного заперечення використовується знак оклику.
+!true; // = false
+!false; // = true
+
+// Строга рівність ===
+1 === 1; // = true
+2 === 1; // = false
+
+// Строга нерівність !==
+1 !== 1; // = false
+2 !== 1; // = true
+
+// Інші оператори порівняння
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Рядки об’єднуються за допомогою оператор +
+"hello, " + "world!"; // = "hello, world!"
+
+// І порівнюються за допомогою > і <
+"a" < "b"; // = true
+
+// Перевірка на рівність з приведнням типів здійснюється оператором ==
+"5" == 5; // = true
+null == undefined; // = true
+
+// ... але приведення не виконується при ===
+"5" === 5; // = false
+null === undefined; // = false 
+
+// ... приведення типів може призвести до дивних результатів
+13 + !0; // 14
+"13" + !0; // '13true'
+
+// Можна отримати доступ до будь-якого символа рядка за допомгою charAt
+"Это строка".charAt(0);  // = 'Э'
+
+// ... або використати метод substring, щоб отримати більший кусок
+"Hello, world".substring(0, 5); // = "Hello"
+
+// length - це не метод, а поле
+"Hello".length; // = 5
+
+// Типи null и undefined
+null; // навмисна відсутність результату
+undefined; // використовується для позначення відсутності присвоєного значення
+
+// false, null, undefined, NaN, 0 и "" — хиба; все інше - істина.
+// Потрібно відмітити, що 0 — це зиба, а "0" — істина, не зважаючи на те що:
+// 0 == "0".
+
+///////////////////////////////////
+// 2. Змінні, Масиви, Об’єкти
+
+// Змінні оголошуються за допомогою ключового слова var. JavaScript — мова з
+// динамічною типізацією, тому не потрібно явно вказувати тип. Для присвоєння
+// значення змінної використовується символ =
+var someVar = 5;
+
+// якщо пропустити слово var, ви не отримаєте повідомлення про помилку, ...
+someOtherVar = 10;
+
+// ... але ваша змінна буде створення в глобальному контексті, а не там, де
+// ви її оголосили
+
+// Змінні, які оголошені без присвоєння, автоматично приймають значення undefined
+var someThirdVar; // = undefined
+
+// У математичних операцій є скорочені форми:
+someVar += 5; // як someVar = someVar + 5;
+someVar *= 10; // тепер someVar = 100
+
+// Інкремент і декремент
+someVar++; // тепер someVar дорівнює 101
+someVar--; // а зараз 100
+
+// Масиви — це нумеровані списку, які зберігають значення будь-якого типу.
+var myArray = ["Hello", 45, true];
+
+// Доступ до елементів можна отримати за допомогою синтаксиса з квадратними дужками
+// Індексація починається з нуля
+myArray[1]; // = 45
+
+// Массивы можно изменять, как и их длину,
+myArray.push("Мир");
+myArray.length; // = 4
+
+// додавання і редагування елементів
+myArray[3] = "Hello";
+
+// Об’єкти в JavaScript сході на словники або асоціативні масиви в інших мовах
+var myObj = {key1: "Hello", key2: "World"};
+
+// Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
+// правилам формування назв змінних. Значення можуть бути будь-яких типів.
+var myObj = {myKey: "myValue", "my other key": 4};
+
+// Атрибути можна отримати використовуючи квадратні дужки
+myObj["my other key"]; // = 4
+
+// Або через точку, якщо ключ є правильним ідентифікатором
+myObj.myKey; // = "myValue"
+
+// Об’єкти можна динамічно змінювати й додавати нові поля
+myObj.myThirdKey = true;
+
+// Коли ви звертаєтесб до поля, яке не існує, ви отримуєте значення undefined
+myObj.myFourthKey; // = undefined
+
+///////////////////////////////////
+// 3. Управляючі конструкції
+
+// Синтаксис для цього розділу майже такий самий, як у Java
+
+// Умовна конструкція
+var count = 1;
+if (count == 3) {
+    // виконується, якщо count дорівнює 3
+} else if (count == 4) {
+    // ..
+} else {
+    // ...
+}
+
+// ...  цикл while.
+while (true){
+    // Нескінченний цикл!
+}
+
+// Цикл do-while такий самий, як while, але завжди виконується принаймні один раз.
+var input
+do {
+    input = getInput();
+} while (!isValid(input))
+
+// цикл for такий самий, кяк в C і Java:
+// ініціалізація; умова; крок.
+for (var i = 0; i < 5; i++) {
+    // виконається 5 разів
+}
+
+// && — логічне І, || — логічне АБО
+if (house.size == "big" && house.color == "blue") {
+    house.contains = "bear";
+}
+if (color == "red" || color == "blue") {
+    // колір червоний або синій
+}
+
+// && і || використовують скорочене обчислення
+// тому їх можна використовувати для задання значень за замовчуванням.
+var name = otherName || "default";
+
+// Оператор switch виконує перевірку на рівність за допомогою ===
+// використовуйте break, щоб призупити виконання наступного case,  
+grade = 4;
+switch (grade) {
+  case 5:
+    console.log("Відмінно");
+    break;
+  case 4:
+    console.log("Добре");
+    break;
+  case 3:
+    console.log("Можна краще");
+    break;
+  default:
+    console.log("Погано!");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Функції, область видимості і замикання
+
+// Функції в  JavaScript оголошуються за допомогою ключового слова function.
+function myFunction(thing) {
+    return thing.toUpperCase();
+}
+myFunction("foo"); // = "FOO"
+ 
+// Зверність увагу, що значення яке буде повернено, повинно починатися на тому ж
+// рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
+// із-за автоматичної вставки крапки з комою
+function myFunction()
+{
+    return // <- крапка з комою вставляється автоматично
+    {
+        thisIsAn: 'object literal'
+    }
+}
+myFunction(); // = undefined
+
+// В JavaScript функції - це об`єкти першого класу, тому вони можуть присвоюватися
+// іншим змінним і передаватися іншим функціям, наприклад, щоб визначити обробник
+// події.
+function myFunction() {
+    // код буде виконано через 5 сек.
+}
+setTimeout(myFunction, 5000);
+// setTimeout не є частиною мови, але реалізований в браузерах і Node.js
+
+// Функции не обязательно должны иметь имя при объявлении — вы можете написать
+// анонимное определение функции непосредственно в аргументе другой функции.
+// Функції не обов’язково мають мати ім’я при оголошенні — ви можете написати
+// анонімну функцію прямо в якості аргумента іншої функції
+setTimeout(function() {
+    // Цей код буде виконано через п’ять секунд
+}, 5000);
+
+// В JavaScript реалізована концепція області видимості; функції мають свою
+// область видимости, а інші блоки не мають
+if (true) {
+    var i = 5;
+}
+i; // = 5, а не undefined, як це звичайно буває в інших мова
+
+// Така особливість призвела до шаблону "анонімних функцій, які викликають самих себе"
+// що дозволяє уникнути проникнення змінних в глобальну область видимості
+(function() {
+    var temporary = 5;
+    // об’єкт window зберігає глобальний контекст; таким чином ми можемо також додавати
+    // змінні до глобальної області
+    window.permanent = 10;
+})();
+temporary; // повідомлення про помилку ReferenceError
+permanent; // = 10
+
+// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
+// определена внутри другой функции, то внутренняя функция имеет доступ к 
+// переменным внешней функции даже после того, как контекст выполнения выйдет из
+// внешней функции.
+// Замикання - одна з найпотужніших інтрументів JavaScript. Якщо функція визначена
+// всередині іншої функції, то внутрішня функція має доступ до змінних зовнішньої
+// функції навіть після того, як код буде виконуватися поза контекстом зовнішньої функції
+function sayHelloInFiveSeconds(name) {
+    var prompt = "Hello, " + name + "!";
+    // Внутрішня функція зберігається в локальній області так,
+    // ніби функція була оголошена за допомогою ключового слова var
+    function inner() {
+        alert(prompt);
+    }
+    setTimeout(inner, 5000);
+    // setTimeout асинхронна, тому функція sayHelloInFiveSeconds зразу завершиться,
+    // після чого setTimeout викличе функцію inner. Але функція inner
+    // «замкнута» кругом sayHelloInFiveSeconds, вона все рівно має доступ до змінної prompt
+}
+sayHelloInFiveSeconds("Адам"); // Через 5 с відкриється вікно «Hello, Адам!»
+
+///////////////////////////////////
+// 5. Об’єкти: конструктори і прототипи
+
+// Об’єкти можуть містити функції
+var myObj = {
+    myFunc: function() {
+        return "Hello, world!";
+    }
+};
+myObj.myFunc(); // = "Hello, world!"
+
+// Функції, що прикріплені до об’єктів мають доступ до поточного об’єкта за 
+// допомогою ключового слова this.
+myObj = {
+    myString: "Hello, world!",
+    myFunc: function() {
+        return this.myString;
+    }
+};
+myObj.myFunc(); // = "Hello, world!"
+
+// Значення this залежить від того, як функція викликається
+// а не від того, де вона визначена. Таким чином наша функція не працює, якщо
+// вона викликана не в контексті об’єкта
+var myFunc = myObj.myFunc;
+myFunc(); // = undefined
+
+// Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до 
+// цього об’єкта через this
+var myOtherFunc = function() {
+}
+myObj.myOtherFunc = myOtherFunc;
+myObj.myOtherFunc(); // = "HELLO, WORLD!"
+
+// Контекст виконання функції можна задати за допомогою сall або apply
+var anotherFunc = function(s) {
+    return this.myString + s;
+}
+anotherFunc.call(myObj, " Hello!"); // = "Hello, world! Hello!"
+
+// Функцiя apply приймає в якості аргументу масив
+anotherFunc.apply(myObj, [" Hello!"]); // = "Hello, world! Hello!"
+
+// apply можна використати, коли функція працює послідовністю аргументів, а
+// ви хочете передати масив
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (Ой-ой!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Але call і apply — тимчасові. Коли ми хочемо зв’язати функцію і об’єкт 
+// використовують bind
+var boundFunc = anotherFunc.bind(myObj);
+boundFunc(" Hello!"); // = "Hello world, Hello!"
+
+// Bind можна використати для задання аргументів
+var product = function(a, b) { return a * b; }
+var doubler = product.bind(this, 2);
+doubler(8); // = 16
+
+// Коли ви викликаєте функцію за допомогою ключового слова new, створюється новий об’єкт,
+// доступний функції за допомогою this. Такі функції називають конструкторами.
+var MyConstructor = function() {
+    this.myNumber = 5;
+}
+myNewObj = new MyConstructor(); // = {myNumber: 5}
+myNewObj.myNumber; // = 5
+
+// У кожного об’єкта є прототип. Коли ви звертаєтесь до поля, яке не існує в цьому
+//  об’єктів, інтерпретатор буде шукати поле в прототипі
+
+// Деякі реалізації мови дозволяють отримати доступ до прототипа об’єкта через
+// "магічну" властивість __proto__. Це поле не є частиною стандарта, але існують
+// стандартні способи використання прототипів, які ми побачимо пізніше
+var myObj = {
+    myString: "Hello, world!"
+};
+var myPrototype = {
+    meaningOfLife: 42,
+    myFunc: function() {
+        return this.myString.toLowerCase()
+    }
+};
+
+myObj.__proto__ = myPrototype;
+myObj.meaningOfLife; // = 42
+
+// Аналогічно для функцій
+myObj.myFunc(); // = "Hello, world!"
+
+// Якщо інтерпретатор не знайде властивість в прототипі, то він продвжить пошук
+// в прототипі прототипа і так далі
+myPrototype.__proto__ = {
+    myBoolean: true
+};
+myObj.myBoolean; // = true
+
+// Кожег об’єкт зберігає посилання на свій прототип. Це значить, що ми можемо змінити
+// наш прототип, і наші зміни будуть всюди відображені.
+myPrototype.meaningOfLife = 43;
+myObj.meaningOfLife; // = 43
+
+// Ми сказали, що властивість __proto__ нестандартне, і нема ніякого стандартного способу
+// змінити прототип об’єкта, що вже існує. Але є два способи створити новий об’єкт зі заданим
+// прототипом
+
+// Перший спосіб — це Object.create, який з’явився JavaScript недавно,
+// а тому в деяких реалізаціях може бути не доступним.
+var myObj = Object.create(myPrototype);
+myObj.meaningOfLife; // = 43
+
+// Другий спосіб: у конструкторів є властивість з іменем prototype. Це *не*
+// прототип функції-конструктора, це прототип для нових об’єктів, які будуть створені
+// цим конструктором і ключового слова new.
+MyConstructor.prototype = {
+    myNumber: 5,
+    getMyNumber: function() {
+        return this.myNumber;
+    }
+};
+var myNewObj2 = new MyConstructor();
+myNewObj2.getMyNumber(); // = 5
+myNewObj2.myNumber = 6
+myNewObj2.getMyNumber(); // = 6
+
+// У вбудованих типів(рядок, число) теж є конструктори, які створють еквівалентні
+// об’єкти-обгортки
+var myNumber = 12;
+var myNumberObj = new Number(12);
+myNumber == myNumberObj; // = true
+
+// Але вони не ідентичні
+typeof myNumber; // = 'number'
+typeof myNumberObj; // = 'object'
+myNumber === myNumberObj; // = false
+if (0) {
+    // Этот код не выполнится, потому что 0 - это ложь.
+}
+
+// Об’єкти-обгортки і вбудовані типи мають спільні прототипи, тому
+// ви можете розширити функціонал рядків:
+String.prototype.firstCharacter = function() {
+    return this.charAt(0);
+}
+"abc".firstCharacter(); // = "a"
+
+// Такий прийом часто використовуються в поліфілах, які реалізують нові можливості
+// JavaScript в старій реалізації мови, так що вони можуть бути використані в старих
+// середовищах
+
+// Наприклад, Object.create доступний не у всіх реалізація, но ми можемо
+// використати функції за допомогою наступного поліфіла:
+if (Object.create === undefined) { // не перезаписываем метод, если он существует
+    Object.create = function(proto) {
+        // Створюємо правильний конструктор з правильним прототипом
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+    
+        return new Constructor();
+    }
+}
+```
+
+## Що почитати
+
+[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+[4]: http://www.learneroo.com/modules/64/nodes/350
+[5]: http://bonsaiden.github.io/JavaScript-Garden/
+[6]: http://www.amazon.com/gp/product/0596805527/
+[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+[8]: http://eloquentjavascript.net/
+[9]: http://jstherightway.org/
-- 
cgit v1.2.3


From 4077facd3c880c96f8044fc99ca656af8d1427b3 Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Wed, 11 Nov 2015 08:58:13 +0200
Subject: Update javascript-ua.html.markdown

Fixed translation and heading.
---
 uk-ua/javascript-ua.html.markdown | 88 ++++++++++++++++++---------------------
 1 file changed, 41 insertions(+), 47 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index fedbf5ac..dae27d32 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -3,11 +3,11 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
-filename: javascript-ru.js
+filename: javascript-ua.js
 translators:
-  - ["Alexey Gonchar", "http://github.com/finico"]
-  - ["Andre Polykanine", "https://github.com/Oire"]
-lang: ru-ru
+  - ["Ivan Neznayu", "https://github.com/IvanEh"]
+  - ["Serhii Maksymchuk", "https://maximchuk.tk"]
+lang: uk-ua
 ---
 
 JavaScript було створено в 1995 році Бренданом Айком, який працював у копаніх Netscape.
@@ -25,7 +25,7 @@ JavaScript було створено в 1995 році Бренданом Айк
 /* а багаторядкові коментарі починаються з послідовності слеша та зірочки і
    закінчуються символами зірочка-слеш */
 
-Інструкції можуть закінчуватися крапкою з комою ;
+//Інструкції можуть закінчуватися крапкою з комою ;
 doStuff();
 
 // ... але не обов’язково, тому що крапка з комою автоматично вставляється на
@@ -51,7 +51,7 @@ doStuff()
 10 * 2; // = 20
 35 / 5; // = 7
 
-// В тому числі ділення з остачою
+// В тому числі ділення з остачею
 5 / 2; // = 2.5
 
 // В JavaScript є побітові операції; коли ви виконуєте таку операцію,
@@ -73,7 +73,7 @@ false;
 
 // Рядки створюються за допомогою подвійних та одинарних лапок
 'абв';
-"Hello, world!";
+"Світ, привіт!";
 
 // Для логічного заперечення використовується знак оклику.
 !true; // = false
@@ -93,10 +93,10 @@ false;
 2 <= 2; // = true
 2 >= 2; // = true
 
-// Рядки об’єднуються за допомогою оператор +
+// Рядки об’єднуються за допомогою оператора +
 "hello, " + "world!"; // = "hello, world!"
 
-// І порівнюються за допомогою > і <
+// І порівнюються за допомогою > та <
 "a" < "b"; // = true
 
 // Перевірка на рівність з приведнням типів здійснюється оператором ==
@@ -112,7 +112,7 @@ null === undefined; // = false
 "13" + !0; // '13true'
 
 // Можна отримати доступ до будь-якого символа рядка за допомгою charAt
-"Это строка".charAt(0);  // = 'Э'
+"Це рядок".charAt(0);  // = 'Ц'
 
 // ... або використати метод substring, щоб отримати більший кусок
 "Hello, world".substring(0, 5); // = "Hello"
@@ -124,8 +124,8 @@ null === undefined; // = false
 null; // навмисна відсутність результату
 undefined; // використовується для позначення відсутності присвоєного значення
 
-// false, null, undefined, NaN, 0 и "" — хиба; все інше - істина.
-// Потрібно відмітити, що 0 — це зиба, а "0" — істина, не зважаючи на те що:
+// false, null, undefined, NaN, 0 та "" — хиба; все інше - істина.
+// Потрібно відмітити, що 0 — це хиба, а "0" — істина, не зважаючи на те що:
 // 0 == "0".
 
 ///////////////////////////////////
@@ -139,7 +139,7 @@ var someVar = 5;
 // якщо пропустити слово var, ви не отримаєте повідомлення про помилку, ...
 someOtherVar = 10;
 
-// ... але ваша змінна буде створення в глобальному контексті, а не там, де
+// ... але ваша змінна буде створена в глобальному контексті, а не там, де
 // ви її оголосили
 
 // Змінні, які оголошені без присвоєння, автоматично приймають значення undefined
@@ -153,21 +153,21 @@ someVar *= 10; // тепер someVar = 100
 someVar++; // тепер someVar дорівнює 101
 someVar--; // а зараз 100
 
-// Масиви — це нумеровані списку, які зберігають значення будь-якого типу.
-var myArray = ["Hello", 45, true];
+// Масиви — це нумеровані списки, які зберігають значення будь-якого типу.
+var myArray = ["Привіт", 45, true];
 
 // Доступ до елементів можна отримати за допомогою синтаксиса з квадратними дужками
 // Індексація починається з нуля
 myArray[1]; // = 45
 
-// Массивы можно изменять, как и их длину,
-myArray.push("Мир");
+// Масиви можна змінювати, як і їх довжину
+myArray.push("Привіт");
 myArray.length; // = 4
 
-// додавання і редагування елементів
-myArray[3] = "Hello";
+// Додавання і редагування елементів
+myArray[3] = "світ";
 
-// Об’єкти в JavaScript сході на словники або асоціативні масиви в інших мовах
+// Об’єкти в JavaScript схожі на словники або асоціативні масиви в інших мовах
 var myObj = {key1: "Hello", key2: "World"};
 
 // Ключі - це рядки, але лапки не обов’язкі, якщо ключ задовольняє
@@ -183,11 +183,11 @@ myObj.myKey; // = "myValue"
 // Об’єкти можна динамічно змінювати й додавати нові поля
 myObj.myThirdKey = true;
 
-// Коли ви звертаєтесб до поля, яке не існує, ви отримуєте значення undefined
+// Коли ви звертаєтесь до поля, що не існує, ви отримуєте значення undefined
 myObj.myFourthKey; // = undefined
 
 ///////////////////////////////////
-// 3. Управляючі конструкції
+// 3. Керуючі конструкції
 
 // Синтаксис для цього розділу майже такий самий, як у Java
 
@@ -212,7 +212,7 @@ do {
     input = getInput();
 } while (!isValid(input))
 
-// цикл for такий самий, кяк в C і Java:
+// цикл for такий самий, як в C і Java:
 // ініціалізація; умова; крок.
 for (var i = 0; i < 5; i++) {
     // виконається 5 разів
@@ -226,7 +226,7 @@ if (color == "red" || color == "blue") {
     // колір червоний або синій
 }
 
-// && і || використовують скорочене обчислення
+// && та || використовують скорочене обчислення
 // тому їх можна використовувати для задання значень за замовчуванням.
 var name = otherName || "default";
 
@@ -260,7 +260,7 @@ myFunction("foo"); // = "FOO"
  
 // Зверність увагу, що значення яке буде повернено, повинно починатися на тому ж
 // рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
-// із-за автоматичної вставки крапки з комою
+// через автоматичну вставку крапки з комою
 function myFunction()
 {
     return // <- крапка з комою вставляється автоматично
@@ -279,8 +279,6 @@ function myFunction() {
 setTimeout(myFunction, 5000);
 // setTimeout не є частиною мови, але реалізований в браузерах і Node.js
 
-// Функции не обязательно должны иметь имя при объявлении — вы можете написать
-// анонимное определение функции непосредственно в аргументе другой функции.
 // Функції не обов’язково мають мати ім’я при оголошенні — ви можете написати
 // анонімну функцію прямо в якості аргумента іншої функції
 setTimeout(function() {
@@ -288,11 +286,11 @@ setTimeout(function() {
 }, 5000);
 
 // В JavaScript реалізована концепція області видимості; функції мають свою
-// область видимости, а інші блоки не мають
+// область видимості, а інші блоки не мають
 if (true) {
     var i = 5;
 }
-i; // = 5, а не undefined, як це звичайно буває в інших мова
+i; // = 5, а не undefined, як це звичайно буває в інших мовах
 
 // Така особливість призвела до шаблону "анонімних функцій, які викликають самих себе"
 // що дозволяє уникнути проникнення змінних в глобальну область видимості
@@ -305,26 +303,22 @@ i; // = 5, а не undefined, як це звичайно буває в інши
 temporary; // повідомлення про помилку ReferenceError
 permanent; // = 10
 
-// Одной из самых мощных возможностей JavaScript являются замыкания. Если функция
-// определена внутри другой функции, то внутренняя функция имеет доступ к 
-// переменным внешней функции даже после того, как контекст выполнения выйдет из
-// внешней функции.
-// Замикання - одна з найпотужніших інтрументів JavaScript. Якщо функція визначена
+// Замикання - один з найпотужніших інтрументів JavaScript. Якщо функція визначена
 // всередині іншої функції, то внутрішня функція має доступ до змінних зовнішньої
 // функції навіть після того, як код буде виконуватися поза контекстом зовнішньої функції
 function sayHelloInFiveSeconds(name) {
-    var prompt = "Hello, " + name + "!";
+    var prompt = "Привіт, " + name + "!";
     // Внутрішня функція зберігається в локальній області так,
     // ніби функція була оголошена за допомогою ключового слова var
     function inner() {
         alert(prompt);
     }
     setTimeout(inner, 5000);
-    // setTimeout асинхронна, тому функція sayHelloInFiveSeconds зразу завершиться,
+    // setTimeout асинхронна, тому функція sayHelloInFiveSeconds одразу завершиться,
     // після чого setTimeout викличе функцію inner. Але функція inner
     // «замкнута» кругом sayHelloInFiveSeconds, вона все рівно має доступ до змінної prompt
 }
-sayHelloInFiveSeconds("Адам"); // Через 5 с відкриється вікно «Hello, Адам!»
+sayHelloInFiveSeconds("Адам"); // Через 5 с відкриється вікно «Привіт, Адам!»
 
 ///////////////////////////////////
 // 5. Об’єкти: конструктори і прототипи
@@ -394,7 +388,7 @@ myNewObj = new MyConstructor(); // = {myNumber: 5}
 myNewObj.myNumber; // = 5
 
 // У кожного об’єкта є прототип. Коли ви звертаєтесь до поля, яке не існує в цьому
-//  об’єктів, інтерпретатор буде шукати поле в прототипі
+// об’єкті, інтерпретатор буде шукати поле в прототипі
 
 // Деякі реалізації мови дозволяють отримати доступ до прототипа об’єкта через
 // "магічну" властивість __proto__. Це поле не є частиною стандарта, але існують
@@ -415,24 +409,24 @@ myObj.meaningOfLife; // = 42
 // Аналогічно для функцій
 myObj.myFunc(); // = "Hello, world!"
 
-// Якщо інтерпретатор не знайде властивість в прототипі, то він продвжить пошук
+// Якщо інтерпретатор не знайде властивість в прототипі, то він продовжить пошук
 // в прототипі прототипа і так далі
 myPrototype.__proto__ = {
     myBoolean: true
 };
 myObj.myBoolean; // = true
 
-// Кожег об’єкт зберігає посилання на свій прототип. Це значить, що ми можемо змінити
+// Кожен об’єкт зберігає посилання на свій прототип. Це значить, що ми можемо змінити
 // наш прототип, і наші зміни будуть всюди відображені.
 myPrototype.meaningOfLife = 43;
 myObj.meaningOfLife; // = 43
 
-// Ми сказали, що властивість __proto__ нестандартне, і нема ніякого стандартного способу
-// змінити прототип об’єкта, що вже існує. Але є два способи створити новий об’єкт зі заданим
+// Ми сказали, що властивість __proto__ нестандартна, і нема ніякого стандартного способу
+// змінити прототип об’єкта, що вже існує. Але є два способи створити новий об’єкт із заданим
 // прототипом
 
-// Перший спосіб — це Object.create, який з’явився JavaScript недавно,
-// а тому в деяких реалізаціях може бути не доступним.
+// Перший спосіб — це Object.create, який з’явився в JavaScript недавно,
+// а тому в деяких реалізаціях може бути недоступним.
 var myObj = Object.create(myPrototype);
 myObj.meaningOfLife; // = 43
 
@@ -461,7 +455,7 @@ typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
 if (0) {
-    // Этот код не выполнится, потому что 0 - это ложь.
+    // Цей код не виконається, тому що 0 - це хиба.
 }
 
 // Об’єкти-обгортки і вбудовані типи мають спільні прототипи, тому
@@ -475,9 +469,9 @@ String.prototype.firstCharacter = function() {
 // JavaScript в старій реалізації мови, так що вони можуть бути використані в старих
 // середовищах
 
-// Наприклад, Object.create доступний не у всіх реалізація, но ми можемо
+// Наприклад, Object.create доступний не у всіх реалізаціях, але ми можемо
 // використати функції за допомогою наступного поліфіла:
-if (Object.create === undefined) { // не перезаписываем метод, если он существует
+if (Object.create === undefined) { // не перезаписуємо метод, якщо він існує
     Object.create = function(proto) {
         // Створюємо правильний конструктор з правильним прототипом
         var Constructor = function(){};
-- 
cgit v1.2.3


From 8738cef0ad36614b80df63d8d942c6c1416f3e8e Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Fri, 27 Nov 2015 12:36:10 +0200
Subject: Update javascript-ua.html.markdown

Updated according to [Andre Polykanine ](https://github.com/Oire) comments.
---
 uk-ua/javascript-ua.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index dae27d32..2c534d83 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -5,8 +5,8 @@ contributors:
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 filename: javascript-ua.js
 translators:
-  - ["Ivan Neznayu", "https://github.com/IvanEh"]
-  - ["Serhii Maksymchuk", "https://maximchuk.tk"]
+  - ["Ivan", "https://github.com/IvanEh"]
+  - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
 lang: uk-ua
 ---
 
@@ -73,7 +73,7 @@ false;
 
 // Рядки створюються за допомогою подвійних та одинарних лапок
 'абв';
-"Світ, привіт!";
+"Привіт, світе!";
 
 // Для логічного заперечення використовується знак оклику.
 !true; // = false
@@ -139,7 +139,7 @@ var someVar = 5;
 // якщо пропустити слово var, ви не отримаєте повідомлення про помилку, ...
 someOtherVar = 10;
 
-// ... але ваша змінна буде створена в глобальному контексті, а не там, де
+// ... але вашу змінну буде створено в глобальному контексті, а не там, де
 // ви її оголосили
 
 // Змінні, які оголошені без присвоєння, автоматично приймають значення undefined
@@ -160,7 +160,7 @@ var myArray = ["Привіт", 45, true];
 // Індексація починається з нуля
 myArray[1]; // = 45
 
-// Масиви можна змінювати, як і їх довжину
+// Масиви в JavaScript змінюють довжину при додаванні нових елементів
 myArray.push("Привіт");
 myArray.length; // = 4
 
@@ -258,7 +258,7 @@ function myFunction(thing) {
 }
 myFunction("foo"); // = "FOO"
  
-// Зверність увагу, що значення яке буде повернено, повинно починатися на тому ж
+// Зверніть увагу, що значення яке буде повернено, повинно починатися на тому ж
 // рядку, що і ключове слово return, інакше завжди буде повертатися значення undefined
 // через автоматичну вставку крапки з комою
 function myFunction()
@@ -280,7 +280,7 @@ setTimeout(myFunction, 5000);
 // setTimeout не є частиною мови, але реалізований в браузерах і Node.js
 
 // Функції не обов’язково мають мати ім’я при оголошенні — ви можете написати
-// анонімну функцію прямо в якості аргумента іншої функції
+// анонімну функцію як аргумент іншої функції
 setTimeout(function() {
     // Цей код буде виконано через п’ять секунд
 }, 5000);
@@ -303,7 +303,7 @@ i; // = 5, а не undefined, як це звичайно буває в інши
 temporary; // повідомлення про помилку ReferenceError
 permanent; // = 10
 
-// Замикання - один з найпотужніших інтрументів JavaScript. Якщо функція визначена
+// Замикання - один з найпотужніших інструментів JavaScript. Якщо функція визначена
 // всередині іншої функції, то внутрішня функція має доступ до змінних зовнішньої
 // функції навіть після того, як код буде виконуватися поза контекстом зовнішньої функції
 function sayHelloInFiveSeconds(name) {
@@ -409,7 +409,7 @@ myObj.meaningOfLife; // = 42
 // Аналогічно для функцій
 myObj.myFunc(); // = "Hello, world!"
 
-// Якщо інтерпретатор не знайде властивість в прототипі, то він продовжить пошук
+// Якщо інтерпретатор не знайде властивості в прототипі, то він продовжить пошук
 // в прототипі прототипа і так далі
 myPrototype.__proto__ = {
     myBoolean: true
-- 
cgit v1.2.3


From aca3a4382e2eeb16e383eeb9fbd6689e4caba131 Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Fri, 27 Nov 2015 12:39:27 +0200
Subject: Update javascript-ua.html.markdown

Small fixes
---
 uk-ua/javascript-ua.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 2c534d83..9614f9ca 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -3,7 +3,7 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
-filename: javascript-ua.js
+filename: javascript-uk.js
 translators:
   - ["Ivan", "https://github.com/IvanEh"]
   - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
@@ -160,7 +160,7 @@ var myArray = ["Привіт", 45, true];
 // Індексація починається з нуля
 myArray[1]; // = 45
 
-// Масиви в JavaScript змінюють довжину при додаванні нових елементів
+// Масиви в JavaScript змінюють свою довжину при додаванні нових елементів
 myArray.push("Привіт");
 myArray.length; // = 4
 
-- 
cgit v1.2.3


From 2099ec480194f747d4292b9d253e4fa416b35188 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 30 Nov 2015 22:22:42 +0700
Subject: Moved ua-ua files to uk-ua

---
 uk-ua/bash-ua.html.markdown | 296 ++++++++++++++++++++++++++++++++++++++++++++
 uk-ua/json-ua.html.markdown |  67 ++++++++++
 2 files changed, 363 insertions(+)
 create mode 100644 uk-ua/bash-ua.html.markdown
 create mode 100644 uk-ua/json-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/bash-ua.html.markdown b/uk-ua/bash-ua.html.markdown
new file mode 100644
index 00000000..b7e4a5ba
--- /dev/null
+++ b/uk-ua/bash-ua.html.markdown
@@ -0,0 +1,296 @@
+---
+category: tool
+tool: bash
+contributors:
+    - ["Max Yankov", "https://github.com/golergka"]
+    - ["Darren Lin", "https://github.com/CogBear"]
+    - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+    - ["Denis Arh", "https://github.com/darh"]
+    - ["akirahirose", "https://twitter.com/akirahirose"]
+    - ["Anton Strömkvist", "http://lutic.org/"]
+    - ["Rahil Momin", "https://github.com/iamrahil"]
+    - ["Gregrory Kielian", "https://github.com/gskielian"]
+    - ["Etan Reisner", "https://github.com/deryni"]
+translators:
+    - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+lang: uk-ua
+---
+
+Bash - командна оболонка unix (unix shell), що також розповсюджувалась як оболонка для
+операційної системи GNU і зараз використовується як командна оболонка за замовчуванням
+для Linux i Max OS X.
+Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
+Майже всі приклади, що наведені нижче можуть бути частиною shell-скриптів або
+виконані в оболонці
+
+[Більш детально тут.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+# Перший рядок скрипта - це shebang, який вказує системі, як потрібно виконувати
+# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - тоже коментар
+
+# Простий приклад hello world:
+echo Hello world!
+
+# Окремі команди починаються з нового рядка або розділяються крапкою з комкою:
+echo 'Перший рядок'; echo 'Другий рядок'
+
+# Оголошення змінної
+VARIABLE="Просто рядок"
+
+# Але не так!
+VARIABLE = "Просто рядок"
+# Bash вирішить, що VARIABLE - це команда, яку він може виконати,
+# і видасть помилку, тому що не зможе знайти її
+
+# І так також не можна писати:
+VARIABLE= 'Просто рядок'
+# Bash сприйме рядок 'Просто рядок' як команду. Але такої команди не має, тому
+# видасть помилку. 
+# (тут 'VARIABLE=' інтерпретується як присвоєння тільки в контексті
+# виконання команди 'Просто рядок')
+
+# Використання змінних:
+echo $VARIABLE
+echo "$VARIABLE"
+echo '$VARIABLE'
+# Коли ви використовуєте змінну - присвоюєте значення, експортуєте і т.д. -
+# пишіть її імя без $. А для отримання значення змінної використовуйте $.
+# Одинарні лапки ' не розкривають значення змінних
+
+# Підстановка рядків в змінні
+echo ${VARIABLE/Просто/A}
+# Цей вираз замінить перше входження підрядка "Просто" на "А"
+
+# Отримання підрядка із рядка
+LENGTH=7
+echo ${VARIABLE:0:LENGTH}
+# Цей вираз поверне тільки перші 7 символів змінної VARIABLE
+
+# Значення за замовчуванням
+echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
+# Це спрацює при відсутності значення (FOO=) і при пустому рядку (FOO="")
+# Нуль (FOO=0) поверне 0.
+# Зауважте, що у всіх випадках значення самої змінної FOO не зміниться
+
+# Вбудовані змінні:
+# В bash є корисні вбудовані змінні, наприклад
+echo "Значення, яке було повернуте в останній раз: $?"
+echo "PID скрипта: $$"
+echo "Кількість аргументів: $#"
+echo "Аргументи скрипта: $@"
+echo "Аргументи скрипта, розподілені по різним змінним: $1 $2..."
+
+# Зчитування змінних з пристроїв  введення
+echo "Як вас звати?"
+read NAME # Зверніть увагу, що вам не потрібно оголошувати нову змінну
+echo Привіт, $NAME!
+
+# В bash є звичайна умовна конструкція if:
+# наберіть 'man test', щоб переглянути детальну інформацію про формати умов
+if [ $NAME -ne $USER ]
+then
+    echo "Ім’я користувача не збігається з введеним"
+else
+    echo "Ім’я збігаєтьяс з іменем користувача"
+fi
+
+# Зауважте! якщо $Name пуста, bash інтерпретує код вище як:
+if [ -ne $USER ]
+# що є неправильним синтаксисом
+# тому безпечний спосіб використання потенційно пустих змінних має вигляд:
+if [ "$Name" -ne $USER ] ...
+# коли $Name пуста, інтерпретується наступним чином:
+if [ "" -ne $USER ] ...
+# що працює як і очікувалося
+
+# Умовне виконання (conditional execution)
+echo "Виконується завжди" || echo "Виконається, якщо перша команда завершиться з помилкою"
+echo "Виконується завжди" && echo "Виконається, якщо перша команда завершиться успішно"
+
+# Щоб використати && і || у конструкції if, потрібно декілька пар дужок:
+if [ $NAME == "Steve" ] && [ $AGE -eq 15 ]
+then
+    echo "Виконається, якщо $NAME="Steve" i AGE=15."
+fi
+
+if [ $NAME == "Daniya" ] || [ $NAME == "Zach" ]
+then
+    echo "Виконається, якщо NAME="Steve" або NAME="Zach"."
+fi
+
+# Вирази позначаються наступним форматом:
+echo $(( 10 + 5 ))
+
+# На відмінно від інших мов програмування, Bash - це командна оболонка, а
+# отже, працює в контексті поточної директорії
+ls
+
+# Ця команда може використовуватися з опціями
+ls -l # Показати кожен файл і директорію на окремому рядку
+
+# Результат попередньої команди можна перенаправити на вхід наступної.
+# Команда grep фільтрує вхід по шаблону.
+# Таким чином ми можемо переглянути тільки *.txt файли в поточній директорії:
+ls -l | grep "\.txt"
+
+# Ви можете перенаправ вхід і вихід команди (stdin, stdout, stderr).
+# Наступна команда означає: читати із stdin, поки не зустрінеться ^EOF$, і
+# перезаписати hello.py наступними рядками (до рядка "EOF"):
+cat > hello.py << EOF
+#!/usr/bin/env python
+from __future__ import print_function
+import sys
+print("#stdout", file=sys.stdout)
+print("#stderr", file=sys.stderr)
+for line in sys.stdin:
+    print(line, file=sys.stdout)
+EOF
+
+# Запуск hello.py з різними варіантами перенаправлення stdin, 
+# stdout, stderr (стандартні потоки введення, виведення і помилок):
+python hello.py < "input.in"
+python hello.py > "output.out"
+python hello.py 2> "error.err"
+python hello.py > "output-and-error.log" 2>&1
+python hello.py > /dev/null 2>&1
+# Поток помилок перезапише фпйл, якщо цей файл існує
+# тому, якщо ви хочете дописувати до файлу, використовуйте ">>":
+python hello.py >> "output.out" 2>> "error.err"
+
+# Перезаписати output.txt, дописати error.err і порахувати кількість рядків:
+info bash 'Basic Shell Features' 'Redirections' > output.out 2>> error.err
+wc -l output.out error.err
+
+# Запустити команду і вивести її файловий дескриптор (див.: man fd; наприклад /dev/fd/123)
+echo <(echo "#helloworld")
+
+# Перезаписати output.txt рядком "#helloworld":
+cat > output.out <(echo "#helloworld")
+echo "#helloworld" > output.out
+echo "#helloworld" | cat > output.out
+echo "#helloworld" | tee output.out >/dev/null
+
+# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
+# Очистити тимчасові файли з детальним виводом (додайте '-i'
+# для інтерактивного режиму)
+rm -v output.out error.err output-and-error.log
+
+# Команди можуть бути підставлені в інші команди використовуючи $():
+# наступна команда виводить кількість файлів і директорій в поточній директорії
+echo "Тут $(ls | wc -l) елементів."
+
+# Те саме можна зробити використовуючи зворотні лапки
+# Але вони не можуть бути вкладеними, тому перший варіант бажаніший
+echo "Тут `ls | wc -l` елементів."
+
+# В Bash є структура case, яка схожа на switch в Java и C++:
+case "$VARIABLE" in 
+    # перерахуйте шаблони, які будуть використовуватися в якості умов
+    0) echo "Тут нуль.";;
+    1) echo "Тут один.";;
+    *) echo "Не пусте значення.";;
+esac
+
+# Цикл for перебирає елементи передані в аргумент:
+# Значення $VARIABLE буде напечатано тричі.
+for VARIABLE in {1..3}
+do
+    echo "$VARIABLE"
+done
+
+# Aбо можна використати звичний синтаксис for:
+for ((a=1; a <= 3; a++))
+do
+    echo $a
+done
+
+# Цикл for можно використати, щоб виконувати дії над файлами.
+# Цей код запустить команду 'cat' для файлів file1 и file2
+for VARIABLE in file1 file2
+do
+    cat "$VARIABLE"
+done
+
+# ... або дії над виводом команд
+# Запустимо cat для виведення із ls.
+for OUTPUT in $(ls)
+do
+    cat "$OUTPUT"
+done
+
+# Цикл while:
+while [ true ]
+do
+    echo "Тіло циклу..."
+    break
+done
+
+# Ви також можете оголосити функцію
+# Оголошення:
+function foo ()
+{
+    echo "Аргументи функції доступні так само, як і аргументи скрипта: $@"
+    echo "$1 $2..."
+    echo "Це функція"
+    return 0
+}
+
+# Або просто
+bar ()
+{
+    echo "Інший спосіб оголошення функцій!"
+    return 0
+}
+
+# Виклик функцій
+foo "Мое имя" $NAME
+
+# Є багато корисних команд:
+# вивести останні 10 рядків файла file.txt
+tail -n 10 file.txt
+# вивести перші 10 рядків файла file.txt
+head -n 10 file.txt
+# відсортувати рядки file.txt
+sort file.txt
+# відібрати або пропустити рядки, що дублюються (з опцією -d відбирає)
+uniq -d file.txt
+# вивести тільки першу колонку перед символом ','
+cut -d ',' -f 1 file.txt
+# замінити кожне 'okay' на 'great' у файлі file.txt (підтримується regex)
+sed -i 's/okay/great/g' file.txt
+# вивести в stdout все рядки з file.txt, що задовольняють шаблону regex;
+# цей приклад виводить рядки, що починаються на foo і закінчуються на bar:
+grep "^foo.*bar$" file.txt
+# використайте опцію -c, щоб вивести кількість входжень
+grep -c "^foo.*bar$" file.txt
+# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
+# щоб здійснити пошук по рядку, а не по шаблону regex, використовуйте fgrea (або grep -F)
+fgrep "^foo.*bar$" file.txt 
+
+# Читайте вбудовану документацію Bash командою 'help':
+help
+help help
+help for
+help return
+help source
+help .
+
+# Читайте Bash man-документацію
+apropos bash
+man 1 bash
+man bash
+
+# Читайте документацію info (? для допомоги)
+apropos info | grep '^info.*('
+man info
+info info
+info 5 info
+
+# Читайте bash info документацію:
+info bash
+info bash 'Bash Features'
+info bash 6
+info --apropos bash
+```
diff --git a/uk-ua/json-ua.html.markdown b/uk-ua/json-ua.html.markdown
new file mode 100644
index 00000000..8ee12a93
--- /dev/null
+++ b/uk-ua/json-ua.html.markdown
@@ -0,0 +1,67 @@
+---
+language: json
+filename: learnjson-ru.json
+contributors:
+  - ["Anna Harren", "https://github.com/iirelu"]
+  - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+  - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+lang: uk-ua
+---
+
+JSON - це надзвичайно простий формат обміну даними. Це мабуть буде найлегшим курсом 
+"Learn X in Y Minutes".
+
+В загальному випадку в JSON немає коментарів, але більшість парсерів дозволяють 
+використовувати коментарі в С-стилі(//, /\* \*/). Можна залишити кому після останнього
+поля, але все-таки краще такого уникати для кращої сумісності
+
+```json
+{
+  "ключ": "значеннь",
+  
+  "ключі": "завжди мають бути обгорнуті в подвійні лапки",
+  "числа": 0,
+  "рядки": "Пρивет, світ. Допускаються всі unicode-символи разом з \"екрануванням\".",
+  "логічний тип": true,
+  "нічого": null,
+
+  "велике число": 1.2e+100,
+
+  "об’єкти": {
+    "коментар": "Більшість ваших структур будуть складатися з об’єктів",
+
+    "масив": [0, 1, 2, 3, "масиви можуть містити будь-які типи", 5],
+
+    "інший об’єкт": {
+      "коментра": "Об’єкти можуть містити інші об’єкти. Це дуже корисно."
+    }
+  },
+
+  "безглуздя": [
+    {
+      "джерело калія": ["банани"]
+    },
+    [
+      [1, 0, 0, 0],
+      [0, 1, 0, 0],
+      [0, 0, 1, "нео"],
+      [0, 0, 0, 1]
+    ]
+  ],
+  
+  "альтернативнтй стиль": {
+    "коментар": "Гляньте!"
+  , "позиція коми": "неважлива, поки вона знаходиться до наступного поля"
+  , "інший коментар": "класно"
+  },
+
+  "Це було не довго": "І ви справилист. Тепер ви знаєте все про JSON."
+}
+
+Одиничний масив значень теж є правильним JSON
+
+[1, 2, 3, "text", true]
+
+
+```
-- 
cgit v1.2.3


From 4ba4c26f36f0c192af089930d11096fb1687f5ff Mon Sep 17 00:00:00 2001
From: oburdin <oleksiiburdin@gmail.com>
Date: Wed, 6 Jan 2016 23:41:37 +0200
Subject: spelling

---
 uk-ua/json-ua.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/json-ua.html.markdown b/uk-ua/json-ua.html.markdown
index 8ee12a93..120fb410 100644
--- a/uk-ua/json-ua.html.markdown
+++ b/uk-ua/json-ua.html.markdown
@@ -22,7 +22,7 @@ JSON - це надзвичайно простий формат обміну да
   
   "ключі": "завжди мають бути обгорнуті в подвійні лапки",
   "числа": 0,
-  "рядки": "Пρивет, світ. Допускаються всі unicode-символи разом з \"екрануванням\".",
+  "рядки": "Пρивіт, світ. Допускаються всі unicode-символи разом із \"екрануванням\".",
   "логічний тип": true,
   "нічого": null,
 
@@ -34,13 +34,13 @@ JSON - це надзвичайно простий формат обміну да
     "масив": [0, 1, 2, 3, "масиви можуть містити будь-які типи", 5],
 
     "інший об’єкт": {
-      "коментра": "Об’єкти можуть містити інші об’єкти. Це дуже корисно."
+      "коментар": "Об’єкти можуть містити інші об’єкти. Це дуже корисно."
     }
   },
 
   "безглуздя": [
     {
-      "джерело калія": ["банани"]
+      "джерело калію": ["банани"]
     },
     [
       [1, 0, 0, 0],
@@ -56,7 +56,7 @@ JSON - це надзвичайно простий формат обміну да
   , "інший коментар": "класно"
   },
 
-  "Це було не довго": "І ви справилист. Тепер ви знаєте все про JSON."
+  "Це було не довго": "І ви впорались! Тепер ви знаєте все про JSON."
 }
 
 Одиничний масив значень теж є правильним JSON
-- 
cgit v1.2.3


From b29ef73fd81c3d89784c0ca9fe1f90d875cbd223 Mon Sep 17 00:00:00 2001
From: oburdin <oleksiiburdin@gmail.com>
Date: Fri, 29 Jan 2016 14:34:53 +0200
Subject: Update json-ua.html.markdown

---
 uk-ua/json-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/json-ua.html.markdown b/uk-ua/json-ua.html.markdown
index 120fb410..a860e9a7 100644
--- a/uk-ua/json-ua.html.markdown
+++ b/uk-ua/json-ua.html.markdown
@@ -22,7 +22,7 @@ JSON - це надзвичайно простий формат обміну да
   
   "ключі": "завжди мають бути обгорнуті в подвійні лапки",
   "числа": 0,
-  "рядки": "Пρивіт, світ. Допускаються всі unicode-символи разом із \"екрануванням\".",
+  "рядки": "Пρивіт, світe. Допускаються всі unicode-символи разом із \"екрануванням\".",
   "логічний тип": true,
   "нічого": null,
 
-- 
cgit v1.2.3


From b71d01fd8aba1a9da6305dc1f52fb748ee824adf Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 20:52:42 +0200
Subject: Changed the name of Ukrainian translation

uk-ua is more correctly
---
 uk-ua/java-ua.html.markdown | 803 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 803 insertions(+)
 create mode 100644 uk-ua/java-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
new file mode 100644
index 00000000..1a0bb670
--- /dev/null
+++ b/uk-ua/java-ua.html.markdown
@@ -0,0 +1,803 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+    - ["Jakukyo Friel", "http://weakish.github.io"]
+    - ["Madison Dickson", "http://github.com/mix3d"]
+    - ["Simon Morgan", "http://sjm.io/"]
+    - ["Zachary Ferguson", "http://github.com/zfergus2"]
+    - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
+    - ["Rachel Stiyer", "https://github.com/rstiyer"]
+translators:
+	- ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"]
+filename: LearnJava.java
+lang: uk-ua
+---
+
+Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах.
+[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
+
+```java
+// Однорядковий коментар починається з //
+/*
+Багаторядковий коментар виглядає так.
+*/
+/**
+JavaDoc коментар виглядає так. Використовується для опису класу та членів класу.
+*/
+
+// Імпорт класу ArrayList з пакету java.util
+import java.util.ArrayList;
+// Імпорт усіх класів з пакету java.security 
+import java.security.*;
+
+// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає
+// з і менем файлу.
+public class LearnJava {
+
+    // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу main.
+    public static void main (String[] args) {
+
+        // Використання System.out.println() для виводу на друк рядків.
+        System.out.println("Hello World!");
+        System.out.println(
+            "Integer: " + 10 +
+            " Double: " + 3.14 +
+            " Boolean: " + true);
+
+        // Для друку з нового рядкка використовується System.out.print().
+        System.out.print("Hello ");
+        System.out.print("World");
+
+        // Використання System.out.printf() для простого форматованого виводу на друк.
+        System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
+
+        ///////////////////////////////////////
+        // Змінні
+        ///////////////////////////////////////
+
+        /*
+        *  Оголошення змінних
+        */
+        // Для оголошення змінних використовується формат <тип> <змінна>
+        int fooInt;
+        // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3>
+        int fooInt1, fooInt2, fooInt3;
+
+        /*
+        *  Ініціалізація змінних
+        */
+
+        // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення>
+        int fooInt = 1;
+        // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення>
+        int fooInt1, fooInt2, fooInt3;
+        fooInt1 = fooInt2 = fooInt3 = 1;
+
+        /*
+        *  Типи змінних
+        */
+        // Байт - 8-бітне ціле число зі знаком
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - 16-бітне ціле число зі знаком
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - 32-бітне ціле число зі знаком
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - 64-бітне ціле число зі знаком
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L використовується для позначення того, що число має тип Long;
+        // інакше число буде трактуватись як integer.
+
+        // Примітка: Java не має беззнакових типів.
+
+        // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 
+        // 2^-149 <= float <= (2-2^-23) * 2^127
+        float fooFloat = 234.5f;
+        // f or F використовується для позначення того, що змінна має тип float;
+        // інакше трактується як double.
+
+        // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 
+        // 2^-1074 <= x <= (2-2^-52) * 2^1023
+        double fooDouble = 123.4;
+
+        // Boolean - true & false (істина чи неправда)
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - 16-бітний символ Unicode
+        char fooChar = 'A';
+
+        // final - посилання на такі змінні не можуть бути присвоєні іншим об'єктам,
+        final int HOURS_I_WORK_PER_WEEK = 9001;
+        // але вони можуть мати відкладену ініціалізацію.
+        final double E;
+        E = 2.71828;
+
+
+        // BigInteger -Незмінні знакові цілі числа довільної точності
+        //
+        // BigInteger є типом даних, який дає можливість розробнику виконувати операції з
+        // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві
+        // байтів, операції над ними виконуються функціями, які має клас BigInteger
+        //
+        // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
+        
+        BigInteger fooBigInteger = new BigInteger(fooByteArray);
+
+
+        // BigDecimal - Незмінні знакові дробові числа довільної точності
+        //
+        // BigDecimal складається з двох частин: цілого числа довільної точності 
+        // з немасштабованим значенням та 32-бітного масштабованого цілого числа
+        //
+        // BigDecimal дозволяє розробника контролювати десяткове округлення.
+        // Рекомндовано використовувати BigDecimal зі значеннями валют
+        // і там, де необхідна точність дробових обчислень.
+        //
+        // BigDecimal може бути ініціалізований типами даних int, long, double or String
+        // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
+
+        BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
+        
+        // Для дотримання заданої точності рекомендується використовувати
+        // конструктор, який приймає String 
+        
+        BigDecimal tenCents = new BigDecimal("0.1");
+
+
+        // Рядки
+        String fooString = "Це мій рядок!";
+
+        // \n символ переходу на новий рядок
+        String barString = "Друк з нового рялка?\nНема питань!";
+        // \t символ табуляції
+        String bazString = "Хочете додати табуляцію?\tТримайте!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Масиви
+        // Розмір масиву має бути визначений перед ініціалізацією
+        // Наведений формат ілюструє ініціалізацію масивів
+        // <тип даних>[] <ім'я змінної> = new <тип даних>[<розмір масиву>];
+        // <тип даних> <ім'я змінної>[] = new <тип даних>[<розмір масиву>];
+        int[] intArray = new int[10];
+        String[] stringArray = new String[1];
+        boolean boolArray[] = new boolean[100];
+
+        // Інший шлях оголошення та ініціалізації масиву
+        int[] y = {9000, 1000, 1337};
+        String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
+        boolean bools[] = new boolean[] {true, false, false};
+
+        // Індексація масиву - доступ за елементами
+        System.out.println("intArray @ 0: " + intArray[0]);
+
+        // Масиви є змінними та мають нульовий елемент.
+        intArray[1] = 1;
+        System.out.println("intArray @ 1: " + intArray[1]); // => 1
+
+        // Додатково
+        // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір.
+        // LinkedLists - Реалізація двозв'язного списку. Всі операції
+        //               виконуються так, як очікується від
+        //               двозв'язного списку.
+        // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є
+        //        інтерфейсом, тому не може бути успадкований.
+        //        Типи ключів і значень, які зберігаються в Map мають
+        //        вказуватись у класі, який його реалізує.
+		//		  Ключ не може повторюватись і пов'язаний лише з одним значенням        
+        // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map.
+        //            Це дозволяє виконувати певні операції,
+        //            такі як отримання та вставка елемента,
+        //            за сталий час для будь-якої кількості значень.
+
+        ///////////////////////////////////////
+        // Operators
+        ///////////////////////////////////////
+        System.out.println("\n->Operators");
+
+        int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+
+        // Arithmetic is straightforward
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
+        System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
+
+        // Modulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Comparison operators
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // Boolean operators
+        System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
+        System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
+        System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
+
+        // Bitwise operators!
+        /*
+        ~      Unary bitwise complement
+        <<     Signed left shift
+        >>     Signed/Arithmetic right shift
+        >>>    Unsigned/Logical right shift
+        &      Bitwise AND
+        ^      Bitwise exclusive OR
+        |      Bitwise inclusive OR
+        */
+
+        // Incrementations
+        int i = 0;
+        System.out.println("\n->Inc/Dec-rementation");
+        // The ++ and -- operators increment and decrement by 1 respectively.
+        // If they are placed before the variable, they increment then return;
+        // after the variable they return then increment.
+        System.out.println(i++); // i = 1, prints 0 (post-increment)
+        System.out.println(++i); // i = 2, prints 2 (pre-increment)
+        System.out.println(i--); // i = 1, prints 2 (post-decrement)
+        System.out.println(--i); // i = 0, prints 0 (pre-decrement)
+
+        ///////////////////////////////////////
+        // Control Structures
+        ///////////////////////////////////////
+        System.out.println("\n->Control Structures");
+
+        // If statements are c-like
+        int j = 10;
+        if (j == 10) {
+            System.out.println("I get printed");
+        } else if (j > 10) {
+            System.out.println("I don't");
+        } else {
+            System.out.println("I also don't");
+        }
+
+        // While loop
+        int fooWhile = 0;
+        while(fooWhile < 100) {
+            System.out.println(fooWhile);
+            // Increment the counter
+            // Iterated 100 times, fooWhile 0,1,2...99
+            fooWhile++;
+        }
+        System.out.println("fooWhile Value: " + fooWhile);
+
+        // Do While Loop
+        int fooDoWhile = 0;
+        do {
+            System.out.println(fooDoWhile);
+            // Increment the counter
+            // Iterated 99 times, fooDoWhile 0->99
+            fooDoWhile++;
+        } while(fooDoWhile < 100);
+        System.out.println("fooDoWhile Value: " + fooDoWhile);
+
+        // For Loop
+        // for loop structure => for(<start_statement>; <conditional>; <step>)
+        for (int fooFor = 0; fooFor < 10; fooFor++) {
+            System.out.println(fooFor);
+            // Iterated 10 times, fooFor 0->9
+        }
+        System.out.println("fooFor Value: " + fooFor);
+        
+        // Nested For Loop Exit with Label
+        outer:
+        for (int i = 0; i < 10; i++) {
+          for (int j = 0; j < 10; j++) {
+            if (i == 5 && j ==5) {
+              break outer;
+              // breaks out of outer loop instead of only the inner one
+            }
+          }
+        }
+        
+        // For Each Loop
+        // The for loop is also able to iterate over arrays as well as objects
+        // that implement the Iterable interface.
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
+        // for each loop structure => for (<object> : <iterable>)
+        // reads as: for each element in the iterable
+        // note: the object type must match the element type of the iterable.
+
+        for (int bar : fooList) {
+            System.out.println(bar);
+            //Iterates 9 times and prints 1-9 on new lines
+        }
+
+        // Switch Case
+        // A switch works with the byte, short, char, and int data types.
+        // It also works with enumerated types (discussed in Enum Types), the
+        // String class, and a few special classes that wrap primitive types:
+        // Character, Byte, Short, and Integer.
+        int month = 3;
+        String monthString;
+        switch (month) {
+            case 1: monthString = "January";
+                    break;
+            case 2: monthString = "February";
+                    break;
+            case 3: monthString = "March";
+                    break;
+            default: monthString = "Some other month";
+                     break;
+        }
+        System.out.println("Switch Case Result: " + monthString);
+        
+        // Starting in Java 7 and above, switching Strings works like this:
+        String myAnswer = "maybe";
+        switch(myAnswer) {
+            case "yes":
+                System.out.println("You answered yes.");
+                break;
+            case "no":
+                System.out.println("You answered no.");
+                break;
+            case "maybe":
+                System.out.println("You answered maybe.");
+                break;
+            default:
+                System.out.println("You answered " + myAnswer);
+                break;
+        }
+
+        // Conditional Shorthand
+        // You can use the '?' operator for quick assignments or logic forks.
+        // Reads as "If (statement) is true, use <first value>, otherwise, use
+        // <second value>"
+        int foo = 5;
+        String bar = (foo < 10) ? "A" : "B";
+        System.out.println(bar); // Prints A, because the statement is true
+
+
+        ////////////////////////////////////////
+        // Converting Data Types And Typecasting
+        ////////////////////////////////////////
+
+        // Converting data
+
+        // Convert String To Integer
+        Integer.parseInt("123");//returns an integer version of "123"
+
+        // Convert Integer To String
+        Integer.toString(123);//returns a string version of 123
+
+        // For other conversions check out the following classes:
+        // Double
+        // Long
+        // String
+
+        // Typecasting
+        // You can also cast Java objects, there's a lot of details and deals
+        // with some more intermediate concepts. Feel free to check it out here:
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Classes And Functions
+        ///////////////////////////////////////
+
+        System.out.println("\n->Classes & Functions");
+
+        // (definition of the Bicycle class follows)
+
+        // Use new to instantiate a class
+        Bicycle trek = new Bicycle();
+
+        // Call object methods
+        trek.speedUp(3); // You should always use setter and getter methods
+        trek.setCadence(100);
+
+        // toString returns this Object's string representation.
+        System.out.println("trek info: " + trek.toString());
+
+        // Double Brace Initialization
+        // The Java Language has no syntax for how to create static Collections
+        // in an easy way. Usually you end up in the following way:
+
+        private static final Set<String> COUNTRIES = new HashSet<String>();
+        static {
+           validCodes.add("DENMARK");
+           validCodes.add("SWEDEN");
+           validCodes.add("FINLAND");
+        }
+
+        // But there's a nifty way to achieve the same thing in an
+        // easier way, by using something that is called Double Brace
+        // Initialization.
+
+        private static final Set<String> COUNTRIES = new HashSet<String>() {{
+            add("DENMARK");
+            add("SWEDEN");
+            add("FINLAND");
+        }}
+
+        // The first brace is creating a new AnonymousInnerClass and the
+        // second one declares an instance initializer block. This block
+        // is called when the anonymous inner class is created.
+        // This does not only work for Collections, it works for all
+        // non-final classes.
+
+    } // End main method
+} // End LearnJava class
+
+
+// You can include other, non-public outer-level classes in a .java file,
+// but it is good practice. Instead split classes into separate files.
+
+
+// Class Declaration Syntax:
+// <public/private/protected> class <class name> {
+//    // data fields, constructors, functions all inside.
+//    // functions are called as methods in Java.
+// }
+
+class Bicycle {
+
+    // Bicycle's Fields/Variables
+    public int cadence; // Public: Can be accessed from anywhere
+    private int speed;  // Private: Only accessible from within the class
+    protected int gear; // Protected: Accessible from the class and subclasses
+    String name; // default: Only accessible from within this package
+
+    static String className; // Static class variable
+
+    // Static block 
+    // Java has no implementation of static constructors, but
+    // has a static block that can be used to initialize class variables 
+    // (static variables). 
+    // This block will be called when the class is loaded.
+    static {
+        className = "Bicycle";
+    }
+
+    // Constructors are a way of creating classes
+    // This is a constructor
+    public Bicycle() {
+        // You can also call another constructor:
+        // this(1, 50, 5, "Bontrager");
+        gear = 1;
+        cadence = 50;
+        speed = 5;
+        name = "Bontrager";
+    }
+
+    // This is a constructor that takes arguments
+    public Bicycle(int startCadence, int startSpeed, int startGear,
+        String name) {
+        this.gear = startGear;
+        this.cadence = startCadence;
+        this.speed = startSpeed;
+        this.name = name;
+    }
+
+    // Method Syntax:
+    // <public/private/protected> <return type> <function name>(<args>)
+
+    // Java classes often implement getters and setters for their fields
+
+    // Method declaration syntax:
+    // <access modifier> <return type> <method name>(<args>)
+    public int getCadence() {
+        return cadence;
+    }
+
+    // void methods require no return statement
+    public void setCadence(int newValue) {
+        cadence = newValue;
+    }
+
+    public void setGear(int newValue) {
+        gear = newValue;
+    }
+
+    public void speedUp(int increment) {
+        speed += increment;
+    }
+
+    public void slowDown(int decrement) {
+        speed -= decrement;
+    }
+
+    public void setName(String newName) {
+        name = newName;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    //Method to display the attribute values of this Object.
+    @Override // Inherited from the Object class.
+    public String toString() {
+        return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
+            " name: " + name;
+    }
+} // end class Bicycle
+
+// PennyFarthing is a subclass of Bicycle
+class PennyFarthing extends Bicycle {
+    // (Penny Farthings are those bicycles with the big front wheel.
+    // They have no gears.)
+
+    public PennyFarthing(int startCadence, int startSpeed){
+        // Call the parent constructor with super
+        super(startCadence, startSpeed, 0, "PennyFarthing");
+    }
+
+    // You should mark a method you're overriding with an @annotation.
+    // To learn more about what annotations are and their purpose check this
+    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setGear(int gear) {
+        gear = 0;
+    }
+}
+
+// Interfaces
+// Interface declaration syntax
+// <access-level> interface <interface-name> extends <super-interfaces> {
+//     // Constants
+//     // Method declarations
+// }
+
+// Example - Food:
+public interface Edible {
+    public void eat(); // Any class that implements this interface, must
+                       // implement this method.
+}
+
+public interface Digestible {
+    public void digest();
+}
+
+
+// We can now create a class that implements both of these interfaces.
+public class Fruit implements Edible, Digestible {
+  
+    @Override
+    public void eat() {
+        // ...
+    }
+
+    @Override
+    public void digest() {
+        // ...
+    }
+}
+
+// In Java, you can extend only one class, but you can implement many
+// interfaces. For example:
+public class ExampleClass extends ExampleClassParent implements InterfaceOne,
+    InterfaceTwo {
+
+    @Override
+    public void InterfaceOneMethod() {
+    }
+
+    @Override
+    public void InterfaceTwoMethod() {
+    }
+
+}
+
+// Abstract Classes
+
+// Abstract Class declaration syntax
+// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Marking a class as abstract means that it contains abstract methods that must
+// be defined in a child class. Similar to interfaces, abstract classes cannot
+// be instantiated, but instead must be extended and the abstract methods
+// defined. Different from interfaces, abstract classes can contain a mixture of
+// concrete and abstract methods. Methods in an interface cannot have a body,
+// unless the method is static, and variables are final by default, unlike an
+// abstract class. Also abstract classes CAN have the "main" method.
+
+public abstract class Animal
+{
+    public abstract void makeSound();
+
+    // Method can have a body
+    public void eat()
+    {
+        System.out.println("I am an animal and I am Eating.");  
+        // Note: We can access private variable here.
+        age = 30;
+    }
+
+    // No need to initialize, however in an interface
+    // a variable is implicitly final and hence has
+    // to be initialized.
+    protected int age;
+
+    public void printAge()
+    {
+        System.out.println(age);  
+    }
+
+    // Abstract classes can have main function.
+    public static void main(String[] args)
+    {
+        System.out.println("I am abstract");
+    }
+}
+
+class Dog extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Bark");
+        // age = 30;	==> ERROR!	age is private to Animal
+    }
+
+    // NOTE: You will get an error if you used the
+    // @Override annotation here, since java doesn't allow
+    // overriding of static methods.
+    // What is happening here is called METHOD HIDING.
+    // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+    public static void main(String[] args)
+    {
+        Dog pluto = new Dog();
+        pluto.makeSound();
+        pluto.eat();
+        pluto.printAge();
+    }
+}
+
+// Final Classes
+
+// Final Class declaration syntax
+// <access-level> final <final-class-name> {
+//     // Constants and variables
+//     // Method declarations
+// }
+
+// Final classes are classes that cannot be inherited from and are therefore a
+// final child. In a way, final classes are the opposite of abstract classes
+// because abstract classes must be extended, but final classes cannot be
+// extended.
+public final class SaberToothedCat extends Animal
+{
+    // Note still have to override the abstract methods in the
+    // abstract class.
+    @Override
+    public void makeSound()
+    {
+        System.out.println("Roar");
+    }
+}
+
+// Final Methods
+public abstract class Mammal()
+{
+    // Final Method Syntax:
+    // <access modifier> final <return type> <function name>(<args>)
+
+    // Final methods, like, final classes cannot be overridden by a child class,
+    // and are therefore the final implementation of the method.
+    public final boolean isWarmBlooded()
+    {
+        return true;
+    }
+}
+
+
+// Enum Type
+//
+// An enum type is a special data type that enables for a variable to be a set
+// of predefined constants. The variable must be equal to one of the values that
+// have been predefined for it. Because they are constants, the names of an enum
+// type's fields are in uppercase letters. In the Java programming language, you
+// define an enum type by using the enum keyword. For example, you would specify
+// a days-of-the-week enum type as:
+
+public enum Day {
+    SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+    THURSDAY, FRIDAY, SATURDAY 
+}
+
+// We can use our enum Day like that:
+
+public class EnumTest {
+    
+    // Variable Enum
+    Day day;
+    
+    public EnumTest(Day day) {
+        this.day = day;
+    }
+    
+    public void tellItLikeItIs() {
+        switch (day) {
+            case MONDAY:
+                System.out.println("Mondays are bad.");
+                break;
+                    
+            case FRIDAY:
+                System.out.println("Fridays are better.");
+                break;
+                         
+            case SATURDAY: 
+            case SUNDAY:
+                System.out.println("Weekends are best.");
+                break;
+                        
+            default:
+                System.out.println("Midweek days are so-so.");
+                break;
+        }
+    }
+    
+    public static void main(String[] args) {
+        EnumTest firstDay = new EnumTest(Day.MONDAY);
+        firstDay.tellItLikeItIs(); // => Mondays are bad.
+        EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
+        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
+    }
+}
+
+// Enum types are much more powerful than we show above. 
+// The enum body can include methods and other fields.
+// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+
+```
+
+## Further Reading
+
+The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
+
+**Official Oracle Guides**:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+
+**Online Practice and Tutorials**
+
+* [Learneroo.com - Learn Java](http://www.learneroo.com)
+
+* [Codingbat.com](http://codingbat.com/java)
+
+
+**Books**:
+
+* [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
+
+* [Thinking in Java](http://www.mindview.net/Books/TIJ/)
+
+* [Objects First with Java](http://www.amazon.com/Objects-First-Java-Practical-Introduction/dp/0132492660)
+
+* [Java The Complete Reference](http://www.amazon.com/gp/product/0071606300)
-- 
cgit v1.2.3


From 6d60e96a1296637e8f1c425c179af241b80838ed Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 21:25:21 +0200
Subject: improving java Ukrainian translation

added operators
---
 uk-ua/java-ua.html.markdown | 40 ++++++++++++++++++++--------------------
 1 file changed, 20 insertions(+), 20 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 1a0bb670..cd3dae56 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -200,23 +200,23 @@ public class LearnJava {
         //            за сталий час для будь-якої кількості значень.
 
         ///////////////////////////////////////
-        // Operators
+        // Оператори
         ///////////////////////////////////////
         System.out.println("\n->Operators");
 
-        int i1 = 1, i2 = 2; // Shorthand for multiple declarations
+        int i1 = 1, i2 = 2; // Коротка форма присвоєння
 
-        // Arithmetic is straightforward
+        // Арифметичні операції виконуються
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
-        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int returns an int)
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (int/int повертається як int)
         System.out.println("1/2 = " + (i1 / (double)i2)); // => 0.5
 
-        // Modulo
+        // Ділення з остачею
         System.out.println("11%3 = "+(11 % 3)); // => 2
 
-        // Comparison operators
+        // Оператори порівняння
         System.out.println("3 == 2? " + (3 == 2)); // => false
         System.out.println("3 != 2? " + (3 != 2)); // => true
         System.out.println("3 > 2? " + (3 > 2)); // => true
@@ -224,28 +224,28 @@ public class LearnJava {
         System.out.println("2 <= 2? " + (2 <= 2)); // => true
         System.out.println("2 >= 2? " + (2 >= 2)); // => true
 
-        // Boolean operators
+        // Логічні оператори
         System.out.println("3 > 2 && 2 > 3? " + ((3 > 2) && (2 > 3))); // => false
         System.out.println("3 > 2 || 2 > 3? " + ((3 > 2) || (2 > 3))); // => true
         System.out.println("!(3 == 2)? " + (!(3 == 2))); // => true
 
-        // Bitwise operators!
+        // Бітові оператори!
         /*
-        ~      Unary bitwise complement
-        <<     Signed left shift
-        >>     Signed/Arithmetic right shift
-        >>>    Unsigned/Logical right shift
-        &      Bitwise AND
-        ^      Bitwise exclusive OR
-        |      Bitwise inclusive OR
+        ~      Унарне бітове доповнення
+        <<     Знаковий зсув уліво
+        >>     Знаковий/Арифметичний зсув управо
+        >>>    Беззнаковий/Логічний зсув управо
+        &      Бітове І
+        ^      Бітови виключне АБО
+        |      Бітове АБО
         */
 
-        // Incrementations
+        // Інкремнт
         int i = 0;
-        System.out.println("\n->Inc/Dec-rementation");
-        // The ++ and -- operators increment and decrement by 1 respectively.
-        // If they are placed before the variable, they increment then return;
-        // after the variable they return then increment.
+        System.out.println("\n->Інкремент/Декремент");
+        // Оператори ++ і -- здійснюють інкремент та декремент ретроспективно.
+        // Якщо вони розташовані перед змінною, операція виконається перед поверненням;
+        // після - повернеться інкремент або декремент.
         System.out.println(i++); // i = 1, prints 0 (post-increment)
         System.out.println(++i); // i = 2, prints 2 (pre-increment)
         System.out.println(i--); // i = 1, prints 2 (post-decrement)
-- 
cgit v1.2.3


From ce3a57d4a08b858e2f5006922bf70b65cbce1d68 Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 21:35:19 +0200
Subject: translated further reading

---
 uk-ua/java-ua.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index cd3dae56..a142680f 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -762,37 +762,37 @@ public class EnumTest {
 
 ```
 
-## Further Reading
+## Додатково для прочитання
 
 The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
 
-**Official Oracle Guides**:
+**Офіційні посібники Oracle**:
 
 * [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
 
-* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+* [Java модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
 
-* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+* [ООП концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
     * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
     * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
     * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
 
-* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+* [Виключення](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
 
-* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+* [Інтерфейси](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
 
-* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+* [параметризація](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
 
 * [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
 
-**Online Practice and Tutorials**
+**Online практика та посібники**
 
 * [Learneroo.com - Learn Java](http://www.learneroo.com)
 
 * [Codingbat.com](http://codingbat.com/java)
 
 
-**Books**:
+**Книжки**:
 
 * [Head First Java](http://www.headfirstlabs.com/books/hfjava/)
 
-- 
cgit v1.2.3


From 5668de06465df72933b0d5c5c33ad1ccf7f4a806 Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 21:40:26 +0200
Subject: tech upgrade

---
 uk-ua/java-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index a142680f..3582f73d 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -9,7 +9,7 @@ contributors:
     - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
 translators:
-	- ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"]
+    - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"]
 filename: LearnJava.java
 lang: uk-ua
 ---
-- 
cgit v1.2.3


From dee2ed5f7c46f5ddaf2a85871f9f97ca819e940d Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 23:12:56 +0200
Subject: final Java translation

can be used
---
 uk-ua/java-ua.html.markdown | 321 +++++++++++++++++++++-----------------------
 1 file changed, 150 insertions(+), 171 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 3582f73d..63472b3f 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -9,8 +9,8 @@ contributors:
     - ["Cameron Schermerhorn", "http://github.com/cschermerhorn"]
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
 translators:
-    - ["Oleksandr Tatarchuk", "http://github.com/tatarchuk"]
-filename: LearnJava.java
+    - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
+filename: LearnJavaUa.java
 lang: uk-ua
 ---
 
@@ -252,92 +252,88 @@ public class LearnJava {
         System.out.println(--i); // i = 0, prints 0 (pre-decrement)
 
         ///////////////////////////////////////
-        // Control Structures
+        // Управляючі конструкції
         ///////////////////////////////////////
         System.out.println("\n->Control Structures");
 
-        // If statements are c-like
+        // Оператор if використовується так само, як у мові С
         int j = 10;
         if (j == 10) {
-            System.out.println("I get printed");
+            System.out.println("Це надрукується");
         } else if (j > 10) {
-            System.out.println("I don't");
+            System.out.println("А це - ні");
         } else {
-            System.out.println("I also don't");
+            System.out.println("Це - також ні");
         }
 
-        // While loop
+        // Цикл з передумовою While
         int fooWhile = 0;
         while(fooWhile < 100) {
             System.out.println(fooWhile);
-            // Increment the counter
-            // Iterated 100 times, fooWhile 0,1,2...99
+            // Інкремент лічильника
+            // Виконається 100 разів, fooWhile 0,1,2...99
             fooWhile++;
         }
         System.out.println("fooWhile Value: " + fooWhile);
 
-        // Do While Loop
+        // Цикл з післяумовою Do While
         int fooDoWhile = 0;
         do {
             System.out.println(fooDoWhile);
-            // Increment the counter
-            // Iterated 99 times, fooDoWhile 0->99
+            // Інкремент лічильника
+            // Виконається 99 разів, fooDoWhile 0->99
             fooDoWhile++;
         } while(fooDoWhile < 100);
         System.out.println("fooDoWhile Value: " + fooDoWhile);
 
-        // For Loop
-        // for loop structure => for(<start_statement>; <conditional>; <step>)
+        // Цикл з параметром For
+        // структура циклу => for(<початковий стан>; <умова завершення>; <крок>)
         for (int fooFor = 0; fooFor < 10; fooFor++) {
             System.out.println(fooFor);
-            // Iterated 10 times, fooFor 0->9
+            // Виконається 10 разів, fooFor 0->9
         }
         System.out.println("fooFor Value: " + fooFor);
         
-        // Nested For Loop Exit with Label
+        // Вихід з вкладеного циклу через Label
         outer:
         for (int i = 0; i < 10; i++) {
           for (int j = 0; j < 10; j++) {
             if (i == 5 && j ==5) {
               break outer;
-              // breaks out of outer loop instead of only the inner one
+              // вихід із зовнішнього циклу, а не лише внутрішнього
             }
           }
         }
         
-        // For Each Loop
-        // The for loop is also able to iterate over arrays as well as objects
-        // that implement the Iterable interface.
-        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};
-        // for each loop structure => for (<object> : <iterable>)
-        // reads as: for each element in the iterable
-        // note: the object type must match the element type of the iterable.
+        // Цикл For Each
+        // Призначений для перебору масивів та колекцій       
+        int[] fooList = {1, 2, 3, 4, 5, 6, 7, 8, 9};       
 
         for (int bar : fooList) {
             System.out.println(bar);
             //Iterates 9 times and prints 1-9 on new lines
         }
 
-        // Switch Case
-        // A switch works with the byte, short, char, and int data types.
-        // It also works with enumerated types (discussed in Enum Types), the
-        // String class, and a few special classes that wrap primitive types:
-        // Character, Byte, Short, and Integer.
+        // Оператор вибору Switch Case
+        // Оператор вибору працює з типами даних byte, short, char, int.
+        // Також працює з переліками Enum, 
+        // класом String та класами-обгортками примітивних типів:
+        // Character, Byte, Short та Integer.
         int month = 3;
         String monthString;
         switch (month) {
-            case 1: monthString = "January";
+            case 1: monthString = "Січень";
                     break;
-            case 2: monthString = "February";
+            case 2: monthString = "Лютий";
                     break;
-            case 3: monthString = "March";
+            case 3: monthString = "Березень";
                     break;
-            default: monthString = "Some other month";
+            default: monthString = "Інший місяць";
                      break;
         }
-        System.out.println("Switch Case Result: " + monthString);
+        System.out.println("Switch Case результат: " + monthString);
         
-        // Starting in Java 7 and above, switching Strings works like this:
+        // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
         String myAnswer = "maybe";
         switch(myAnswer) {
             case "yes":
@@ -354,59 +350,55 @@ public class LearnJava {
                 break;
         }
 
-        // Conditional Shorthand
-        // You can use the '?' operator for quick assignments or logic forks.
-        // Reads as "If (statement) is true, use <first value>, otherwise, use
-        // <second value>"
+        // Тернарний оператор вибору
+        // Можна використовувати '?' оператор для визначення умови.
+        // Читається так "Якщо (умова) вірна, то <перше значення>, інакше
+        // <друге значення"
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
-        System.out.println(bar); // Prints A, because the statement is true
+        System.out.println(bar); // Надрукується А, бо умова вірна
 
 
         ////////////////////////////////////////
-        // Converting Data Types And Typecasting
+        // Перетворення типів
         ////////////////////////////////////////
 
-        // Converting data
+        // Перетворення String на Integer
+        Integer.parseInt("123");//поверне числову версію рядка "123"
 
-        // Convert String To Integer
-        Integer.parseInt("123");//returns an integer version of "123"
+        // Перетворення Integer на String
+        Integer.toString(123);//повертає рядкову версію 123
 
-        // Convert Integer To String
-        Integer.toString(123);//returns a string version of 123
-
-        // For other conversions check out the following classes:
+        // Для інших перетворень є наступні класи:
         // Double
         // Long
         // String
 
-        // Typecasting
-        // You can also cast Java objects, there's a lot of details and deals
-        // with some more intermediate concepts. Feel free to check it out here:
+        // Приведення типів
+        // Тут можна прочитати про приведення об'єктів:
         // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
 
 
         ///////////////////////////////////////
-        // Classes And Functions
+        // Класи та функції
         ///////////////////////////////////////
 
         System.out.println("\n->Classes & Functions");
 
-        // (definition of the Bicycle class follows)
+        // (Клас Bicycle наведений нижче)
 
-        // Use new to instantiate a class
+        // Новий об'єкт класу
         Bicycle trek = new Bicycle();
 
-        // Call object methods
-        trek.speedUp(3); // You should always use setter and getter methods
+        // Виклик методу об'єкта
+        trek.speedUp(3); // Постійно використовуються методи з назвами set і get
         trek.setCadence(100);
 
-        // toString returns this Object's string representation.
+        // toString повертає рядкове представленя об'єкту.
         System.out.println("trek info: " + trek.toString());
-
-        // Double Brace Initialization
-        // The Java Language has no syntax for how to create static Collections
-        // in an easy way. Usually you end up in the following way:
+        
+        // У Java немає синтаксису для явного створення статичних колекцій.
+        // Це можна зробити так:
 
         private static final Set<String> COUNTRIES = new HashSet<String>();
         static {
@@ -415,9 +407,7 @@ public class LearnJava {
            validCodes.add("FINLAND");
         }
 
-        // But there's a nifty way to achieve the same thing in an
-        // easier way, by using something that is called Double Brace
-        // Initialization.
+        // Але є інший спосіб - Double Brace Initialization.
 
         private static final Set<String> COUNTRIES = new HashSet<String>() {{
             add("DENMARK");
@@ -425,49 +415,44 @@ public class LearnJava {
             add("FINLAND");
         }}
 
-        // The first brace is creating a new AnonymousInnerClass and the
-        // second one declares an instance initializer block. This block
-        // is called when the anonymous inner class is created.
-        // This does not only work for Collections, it works for all
-        // non-final classes.
+        // Використовується анонімний внутрішній клас
 
-    } // End main method
-} // End LearnJava class
+    } // Кінець методу main
+} // Кінець класу LearnJava
 
 
-// You can include other, non-public outer-level classes in a .java file,
-// but it is good practice. Instead split classes into separate files.
+// Можна додавати інші, не public класи зовнішнього рівня у .java файл,
+// але це не є хорошою практикою. Розміщуйте класи в окремих файлах.
 
 
-// Class Declaration Syntax:
+// Синтаксис оголошення класу:
 // <public/private/protected> class <class name> {
-//    // data fields, constructors, functions all inside.
-//    // functions are called as methods in Java.
+//    // поля, конструктори, функції та ін.
+//    // у Java функції називаються методами.
 // }
 
 class Bicycle {
 
-    // Bicycle's Fields/Variables
-    public int cadence; // Public: Can be accessed from anywhere
-    private int speed;  // Private: Only accessible from within the class
-    protected int gear; // Protected: Accessible from the class and subclasses
-    String name; // default: Only accessible from within this package
+    // Поля (змінні) класу Bicycle
+    public int cadence; // Public: доступно звідусіль
+    private int speed;  // Private: доступно лише у межах класу
+    protected int gear; // Protected: доступно лише класу та нащадкам
+    String name; // default: доступно у даному пакеті
 
-    static String className; // Static class variable
+    static String className; // статична змінна класу
 
-    // Static block 
-    // Java has no implementation of static constructors, but
-    // has a static block that can be used to initialize class variables 
-    // (static variables). 
-    // This block will be called when the class is loaded.
+    // статичний блок
+    // Java не має статичних конструкторів, але
+    // має статичний блок ініціалізації змінних класу    
+    // Цей блок виконується при завантаженні класу.
     static {
         className = "Bicycle";
     }
 
-    // Constructors are a way of creating classes
-    // This is a constructor
+    // Конструктори є способом створення класу
+    // Це - конструктор
     public Bicycle() {
-        // You can also call another constructor:
+        // Можна викликати інший конструктор:
         // this(1, 50, 5, "Bontrager");
         gear = 1;
         cadence = 50;
@@ -475,7 +460,7 @@ class Bicycle {
         name = "Bontrager";
     }
 
-    // This is a constructor that takes arguments
+    // Цей конструктор приймає аргументи
     public Bicycle(int startCadence, int startSpeed, int startGear,
         String name) {
         this.gear = startGear;
@@ -484,18 +469,18 @@ class Bicycle {
         this.name = name;
     }
 
-    // Method Syntax:
-    // <public/private/protected> <return type> <function name>(<args>)
+    // Синтаксис методу:
+    // <public/private/protected> <тип повернутого значення> <ім'я методу>(<аргументи>)
 
-    // Java classes often implement getters and setters for their fields
+    // Java класи часто мають методи для отримання та встановлення змінних
 
-    // Method declaration syntax:
-    // <access modifier> <return type> <method name>(<args>)
+    // Синтаксис оголошення методу:
+    // <модифікатор доступу> <тип повернутого значення> <ім'я методу>(<аргументи>)
     public int getCadence() {
         return cadence;
     }
 
-    // void methods require no return statement
+    // void методи не повертають значень
     public void setCadence(int newValue) {
         cadence = newValue;
     }
@@ -520,26 +505,26 @@ class Bicycle {
         return name;
     }
 
-    //Method to display the attribute values of this Object.
+    //Метод показує значення змінних об'єкту.
     @Override // Inherited from the Object class.
     public String toString() {
         return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
             " name: " + name;
     }
-} // end class Bicycle
+} // кінець класу Bicycle
 
-// PennyFarthing is a subclass of Bicycle
+// PennyFarthing є розширенням (нащадком) класу Bicycle
 class PennyFarthing extends Bicycle {
-    // (Penny Farthings are those bicycles with the big front wheel.
-    // They have no gears.)
+    // (Penny Farthings мають велике переднє колесо.
+    // Вони не мають передач.)
 
     public PennyFarthing(int startCadence, int startSpeed){
-        // Call the parent constructor with super
+        // Виклик батьківського конструктора через super
         super(startCadence, startSpeed, 0, "PennyFarthing");
     }
 
-    // You should mark a method you're overriding with an @annotation.
-    // To learn more about what annotations are and their purpose check this
+    // Перевизначений метод має відти відмічений аннотацією @annotation.
+    // Для ознайомлення з аннотаціями перейдіть за посиланням
     // out: http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setGear(int gear) {
@@ -547,17 +532,17 @@ class PennyFarthing extends Bicycle {
     }
 }
 
-// Interfaces
-// Interface declaration syntax
-// <access-level> interface <interface-name> extends <super-interfaces> {
-//     // Constants
-//     // Method declarations
+// Інтерфейси
+// Синтаксис оголошення інтерфейсів
+// <рівень доступу> interface <ім'я інтерфейсу> extends <супер-інтерфейс> {
+//     // Констатнти
+//     // Оголошення методів
 // }
 
-// Example - Food:
+//Приклад - Food:
 public interface Edible {
-    public void eat(); // Any class that implements this interface, must
-                       // implement this method.
+    public void eat(); // Будь-які класи, що реалізують цей інтерфейс
+                       // повинні реалізувати цей метод.
 }
 
 public interface Digestible {
@@ -565,7 +550,7 @@ public interface Digestible {
 }
 
 
-// We can now create a class that implements both of these interfaces.
+// Можна створити клас, що реалізує обидва інтерфейси.
 public class Fruit implements Edible, Digestible {
   
     @Override
@@ -579,8 +564,8 @@ public class Fruit implements Edible, Digestible {
     }
 }
 
-// In Java, you can extend only one class, but you can implement many
-// interfaces. For example:
+// В Java можна успадковувати лише один клас, але реалізовувати багато
+// інтерфейсів. Наприклад:
 public class ExampleClass extends ExampleClassParent implements InterfaceOne,
     InterfaceTwo {
 
@@ -594,37 +579,35 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 
 }
 
-// Abstract Classes
+// Абстрактні класи
 
-// Abstract Class declaration syntax
-// <access-level> abstract <abstract-class-name> extends <super-abstract-classes> {
-//     // Constants and variables
-//     // Method declarations
+// Синтаксис оголошення абстрактних класів:
+// <ріаень доступу> abstract <ім1я класу> extends <супер-абстрактний клас> {
+//     // Константи і змінні
+//     // Оголошення методів
 // }
 
-// Marking a class as abstract means that it contains abstract methods that must
-// be defined in a child class. Similar to interfaces, abstract classes cannot
-// be instantiated, but instead must be extended and the abstract methods
-// defined. Different from interfaces, abstract classes can contain a mixture of
-// concrete and abstract methods. Methods in an interface cannot have a body,
-// unless the method is static, and variables are final by default, unlike an
-// abstract class. Also abstract classes CAN have the "main" method.
+// Позначення класу як абстрактного означає, що оголошені у ньому методи мають
+// бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри
+// абстракних класів, але їх можна успадковувати. Нащадок зобов'язаний реалізувати всі абстрактні
+// методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
+// так і абстрактні методи. Методи в інтерфейсах не мають тіла,
+// за вийнятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
+// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод "main".
 
 public abstract class Animal
 {
     public abstract void makeSound();
 
-    // Method can have a body
+    // Метод може мати тіло
     public void eat()
     {
         System.out.println("I am an animal and I am Eating.");  
-        // Note: We can access private variable here.
+        // Зауваження: є доступ до privat змінних.
         age = 30;
     }
 
-    // No need to initialize, however in an interface
-    // a variable is implicitly final and hence has
-    // to be initialized.
+    // Ініціалізація не потрібна
     protected int age;
 
     public void printAge()
@@ -632,7 +615,7 @@ public abstract class Animal
         System.out.println(age);  
     }
 
-    // Abstract classes can have main function.
+    // Абстрактні класи МОЖУТЬ мати метод "main".
     public static void main(String[] args)
     {
         System.out.println("I am abstract");
@@ -641,20 +624,19 @@ public abstract class Animal
 
 class Dog extends Animal
 {
-    // Note still have to override the abstract methods in the
-    // abstract class.
+    // Слід помічати перевизначення абстрактних методів
     @Override
     public void makeSound()
     {
         System.out.println("Bark");
-        // age = 30;	==> ERROR!	age is private to Animal
+        // age = 30;	==> ПОМИЛКА! age є private для Animal
     }
 
-    // NOTE: You will get an error if you used the
-    // @Override annotation here, since java doesn't allow
-    // overriding of static methods.
-    // What is happening here is called METHOD HIDING.
-    // Check out this awesome SO post: http://stackoverflow.com/questions/16313649/
+    // NOTE: Буде помилка, якщо використати аннотацію
+    // @Override тут, так як у java не можна
+    // перевизначати статичні методи.
+    // Те, що тут відбувається, називається METHOD HIDING.
+    // Більш детально: http://stackoverflow.com/questions/16313649/
     public static void main(String[] args)
     {
         Dog pluto = new Dog();
@@ -664,22 +646,20 @@ class Dog extends Animal
     }
 }
 
-// Final Classes
+// Final класи
 
-// Final Class declaration syntax
-// <access-level> final <final-class-name> {
-//     // Constants and variables
-//     // Method declarations
+// Синтаксис оголошення Final класів
+// <рівень доступу> final <ім'я класу> {
+//     // Константи і змінні
+//     // Оголошення методів
 // }
 
-// Final classes are classes that cannot be inherited from and are therefore a
-// final child. In a way, final classes are the opposite of abstract classes
-// because abstract classes must be extended, but final classes cannot be
-// extended.
+// Final не можуть мати нащадків, також самі вони є останніми нащадками.
+// Final класи є протилежністю абстрактних у цьому плані.
+
 public final class SaberToothedCat extends Animal
 {
-    // Note still have to override the abstract methods in the
-    // abstract class.
+    // Перевизначення методу
     @Override
     public void makeSound()
     {
@@ -687,14 +667,14 @@ public final class SaberToothedCat extends Animal
     }
 }
 
-// Final Methods
+// Final методи
 public abstract class Mammal()
 {
-    // Final Method Syntax:
-    // <access modifier> final <return type> <function name>(<args>)
+    // Синтаксис Final методів:
+    // <модифікаор доступу> final <тип повернутого значення> <ім'я функції>(<аргументи>)
 
-    // Final methods, like, final classes cannot be overridden by a child class,
-    // and are therefore the final implementation of the method.
+    // Final методи не можуть бути перевизначені класом-нащадком,
+    // вони є остаточною реалізацією методу.
     public final boolean isWarmBlooded()
     {
         return true;
@@ -702,21 +682,20 @@ public abstract class Mammal()
 }
 
 
-// Enum Type
+// Тип Enum (перелік)
 //
-// An enum type is a special data type that enables for a variable to be a set
-// of predefined constants. The variable must be equal to one of the values that
-// have been predefined for it. Because they are constants, the names of an enum
-// type's fields are in uppercase letters. In the Java programming language, you
-// define an enum type by using the enum keyword. For example, you would specify
-// a days-of-the-week enum type as:
+// Enum є спеціальним типом даних, який дозволяє змінним бути певною множиною
+// визначених констант. Змінна має відповідати одному зі значень, що
+// заздалегідь визначені для неї. Так як це константи, імена типів полів у enum
+// задаються у верхньому регістрі. У Java задається тип переліку за допомогою
+// ключового слова. Наприклад, перелік днів тижня можна задати так:
 
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
     THURSDAY, FRIDAY, SATURDAY 
 }
 
-// We can use our enum Day like that:
+// Можна використовувати перелік Day так:
 
 public class EnumTest {
     
@@ -756,13 +735,13 @@ public class EnumTest {
     }
 }
 
-// Enum types are much more powerful than we show above. 
-// The enum body can include methods and other fields.
-// You can se more at https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
+// Переліки набагато потужніші, ніж тут показано. 
+// Тіло переліків може містити методи та інші змінні.
+// Дивіться більше тут: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
 
 ```
 
-## Додатково для прочитання
+## Додатково для читання
 
 The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
 
-- 
cgit v1.2.3


From 6a76bb326c246e3f78db6dbe35e879daafab7ed3 Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 31 Oct 2015 23:20:04 +0200
Subject: some bug fixing

---
 uk-ua/java-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 63472b3f..3127f7f5 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -10,7 +10,7 @@ contributors:
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
 translators:
     - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
-filename: LearnJavaUa.java
+filename: LearnJava.java
 lang: uk-ua
 ---
 
-- 
cgit v1.2.3


From 3df055f2f71d7fe27186a9d61c1d8af66d2295d9 Mon Sep 17 00:00:00 2001
From: Oleksandr Tatarchuk <o.tatarchuk-2016@kpi.ua>
Date: Sat, 14 Nov 2015 20:13:56 +0200
Subject: Added -ua to the filename

In order to Java Code Conventions, LearnJavaUa.java
---
 uk-ua/java-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 3127f7f5..63472b3f 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -10,7 +10,7 @@ contributors:
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
 translators:
     - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
-filename: LearnJava.java
+filename: LearnJavaUa.java
 lang: uk-ua
 ---
 
-- 
cgit v1.2.3


From 4c814b4df9bb73f200b2ab08e5660b6c74c5397f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andre=20Polykanine=20A=2EK=2EA=2E=20Menelion=20Elens=C3=BA?=
 =?UTF-8?q?l=C3=AB?= <andre@oire.org>
Date: Sat, 27 Feb 2016 18:24:20 +0200
Subject: [java/uk] Applied comments to #1969

---
 uk-ua/java-ua.html.markdown | 293 ++++++++++++++++++++++----------------------
 1 file changed, 147 insertions(+), 146 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 63472b3f..1ea30f3d 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -10,12 +10,13 @@ contributors:
     - ["Rachel Stiyer", "https://github.com/rstiyer"]
 translators:
     - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
+    - ["Andre Polykanine", "https://github.com/Oire"]
 filename: LearnJavaUa.java
 lang: uk-ua
 ---
 
-Java є об'єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах.
-[Read more here.](http://docs.oracle.com/javase/tutorial/java/)
+Java є об’єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах.
+[Детальніше читайте тут, англ.](http://docs.oracle.com/javase/tutorial/java/)
 
 ```java
 // Однорядковий коментар починається з //
@@ -23,31 +24,31 @@ Java є об'єктно-орієнтованою мовою програмува
 Багаторядковий коментар виглядає так.
 */
 /**
-JavaDoc коментар виглядає так. Використовується для опису класу та членів класу.
+JavaDoc-коментар виглядає так. Використовується для опису класу та членів класу.
 */
 
-// Імпорт класу ArrayList з пакету java.util
+// Імпорт класу ArrayList з пакета java.util
 import java.util.ArrayList;
-// Імпорт усіх класів з пакету java.security 
+// Імпорт усіх класів з пакета java.security 
 import java.security.*;
 
-// Кожний .java файл містить один зовнішній публічний клас, ім'я якого співпадає
-// з і менем файлу.
+// Кожний .java файл містить один зовнішній публічний клас, ім’я якого співпадає
+// з іменем файлу.
 public class LearnJava {
 
     // Для запуску програма, написана на java, повинна мати точку входу у вигляді методу main.
     public static void main (String[] args) {
 
         // Використання System.out.println() для виводу на друк рядків.
-        System.out.println("Hello World!");
+        System.out.println("Привіт, світе!");
         System.out.println(
-            "Integer: " + 10 +
-            " Double: " + 3.14 +
-            " Boolean: " + true);
+            " Ціле число: " + 10 +
+            " Число з рухомою комою подвійної точности: " + 3.14 +
+            " Булеве значення: " + true);
 
-        // Для друку з нового рядкка використовується System.out.print().
-        System.out.print("Hello ");
-        System.out.print("World");
+        // Для друку без переходу на новий рядок використовується System.out.print().
+        System.out.print("Привіт, ");
+        System.out.print("світе");
 
         // Використання System.out.printf() для простого форматованого виводу на друк.
         System.out.printf("pi = %.5f", Math.PI); // => pi = 3.14159
@@ -61,60 +62,60 @@ public class LearnJava {
         */
         // Для оголошення змінних використовується формат <тип> <змінна>
         int fooInt;
-        // Оголошення декількох змінних одного типу <тип> <ім'я1>, <ім'я2>, <ім'я3>
+        // Оголошення декількох змінних одного типу <тип> <ім’я1>, <ім’я2>, <ім’я3>
         int fooInt1, fooInt2, fooInt3;
 
         /*
         *  Ініціалізація змінних
         */
 
-        // Ініціалізація змінної з використанням формату <тип> <ім'я> = <значення>
+        // Ініціалізація змінної з використанням формату <тип> <ім’я> = <значення>
         int fooInt = 1;
-        // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім'я1>, <ім'я2>, <ім'я3> = <значення>
+        // Ініціалізація декількох змінних одного типу з одним значенням <тип> <ім’я1>, <ім’я2>, <ім’я3> = <значення>
         int fooInt1, fooInt2, fooInt3;
         fooInt1 = fooInt2 = fooInt3 = 1;
 
         /*
         *  Типи змінних
         */
-        // Байт - 8-бітне ціле число зі знаком
+        // Байт — 8-бітне ціле число зі знаком
         // (-128 <= byte <= 127)
         byte fooByte = 100;
 
-        // Short - 16-бітне ціле число зі знаком
-        // (-32,768 <= short <= 32,767)
+        // Short — 16-бітне ціле число зі знаком
+        // (-32 768 <= short <= 32 767)
         short fooShort = 10000;
 
-        // Integer - 32-бітне ціле число зі знаком
-        // (-2,147,483,648 <= int <= 2,147,483,647)
+        // Integer — 32-бітне ціле число зі знаком
+        // (-2 147 483 648 <= int <= 2 147 483 647)
         int fooInt = 1;
 
-        // Long - 64-бітне ціле число зі знаком
-        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        // Long — 64-бітне ціле число зі знаком
+        // (-9 223 372 036 854 775 808 <= long <= 9 223 372 036 854 775 807)
         long fooLong = 100000L;
         // L використовується для позначення того, що число має тип Long;
         // інакше число буде трактуватись як integer.
 
         // Примітка: Java не має беззнакових типів.
 
-        // Float - 32-бітне число з плаваючою комою одиничної точності за стандартом IEEE 754 
+        // Float — 32-бітне число з рухомою комою одиничної точності за стандартом IEEE 754 
         // 2^-149 <= float <= (2-2^-23) * 2^127
         float fooFloat = 234.5f;
-        // f or F використовується для позначення того, що змінна має тип float;
+        // f або F використовується для позначення того, що змінна має тип float;
         // інакше трактується як double.
 
-        // Double - 64-бітне число з плаваючою комою подвійної точності за стандартом IEEE 754 
+        // Double — 64-бітне число з рухомою комою подвійної точності за стандартом IEEE 754 
         // 2^-1074 <= x <= (2-2^-52) * 2^1023
         double fooDouble = 123.4;
 
-        // Boolean - true & false (істина чи неправда)
+        // Boolean — true & false (істина чи хиба)
         boolean fooBoolean = true;
         boolean barBoolean = false;
 
-        // Char - 16-бітний символ Unicode
+        // Char — 16-бітний символ Unicode
         char fooChar = 'A';
 
-        // final - посилання на такі змінні не можуть бути присвоєні іншим об'єктам,
+        // final - посилання на такі змінні не можуть бути присвоєні іншим об’єктам,
         final int HOURS_I_WORK_PER_WEEK = 9001;
         // але вони можуть мати відкладену ініціалізацію.
         final double E;
@@ -123,25 +124,25 @@ public class LearnJava {
 
         // BigInteger -Незмінні знакові цілі числа довільної точності
         //
-        // BigInteger є типом даних, який дає можливість розробнику виконувати операції з
+        // BigInteger є типом даних, який дає можливість розробнику виконувати операції
         // з цілими числами, розрядність яких більша за 64 біти. Числа зберігаються у масиві
-        // байтів, операції над ними виконуються функціями, які має клас BigInteger
+        // байтів, операції над ними виконуються функціями, які мають клас BigInteger
         //
         // BigInteger можна ініціалізувати, використовуючи масив байтів чи рядок.
         
         BigInteger fooBigInteger = new BigInteger(fooByteArray);
 
 
-        // BigDecimal - Незмінні знакові дробові числа довільної точності
+        // BigDecimal — Незмінні знакові дробові числа довільної точності
         //
         // BigDecimal складається з двох частин: цілого числа довільної точності 
         // з немасштабованим значенням та 32-бітного масштабованого цілого числа
         //
-        // BigDecimal дозволяє розробника контролювати десяткове округлення.
-        // Рекомндовано використовувати BigDecimal зі значеннями валют
+        // BigDecimal дозволяє розробникам контролювати десяткове округлення.
+        // Рекомендовано використовувати BigDecimal зі значеннями валют
         // і там, де необхідна точність дробових обчислень.
         //
-        // BigDecimal може бути ініціалізований типами даних int, long, double or String
+        // BigDecimal може бути ініціалізований типами даних int, long, double або String
         // чи немасштабованим значенням (BigInteger) і масштабованим значенням (int).
 
         BigDecimal fooBigDecimal = new BigDecimal(fooBigInteger, fooInt);
@@ -155,9 +156,9 @@ public class LearnJava {
         // Рядки
         String fooString = "Це мій рядок!";
 
-        // \n символ переходу на новий рядок
-        String barString = "Друк з нового рялка?\nНема питань!";
-        // \t символ табуляції
+        // \n є символом переходу на новий рядок
+        String barString = "Друк з нового рядка?\nНема питань!";
+        // \t — це символ табуляції
         String bazString = "Хочете додати табуляцію?\tТримайте!";
         System.out.println(fooString);
         System.out.println(barString);
@@ -166,8 +167,8 @@ public class LearnJava {
         // Масиви
         // Розмір масиву має бути визначений перед ініціалізацією
         // Наведений формат ілюструє ініціалізацію масивів
-        // <тип даних>[] <ім'я змінної> = new <тип даних>[<розмір масиву>];
-        // <тип даних> <ім'я змінної>[] = new <тип даних>[<розмір масиву>];
+        // <тип даних>[] <ім’я змінної> = new <тип даних>[<розмір масиву>];
+        // <тип даних> <ім’я змінної>[] = new <тип даних>[<розмір масиву>];
         int[] intArray = new int[10];
         String[] stringArray = new String[1];
         boolean boolArray[] = new boolean[100];
@@ -177,7 +178,7 @@ public class LearnJava {
         String names[] = {"Bob", "John", "Fred", "Juan Pedro"};
         boolean bools[] = new boolean[] {true, false, false};
 
-        // Індексація масиву - доступ за елементами
+        // Індексація масиву — доступ за елементами
         System.out.println("intArray @ 0: " + intArray[0]);
 
         // Масиви є змінними та мають нульовий елемент.
@@ -185,28 +186,28 @@ public class LearnJava {
         System.out.println("intArray @ 1: " + intArray[1]); // => 1
 
         // Додатково
-        // ArrayLists - Схожі на масив, але мають більший функціонал та змінний розмір.
-        // LinkedLists - Реалізація двозв'язного списку. Всі операції
+        // ArrayLists — Схожі на масив, але мають більший функціонал та змінний розмір.
+        // LinkedLists — Реалізація двозв’язного списку. Всі операції
         //               виконуються так, як очікується від
-        //               двозв'язного списку.
-        // Maps - Множина об'єктів, які пов'язують ключ зі значенням. Map є
+        //               двозв’язного списку.
+        // Maps — Множина об’єктів, які пов’язують ключ зі значенням. Map є
         //        інтерфейсом, тому не може бути успадкований.
-        //        Типи ключів і значень, які зберігаються в Map мають
+        //        Типи ключів і значень, які зберігаються в Map, мають
         //        вказуватись у класі, який його реалізує.
-		//		  Ключ не може повторюватись і пов'язаний лише з одним значенням        
-        // HashMaps - Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map.
+		//		  Ключ не може повторюватись і пов’язаний лише з одним значенням        
+        // HashMaps — Цей клас використовує хеш-таблицю для реалізації інтерфейсу Map.
         //            Це дозволяє виконувати певні операції,
-        //            такі як отримання та вставка елемента,
-        //            за сталий час для будь-якої кількості значень.
+        //            такі, як отримання та вставка елемента,
+        //            залишаючись постійними навіть для великої кількості елементів.
 
         ///////////////////////////////////////
         // Оператори
         ///////////////////////////////////////
-        System.out.println("\n->Operators");
+        System.out.println("\n->Оператори");
 
         int i1 = 1, i2 = 2; // Коротка форма присвоєння
 
-        // Арифметичні операції виконуються
+        // Арифметичні операції виконуються очевидним способом
         System.out.println("1+2 = " + (i1 + i2)); // => 3
         System.out.println("2-1 = " + (i2 - i1)); // => 1
         System.out.println("2*1 = " + (i2 * i1)); // => 2
@@ -240,30 +241,30 @@ public class LearnJava {
         |      Бітове АБО
         */
 
-        // Інкремнт
+        // Інкремент
         int i = 0;
         System.out.println("\n->Інкремент/Декремент");
         // Оператори ++ і -- здійснюють інкремент та декремент ретроспективно.
         // Якщо вони розташовані перед змінною, операція виконається перед поверненням;
-        // після - повернеться інкремент або декремент.
-        System.out.println(i++); // i = 1, prints 0 (post-increment)
-        System.out.println(++i); // i = 2, prints 2 (pre-increment)
-        System.out.println(i--); // i = 1, prints 2 (post-decrement)
-        System.out.println(--i); // i = 0, prints 0 (pre-decrement)
+        // якщо після неї — повернеться інкремент або декремент.
+        System.out.println(i++); // i = 1, друкує 0 (постінкремент)
+        System.out.println(++i); // i = 2, друкує 2 (преінкремент)
+        System.out.println(i--); // i = 1, друкує 2 (постдекремент)
+        System.out.println(--i); // i = 0, друкує 0 (предекремент)
 
         ///////////////////////////////////////
-        // Управляючі конструкції
+        // Керуючі конструкції
         ///////////////////////////////////////
-        System.out.println("\n->Control Structures");
+        System.out.println("\n->Керуючі конструкції");
 
-        // Оператор if використовується так само, як у мові С
+        // Оператор if використовується так само, як у мові C
         int j = 10;
         if (j == 10) {
             System.out.println("Це надрукується");
         } else if (j > 10) {
-            System.out.println("А це - ні");
+            System.out.println("А це — ні");
         } else {
-            System.out.println("Це - також ні");
+            System.out.println("Це — також ні");
         }
 
         // Цикл з передумовою While
@@ -284,7 +285,7 @@ public class LearnJava {
             // Виконається 99 разів, fooDoWhile 0->99
             fooDoWhile++;
         } while(fooDoWhile < 100);
-        System.out.println("fooDoWhile Value: " + fooDoWhile);
+        System.out.println("Значення fooDoWhile: " + fooDoWhile);
 
         // Цикл з параметром For
         // структура циклу => for(<початковий стан>; <умова завершення>; <крок>)
@@ -292,9 +293,9 @@ public class LearnJava {
             System.out.println(fooFor);
             // Виконається 10 разів, fooFor 0->9
         }
-        System.out.println("fooFor Value: " + fooFor);
+        System.out.println("Значення fooFor: " + fooFor);
         
-        // Вихід з вкладеного циклу через Label
+        // Вихід із вкладеного циклу через мітку
         outer:
         for (int i = 0; i < 10; i++) {
           for (int j = 0; j < 10; j++) {
@@ -311,7 +312,7 @@ public class LearnJava {
 
         for (int bar : fooList) {
             System.out.println(bar);
-            //Iterates 9 times and prints 1-9 on new lines
+            // Повторюється 9 разів та друкує числа від 1 до 9 на нових рядках
         }
 
         // Оператор вибору Switch Case
@@ -331,29 +332,29 @@ public class LearnJava {
             default: monthString = "Інший місяць";
                      break;
         }
-        System.out.println("Switch Case результат: " + monthString);
+        System.out.println("Результат Switch Case: " + monthString);
         
         // Починаючи з Java 7 і далі, вибір рядкових змінних здійснюється так:
-        String myAnswer = "maybe";
+        String myAnswer = "можливо";
         switch(myAnswer) {
-            case "yes":
-                System.out.println("You answered yes.");
+            case "так":
+                System.out.println("Ви відповіли «Так».");
                 break;
-            case "no":
-                System.out.println("You answered no.");
+            case "ні":
+                System.out.println("Ви відповіли «ні».");
                 break;
-            case "maybe":
-                System.out.println("You answered maybe.");
+            case "можливо":
+                System.out.println("Ви відповіли «Можливо».");
                 break;
             default:
-                System.out.println("You answered " + myAnswer);
+                System.out.println("Ви відповіли «" + myAnswer + "»");
                 break;
         }
 
         // Тернарний оператор вибору
-        // Можна використовувати '?' оператор для визначення умови.
-        // Читається так "Якщо (умова) вірна, то <перше значення>, інакше
-        // <друге значення"
+        // Можна використовувати оператор «?» (знак питання) для визначення умови.
+        // Читається так: «Якщо (умова) вірна, то <перше значення>, інакше
+        // <друге значення>»
         int foo = 5;
         String bar = (foo < 10) ? "A" : "B";
         System.out.println(bar); // Надрукується А, бо умова вірна
@@ -375,7 +376,7 @@ public class LearnJava {
         // String
 
         // Приведення типів
-        // Тут можна прочитати про приведення об'єктів:
+        // Тут можна прочитати про приведення об’єктів (англ.):
         // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
 
 
@@ -383,19 +384,19 @@ public class LearnJava {
         // Класи та функції
         ///////////////////////////////////////
 
-        System.out.println("\n->Classes & Functions");
+        System.out.println("\n->Класи та функції");
 
         // (Клас Bicycle наведений нижче)
 
-        // Новий об'єкт класу
+        // Новий об’єкт класу
         Bicycle trek = new Bicycle();
 
-        // Виклик методу об'єкта
+        // Виклик методу об’єкта
         trek.speedUp(3); // Постійно використовуються методи з назвами set і get
         trek.setCadence(100);
 
-        // toString повертає рядкове представленя об'єкту.
-        System.out.println("trek info: " + trek.toString());
+        // toString повертає рядкове представлення об’єкту.
+        System.out.println("Інформація про об’єкт trek: " + trek.toString());
         
         // У Java немає синтаксису для явного створення статичних колекцій.
         // Це можна зробити так:
@@ -407,7 +408,7 @@ public class LearnJava {
            validCodes.add("FINLAND");
         }
 
-        // Але є інший спосіб - Double Brace Initialization.
+        // Але є інший спосіб — ініціалізація з подвійними фігурними дужками.
 
         private static final Set<String> COUNTRIES = new HashSet<String>() {{
             add("DENMARK");
@@ -421,12 +422,12 @@ public class LearnJava {
 } // Кінець класу LearnJava
 
 
-// Можна додавати інші, не public класи зовнішнього рівня у .java файл,
+// У .java-файл можна додавати інші, не public класи зовнішнього рівня,
 // але це не є хорошою практикою. Розміщуйте класи в окремих файлах.
 
 
 // Синтаксис оголошення класу:
-// <public/private/protected> class <class name> {
+// <public/private/protected> class <ім’я класу> {
 //    // поля, конструктори, функції та ін.
 //    // у Java функції називаються методами.
 // }
@@ -436,8 +437,8 @@ class Bicycle {
     // Поля (змінні) класу Bicycle
     public int cadence; // Public: доступно звідусіль
     private int speed;  // Private: доступно лише у межах класу
-    protected int gear; // Protected: доступно лише класу та нащадкам
-    String name; // default: доступно у даному пакеті
+    protected int gear; // Protected: доступно лише класові та його нащадкам
+    String name; // за замовчанням: доступно у даному пакеті
 
     static String className; // статична змінна класу
 
@@ -450,7 +451,7 @@ class Bicycle {
     }
 
     // Конструктори є способом створення класу
-    // Це - конструктор
+    // Оце — конструктор
     public Bicycle() {
         // Можна викликати інший конструктор:
         // this(1, 50, 5, "Bontrager");
@@ -470,17 +471,17 @@ class Bicycle {
     }
 
     // Синтаксис методу:
-    // <public/private/protected> <тип повернутого значення> <ім'я методу>(<аргументи>)
+    // <public/private/protected> <тип повернутого значення> <ім’я методу>(<аргументи>)
 
-    // Java класи часто мають методи для отримання та встановлення змінних
+    // Java-класи часто мають методи для отримання та встановлення змінних
 
     // Синтаксис оголошення методу:
-    // <модифікатор доступу> <тип повернутого значення> <ім'я методу>(<аргументи>)
+    // <модифікатор доступу> <тип повернутого значення> <ім’я методу>(<аргументи>)
     public int getCadence() {
         return cadence;
     }
 
-    // void методи не повертають значень
+    // void-методи не повертають значень
     public void setCadence(int newValue) {
         cadence = newValue;
     }
@@ -505,8 +506,8 @@ class Bicycle {
         return name;
     }
 
-    //Метод показує значення змінних об'єкту.
-    @Override // Inherited from the Object class.
+    //Метод показує значення змінних об’єкту.
+    @Override // Успадковано від класу Object.
     public String toString() {
         return "gear: " + gear + " cadence: " + cadence + " speed: " + speed +
             " name: " + name;
@@ -523,9 +524,9 @@ class PennyFarthing extends Bicycle {
         super(startCadence, startSpeed, 0, "PennyFarthing");
     }
 
-    // Перевизначений метод має відти відмічений аннотацією @annotation.
+    // Перевизначений метод має бути відмічений аннотацією, яка починається зі знака @.
     // Для ознайомлення з аннотаціями перейдіть за посиланням
-    // out: http://docs.oracle.com/javase/tutorial/java/annotations/
+    // http://docs.oracle.com/javase/tutorial/java/annotations/
     @Override
     public void setGear(int gear) {
         gear = 0;
@@ -534,14 +535,14 @@ class PennyFarthing extends Bicycle {
 
 // Інтерфейси
 // Синтаксис оголошення інтерфейсів
-// <рівень доступу> interface <ім'я інтерфейсу> extends <супер-інтерфейс> {
-//     // Констатнти
+// <рівень доступу> interface <ім’я інтерфейсу> extends <батьківський інтерфейс> {
+//     // Константи
 //     // Оголошення методів
 // }
 
-//Приклад - Food:
+//Приклад — їжа (Food):
 public interface Edible {
-    public void eat(); // Будь-які класи, що реалізують цей інтерфейс
+    public void eat(); // Будь-які класи, що реалізують цей інтерфейс,
                        // повинні реалізувати цей метод.
 }
 
@@ -582,18 +583,18 @@ public class ExampleClass extends ExampleClassParent implements InterfaceOne,
 // Абстрактні класи
 
 // Синтаксис оголошення абстрактних класів:
-// <ріаень доступу> abstract <ім1я класу> extends <супер-абстрактний клас> {
+// <рівень доступу> abstract <ім’я класу> extends <батьківський абстрактний клас> {
 //     // Константи і змінні
 //     // Оголошення методів
 // }
 
 // Позначення класу як абстрактного означає, що оголошені у ньому методи мають
 // бути реалізовані у дочірніх класах. Подібно до інтерфейсів, не можна створити екземпляри
-// абстракних класів, але їх можна успадковувати. Нащадок зобов'язаний реалізувати всі абстрактні
+// абстракних класів, але їх можна успадковувати. Нащадок зобов’язаний реалізувати всі абстрактні
 // методи. на відміну від інтерфейсів, абстрактні класи можуть мати як визначені,
 // так і абстрактні методи. Методи в інтерфейсах не мають тіла,
-// за вийнятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
-// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод "main".
+// за винятком статичних методів, а змінні неявно мають модифікатор final, на відміну від
+// абстрактного класу. Абстрактні класи МОЖУТЬ мати метод «main».
 
 public abstract class Animal
 {
@@ -602,8 +603,8 @@ public abstract class Animal
     // Метод може мати тіло
     public void eat()
     {
-        System.out.println("I am an animal and I am Eating.");  
-        // Зауваження: є доступ до privat змінних.
+        System.out.println("Я тварина, і я їм.");  
+        // Зауваження: є доступ до приватних змінних.
         age = 30;
     }
 
@@ -615,10 +616,10 @@ public abstract class Animal
         System.out.println(age);  
     }
 
-    // Абстрактні класи МОЖУТЬ мати метод "main".
+    // Абстрактні класи МОЖУТЬ мати метод «main».
     public static void main(String[] args)
     {
-        System.out.println("I am abstract");
+        System.out.println("Я абстрактний");
     }
 }
 
@@ -628,14 +629,14 @@ class Dog extends Animal
     @Override
     public void makeSound()
     {
-        System.out.println("Bark");
+        System.out.println("Гав!");
         // age = 30;	==> ПОМИЛКА! age є private для Animal
     }
 
-    // NOTE: Буде помилка, якщо використати аннотацію
+    // Зауваження: Буде помилка, якщо використати аннотацію
     // @Override тут, так як у java не можна
     // перевизначати статичні методи.
-    // Те, що тут відбувається, називається METHOD HIDING.
+    // Те, що тут відбувається, називається приховування методів.
     // Більш детально: http://stackoverflow.com/questions/16313649/
     public static void main(String[] args)
     {
@@ -646,16 +647,16 @@ class Dog extends Animal
     }
 }
 
-// Final класи
+// Фінальні класи
 
-// Синтаксис оголошення Final класів
-// <рівень доступу> final <ім'я класу> {
+// Синтаксис оголошення фінальних класів
+// <рівень доступу> final <ім’я класу> {
 //     // Константи і змінні
 //     // Оголошення методів
 // }
 
-// Final не можуть мати нащадків, також самі вони є останніми нащадками.
-// Final класи є протилежністю абстрактних у цьому плані.
+// Фінальні класи не можуть мати нащадків, також самі вони є останніми нащадками.
+// Фінальні класи є протилежністю абстрактних у цьому плані.
 
 public final class SaberToothedCat extends Animal
 {
@@ -663,17 +664,17 @@ public final class SaberToothedCat extends Animal
     @Override
     public void makeSound()
     {
-        System.out.println("Roar");
+        System.out.println("Гррр!");
     }
 }
 
-// Final методи
+// Фінальні методи
 public abstract class Mammal()
 {
-    // Синтаксис Final методів:
-    // <модифікаор доступу> final <тип повернутого значення> <ім'я функції>(<аргументи>)
+    // Синтаксис фінальних методів:
+    // <модифікатор доступу> final <тип повернутого значення> <ім’я функції>(<аргументи>)
 
-    // Final методи не можуть бути перевизначені класом-нащадком,
+    // Фінальні методи не можуть бути перевизначені класом-нащадком,
     // вони є остаточною реалізацією методу.
     public final boolean isWarmBlooded()
     {
@@ -686,20 +687,20 @@ public abstract class Mammal()
 //
 // Enum є спеціальним типом даних, який дозволяє змінним бути певною множиною
 // визначених констант. Змінна має відповідати одному зі значень, що
-// заздалегідь визначені для неї. Так як це константи, імена типів полів у enum
-// задаються у верхньому регістрі. У Java задається тип переліку за допомогою
-// ключового слова. Наприклад, перелік днів тижня можна задати так:
+// заздалегідь визначені для неї. Оскільки це константи, імена типів полів у enum
+// задаються у верхньому регістрі. Тип «перелік» у Java задається за допомогою
+// ключового слова enum. Наприклад, перелік днів тижня можна задати так:
 
 public enum Day {
     SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
     THURSDAY, FRIDAY, SATURDAY 
 }
 
-// Можна використовувати перелік Day так:
+// Перелік Day можна використовувати так:
 
 public class EnumTest {
     
-    // Variable Enum
+    // Змінна того же типу, що й перелік
     Day day;
     
     public EnumTest(Day day) {
@@ -709,29 +710,29 @@ public class EnumTest {
     public void tellItLikeItIs() {
         switch (day) {
             case MONDAY:
-                System.out.println("Mondays are bad.");
+                System.out.println("Понеділкі важкі.");
                 break;
                     
             case FRIDAY:
-                System.out.println("Fridays are better.");
+                System.out.println("П’ятниці краще.");
                 break;
                          
             case SATURDAY: 
             case SUNDAY:
-                System.out.println("Weekends are best.");
+                System.out.println("Вихідні найліпші.");
                 break;
                         
             default:
-                System.out.println("Midweek days are so-so.");
+                System.out.println("Середина тижня так собі.");
                 break;
         }
     }
     
     public static void main(String[] args) {
         EnumTest firstDay = new EnumTest(Day.MONDAY);
-        firstDay.tellItLikeItIs(); // => Mondays are bad.
+        firstDay.tellItLikeItIs(); // => Понеділки важкі.
         EnumTest thirdDay = new EnumTest(Day.WEDNESDAY);
-        thirdDay.tellItLikeItIs(); // => Midweek days are so-so.
+        thirdDay.tellItLikeItIs(); // => Середина тижня так собі.
     }
 }
 
@@ -743,18 +744,18 @@ public class EnumTest {
 
 ## Додатково для читання
 
-The links provided here below are just to get an understanding of the topic, feel free to Google and find specific examples.
+Посилання, наведені нижче, дозволяють тільки зрозуміти тему. Щоб знайти конкретні приклади, використовуйте Ґуґл.
 
 **Офіційні посібники Oracle**:
 
-* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+* [Посібник Java від Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
 
-* [Java модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+* [Java — модифікатори доступу](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
 
-* [ООП концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
-    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
-    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
-    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+* [ООП-концепції](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Наслідування](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Поліморфізм](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Абстракція](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
 
 * [Виключення](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
 
@@ -762,11 +763,11 @@ The links provided here below are just to get an understanding of the topic, fee
 
 * [параметризація](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
 
-* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
+* [Стиль коду у Java](http://www.oracle.com/technetwork/java/codeconvtoc-136057.html)
 
-**Online практика та посібники**
+**Online-практика та посібники**
 
-* [Learneroo.com - Learn Java](http://www.learneroo.com)
+* [Learneroo.com — Вивчаємо Java](http://www.learneroo.com)
 
 * [Codingbat.com](http://codingbat.com/java)
 
-- 
cgit v1.2.3


From 085ddf3aab1bb682da701cf1ab320b78052a3b06 Mon Sep 17 00:00:00 2001
From: clearsense <vlad_bochar@ukr.net>
Date: Sat, 14 May 2016 14:35:38 +0300
Subject: fix few mistakes in comments and code

delete if-statement in 458 line, because there is not place for it
---
 uk-ua/javascript-ua.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 9614f9ca..ff44b656 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -350,6 +350,7 @@ myFunc(); // = undefined
 // Функція може бути присвоєна іншому об’єкту. Тоді вона матиме доступ до 
 // цього об’єкта через this
 var myOtherFunc = function() {
+    return this.myString.toUpperCase();
 }
 myObj.myOtherFunc = myOtherFunc;
 myObj.myOtherFunc(); // = "HELLO, WORLD!"
@@ -407,7 +408,7 @@ myObj.__proto__ = myPrototype;
 myObj.meaningOfLife; // = 42
 
 // Аналогічно для функцій
-myObj.myFunc(); // = "Hello, world!"
+myObj.myFunc(); // = "hello, world!"
 
 // Якщо інтерпретатор не знайде властивості в прототипі, то він продовжить пошук
 // в прототипі прототипа і так далі
@@ -432,7 +433,7 @@ myObj.meaningOfLife; // = 43
 
 // Другий спосіб: у конструкторів є властивість з іменем prototype. Це *не*
 // прототип функції-конструктора, це прототип для нових об’єктів, які будуть створені
-// цим конструктором і ключового слова new.
+// цим конструктором і ключовим словом new.
 MyConstructor.prototype = {
     myNumber: 5,
     getMyNumber: function() {
-- 
cgit v1.2.3


From 8bda31f05386dcca40400aad34a7c45507c464b7 Mon Sep 17 00:00:00 2001
From: clearsense <vlad_bochar@ukr.net>
Date: Sat, 14 May 2016 14:37:54 +0300
Subject: fix some mistakes in comments and code

---
 uk-ua/javascript-ua.html.markdown | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index ff44b656..19dc790b 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -455,9 +455,6 @@ myNumber == myNumberObj; // = true
 typeof myNumber; // = 'number'
 typeof myNumberObj; // = 'object'
 myNumber === myNumberObj; // = false
-if (0) {
-    // Цей код не виконається, тому що 0 - це хиба.
-}
 
 // Об’єкти-обгортки і вбудовані типи мають спільні прототипи, тому
 // ви можете розширити функціонал рядків:
-- 
cgit v1.2.3


From 4cfac645fc4d5cb9c78f74f18c01c7a00f7bafba Mon Sep 17 00:00:00 2001
From: clearsense <vlad_bochar@ukr.net>
Date: Sat, 14 May 2016 14:45:20 +0300
Subject: fix list of Further Reading

---
 uk-ua/javascript-ua.html.markdown | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 19dc790b..11c8db02 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -482,12 +482,12 @@ if (Object.create === undefined) { // не перезаписуємо метод
 
 ## Що почитати
 
-[1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
-[2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
-[3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
-[4]: http://www.learneroo.com/modules/64/nodes/350
-[5]: http://bonsaiden.github.io/JavaScript-Garden/
-[6]: http://www.amazon.com/gp/product/0596805527/
-[7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
-[8]: http://eloquentjavascript.net/
-[9]: http://jstherightway.org/
+* [1]: https://developer.mozilla.org/en-US/docs/Web/JavaScript
+* [2]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+* [3]: https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core
+* [4]: http://www.learneroo.com/modules/64/nodes/350
+* [5]: http://bonsaiden.github.io/JavaScript-Garden/
+* [6]: http://www.amazon.com/gp/product/0596805527/
+* [7]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript
+* [8]: http://eloquentjavascript.net/
+* [9]: http://jstherightway.org/
-- 
cgit v1.2.3


From cc526773bd490520a5a25319cdc971a30f8ff6f9 Mon Sep 17 00:00:00 2001
From: clearsense <vlad_bochar@ukr.net>
Date: Sat, 14 May 2016 14:58:16 +0300
Subject: add me to list of contributors

---
 uk-ua/javascript-ua.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index 11c8db02..a84eba67 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -3,6 +3,7 @@ language: javascript
 contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
+    - ["clearsense", "https://github.com/clearsense"]
 filename: javascript-uk.js
 translators:
   - ["Ivan", "https://github.com/IvanEh"]
-- 
cgit v1.2.3


From 274067e05bcf37061c192bab4f4fb93d750c9cac Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Sat, 15 Oct 2016 15:32:41 +0300
Subject: [bash/uk-ua] translation fixes

---
 uk-ua/bash-ua.html.markdown | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/bash-ua.html.markdown b/uk-ua/bash-ua.html.markdown
index b7e4a5ba..c6e9ebb1 100644
--- a/uk-ua/bash-ua.html.markdown
+++ b/uk-ua/bash-ua.html.markdown
@@ -13,13 +13,13 @@ contributors:
     - ["Etan Reisner", "https://github.com/deryni"]
 translators:
     - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+    - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
 lang: uk-ua
 ---
 
 Bash - командна оболонка unix (unix shell), що також розповсюджувалась як оболонка для
 операційної системи GNU і зараз використовується як командна оболонка за замовчуванням
 для Linux i Max OS X.
-Почти все нижеприведенные примеры могут быть частью shell-скриптов или исполнены напрямую в shell.
 Майже всі приклади, що наведені нижче можуть бути частиною shell-скриптів або
 виконані в оболонці
 
@@ -28,7 +28,7 @@ Bash - командна оболонка unix (unix shell), що також ро
 ```bash
 #!/bin/bash
 # Перший рядок скрипта - це shebang, який вказує системі, як потрібно виконувати
-# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - тоже коментар
+# скрипт. Як ви вже зрозуміли, коментарі починаються з #. Shebang - також коментар
 
 # Простий приклад hello world:
 echo Hello world!
@@ -123,7 +123,7 @@ fi
 # Вирази позначаються наступним форматом:
 echo $(( 10 + 5 ))
 
-# На відмінно від інших мов програмування, Bash - це командна оболонка, а
+# На відміну від інших мов програмування, Bash - це командна оболонка, а
 # отже, працює в контексті поточної директорії
 ls
 
@@ -135,7 +135,7 @@ ls -l # Показати кожен файл і директорію на окр
 # Таким чином ми можемо переглянути тільки *.txt файли в поточній директорії:
 ls -l | grep "\.txt"
 
-# Ви можете перенаправ вхід і вихід команди (stdin, stdout, stderr).
+# Ви можете перенаправити вхід і вихід команди (stdin, stdout, stderr).
 # Наступна команда означає: читати із stdin, поки не зустрінеться ^EOF$, і
 # перезаписати hello.py наступними рядками (до рядка "EOF"):
 cat > hello.py << EOF
@@ -155,7 +155,7 @@ python hello.py > "output.out"
 python hello.py 2> "error.err"
 python hello.py > "output-and-error.log" 2>&1
 python hello.py > /dev/null 2>&1
-# Поток помилок перезапише фпйл, якщо цей файл існує
+# Потік помилок перезапише файл, якщо цей файл існує
 # тому, якщо ви хочете дописувати до файлу, використовуйте ">>":
 python hello.py >> "output.out" 2>> "error.err"
 
@@ -172,7 +172,6 @@ echo "#helloworld" > output.out
 echo "#helloworld" | cat > output.out
 echo "#helloworld" | tee output.out >/dev/null
 
-# Подчистить временные файлы с подробным выводом ('-i' - интерактивый режим)
 # Очистити тимчасові файли з детальним виводом (додайте '-i'
 # для інтерактивного режиму)
 rm -v output.out error.err output-and-error.log
@@ -194,7 +193,7 @@ case "$VARIABLE" in
 esac
 
 # Цикл for перебирає елементи передані в аргумент:
-# Значення $VARIABLE буде напечатано тричі.
+# Значення $VARIABLE буде надруковано тричі.
 for VARIABLE in {1..3}
 do
     echo "$VARIABLE"
@@ -260,12 +259,11 @@ uniq -d file.txt
 cut -d ',' -f 1 file.txt
 # замінити кожне 'okay' на 'great' у файлі file.txt (підтримується regex)
 sed -i 's/okay/great/g' file.txt
-# вивести в stdout все рядки з file.txt, що задовольняють шаблону regex;
+# вивести в stdout всі рядки з file.txt, що задовольняють шаблону regex;
 # цей приклад виводить рядки, що починаються на foo і закінчуються на bar:
 grep "^foo.*bar$" file.txt
 # використайте опцію -c, щоб вивести кількість входжень
 grep -c "^foo.*bar$" file.txt
-# чтобы искать по строке, а не шаблону regex, используйте fgrep (или grep -F)
 # щоб здійснити пошук по рядку, а не по шаблону regex, використовуйте fgrea (або grep -F)
 fgrep "^foo.*bar$" file.txt 
 
-- 
cgit v1.2.3


From ba574ecdb2658cb2d8f6e461772616c25b161681 Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Sat, 15 Oct 2016 18:29:43 +0300
Subject: [json/uk-ua] translation improvement (#2461)

---
 uk-ua/json-ua.html.markdown | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

(limited to 'uk-ua')

diff --git a/uk-ua/json-ua.html.markdown b/uk-ua/json-ua.html.markdown
index a860e9a7..c9a3d3fb 100644
--- a/uk-ua/json-ua.html.markdown
+++ b/uk-ua/json-ua.html.markdown
@@ -1,24 +1,30 @@
 ---
 language: json
-filename: learnjson-ru.json
+filename: learnjson-ua.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
   - ["Ehreshi Ivan", "https://github.com/IvanEh"]
+  - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
 lang: uk-ua
 ---
 
-JSON - це надзвичайно простий формат обміну даними. Це мабуть буде найлегшим курсом 
-"Learn X in Y Minutes".
+JSON - це надзвичайно простий формат обміну даними. Згідно з [json.org](http://json.org), для людей він легкий в написанні і читанні, а для комп’ютерів в розборі та генерації.
 
-В загальному випадку в JSON немає коментарів, але більшість парсерів дозволяють 
-використовувати коментарі в С-стилі(//, /\* \*/). Можна залишити кому після останнього
-поля, але все-таки краще такого уникати для кращої сумісності
+JSON підтримує наступні структури даних:
+
+* Колекція пар ключ/значення (`{ "ключ": "значення" }`). У різних мовах програмування реалізується як об’єкт, запис, структура, словник, хеш-таблиця, іменований список або асоціативний масив.
+* Впорядкований список значень (`[ "елемент0", "елемент1" ]`). У різних мовах програмування реалізується як масив, вектор, список або послідовність.
+* Рядки: `"привіт"`, `"\"Лапки\""`, `"\u0abe"`, `"Новий рядок.\n"`
+* Числа: `23`, `0.11`, `12e10`, `3.141e-10`, `1.23e+4`
+* Інші: `true`, `false`, `null`
+
+JSON в чистій формі не містить коментарів, але більшість парсерів підтримують коментарі в C-стилі (`//`, `/* */`). Деякі парсери також не звертають уваги на кому після останнього поля, але їх варто уникати для кращої сумісності.
 
 ```json
 {
-  "ключ": "значеннь",
+  "ключ": "значення",
   
   "ключі": "завжди мають бути обгорнуті в подвійні лапки",
   "числа": 0,
@@ -50,9 +56,9 @@ JSON - це надзвичайно простий формат обміну да
     ]
   ],
   
-  "альтернативнтй стиль": {
+  "альтернативний стиль": {
     "коментар": "Гляньте!"
-  , "позиція коми": "неважлива, поки вона знаходиться до наступного поля"
+  , "позиція коми": "неважлива, коректно якщо вона знаходиться перед наступним полем"
   , "інший коментар": "класно"
   },
 
-- 
cgit v1.2.3


From da14e53217cfb435828c3d3e0d5ce7df08d015e2 Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Sat, 22 Oct 2016 15:45:38 +0300
Subject: [javascript/uk-ua] Fixed typo (#2492)

---
 uk-ua/javascript-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index a84eba67..ffca2ba0 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -11,7 +11,7 @@ translators:
 lang: uk-ua
 ---
 
-JavaScript було створено в 1995 році Бренданом Айком, який працював у копаніх Netscape.
+JavaScript було створено в 1995 році Бренданом Айком, який працював у копанії Netscape.
 Він був задуманий як проста мова сценаріїв для веб-сайтів, який би доповнював Java
 для більш складних веб-застосунків. Але тісна інтеграція з веб-сторінками і
 вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
-- 
cgit v1.2.3


From f8f071c67db08a2989c85af7686e6aee46a71dbb Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Sun, 23 Oct 2016 20:00:57 +0300
Subject: [javascript/uk-ua] Fixed typo (#2499)

---
 uk-ua/javascript-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index ffca2ba0..ac6a2bde 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -11,7 +11,7 @@ translators:
 lang: uk-ua
 ---
 
-JavaScript було створено в 1995 році Бренданом Айком, який працював у копанії Netscape.
+JavaScript було створено в 1995 році Бренданом Айком, який працював у компанії Netscape.
 Він був задуманий як проста мова сценаріїв для веб-сайтів, який би доповнював Java
 для більш складних веб-застосунків. Але тісна інтеграція з веб-сторінками і
 вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
-- 
cgit v1.2.3


From 47c209e04baee833a7a08ddfcb0942e7f2aa24fc Mon Sep 17 00:00:00 2001
From: Serg <serg.maximchuk@gmail.com>
Date: Sun, 23 Oct 2016 20:24:46 +0300
Subject: [ruby/uk-ua] Created Ukrainian's Ruby translation (#2500)

---
 uk-ua/ruby-ua.html.markdown | 625 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 625 insertions(+)
 create mode 100644 uk-ua/ruby-ua.html.markdown

(limited to 'uk-ua')

diff --git a/uk-ua/ruby-ua.html.markdown b/uk-ua/ruby-ua.html.markdown
new file mode 100644
index 00000000..c41486c9
--- /dev/null
+++ b/uk-ua/ruby-ua.html.markdown
@@ -0,0 +1,625 @@
+---
+language: ruby
+filename: learnruby.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+  - ["Tristan Hume", "http://thume.ca/"]
+  - ["Nick LaMuro", "https://github.com/NickLaMuro"]
+  - ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
+  - ["Ariel Krakowski", "http://www.learneroo.com"]
+  - ["Dzianis Dashkevich", "https://github.com/dskecse"]
+  - ["Levi Bostian", "https://github.com/levibostian"]
+  - ["Rahil Momin", "https://github.com/iamrahil"]
+  - ["Gabriel Halley", "https://github.com/ghalley"]
+  - ["Persa Zula", "http://persazula.com"]
+  - ["Jake Faris", "https://github.com/farisj"]
+translators:
+  - ["Serhii Maksymchuk", "https://github.com/Serg-Maximchuk"]
+lang: uk-ua
+---
+
+Rubi — це інтерпретована, повністю об'єктно-орієнтована мова програмування з чіткою динамічною типізацією.
+
+```ruby
+# Це коментар
+
+=begin
+Це багаторядковий коментар
+Ніхто їх не використовує
+Тобі теж не варто
+=end
+
+# В першу чергу: все являється об’єктом.
+
+# Числа це об’єкти
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Базова арифметика
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+2**5 #=> 32
+5 % 3 #=> 2
+
+# Побітові оператори
+3 & 5 #=> 1
+3 | 5 #=> 7
+3 ^ 5 #=> 6
+
+# Арифметика це просто синтаксичний цукор
+# для виклику методу об’єкта
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Спеціальні значення теж об’єкти
+nil # еквівалентно null в інших мовах
+true # істина
+false # хиба
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Рівність
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Нерівність
+1 != 1 #=> false
+2 != 1 #=> true
+
+# Окрім власне false, nil це ще одне "хибне" значення
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Інші порівняння
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Комбінований оператор порівняння
+1 <=> 10 #=> -1
+10 <=> 1 #=> 1
+1 <=> 1 #=> 0
+
+# Логічні оператори
+true && false #=> false
+true || false #=> true
+!true #=> false
+
+# Є альтернативні версії логічних операторів з набагато меншим
+# прецедентом. Вони використовуються в конструкціях з контролем
+# виконання ланцюга виразів які повертають булевий результат.
+
+# `do_something_else` викликається лише якщо `do_something` повертає true.
+do_something() and do_something_else()
+# `log_error` викликається лише якщо `do_something` повертає false.
+do_something() or log_error()
+
+
+# Strings це об’єкти
+
+'Я — рядок'.class #=> String
+"Я теж рядок".class #=> String
+
+placeholder = 'використовувати інтерполяцію рядків'
+"Я можу #{placeholder} коли користуюсь рядками в подвійних лапках"
+#=> "Я можу використовувати інтерполяцію рядків коли користуюсь рядками в подвійних лапках"
+
+# Варто надавати перевагу рядкам в одинарних лапках де це можливо
+# Рядки в подвійних лапках викликають додаткові внутрішні обчислення
+
+# Об’єднуйте рядки, але не з числами
+'hello ' + 'world'  #=> "hello world"
+'hello ' + 3 #=> TypeError: can't convert Fixnum into String
+'hello ' + 3.to_s #=> "hello 3"
+
+# Об’єднуйте рядки з операторами
+'hello ' * 3 #=> "hello hello hello "
+
+# Додавання до рядка
+'hello' << ' world' #=> "hello world"
+
+# Вивести рядок з переходом на новий рядок вкінці
+puts "Я надрукований!"
+#=> Я надрукований!
+#=> nil
+
+# Вивести рядок без переходу на новий
+print "Я надрукований!"
+#=> Я надрукований! => nil
+
+# Змінні
+x = 25 #=> 25
+x #=> 25
+
+# Зверніть увагу, оператор присвоєння повертає присвоєне значення
+# Отже можна робити одночасне присвоєння кількох змінних:
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Для назв змінних використовується зміїний_регістр
+snake_case = true
+
+# Використовуйте назви змінних які їх характеризують 
+path_to_project_root = '/good/name/'
+path = '/bad/name/'
+
+# Символи (теж об’єкти)
+# Символи є незмінними константами багаторазового використання, внутрішньо
+# представлені цілочисельним значенням. Вони часто використовуються замість
+# рядків щоб ефективно передати конкретні, значущі значення.
+
+:pending.class #=> Symbol
+
+status = :pending
+
+status == :pending #=> true
+
+status == 'pending' #=> false
+
+status == :approved #=> false
+
+# Масиви
+
+# Ось масив
+array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Масиви можуть містити елементи різних типів
+[1, 'hello', false] #=> [1, "hello", false]
+
+# Масиви можуть бути проіндексовані
+# З початку
+array[0] #=> 1
+array.first #=> 1
+array[12] #=> nil
+
+# Як і арифметика, доступ до елемента масиву у вигляді [індекс] — це лише
+# синтаксичний цукор виклику методу [] об’єкта
+array.[] 0 #=> 1
+array.[] 12 #=> nil
+
+# З кінця
+array[-1] #=> 5
+array.last #=> 5
+
+# З початковим індексом та довжиною
+array[2, 3] #=> [3, 4, 5]
+
+# Реверс масиву
+a=[1,2,3]
+a.reverse! #=> [3,2,1]
+
+# Елементи масиву за діапазоном індексів
+array[1..3] #=> [2, 3, 4]
+
+# Додавати елементи в масив можна так:
+array << 6 #=> [1, 2, 3, 4, 5, 6]
+# Або так:
+array.push(6) #=> [1, 2, 3, 4, 5, 6]
+
+# Перевірити чи масив містить елемент
+array.include?(1) #=> true
+
+# Хеш — це масив пар ключ/значення.
+# Хеш оголошується з використанням фігурних дужок:
+hash = { 'color' => 'green', 'number' => 5 }
+
+hash.keys #=> ['color', 'number']
+
+# Значення в хеші може бути швидко знайдене за ключем:
+hash['color'] #=> 'green'
+hash['number'] #=> 5
+
+# Запит значення за неіснуючим ключем повертає nil:
+hash['nothing here'] #=> nil
+
+# Починаючи з Ruby 1.9 з’явився спеціальний синтаксис при використанні
+# символів в якості ключів:
+new_hash = { defcon: 3, action: true }
+
+new_hash.keys #=> [:defcon, :action]
+
+# Перевірка наявності ключів та значень в хеші
+new_hash.key?(:defcon) #=> true
+new_hash.value?(3) #=> true
+
+# Хеші та масиви — перелічувальні типи даних
+# Вони мають багато корисних методів, такі як each, map, count, та інші.
+
+# Оператор вибору "if"
+if true
+  'якщо'
+elsif false
+  'інакше якщо, опціонально'
+else
+  'інакше, також опціонально'
+end
+
+# Оператор циклу "for"
+for counter in 1..5
+  puts "ітерація #{counter}"
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Проте, ніхто не використовує "for" в циклах.
+# Замість цього варто використовувати метод "each" і передати йому блок.
+# Блок — це відокремлений код який можна передати в метод, наприклад в "each".
+# Це аналог лямбда-виразів, анонімних функцій або замикань в інших мовах програмування.
+
+# Метод "each" для діапазону запускає блок один раз для кожного елементу діапазону.
+# Лічильник передається блоку в якості аргументу.
+
+# Виклик методу "each" з блоком виглядає наступним чином:
+(1..5).each do |counter|
+  puts "ітерація #{counter}"
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Також можна загорнути блок в фігурні дужки:
+(1..5).each { |counter| puts "ітерація #{counter}" }
+
+# Вміст структур даних також може бути ітерований використовуючи метод "each":
+array.each do |element|
+  puts "#{element} є елементом масиву"
+end
+hash.each do |key, value|
+  puts "#{key} є #{value}"
+end
+
+# Якщо є необхідність індексувати ітерацію, можна використати метод "each_with_index":
+array.each_with_index do |element, index|
+  puts "#{element} під номером #{index} в масиві"
+end
+
+# Оператор циклу "while"
+counter = 1
+while counter <= 5 do
+  puts "ітерація #{counter}"
+  counter += 1
+end
+#=> ітерація 1
+#=> ітерація 2
+#=> ітерація 3
+#=> ітерація 4
+#=> ітерація 5
+
+# Є й інші корисні функції для циклів, такі як "map", "reduce",
+# "inject" та інші. Наприклад "map" в циклі проходить по масиву,
+# виконує над елементами операцію(-ї) в блоці і повертає абсолютно
+# новий масив.
+array = [1,2,3,4,5]
+doubled = array.map do |element|
+  element * 2
+end
+puts doubled
+#=> [2,4,6,8,10]
+puts array
+#=> [1,2,3,4,5]
+
+# Оператор множинного вибору
+grade = 'B'
+
+case grade
+when 'A'
+  puts 'Відмінно!'
+when 'B'
+  puts 'Пощастить наступного разу'
+when 'C'
+  puts 'Ти можеш краще'
+when 'D'
+  puts 'Майже четвірка'
+when 'E'
+  puts 'Випросив'
+when 'F'
+  puts 'Не здав!'
+else
+  puts 'Інша система оцінювання, так?'
+end
+#=> "Пощастить наступного разу"
+
+# Оператор "case" також може використовувати діапазон:
+grade = 82
+case grade
+when 90..100
+  puts 'Ура!'
+when 80...90
+  puts 'Хороша робота'
+when 60...80
+  puts 'Ну, хоч щось'
+else
+  puts 'Не здав!'
+end
+#=> "Хороша робота"
+
+# Обробка вийнятків:
+begin
+  # код з можливим вийнятком
+  raise NoMemoryError, 'Ви використали всю пам’ять.'
+rescue NoMemoryError => exception_variable
+  puts 'Помилка NoMemoryError', exception_variable
+rescue RuntimeError => other_exception_variable
+  puts 'Помилка RuntimeError'
+else
+  puts 'Цей код запуститься якщо вийнятків не було взагалі'
+ensure
+  puts 'Цей код запуститься в будь-якому випадку'
+end
+
+# Функції
+
+def double(x)
+  x * 2
+end
+
+# Функції (і всі блоки) неявно повертають значення останнього виразу
+double(2) #=> 4
+
+# Дужки не є обов’язковими якщо результат недвозначний
+double 3 #=> 6
+
+double double 3 #=> 12
+
+def sum(x, y)
+  x + y
+end
+
+# Аргументи методів розділяються комою
+sum 3, 4 #=> 7
+
+sum sum(3, 4), 5 #=> 12
+
+# yield
+# Всі методи мають неявний, опціональний параметр, який
+# можна викликат за допомогою ключового слова 'yield'
+def surround
+  puts '{'
+  yield
+  puts '}'
+end
+
+surround { puts 'привіт світ' }
+
+# {
+# привіт світ
+# }
+
+
+# Ви можете передати блок у функцію
+# "&" позначає посилання на блок
+def guests(&block)
+  block.call 'some_argument'
+end
+
+# Ви можете передати список аргументів, вони будуть перетворені в масив
+# Для цього існує оператор ("*")
+def guests(*array)
+  array.each { |guest| puts guest }
+end
+
+# Якщо метод повертає масив, ви можете використати деструктуризацію
+def foods
+    ['млинці', 'бутерброд', 'лазанья']
+end
+breakfast, lunch, dinner = foods
+breakfast #=> 'млинці'
+dinner #=> 'лазанья'
+
+# Зазвичай методи які повертають булевий результат закінчуються знаком питання
+5.even? # false
+5.odd? # true
+
+# І якщо метод закінчується знаком оклику, то він робить щось деструктивне 
+# типу зміни отриманого аргументу. Багато методів мають версію з "!" які
+# змінюють аргумент, та без "!" що повертають новий об’єкт
+company_name = "Дандер Міфлін"
+company_name.upcase #=> "ДАНДЕР МІФЛІН"
+company_name #=> "Дандер Міфлін"
+company_name.upcase! # змінна company_name зміниться цього разу!
+company_name #=> "ДАНДЕР МІФЛІН"
+
+
+# Клас оголошується ключовим словом class
+class Human
+
+  # Змінна класу. Вона поширюється на всі екземпляри цього класу.
+  @@species = 'Homo sapiens'
+
+  # Основний ініціалізатор
+  def initialize(name, age = 0)
+    # Призначення аргументу "name" до однойменної змінної екземпляру
+    @name = name
+    # Якщо аргумент "age" не заданий, то йому буде присвоєно дефолтне значення
+    # зі списку аргументів
+    @age = age
+  end
+
+  # Метод-сетер
+  def name=(name)
+    @name = name
+  end
+
+  # Метод-ґетер
+  def name
+    @name
+  end
+
+  # Функціональність вище може бути інкапсульована використовуючи метод attr_accessor:
+  attr_accessor :name
+
+  # Ґетери і сетери можуть бути створені індивідуально, наприклад:
+  attr_reader :name
+  attr_writer :name
+
+  # Метод класу позначається ключовим словом "self", щоб відрізнити від
+  # методів екземпляра класу.
+  # Він може бути викликаний лише в класі, але не в екземплярі.
+  def self.say(msg)
+    puts msg
+  end
+
+  def species
+    @@species
+  end
+end
+
+
+# Ініціалізуємо клас
+jim = Human.new('Джим Галперт')
+
+dwight = Human.new('Дуайт Шрут')
+
+# Викличемо кілька методів
+jim.species #=> "Homo sapiens"
+jim.name #=> "Джим Галперт"
+jim.name = "Джим Галперт II" #=> "Джим Галперт II"
+jim.name #=> "Джим Галперт II"
+dwight.species #=> "Homo sapiens"
+dwight.name #=> "Дуайт Шрут"
+
+# Викликати метод класу
+Human.say('Привіт') #=> "Привіт"
+
+# Область видимості змінних визначається способом оголошення імені змінної.
+# Змінні, що починаються на "$" мають глобальну область видимості.
+$var = "Я глобальна змінна"
+defined? $var #=> "global-variable"
+
+# Зміннні, що опчинають на "@" мають область видимості екзкмпляра
+@var = "Я змінна екземпляра"
+defined? @var #=> "instance-variable"
+
+# Змінні, що починаються на "@@" мають область видимості класу
+@@var = "Я змінна класу"
+defined? @@var #=> "class variable"
+
+# Змінні, що починаються з великої букви, є константами
+Var = "Я константа"
+defined? Var #=> "constant"
+
+# Клас теж об’єкт. Тому клас може мати змінні екземпляра.
+# Змінна класу поширюється між класом і всіма його нащадками.
+
+# Базовий клас
+class Human
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(value)
+    @@foo = value
+  end
+end
+
+# Похідний клас (нащадок)
+class Worker < Human
+end
+
+Human.foo # 0
+Worker.foo # 0
+
+Human.foo = 2 # 2
+Worker.foo # 2
+
+# Змінна екземпляра класу не поширюється між класами-нащадками.
+class Human
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(value)
+    @bar = value
+  end
+end
+
+class Doctor < Human
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+module ModuleExample
+  def foo
+    'foo'
+  end
+end
+
+# Включення модулів додає їхні методи до екземплярів класу
+# Розширення модулів додає їхні методи в сам клас
+
+class Person
+  include ModuleExample
+end
+
+class Book
+  extend ModuleExample
+end
+
+Person.foo     # => NoMethodError: undefined method `foo' for Person:Class
+Person.new.foo # => 'foo'
+Book.foo       # => 'foo'
+Book.new.foo   # => NoMethodError: undefined method `foo'
+
+# Колбек виконується при включенні і розширенні модуля
+
+module ConcernExample
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.send(:include, InstanceMethods)
+  end
+
+  module ClassMethods
+    def bar
+      'bar'
+    end
+  end
+
+  module InstanceMethods
+    def qux
+      'qux'
+    end
+  end
+end
+
+class Something
+  include ConcernExample
+end
+
+Something.bar     # => 'bar'
+Something.qux     # => NoMethodError: undefined method `qux'
+Something.new.bar # => NoMethodError: undefined method `bar'
+Something.new.qux # => 'qux'
+```
+
+## Додаткові ресурси
+
+- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - A variant of this reference with in-browser challenges.
+- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Learn Ruby through a series of interactive tutorials.
+- [Official Documentation](http://ruby-doc.org/core)
+- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
+- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
+- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
+- [Try Ruby](http://tryruby.org) - Learn the basic of Ruby programming language, interactive in the browser.
-- 
cgit v1.2.3


From 4a8c39a21f0d17cdfc49baad9dec06155219d133 Mon Sep 17 00:00:00 2001
From: ven <vendethiel@hotmail.fr>
Date: Sun, 23 Oct 2016 19:25:09 +0200
Subject: #2500 followup

---
 uk-ua/ruby-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/ruby-ua.html.markdown b/uk-ua/ruby-ua.html.markdown
index c41486c9..74346dfe 100644
--- a/uk-ua/ruby-ua.html.markdown
+++ b/uk-ua/ruby-ua.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: ruby
-filename: learnruby.rb
+filename: learnruby-ua.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
-- 
cgit v1.2.3


From 3959728d8c8ac2cedfe2aba3c4b8ee10715c53d8 Mon Sep 17 00:00:00 2001
From: Pratik Karki <prertik@outlook.com>
Date: Fri, 25 Aug 2017 14:17:12 +0545
Subject: fix language code suffix(#2832)

---
 uk-ua/java-ua.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/java-ua.html.markdown b/uk-ua/java-ua.html.markdown
index 1ea30f3d..1d600400 100644
--- a/uk-ua/java-ua.html.markdown
+++ b/uk-ua/java-ua.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: java
+filename: LearnJava-ua.java
 contributors:
     - ["Jake Prather", "http://github.com/JakeHP"]
     - ["Jakukyo Friel", "http://weakish.github.io"]
@@ -11,8 +12,8 @@ contributors:
 translators:
     - ["Oleksandr Tatarchuk", "https://github.com/tatarchuk"]
     - ["Andre Polykanine", "https://github.com/Oire"]
-filename: LearnJavaUa.java
 lang: uk-ua
+
 ---
 
 Java є об’єктно-орієнтованою мовою програмування загального призначення з підтримкою паралельного програмування, яка базується на класах.
-- 
cgit v1.2.3


From 2095b65d8cc828b38d7d7641ea42c2fc15a78c59 Mon Sep 17 00:00:00 2001
From: Vasiliy Petrov <saugardas@yandex.ru>
Date: Wed, 11 Oct 2017 21:50:51 +0300
Subject: [javascript/uk-ua] Fix typo

---
 uk-ua/javascript-ua.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'uk-ua')

diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown
index ac6a2bde..397b1c5e 100644
--- a/uk-ua/javascript-ua.html.markdown
+++ b/uk-ua/javascript-ua.html.markdown
@@ -17,7 +17,7 @@ JavaScript було створено в 1995 році Бренданом Айк
 вбудована підтримка браузерами призвела до того, що JavaScript став популярніший
 за власне Java.
 
-Зараз JavaScript не обмежується тільки веб-браузеорм. Наприклад, Node.js,
+Зараз JavaScript не обмежується тільки веб-браузером. Наприклад, Node.js,
 програмна платформа, що дозволяє виконувати JavaScript код з використанням
 рушія V8 від браузера Google Chrome, стає все більш і більш популярною.
 
-- 
cgit v1.2.3