diff options
Diffstat (limited to 'uk-ua')
| -rw-r--r-- | uk-ua/bash-ua.html.markdown | 20 | ||||
| -rw-r--r-- | uk-ua/c-ua.html.markdown | 860 | ||||
| -rw-r--r-- | uk-ua/cypher-ua.html.markdown | 254 | ||||
| -rw-r--r-- | uk-ua/go-ua.html.markdown | 449 | ||||
| -rw-r--r-- | uk-ua/javascript-ua.html.markdown | 2 | ||||
| -rw-r--r-- | uk-ua/kotlin-ua.html.markdown | 464 | ||||
| -rw-r--r-- | uk-ua/mips-ua.html.markdown | 366 | ||||
| -rw-r--r-- | uk-ua/pythonlegacy-ua.html.markdown (renamed from uk-ua/python-ua.html.markdown) | 4 | ||||
| -rw-r--r-- | uk-ua/ruby-ua.html.markdown | 2 | ||||
| -rw-r--r-- | uk-ua/rust-ua.html.markdown | 4 |
10 files changed, 2409 insertions, 16 deletions
diff --git a/uk-ua/bash-ua.html.markdown b/uk-ua/bash-ua.html.markdown index c6e9ebb1..9375d5f3 100644 --- a/uk-ua/bash-ua.html.markdown +++ b/uk-ua/bash-ua.html.markdown @@ -19,7 +19,7 @@ lang: uk-ua Bash - командна оболонка unix (unix shell), що також розповсюджувалась як оболонка для операційної системи GNU і зараз використовується як командна оболонка за замовчуванням -для Linux i Max OS X. +для Linux i Mac OS X. Майже всі приклади, що наведені нижче можуть бути частиною shell-скриптів або виконані в оболонці @@ -52,9 +52,9 @@ VARIABLE= 'Просто рядок' # виконання команди 'Просто рядок') # Використання змінних: -echo $VARIABLE -echo "$VARIABLE" -echo '$VARIABLE' +echo $VARIABLE # Просто рядок +echo "$VARIABLE" # Просто рядок +echo '$VARIABLE' # $VARIABLE # Коли ви використовуєте змінну - присвоюєте значення, експортуєте і т.д. - # пишіть її імя без $. А для отримання значення змінної використовуйте $. # Одинарні лапки ' не розкривають значення змінних @@ -96,12 +96,12 @@ else echo "Ім’я збігаєтьяс з іменем користувача" fi -# Зауважте! якщо $Name пуста, bash інтерпретує код вище як: +# Зауважте! якщо $NAME пуста, bash інтерпретує код вище як: if [ -ne $USER ] # що є неправильним синтаксисом # тому безпечний спосіб використання потенційно пустих змінних має вигляд: -if [ "$Name" -ne $USER ] ... -# коли $Name пуста, інтерпретується наступним чином: +if [ "$NAME" -ne $USER ] ... +# коли $NAME пуста, інтерпретується наступним чином: if [ "" -ne $USER ] ... # що працює як і очікувалося @@ -205,7 +205,7 @@ do echo $a done -# Цикл for можно використати, щоб виконувати дії над файлами. +# Цикл for можна використати, щоб виконувати дії над файлами. # Цей код запустить команду 'cat' для файлів file1 и file2 for VARIABLE in file1 file2 do @@ -259,12 +259,12 @@ 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, використовуйте fgrea (або grep -F) +# щоб здійснити пошук по рядку, а не по шаблону regex, використовуйте fgrep (або grep -F) fgrep "^foo.*bar$" file.txt # Читайте вбудовану документацію Bash командою 'help': diff --git a/uk-ua/c-ua.html.markdown b/uk-ua/c-ua.html.markdown new file mode 100644 index 00000000..56a2b2ad --- /dev/null +++ b/uk-ua/c-ua.html.markdown @@ -0,0 +1,860 @@ +--- +language: C +filename: learnc-ua.c +contributors: + - ["Adam Bard", "http://adambard.com/"] + - ["Árpád Goretity", "http://twitter.com/H2CO3_iOS"] + - ["Jakub Trzebiatowski", "http://cbs.stgn.pl"] + - ["Marco Scannadinari", "https://marcoms.github.io"] + - ["Zachary Ferguson", "https://github.io/zfergus2"] + - ["himanshu", "https://github.com/himanshu81494"] + - ["Joshua Li", "https://github.com/JoshuaRLi"] + - ["Dragos B. Chirila", "https://github.com/dchirila"] +translators: + - ["AstiaSun", "https://github.com/AstiaSun"] +lang: uk-ua +--- + +О, C! Досі мова для сучасних обчислень у високопродуктивних продуктах. + +C це імовірно найбільш низькорівнева мова, яку будуть використовувати більшість програмістів. Проте, вона компенсує це не тільки швидкістю виконання. Як тільки ви оціните її можливість ручного управління пам'яттю, С зможе відвести саме в ті місця, в які вам потрібно було потрапити. + +> **Дещо про прапори компілятора** +> +> За замовчуванням, gcc та clang досить тихо інформують про попередження та помилки +> при компіляції, хоч це і може бути дуже корисною інформацією. Тому рекомендується +> використовувати більш вимогливий компілятор. Ось кілька рекомендацій: +> +> `-Wall -Wextra -Werror -O2 -std=c99 -pedantic` +> +> За інформацією про ці та інші прапори зверніться до головної сторінки man вашого +> компілятора C (наприклад, `man 1 gcc`) або ж просто заґуґліть. + + +```c +// Однорядкові коментарі починаються з // +// Проте вони з'явились тільки після С99. + +/* +Багаторядкові коментарі мають такий вигляд. І працюють в C89. +*/ + +/* +Багаторядкові коментарі не можуть вкладатись один в одний. +/* Будьте обережними */ // коментар закінчується на цьому рядку... +*/ // ...а не на цьому! + +// Константа: #define <keyword> +// Назви констант, як правило, пишуться великими літерами, проте це не вимога +#define DAYS_IN_YEAR 365 + +// Ще одним способом оголосити константи є перелічення констант. +// До речі, всі вирази мають закінчуватись крапкою з комою. +enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT}; +// MON отримає значення 2 автоматично, TUE дорівнюватиме 3 і т.д. + +// Імпортувати заголовки можна за допомогою #include +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +// (Заголовки із стандартної бібліотеки С вказуються між <кутовими дужками>.) +// Щоб додати власні заголовки, потрібно використовувати "подвійні лапки" +// замість кутових: +//#include "my_header.h" + +// Сигнатури функцій попередньо оголошуються в .h файлах або на початку .с файлів. +void function_1(); +int function_2(void); + +// Потрібно оголосити 'прототип функції' перед main(), реалізація функцій +// відбувається після функції main(). +int add_two_ints(int x1, int x2); // прототип функції +// Варіант `int add_two_ints(int, int);` теж правильний (не потрібно називати +// аргументи). Рекомендується також називати аргументи в прототипі для +// кращого розуміння. + +// Вхідною точкою програми є функція під назвою main. Вона повертає чисельний тип. +int main(void) { + // реалізація програми +} + +// Аргументи командного рядка, вказані при запуску програми, також передаються +// у функцію main. +// argc - це кількість переданих аргументів +// argv — це масив масивів символів, що містить самі аргументи +// argv[0] - назва програми, argv[1] - перший аргумент, і т.д. +int main (int argc, char** argv) +{ + // printf дозволяє вивести на екран значення, вивід - це форматований рядок, + // в даному випадку %d позначає чисельне значення, \n — це новий рядок + printf("%d\n", 0); // => Виводить 0 + + /////////////////////////////////////// + // Типи + /////////////////////////////////////// + + // Всі змінні повинні бути оголошені на початку поточного блоку області видимості. + // В цьому коді вони оголошуються динамічно. С99-сумісні компілятори + // дозволяють оголошення близько до місця, де значення використовується. + + // int (цілочисельний знаковий тип) зазвичай займає 4 байти + int x_int = 0; + + // short (цілочисельний знаковий тип) зазвичай займає 2 байти + // + short x_short = 0; + + // Символьний тип char гарантовано займає 1 байт + char x_char = 0; + char y_char = 'y'; // Символьні літерали позначаються '' + + // long (цілочисельний знаковий тип) має розмір від 4 до 8 байтів; великі значення + // типу long гарантовано займають 8 байтів + long x_long = 0; + long long x_long_long = 0; + + // Тип float - це зазвичай 32-бітове число з плаваючою крапкою + float x_float = 0.0f; // Суфікс 'f' позначає літерал з плаваючою крапкою + + // Тип double - це зазвийчай 64-бітове число з плаваючою крапкою + double x_double = 0.0; // дійсне число без суфіксів має тип double + + // Цілочисельні типи можуть не мати знаку (бути більше, або ж рівними нулю) + unsigned short ux_short; + unsigned int ux_int; + unsigned long long ux_long_long; + + // Char всередині одинарних лапок інтерпретуються як числа в наборі + // символів комп'ютера. + '0'; // => 48 в таблиці ASCII. + 'A'; // => 65 в таблиці ASCII. + + // sizeof(T) повертає розмір змінної типу Т в байтах + // sizeof(obj) віддає розмір виразу (змінна, літерал, і т.п.) + printf("%zu\n", sizeof(int)); // => 4 (на більшості пристроїв з 4-байтним словом) + + // Якщо аргумент оператора `sizeof` — це вираз, тоді його аргументи не оцінюються + // (крім масивів, розмір яких залежить від змінної). + // Значення, що повертається в цьому випадку, - це константа часу компіляції. + int a = 1; + // size_t - беззнаковий чисельний тип розміром щонайменше 2 байти, який + // використовується для відображення розміру об'єкта. + size_t size = sizeof(a++); // a++ не оцінюється + printf("sizeof(a++) = %zu where a = %d\n", size, a); + // Виводить "sizeof(a++) = 4 where a = 1" (на 32-бітній архітектурі) + + // Масиви повинні бути проініціалізовані з конкретним розміром. + char my_char_array[20]; // Цей масив займає 1 * 20 = 20 байтів + int my_int_array[20]; // Цей масив займає 4 * 20 = 80 байтів + // (припускаючи 4-байтні числа) + + // Таким чином можна проініціалізувати масив нулем: + char my_array[20] = {0}; + // де "{0}" називається "ініціалізатором масиву". + + // Зазначте, можна явно не оголошувати розмір масиву, ЯКЩО ви проініціалізуєте + // масив у тому ж рядку. Тому, наступне оголошення еквівалентне: + char my_array[] = {0}; + // АЛЕ, потрібно визначити розмір масиву під час виконання, як тут: + size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]); + + // ПОПЕРЕДЖЕННЯ якщо ви вирішили використовувати даний підхід, потрібно + // визначити розмір **перед тим**, як ви почнете передавати масив у функцію + // (побачите дискусію пізніше). Масиви перетворюються на вказівники при + // передачі як аргументи у функцію, тому попереднє твердження буде видавати + // хибний результат всередині функції. + + // Індексація по масиву така ж сама, як і в інших мовах програмування або, + // скоріше, як у інших с-подібних мовах. + my_array[0]; // => 0 + + // Масиви незмінні, це просто частина пам'яті! + my_array[1] = 2; + printf("%d\n", my_array[1]); // => 2 + + // Масиви, розмір яких залежить від змінної, в С99 (та в С11 як вибірковий + // функціонал) можуть бути оголошені також. Розмір такого масиву не має бути + // константою під час компіляції: + printf("Enter the array size: "); // спитати користувача розмір масиву + int array_size; + fscanf(stdin, "%d", &array_size); + int var_length_array[array_size]; // оголосити масив + printf("sizeof array = %zu\n", sizeof var_length_array); + + // Приклад: + // > Enter the array size: 10 + // > sizeof array = 40 + + // Рядки - це просто масиви символьних літералів (char), що закінчуються NULL + // (0x00) байтом, представленим у рядках як спеціальний символ '\0'. + // (Не потрібно включати байт NULL в рядкові літерали; компілятор сам вставляє + // його наприкінці масиву.) + char a_string[20] = "This is a string"; + printf("%s\n", a_string); // %s форматує рядок + + printf("%d\n", a_string[16]); // => 0 + // тобто, байт #17 - це 0 (так само, як і 18-ий, 19-ий, та 20-ий) + + // Якщо між одинарними лапками є букви, тоді це символьний літерал. + // Він має тип `int`, а не `char` (так історично склалось). + int cha = 'a'; // добре + char chb = 'a'; // також добре (неявне перетворення з int на char) + + // Багатовимірні масиви: + int multi_array[2][5] = { + {1, 2, 3, 4, 5}, + {6, 7, 8, 9, 0} + }; + // Доступ до елементів: + int array_int = multi_array[0][2]; // => 3 + + /////////////////////////////////////// + // Оператори + /////////////////////////////////////// + + // Скорочення для багатьох оголошень: + int i1 = 1, i2 = 2; + float f1 = 1.0, f2 = 2.0; + + int b, c; + b = c = 0; + + // Арифметичні операції + i1 + i2; // => 3 + i2 - i1; // => 1 + i2 * i1; // => 2 + i1 / i2; // => 0 (0.5 округлено до 0) + + // Потрібно перетворити хоча б одну з цілочисельних змінних на float, щоб + // отримати результат з плаваючою крапкою + (float)i1 / i2; // => 0.5f + i1 / (double)i2; // => 0.5 // Так само і для типу double + f1 / f2; // => 0.5, з певною точністю + // Такі обчислення не є точними + + // Ділення за модулем також є + 11 % 3; // => 2, остача від ділення + + // Оператори порівняння ймовірно схожі, проте в С немає логічного типу. + // Натомість використовується int. + // (Або _Bool або bool в C99.) + // 0 - хибно (false), всі інші значення - правда (true). Оператори + // порівняння завжди повертають 0 або 1. + 3 == 2; // => 0 (false) + 3 != 2; // => 1 (true) + 3 > 2; // => 1 + 3 < 2; // => 0 + 2 <= 2; // => 1 + 2 >= 2; // => 1 + + // C - це не Python, порівняння не утворюють ланцюги. + // Попередження: Рядок нижче скомпілюється, але він означає `(0 < a) < 2`. + // В даному випадку, це 1, тому що (0 < 1). + int between_0_and_2 = 0 < a < 2; + // Натомість потрібно використати: + int between_0_and_2 = 0 < a && a < 2; + + // Логічні оператори з числами + !3; // => 0 (Логічне НЕ) + !0; // => 1 + 1 && 1; // => 1 (Логічне І) + 0 && 1; // => 0 + 0 || 1; // => 1 (Логічне АБО) + 0 || 0; // => 0 + + // Тернарний вираз з умовою ( ? : ) + int e = 5; + int f = 10; + int z; + z = (e > f) ? e : f; // => 10 "if e > f return e, else return f." + + // Оператори збільшення та зменшення на 1: + int j = 0; + int s = j++; // Повернути j ПОТІМ збільшити j. (s = 0, j = 1) + s = ++j; // Збільшити j ПОТІМ повернути j. (s = 2, j = 2) + // так само і для j-- та --j + + // Побітові операції! + ~0x0F; // => 0xFFFFFFF0 (побітове заперечення, "перше доповнення", результат + // для 32-бітного int) + 0x0F & 0xF0; // => 0x00 (побітове І) + 0x0F | 0xF0; // => 0xFF (побітове АБО) + 0x04 ^ 0x0F; // => 0x0B (побітове XOR) + 0x01 << 1; // => 0x02 (побітовий зсув вліво (на 1)) + 0x02 >> 1; // => 0x01 (побітовий зсув вправо (на 1)) + + // Будьте обережними при зсуві цілочисельних значень зі знаком. + // Наступні дії дають невизначений результат: + // - зсув на біт, що зберігає знак числа (int a = 1 << 31) + // - зсув вліво на від'ємне число (int a = -1 << 2) + // - зсув на число, що більше за ширину типу + // TODO: LHS + // - зсув на зміщення, що >= ширині типу в лівій частині виразу: + // int a = 1 << 32; // Невизначена поведінка, якщо ширина int 32 біти. + + /////////////////////////////////////// + // Структури розгалуження + /////////////////////////////////////// + + // Оператор умови + if (0) { + printf("I am never run\n"); // ніколи не буде виконано + } else if (0) { + printf("I am also never run\n"); // теж ніколи не буде виконано + } else { + printf("I print\n"); // це буде надруковано + } + + // Цикл з передумовою + int ii = 0; + while (ii < 10) { // БУДЬ-ЯКЕ значення, що менше 10 - правда. + printf("%d, ", ii++); // ii++ збільшує ii на 1 ПІСЛЯ передачі поточного значення. + } // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Цикл з післяумовою + int kk = 0; + do { + printf("%d, ", kk); + } while (++kk < 10); // ++kk збільшує kk на 1 ПЕРЕД передачою поточного значення. + // => надрукує "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // Цикл з лічильником + int jj; + for (jj=0; jj < 10; jj++) { + printf("%d, ", jj); + } // => виводить "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, " + + printf("\n"); + + // *****Додатково*****: + // Цикли та функції обов'язково повинні мати тіло. Якщо тіло не потрібно: + int i; + for (i = 0; i <= 5; i++) { + ; // використовуйте крапку з комою, щоб симулювати тіло (пусте твердження) + } + // Або + for (i = 0; i <= 5; i++); + + // Розгалуження з множинним вибором: switch() + switch (a) { + case 0: // значення повинні бути *константними* виразами і мати вбудований тип + //(наприклад, перелічення) + printf("Hey, 'a' equals 0!\n"); + break; // якщо не використати break, то управління буде передано наступному блоку + case 1: + printf("Huh, 'a' equals 1!\n"); + break; + // Будьте обережними, виконання продовжиться до тих пір, поки + // не зустрінеться наступний "break". + case 3: + case 4: + printf("Look at that.. 'a' is either 3, or 4\n"); + break; + default: + // якщо вираз a не співпадає з описаними значеннями, то виконується + // блок default + fputs("Error!\n", stderr); + exit(-1); + break; + } + /* + Використання "goto" в С + */ + typedef enum { false, true } bool; + // вводимо таке перелічення, оскільки С не має логічного типу до С99 + bool disaster = false; + int i, j; + for(i=0;i<100;++i) + for(j=0;j<100;++j) + { + if((i + j) >= 150) + disaster = true; + if(disaster) + goto error; + } + error : + printf("Error occurred at i = %d & j = %d.\n", i, j); + /* + https://ideone.com/GuPhd6 + Даний приклад виведе "Error occurred at i = 51 & j = 99." + */ + + /////////////////////////////////////// + // Приведення до типів + /////////////////////////////////////// + + // Кожне значенння в С має тип, але можна перевести значення з одного типу в + // інший, якщо потрібно (із деякими обмеженнями). + + int x_hex = 0x01; // Змінним можна присвоювати літерали в шістнадцятковій + // системі числення + + // Приведення до типу призведе до спроби зберегти чисельне значення + printf("%d\n", x_hex); // => Виводить 1 + printf("%d\n", (short) x_hex); // => Виводить 1 + printf("%d\n", (char) x_hex); // => Виводить 1 + + // В данному випадку попередження не виникатиме, якщо значення виходить за межі + // значення типу + printf("%d\n", (unsigned char) 257); // => 1 (максимальне значення char = 255, + // якщо char має довжину 8 біт) + + // Для того, щоб дізнатись максимальний розмір `char`, `signed char` або ж + // `unsigned char`, потрібно використати макроси CHAR_MAX, SCHAR_MAX та UCHAR_MAX + // відповідно з <limits.h>. + + // Вбудовані типи можуть бути приведені до типу із плаваючою крапкою і навпаки. + printf("%f\n", (double) 100); // %f завжди перетворює число на double... + printf("%f\n", (float) 100); // ...навіть, якщо це float. + printf("%d\n", (char)100.0); + + /////////////////////////////////////// + // Вказівники + /////////////////////////////////////// + + // Вказівник - це змінна, що зберігає адресу у пам'яті. Оголошення вказівника + // також потребує інформації про тип об'єкта, на який він вказує. Можна + // отримати адресу пам'яті будь-якої змінної, а потім працювати з нею. + + int x = 0; + printf("%p\n", (void *)&x); // Оператор & повертає адресу змінної у пам'яті + // (%p форматує об'єкт вказівника типу void *) + // => Виводить деяку адресу в пам'яті + + // Для оголошення вказівника потрібно поставити * перед його назвою. + int *px, not_a_pointer; // px - це вказівник на цілочисельне значення (int) + px = &x; // Зберігає адресу змінної x в px + printf("%p\n", (void *)px); // => Виводить адресу в пам'яті + printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer)); + // => Виводить "8, 4" на звичайній 64-бітній системі + + // Щоб прочитати значення, яке зберігається за адресою, на яку вказує вказівник, + // потрібно поставити знак * перед назвою змінної. + // Так, * використовується одночасно і для оголошення вказівника, і для отримання + // значення за адресою. Звучить заплутано, проте тільки спочатку. + printf("%d\n", *px); // => Виводить 0, значення x + + // Можна також змінити значення, на яке посилається вказівник. + // Тут звернення до адреси обернене у круглі дужки, тому що + // ++ має вищий пріоритет виконання, ніж *. + (*px)++; // Збільшити значення, на яке вказує px, на 1 + printf("%d\n", *px); // => Виводить 1 + printf("%d\n", x); // => Виводить 1 + + // Масиви зручно використовувати для виділення неперервного блоку пам'яті. + int x_array[20]; // оголошує масив з 20 елементів (розмір можна задати лише один раз) + int xx; + for (xx = 0; xx < 20; xx++) { + x_array[xx] = 20 - xx; + } // Ініціалізує x_array значеннями 20, 19, 18,... 2, 1 + + // Оголосити вказівник типу int, який посилається на масив x_array + int* x_ptr = x_array; + // x_ptr тепер вказує на перший елемент масиву (число 20). + // + // Це працює, тому що при зверненні до імені масиву повертається вказівник + // на перший елемент. Наприклад, коли масив передається у функцію або присвоюється + // вказівнику, він неявно приводиться до вказівника. + // Виключення: + // - коли вказівник передається як аргумент із оператором `&`: + int arr[10]; + int (*ptr_to_arr)[10] = &arr; // &arr НЕ має тип `int *`! + // Він має тип "вказівник на масив" (з 10 чисел). + // - коли масив - це рядковий літерал, що використовується для ініціалізації + // масив символів: + char otherarr[] = "foobarbazquirk"; + // - коли масив - це аргумент операторів `sizeof` або `alignof`: + int arraythethird[10]; + int *ptr = arraythethird; // те ж саме, що з int *ptr = &arr[0]; + printf("%zu, %zu\n", sizeof(arraythethird), sizeof(ptr)); + // Ймовірно, виводить "40, 4" або "40, 8" + + // Інкрементація та декрементація вказівника залежить від його типу. + // (так звана арифметика вказівників) + printf("%d\n", *(x_ptr + 1)); // => Виводить 19 + printf("%d\n", x_array[1]); // => Виводить 19 + + // Можна також динамічно виділити послідовні блоки в пам'яті за допомогою + // функції malloc зі стандартної бібліотеки. malloc приймає один аргумент типу + // size_t, що описує кількість байтів для виділення (зазвичай із купи, проте це + // може бути неправдою на вбудованих системах - стандарт С нічого про це не повідомляє). + int *my_ptr = malloc(sizeof(*my_ptr) * 20); + for (xx = 0; xx < 20; xx++) { + *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx + } // Проініціалізувати пам'ять значеннями 20, 19, 18, 17... 2, 1 (як int) + + // Будьте обережними із передачею значень, що надаються користувачем, в malloc! + // Про всяк випадок, використовуйте calloc в таких ситуаціях (який, на відміну від + // malloc, також заповнює пам'ять нулями). + int* my_other_ptr = calloc(20, sizeof(int)); + + // Немає стандартного способу визначити розмір динамічно виділеного масиву в С. + // Через це, якщо масиви будуть часто передаватись в програмі, потрібна інша змінна, + // яка буде відслідковувати кількість елементів в масиві. Детальніше в розділі + // про функції. + size_t size = 10; + int *my_arr = calloc(size, sizeof(int)); + // Додати елемент до масиву. + size++; + my_arr = realloc(my_arr, sizeof(int) * size); + if (my_arr == NULL) { + // Не забувайте перевіряти результат виконання realloc на помилки! + return + } + my_arr[10] = 5; + + // Робота з вказівниками може призводити до неочікуваних і непрогнозованих + // результатів, якщо звернутись до пам'яті, що не була виділена вами. + printf("%d\n", *(my_ptr + 21)); // => Хто зна, що буде виведено. + // Може навіть вилетіти з помилкою. + + // Після закінчення роботи із виділеною за допомогою malloc пам'яттю, її обов'язково + // потрібно звільнити. Інакше ніхто не зможе нею скористатися, аж поки програма не + // завершить свою роботу (така ситуація називається "витоком пам'яті"). + free(my_ptr); + + // Рядки - це масиви символів, проте вони найчастіше представлені як + // вказівник на символ (тобто, вказівник на перший елемент масиву). Вважається + // хорошим підходом використовувати `const char *', посилаючись на об'єкт + // рядка, оскільки його не можна змінити ("foo"[0] = 'a' ЗАБОРОНЕНО). + const char *my_str = "This is my very own string literal"; + printf("%c\n", *my_str); // => 'T' + + // Це не працюватиме, якщо рядок - це масив (потенційно створений за допомогою + // рядкового літерала), що зберігається у частині пам'яті, яку можна перезаписувати: + char foo[] = "foo"; + foo[0] = 'a'; // Дозволяється, foo тепер містить "aoo" + + function_1(); +} // Кінець функції main + +/////////////////////////////////////// +// Функції +/////////////////////////////////////// + +// Синтаксис оголошення функції: +// <тип повернення> <назва функції>(<аргументи>) + +int add_two_ints(int x1, int x2) +{ + return x1 + x2; // Використовуйте return, щоб повернути значення +} + +/* +Дані у функцію передають за значенням. Коли функція викликається, аргументи, що +передаються у функцію, копіюються з оригіналів (окрім масивів). Всі зміни над +значенням аргументів всередині функції не впливають на значення оригіналів. + +Використовуйте вказівники, якщо потрібно редагувати безпосередньо оригінальні +значення аргументів. + +Приклад: замінити рядок на обернений. +*/ + +// void означає, що функція нічого не повертає +void str_reverse(char *str_in) +{ + char tmp; + size_t ii = 0; + size_t len = strlen(str_in); // `strlen()` це частина стандартної бібліотеки С + // Зауважте: довжина, яку повертає `strlen`, не включає + // термінальний NULL байт ('\0') + for (ii = 0; ii < len / 2; ii++) { // в C99 можна напряму оголошувати тип `ii` в циклі + tmp = str_in[ii]; + str_in[ii] = str_in[len - ii - 1]; // ii-й символ з кінця + str_in[len - ii - 1] = tmp; + } +} +// Зауважте: для використання strlen() потрібно завантажити файл заголовку string.h + +/* +char c[] = "This is a test."; +str_reverse(c); +printf("%s\n", c); // => ".tset a si sihT" +*/ +/* +Оскільки можна повертати тільки одну змінну, для зміни значення більшої +кількості змінних можна використовувати виклик за посиланням +*/ +void swapTwoNumbers(int *a, int *b) +{ + int temp = *a; + *a = *b; + *b = temp; +} +/* +int first = 10; +int second = 20; +printf("first: %d\nsecond: %d\n", first, second); +swapTwoNumbers(&first, &second); +printf("first: %d\nsecond: %d\n", first, second); +// змінні обмінюються значеннями +*/ + +/* +Масиви завжди передаються у функції як вказівники, не зважаючи на тип масиву +(статичний чи динамічний). Тому всередині функція не знає про розмір масиву. +*/ +// Розмір масиву завжди має передаватись разом із масивом! +void printIntArray(int *arr, size_t size) { + int i; + for (i = 0; i < size; i++) { + printf("arr[%d] is: %d\n", i, arr[i]); + } +} +/* +int my_arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; +int size = 10; +printIntArray(my_arr, size); +// виведе "arr[0] is: 1" і т.д. +*/ + +// Ключове слово extern використовується, якщо всередині функції потрібно звернутись +// до змінної, що була оголошена поза функцією. +int i = 0; +void testFunc() { + extern int i; // використовуємо зовнішню змінну i +} + +// Зробити зовнішню змінну приватною у вихідному файлі за допомогою static: +static int j = 0; // інші файли, що використовують testFunc2(), + // не матимуть доступу до змінної j +void testFunc2() { + extern int j; +} +// Ключове слово static робить змінну недоступною для коду поза даною одиницею +// компіляції. (На більшості систем, одиниця компіляції - це файл). +// static можна використовувати до глобальних змінних, функцій, локальних +// змінних у функціях. Локальні змінні, проініціалізовані static, поводять +// себе як глобальні змінні, проте тільки в межах даного файлу. Статичні +// змінні ініціалізуються 0, якщо інше значення не було вказане. +// **Як варіант, функції можна зробити приватними оголосивши їх як static** + +/////////////////////////////////////// +// Користувацькі типи та структури +/////////////////////////////////////// + +// Ключове слово typedef використовується, щоб створити псевдонім типу +typedef int my_type; +my_type my_type_var = 0; + +// Структури - це такі собі колекції з даними. Пам'ять для полів виділяється +// послідовно, в порядку їх написання: +struct rectangle { + int width; + int height; +}; + +// Проте це не означає, що +// sizeof(struct rectangle) == sizeof(int) + sizeof(int) +// в зв'язку з вирівнюванням пам'яті [1] + +void function_1() +{ + struct rectangle my_rec; + + // Доступ до полів структури відбувається через . + my_rec.width = 10; + my_rec.height = 20; + + // Можна створити вказівники на структуру + struct rectangle *my_rec_ptr = &my_rec; + + // Звернення до структури через вказівник та зміна значень поля: + (*my_rec_ptr).width = 30; + + // Але є й альтернативний спосіб звернутись до поля через вказівник, використовуючи + // оператор -> (краще читається) + my_rec_ptr->height = 10; // Те ж саме, що (*my_rec_ptr).height = 10; +} + +// Можна використати typedef перед struct +typedef struct rectangle rect; + +int area(rect r) +{ + return r.width * r.height; +} + +// Якщо ваша структура доволі громіздка, можна звертатись до неї через вказівник, +// щоб уникнути копіювання всієї структури: +int areaptr(const rect *r) +{ + return r->width * r->height; +} + +/////////////////////////////////////// +// Вказівники на функції +/////////////////////////////////////// +/* +Під час виконання функції знаходяться за відомими адресами в пам'яті. Вказівники +на функції - це ті ж самі вказівники, що зберігають адресу у пам'яті, проте можуть +використовуватись, щоб викликати функції напряму і передавати обробники (або функції зі +зворотнім зв'язком). Хоча, синтаксис спочатку може бути доволі незрозумілим. + +Приклад: use str_reverse from a pointer +*/ +void str_reverse_through_pointer(char *str_in) { + // Оголосити вказівник на функцію під назвою f. + void (*f)(char *); // Сигнатура повинна точно співпадати із цільовою функцією. + f = &str_reverse; // Присвойте адресу певної функції (визначається під час виконання) + // f = str_reverse; повинно працювати також + (*f)(str_in); // Виклик функції через вказівник + // f(str_in); // Це альтернативний, але теж вірний синтаксис виклику функції. +} + +/* +Якщо сигнатури функцій співпадають, можна присвоїти будь-яку функцію тому ж +самому вказівнику. Вказівники на функції зазвичай використовуються як псевдоніми +для спрощення та покращення читабельності коду. Приклад: +*/ + +typedef void (*my_fnp_type)(char *); + +// Використання при оголошенні змінної вказівника: +// ... +// my_fnp_type f; + + +// Спеціальні символи: +/* +'\a'; // символ попередження (дзвінок) +'\n'; // символ нового рядка +'\t'; // символ табуляції (вирівнювання по лівому краю) +'\v'; // вертикальна табуляція +'\f'; // нова сторінка +'\r'; // повернення каретки +'\b'; // стирання останнього символу +'\0'; // нульовий символ. Зазвичай розташовується в кінці рядка. +// hello\n\0. \0 використовується для позначення кінця рядка. +'\\'; // зворотній слеш +'\?'; // знак питання +'\''; // одинарні лапки +'\"'; // подвійні лапки +'\xhh'; // шістнадцяткове число. Наприклад: '\xb' = символ вертикальної табуляції +'\0oo'; // вісімкове число. Наприклад: '\013' = символ вертикальної табуляції + +// форматування виводу: +"%d"; // ціле число (int) +"%3d"; // ціле число, щонайменше 3 символи (вирівнювання по правому краю) +"%s"; // рядок +"%f"; // число з плаваючою крапкою (float) +"%ld"; // велике ціле число (long) +"%3.2f"; // число з плаваючою крапкою, щонайменше 3 цифри зліва і 2 цифри справа +"%7.4s"; // (аналогічно для рядків) +"%c"; // символ +"%p"; // вказівник. Зазначте: потребує перетворення типу на (void *) перед + // використанням у `printf`. +"%x"; // шістнадцяткове число +"%o"; // вісімкове число +"%%"; // друкує % +*/ + +/////////////////////////////////////// +// Порядок виконання +/////////////////////////////////////// + +//---------------------------------------------------// +// Оператори | Асоціативність// +//---------------------------------------------------// +// () [] -> . | зліва направо // +// ! ~ ++ -- + = *(type)sizeof | справа наліво // +// * / % | зліва направо // +// + - | зліва направо // +// << >> | зліва направо // +// < <= > >= | зліва направо // +// == != | зліва направо // +// & | зліва направо // +// ^ | зліва направо // +// | | зліва направо // +// && | зліва направо // +// || | зліва направо // +// ?: | справа наліво // +// = += -= *= /= %= &= ^= |= <<= >>= | справа наліво // +// , | зліва направо // +//---------------------------------------------------// + +/****************************** Файли заголовків ********************************* + +Файли заголовків важливі в С. Вони розділяють вихідний код та визначення на різні +файли, що робить їх кращими для розуміння. + +Файли заголовків синтаксично подібні до вихідних файлів С, проте описуються у".h" +файлах. Їх можна додати в код за допомогою директиви #include "example.h", якщо +example.h існує в тому ж каталозі, що і файл С. +*/ + +/* +Так можна запобігти тому, що заголовок буде оголошений кілька разів. Така ситуація +виникає у випадку циклічної залежності, тобто коли вміст заголовку вже було +оголошено. +*/ +#ifndef EXAMPLE_H /* якщо EXAMPLE_H ще не оголошено. */ +#define EXAMPLE_H /* Визначити макрос EXAMPLE_H. */ + +/* +Заголовки можна додавати в інші заголовки, таким чином вони разом додаються +у подальшому. +*/ +#include <string.h> + +/* +Макроси можуть бути визначені також у заголовку та використовуватись у файлах, +що містять цей заголовок. +*/ +#define EXAMPLE_NAME "Dennis Ritchie" + +/* Макроси функції також можна визначити. */ +#define ADD(a, b) ((a) + (b)) +/* +Зверніть увагу на круглі дужки навколо аргументів! Важливо переконатись, що +a та b не можна проінтерпретувати інакше. Наприклад: +MUL(x, y) (x * y); +MUL(1 + 2, 3) -> (1 + 2 * 3), що є помилкою +*/ + +/* Struct та typedef можуть використовуватись для узгодженості між файлами. */ +typedef struct Node +{ + int val; + struct Node *next; +} Node; + +/* Так само і перелічення. */ +enum traffic_light_state {GREEN, YELLOW, RED}; + +/* +Прототипи функцій також можна оголосити так, щоб використовувати у кількох +файлах. Але так робити не варто. Краще оголосити їх у С файлі. +*/ +Node createLinkedList(int *vals, int len); + +/* +Окрім вище згаданих випадків, всі інші визначення мають описуватись у С файлах. +*/ + +#endif /* Кінець директиви передкомпіляції if. */ + +``` +## Додаткові матеріали + +Кращим посібником для вивчення С буде книга авторства Деніса Рітчі (творець С) та Браяна Кернігана, +[K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language). +Але обережно з нею, книга старезна і містить неточності (ідеї, що вже вважаються не надто прийнятними). + +Ще одним хорошим ресурсом є книга "Learn C The Hard Way" (наявна тільки англійською). + +На деякі часті запитання дасть відповідь англомовний ресурс [compl.lang.c Frequently Asked Questions](http://c-faq.com). + +Нагадаю, що важливо використовувати правильні інтервали, відступи та загалом мати узгоджений стиль коду. +Зручний для читання код краще, ніж складний код або зроблений нашвидкоруч. За прикладом можна звернутись до +[Linux kernel coding style](https://www.kernel.org/doc/Documentation/process/coding-style.rst). + +Щодо всього іншого, Ґуґл на допомогу! + +[1] [Чому розмір структури не дорівнює сумі розмірів її полів? (англ.)](http://stackoverflow.com/questions/119123/why-isnt-sizeof-for-a-struct-equal-to-the-sum-of-sizeof-of-each-member) diff --git a/uk-ua/cypher-ua.html.markdown b/uk-ua/cypher-ua.html.markdown new file mode 100644 index 00000000..0911793b --- /dev/null +++ b/uk-ua/cypher-ua.html.markdown @@ -0,0 +1,254 @@ +--- +language: cypher +filename: LearnCypher-ua.cql +contributors: + - ["Théo Gauchoux", "https://github.com/TheoGauchoux"] +translators: + - ["AstiaSun", "https://github.com/AstiaSun"] +lang: uk-ua +--- + +Cypher - це мова запитів Neo4j для спрощення роботи з графами. Вона повторює синтаксис SQL та перемішує його з таким собі ascii стилем для відображення структури графа. +Цей навчальний матеріал передбачає, що ви вже знайомі із концепцією графів, зобрема що таке вершини та зв'язки між ними. + +[Деталі тут](https://neo4j.com/developer/cypher-query-language/) + + +Вершини +--- + +**Відображує запис у графі.** + +`()` +Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту. + +`(n)` +Це вершина, яка має назву **n**, до неї можна повторно звертатись у запиті. Звернення до вершини **n** починається з нижнього підкреслення та використовує camelCase (верблюжий регіст). + +`(p:Person)` +Можна також додати *ярлик* до вершини, в данному випадку - **Person**. Це як тип / клас / категорія. Назва *ярлика* починається з великої літери та використовує верблюжу нотацію. + +`(p:Person:Manager)` +Вершина може мати кілька *ярликів*. + +`(p:Person {name : 'Théo Gauchoux', age : 22})` +Вершина також може мати різні *властивості*, в данному випадку - **name** та **age**. Також мають починатися з великої літери та використовувати верблюжу нотацію. + +Наступні типи дозволяється використовувати у властивостях: + + - Чиселиний + - Булевий + - Рядок + - Списки попередніх примітивних типів + +*Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.* + +`p.name` +За допомогою крапки можна звернутись до властивості вершини. + + +Зв'язки (або ребра) +--- + +**Сполучають дві вершини** + +`[:KNOWS]` +Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ. + +`[k:KNOWS]` +Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. + +`[k:KNOWS {since:2017}]` +Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це **since**. + +`[k:KNOWS*..4]` +Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів." + + +Шляхи +--- + +**Спосіб поєднувати вершини та зв'язки.** + +`(a:Person)-[:KNOWS]-(b:Person)` +Шлях описує, що вершини **a** та **b** знають (knows) один одного. + +`(a:Person)-[:MANAGES]->(b:Person)` +Шлях може бути направленим. Цей описує, що **а** є менеджером **b**. + +`(a:Person)-[:KNOWS]-(b:Person)-[:KNOWS]-(c:Person)` +Можна створювати ланцюги зі зв'язків. Цей шлях описує друга друга (**a** знає **b**, який в свою чергу знає **c**). + +`(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)` +Ланцюг, аналогічно, також може бути направленим. Шлях описує, що **a** - бос **b** і супер бос для **c**. + +Шаблони, які часто використовуються (з документації Neo4j): + +``` +// Друг-мого-друга +(user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf) + +// Найкоротший шлях +path = shortestPath( (user)-[:KNOWS*..5]-(other) ) + +// Спільна фільтрація +(user)-[:PURCHASED]->(product)<-[:PURCHASED]-()-[:PURCHASED]->(otherProduct) + +// Навігація по дереву +(root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product) + +``` + + +Запити на створення +--- + +Створити нову вершину: +``` +CREATE (a:Person {name:"Théo Gauchoux"}) +RETURN a +``` +*`RETURN` дозволяє повернути результат після виконання запиту. Можна повертати кілька значень, наприклад, `RETURN a, b`.* + +Створити новий зв'язок (із двома вершинами): +``` +CREATE (a:Person)-[k:KNOWS]-(b:Person) +RETURN a,k,b +``` + +Запити на знаходження +--- + +Знайти всі вершини: +``` +MATCH (n) +RETURN n +``` + +Знайти вершини за ярликом: +``` +MATCH (a:Person) +RETURN a +``` + +Знайти вершини за ярликом та властивістю: +``` +MATCH (a:Person {name:"Théo Gauchoux"}) +RETURN a +``` + +Знайти вершини відповідно до зв'язків (ненаправлених): +``` +MATCH (a)-[:KNOWS]-(b) +RETURN a,b +``` + +Знайти вершини відповідно до зв'язків (направлених): +``` +MATCH (a)-[:MANAGES]->(b) +RETURN a,b +``` + +Знайти вершини за допомогою `WHERE`: +``` +MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City) +WHERE s.since = 2015 +RETURN p,state +``` + +Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`: +``` +MATCH (a), (b) +WHERE a.name = "Jacquie" AND b.name = "Michel" +CREATE (a)-[:KNOWS]-(b) +``` + + +Запити на оновлення +--- + +Оновити окрему властивість вершини: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p.age = 23 +``` + +Оновити всі властивості вершини: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p = {name: "Michel", age: 23} +``` + +Додати нову властивіcть до вершини: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p + = {studies: "IT Engineering"} +``` + +Повісити ярлик на вершину: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +SET p:Internship +``` + + +Запити на видалення +--- + +Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим): +``` +MATCH (p:Person)-[relationship]-() +WHERE p.name = "Théo Gauchoux" +DELETE relationship, p +``` + +Видалити властивість певної вершини: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +REMOVE p.age +``` + +*Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й `DELETE`!* + +Видалити ярлик певної вершини: +``` +MATCH (p:Person) +WHERE p.name = "Théo Gauchoux" +DELETE p:Person +``` + +Видалити всю базу даних: +``` +MATCH (n) +OPTIONAL MATCH (n)-[r]-() +DELETE n, r +``` + +*Так, це `rm -rf /` на мові Cypher !* + + +Інші корисні запити +--- + +`PROFILE` +Перед виконанням, показати план виконання запитів. + +`COUNT(e)` +Порахувати елементи (вершини та зв'язки), що відповідають **e**. + +`LIMIT x` +Обмежити результат до x перших результатів. + + +Особливі підказки +--- + +- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар +- Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**). +- Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко. +- Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як **OpenCypher**). diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown new file mode 100644 index 00000000..6f294b1f --- /dev/null +++ b/uk-ua/go-ua.html.markdown @@ -0,0 +1,449 @@ +--- +name: Go +category: language +language: Go +filename: learngo-ua.go +contributors: + - ["Sonia Keys", "https://github.com/soniakeys"] + - ["Christopher Bess", "https://github.com/cbess"] + - ["Jesse Johnson", "https://github.com/holocronweaver"] + - ["Quint Guvernator", "https://github.com/qguv"] + - ["Jose Donizetti", "https://github.com/josedonizetti"] + - ["Alexej Friesen", "https://github.com/heyalexej"] + - ["Clayton Walker", "https://github.com/cwalk"] + - ["Leonid Shevtsov", "https://github.com/leonid-shevtsov"] +translators: + - ["AstiaSun", "https://github.com/AstiaSun"] +lang: uk-ua +--- + +Go був створений для того, щоб виконати задачу. Це не останній тренд в теорії мов програмування, а спосіб вирішення реальних проблем. + +Він увібрав принципи з імперативних мов зі статичною типізацією. +Go швидко компілюється та виконується, а його багатопоточність легка для +вивчення, оскільки багатоядерні CPU стали буденністю. Ця мова програмування успішно використовується у кодах великих продуктів (~100 мільйонів в Google, Inc.) + +Go має чудову стандартну бібліотеку та чимале ком'юніті. + +```go +// Однорядковий коментар +/* Багато- + рядковий коментар */ + +// Кожен файл вихідного коду має починатись із ключового слова package. +// main - це спеціальна назва, що оголошує виконуваний код, а не бібліотеку. +package main + +// import оголошує бібліотеки, що використовуються в даному файлі. +import ( + "fmt" // Пакет стандартної бібліотеки Go. + "io/ioutil" // Цей пакет реалізує деякі I/O функції утиліт. + m "math" // Бібліотека математичних операцій з локальним псевдонімом m. + "net/http" // Так, веб сервер! + "os" // Функції операційної системи, такі як робота з файловою системою. + "strconv" // Перетворення текстових змінних. +) + +// Оголошення функції. +// Функція main - особлива. Це вхідна точка для виконуваних програм. +// Ви можете любити це, або ж ненавидіти, але Go використовує фігурні дужки. +func main() { + // Println виводить рядок в stdout. + // Ця функція входить у пакет fmt. + fmt.Println("Hello world!") + + // Викликати іншу функцію з цього файлу. + beyondHello() +} + +// Аргументи функцій описуються у круглих дужках. +// Навіть якщо ніякі аргументи не передаються, пусті круглі дужки - обов`язкові. +func beyondHello() { + var x int // Оголошення змінної. Перед використанням змінні обов'язково мають бути оголошені. + x = 3 // Присвоєння значення. + // "Короткі" оголошення використовують := щоб окреслити тип, оголосити та присвоїти значення. + y := 4 + sum, prod := learnMultiple(x, y) // Функція повертає два значення. + fmt.Println("sum:", sum, "prod:", prod) // Просто вивід. + learnTypes() // < y хвилин, потрібно вивчити більше! +} + +/* <- багаторядковий коментар +Функції можуть мати параметри та повертати довільну кількість значень. +В цьому прикладі `x`, `y` - це аргументи, а `sum`, `prod` - це змінні, що повертаються. +Зверніть увагу, що `x` та `sum` мають тип `int`. +*/ +func learnMultiple(x, y int) (sum, prod int) { + return x + y, x * y // Повернути два значення. +} + +// Кілька вбудованих типів та літералів. +func learnTypes() { + // Короткі оголошення зазвичай виконують все, що необхідно. + str := "Вчи Go!" // рядок (string). + + s2 := `"Необроблений" текст +може містити переноси рядків.` // Також має тип рядок. + + // Не ASCII символи. Go використовує UTF-8. + g := 'Σ' // руничний тип, псевдонім для int32, містить позицію юнікод кода. + + f := 3.14195 // float64, IEEE-754 64-бітне число з плаваючою крапкою. + c := 3 + 4i // complex128, комплексні числа, що являють собою два float64. + + // Синтаксис ініціалізації з var. + var u uint = 7 // Беззнаковий цілочисельний тип, проте розмір залежить від імплементації, так само як і int. + var pi float32 = 22. / 7 + + // Синтаксис перетворення типів з коротким оголошенням. + n := byte('\n') // Байт - це переіменований uint8. + + // Розмір масива фіксований протягом часу виконання. + var a4 [4]int // Масив з 4 чисел, всі проініціалізовані 0. + a5 := [...]int{3, 1, 5, 10, 100} // Масив проініціалізованих чисел з фіксованим розміром у + // п'ять елементів, що мають значення 3, 1, 5, 10, та 100. + + // Зрізи мають динамічний розмір. Переваги є і у масивів, й у зрізів, проте + // останні використовуються частіше. + s3 := []int{4, 5, 9} // Порівняйте з a5. Тут немає трьокрапки. + s4 := make([]int, 4) // Виділяє пам'ять для зрізу з 4 чисел, проініціалізованих 0. + var d2 [][]float64 // Декларація, нічого не виділяється. + bs := []byte("a slice") // Синтаксис переведення у інший тип. + + // Оскільки зрізи динамічні, до них можна додавати елементи за необхідністю. + // Для цієї операції використовується вбудована функція append(). + // Перший аргумент - це зріз, до якого додається елемент. Зазвичай + // змінна масиву оновлюється на місці, як у прикладі нижче. + s := []int{1, 2, 3} // В результаті отримуємо зріз із 3 чисел. + s = append(s, 4, 5, 6) // додаємо 3 елементи. Зріз тепер довжини 6. + fmt.Println(s) // Оновлений зріз тепер має значення [1 2 3 4 5 6] + + // Щоб об'єднати два зрізи, замість того, щоб проходитись по всім елементам, + // можна передати посилання на зріз із трьокрапкою, як у прикладі нижче. Таким чином, + // зріз розпакується і його елементи додадуться до зріза s. + s = append(s, []int{7, 8, 9}...) + fmt.Println(s) // Оновлений зріз тепер дорівнює [1 2 3 4 5 6 7 8 9] + + p, q := learnMemory() // Оголошує змінні p, q, що є вказівниками на числа. + fmt.Println(*p, *q) // * іде попереду вказівника. Таким чином, виводяться числа. + + // Асоціативний масив (map) - це динамічно розширюваний тип даних, як хеш + // або словник в інших мовах програмування + m := map[string]int{"three": 3, "four": 4} + m["one"] = 1 + + // В Go змінні, які не використовуються, вважаються помилкою. + // Нижнє підкреслення дозволяє "використати" змінну, але проігнорувати значення. + _, _, _, _, _, _, _, _, _, _ = str, s2, g, f, u, pi, n, a5, s4, bs + // Зазвичай це використовується, щоб проігнорувати значення, що повертає функція. + // Наприклад, в скрипті нашвидкоруч можна проігнорувати помилку, яку повертає + // функція os.Create, вважаючи, що файл буде створений за будь-яких умов. + file, _ := os.Create("output.txt") + fmt.Fprint(file, "Приклад, як відбувається запис у файл.") + file.Close() + + // Вивід значень змінних. + fmt.Println(s, c, a4, s3, d2, m) + + learnFlowControl() // Рухаємось далі. +} + +// Навідміну від більшості інших мов програмування, функції в Go підтримують +// іменоване значення, що повертається. +// Змінні, значення яких повертається функцією, вказуються із зазначенням типу при +// оголошенні функції. Таким чином, можна з легкістю повернути їхні значення в різних +// точках коду, не перелічуючи їх після ключового слова return. +func learnNamedReturns(x, y int) (z int) { + z = x * y + return // z не потрібно вказувати, при оголошенні описано змінну для повернення. +} + +// Go використовує сміттєзбірник. В ньому використовуються вказівники, проте немає +// операцій з вказівниками. Можлива помилка при використовуванні вказівника nil, але не +// при збільшенні значення вказівника (перехід по адресам пам'яті). +func learnMemory() (p, q *int) { + // Іменовані змінні, що повертаються, p та q, мають тип вказівника на чисельне значення. + p = new(int) // Вбудована функція виділяє нову пам'ять. + // Виділена адреса пам'яті чисельного типу int ініціалізовується 0, p більше не nil. + s := make([]int, 20) // Виділити пам'ять для 20 чисел у вигляді суцільного блоку в пам'яті. + s[3] = 7 // Присвоїти значення одному з них. + r := -2 // Оголосити нову локальну змінну. + return &s[3], &r // Оператор & повертає адресу в пам'яті об'єкта. +} + +func expensiveComputation() float64 { + return m.Exp(10) +} + +func learnFlowControl() { + // if твердження вимагає фігурні дужки, але не вимагає округлих. + if true { + fmt.Println("Кажу ж") + } + // Форматування стандартизовано командою командного рядка "go fmt". + if false { + // Pout. + } else { + // Gloat. + } + // Використання перемикача (switch) замість ланцюга if-тверджень. + x := 42.0 + switch x { + case 0: + case 1: + case 42: + // Кейси не "провалюються". Натомість, є ключове слово `fallthrough`: + // https://github.com/golang/go/wiki/Switch#fall-through (англ) + case 43: + // Недоступний. + default: + // Кейс за замовчуванням не обов'язковий. + } + // Як і if, формат оголошення циклу for не вимагає круглих дужок: + // Змінні, оголошені всередині if та for - належать цій області видимості. + for x := 0; x < 3; x++ { // ++ - це твердження. + fmt.Println("iteration", x) + } + // Тут x == 42. + + // For - це єдиний цикл в Go, проте він має кілька різних форм. + for { // Ініціалізація циклу. + break // Упс, помилково зайшли. + continue // Недоступне твердження. + } + + // Можна використовувати діапазони, зрізи, рядки, асоціативні масиви, або ж + // канал для ітерації в циклі. Діапазон (range) повертає один (канал) або два + // значення (масив, зріз, рядок та асоціативний масив). + for key, value := range map[string]int{"one": 1, "two": 2, "three": 3} { + // для кожної пари в асоціативному масиві, надрукувати ключ та значення + fmt.Printf("key=%s, value=%d\n", key, value) + } + // якщо потрібне тільки значення, можна застосувати нижнє підкреслення як ключ + for _, name := range []string{"Bob", "Bill", "Joe"} { + fmt.Printf("Hello, %s\n", name) + } + + // так само, як і з циклом for, оператор := в розгалуженні означає оголосити + // локальну змінну в області видимості if та присвоїти значення. Далі + // значення змінної проходить перевірку y > x. + if y := expensiveComputation(); y > x { + x = y + } + // Літерали функцій - це замикання + xBig := func() bool { + return x > 10000 // Посилання на x, що був оголошений раніше, перед switch. + } + x = 99999 + fmt.Println("xBig:", xBig()) // true + x = 1.3e3 // Тобто, тепер x == 1300 + fmt.Println("xBig:", xBig()) // false тепер. + + // Функція може бути оголошена та викликана в одному рядку, поводячи себе + // як аргумент функції, але за наступних умов: + // 1) літерал функції негайно викликається за допомогою () + // 2) тип значення, що повертається, точно відповідає очікуваному типу аргументу + fmt.Println("Add + double two numbers: ", + func(a, b int) int { + return (a + b) * 2 + }(10, 2)) // Викликаємо з аргументами 10 та 2 + // => Додати + подвоїти два числа: 24 + + // Коли вам це знадобиться, ви полюбите це + goto love +love: + + learnFunctionFactory() // функція, що повертає функцію - це весело(3)(3) + learnDefer() // Швидкий обхід до важливого ключового слова. + learnInterfaces() // Тут на вас чекає крута штука! +} + +func learnFunctionFactory() { + // Два наступних твердження роблять однакові дії, але другий приклад частіше + // застосовується + fmt.Println(sentenceFactory("summer")("A beautiful", "day!")) + + d := sentenceFactory("summer") + fmt.Println(d("A beautiful", "day!")) + fmt.Println(d("A lazy", "afternoon!")) +} + +// Декоратори звична річ для багатьох мов програмування. В Go їх можна реалізувати +// за допомогою літералів функцій, що приймають аргументи. +func sentenceFactory(mystring string) func(before, after string) string { + return func(before, after string) string { + return fmt.Sprintf("%s %s %s", before, mystring, after) // новий рядок + } +} + +func learnDefer() (ok bool) { + // твердження defer змушує функцію посилатись на список. Список + // збережених викликів виконується ПІСЛЯ того, як оточуюча функція закінчує + // виконання. + defer fmt.Println("відкладені твердження виконуються у зворотньому порядку (LIFO).") + defer fmt.Println("\nЦей рядок надрукується першим, тому що") + // Відкладення зазвичай використовується для того, щоб закрити файл. Таким чином, + // функція, що закриває файл, залишається близькою до функції, що відкриває файл. + return true +} + +// Оголошує Stringer як тип інтерфейсу з одним методом, String. +type Stringer interface { + String() string +} + +// Оголошує pair як структуру з двома полями, цілими числами x та y. +type pair struct { + x, y int +} + +// Оголошує метод для типу pair. pair тепер реалізує Stringer, оскільки pair оголосив +// всі методи в цьому інтерфейсі. +func (p pair) String() string { // p тепер називається "приймачем" + // Sprintf - ще одна функція з пакету fmt. + // Крапка використовується, щоб звернутись до полів об'єкту p. + return fmt.Sprintf("(%d, %d)", p.x, p.y) +} + +func learnInterfaces() { + // Синтаксис з використанням фігурних дужок називається "літералом структури". + // Він застосовується до ініціалізованої структури. Оператор := оголошує + // та ініціалізує p цією структурою. + p := pair{3, 4} + fmt.Println(p.String()) // Викликає метод String об'єкта p типу pair. + var i Stringer // Оголошує і інтерфейсного типу Stringer. + i = p // Допустиме, оскільки pair реалізує Stringer + // Викликає метод String об'єкта і, що має тип Stringer. Виводить те ж саме, що й + // аналогічний метод вище. + fmt.Println(i.String()) + + // Функції з бібліотеки fmt викликають метод String, щоб запросити у об'єкта + // своє представлення, яке можна надрукувати. + fmt.Println(p) // Виводить те ж саме, що й раніше. + fmt.Println(i) // Виводить те ж саме, що й раніше. + + learnVariadicParams("great", "learning", "here!") +} + +// Кількість аргументів функції може бути змінною. +func learnVariadicParams(myStrings ...interface{}) { + // Пройтись по значенням всіх аргументів. + // _ - це ігнорування порядкового номеру аргумента в масиві. + for _, param := range myStrings { + fmt.Println("param:", param) + } + + // Передати значення аргументів як параметр змінної величини. + fmt.Println("params:", fmt.Sprintln(myStrings...)) + + learnErrorHandling() +} + +func learnErrorHandling() { + // Ідіома ", ok"використовується, щоб перевірити виконання команди без помилок. + m := map[int]string{3: "three", 4: "four"} + if x, ok := m[1]; !ok { // ok буде мати значення false, тому що 1 не знаходиться + // в асоціативному масиві. + fmt.Println("немає таких") + } else { + fmt.Print(x) // x буде мати значення 1, якщо 1 знаходиться в m. + } + // Значення помилки повідомляє не тільки, що все добре, але й може розповісти + // більше про проблему. + if _, err := strconv.Atoi("non-int"); err != nil { // _ ігнорує значення + // виводить помилку 'strconv.ParseInt: parsing "non-int": invalid syntax' + fmt.Println(err) + } + // Ми розглянемо інтерфейси дещо пізніше. А поки, розглянемо багатопоточність. + learnConcurrency() +} + +// Канал с - це потокозохищений об'єкт для спілкування між потоками. +func inc(i int, c chan int) { + c <- i + 1 // Оператор <- виконує операцію "надіслати",якщо змінна каналу + // знаходиться зліва від нього. +} + +// inc виконує збільшення значення на 1. Ми використаємо його, щоб збільшувати +// числа рівночасно. +func learnConcurrency() { + // вже знайома функція make, яка раніше використовувалась для виділення пам'яті, + // тут використовується для створення каналу. Make виділяє пам'ять та ініціалізує + // зрізи, асоційовані масиви та канали. Новостворений канал буде передавати + // цілочисельні значення. + c := make(chan int) + // Запустити три одночасні ґорутини. Числа будуть збільшуватись рівночасно, імовірно + // паралельно якщо пристрій здатний до цього та правильно сконфігурований. + // Всі три ґорутини надсилають значення в один канал. + go inc(0, c) // Твердження go запускає нову ґорутину. + go inc(10, c) + go inc(-805, c) + // Читаємо три результати з каналу та друкуємо їх. + // Порядок результатів - невідомий! + fmt.Println(<-c, <-c, <-c) // якщо канал знаходиться справа від оператора <-, + // він виконує функцію "приймача". + + cs := make(chan string) // Ще один канал, який примає рядки. + ccs := make(chan chan string) // Канал каналів рядків. + go func() { c <- 84 }() // Запустимо нову ґорутину, щоб надіслати значення в канал с. + go func() { cs <- "wordy" }() // Надсилаємо "wordy" в канал cs. + // Ключове слово select має синтаксис, подібний до switch, проте кожен кейс + // включає в себе операцію з каналом. Він обирає довільний кейс з наявних, які готові + // комунікувати (передавати дані). + select { + case i := <-c: // Отримане значення може бути присвоєно змінній, + fmt.Printf("it's a %T", i) + case <-cs: // або значення може бути проігнороване. + fmt.Println("it's a string") + case <-ccs: // Пустий канал, не готовий комунікувати. + fmt.Println("Не відбудеться.") + } + // На цьому етапі, значення було прочитане або з с або з cs. Одна з двох + // ґорутин завершилась, але інша все ще заблокована. + + learnWebProgramming() // Go вміє й у веб. Так, ти хочеш зробити це. +} + +// Лиш одна функція з пакету http запускає веб сервер. +func learnWebProgramming() { + + // перший аргумент ListenAndServe - це TCP адреса, який сервер буде слухати. + // Другий аргумент - це інтерфейс, а точніше http.Handler. + go func() { + err := http.ListenAndServe(":8080", pair{}) + fmt.Println(err) // не ігноруйте помилки + }() + + requestServer() +} + +// pair матиме тип http.Handler, якщо реалізувати один його метод, ServeHTTP. +func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) { + // Відповідати на запити можна методом, що належить http.ResponseWriter. + w.Write([]byte("Ти вивчив Go за Y хвилин!")) +} + +func requestServer() { + resp, err := http.Get("http://localhost:8080") + fmt.Println(err) + defer resp.Body.Close() + body, err := ioutil.ReadAll(resp.Body) + fmt.Printf("\nWebserver said: `%s`", string(body)) +} +``` + +## Подальше вивчення + +Основним джерелом всієї інформації про Go залишається [офіційна веб-сторінка](https://go.dev/). Там можна знайти уроки, інтерактивно пограти та багато про що почитати. +Окрім туру, у [документації](https://go.dev/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів. + +Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами). + +Можна погратись з кодом вище на [Go playground](https://go.dev/play/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://go.dev/play/](https://go.dev/play/) як [REPL](https://uk.wikipedia.org/wiki/REPL) до тестів та коду в твоєму браузері, без встановлення Go. + +В списку для прочитання новачкам в Go - [вихідний код стандартної бібліотеки](https://go.dev/src/). Код всеосяжно задокоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go. +Крім того, можна просто натиснути на назву функції в [документації](https://go.dev/pkg/), щоб перейти до її реалізації. + +Іншим прекрасним посиланням для вивчення Go є [Go by example](https://gobyexample.com/). + +Go Mobile додає підтримку мобільних платформ (Android та iOS). Можна написати нативний код на Go для мобільних застосунків або написати бібліотеку, що міститиме прив'язки (bindings) з пакету Go, які можуть бути викликані з Java (Android) та Objective-C (iOS). Деталі можна дізнатись на [веб-сторінці Go Mobile](https://github.com/golang/go/wiki/Mobile). diff --git a/uk-ua/javascript-ua.html.markdown b/uk-ua/javascript-ua.html.markdown index 6a64a623..2f17f586 100644 --- a/uk-ua/javascript-ua.html.markdown +++ b/uk-ua/javascript-ua.html.markdown @@ -1,7 +1,7 @@ --- language: javascript contributors: - - ["Adam Brenecki", "http://adam.brenecki.id.au"] + - ["Leigh Brenecki", "https://leigh.net.au"] - ["Ariel Krakowski", "http://www.learneroo.com"] - ["clearsense", "https://github.com/clearsense"] filename: javascript-uk.js diff --git a/uk-ua/kotlin-ua.html.markdown b/uk-ua/kotlin-ua.html.markdown new file mode 100644 index 00000000..5e79cc48 --- /dev/null +++ b/uk-ua/kotlin-ua.html.markdown @@ -0,0 +1,464 @@ +--- +language: kotlin +filename: LearnKotlin-uk.kt +lang: uk-ua +contributors: + - ["S Webber", "https://github.com/s-webber"] +translators: + - ["AstiaSun", "https://github.com/AstiaSun"] +--- + +Kotlin - це мова програмування зі статичною типізацією для JVM, Android та браузера. +Вона має 100% сумісність із Java. + +[Детальніше](https://kotlinlang.org/) + +```kotlin +// Однорядкові коментарі починаються з // +/* +Такий вигляд мають багаторядкові коментарі +*/ + +// Ключове слово package працює так само, як і в Java. +package com.learnxinyminutes.kotlin + +/* +Точкою входу для програм на Kotlin є функція під назвою main. +Вона приймає масив із аргументів, що були передані через командний рядок. +Починаючи з Kotlin 1.3, функція main може бути оголошена без параметрів взагалі. +*/ +fun main(args: Array<String>) { + /* + Оголошення змінних відбувається за допомогою ключових слів var або val. + Відмінність між ними полягає в тому, що значення змінних, оголошених через + val, не можна змінювати. Водночас, змінній "var" можна переприсвоїти нове + значення в подальшому. + */ + val fooVal = 10 // більше ми не можемо змінити значення fooVal на інше + var fooVar = 10 + fooVar = 20 // fooVar може змінювати значення + + /* + В більшості випадків Kotlin може визначати, якого типу змінна, тому не + потрібно щоразу точно вказувати її тип. + Тип змінної вказується наступним чином: + */ + val foo: Int = 7 + + /* + Рядки мають аналогічне з Java представлення. Спеціальні символи + позначаються за допомогою зворотнього слеша. + */ + val fooString = "My String Is Here!" + val barString = "Printing on a new line?\nNo Problem!" + val bazString = "Do you want to add a tab?\tNo Problem!" + println(fooString) + println(barString) + println(bazString) + + /* + Необроблений рядок розмежовується за допомогою потрійних лапок ("""). + Необроблені рядки можуть містити переніс рядка (не спеціальний символ \n) та + будь-які інші символи. + */ + val fooRawString = """ +fun helloWorld(val name : String) { + println("Hello, world!") +} +""" + println(fooRawString) + + /* + Рядки можуть містити шаблонні вирази. + Шаблонний вираз починається із символа доллара "$". + */ + val fooTemplateString = "$fooString has ${fooString.length} characters" + println(fooTemplateString) // => My String Is Here! has 18 characters + + /* + Щоб змінна могла мати значення null, потрібно це додатково вказати. + Для цього після оголошеного типу змінної додається спеціальний символ "?". + Отримати значення такої змінної можна використавши оператор "?.". + Оператор "?:" застосовується, щоб оголосити альтернативне значення змінної + у випадку, якщо вона буде рівна null. + */ + var fooNullable: String? = "abc" + println(fooNullable?.length) // => 3 + println(fooNullable?.length ?: -1) // => 3 + fooNullable = null + println(fooNullable?.length) // => null + println(fooNullable?.length ?: -1) // => -1 + + /* + Функції оголошуються з використанням ключового слова fun. + Аргументи функції перелічуються у круглих дужках після назви функції. + Аргументи можуть мати значення за замовчуванням. Тип значення, що повертатиметься + функцією, вказується після оголошення аргументів за необхідністю. + */ + fun hello(name: String = "world"): String { + return "Hello, $name!" + } + println(hello("foo")) // => Hello, foo! + println(hello(name = "bar")) // => Hello, bar! + println(hello()) // => Hello, world! + + /* + Аргументи функції можуть бути помічені ключовим словом vararg. Це дозволяє + приймати довільну кількість аргументів функції зазначеного типу. + */ + fun varargExample(vararg names: Int) { + println("Argument has ${names.size} elements") + } + varargExample() // => Argument has 0 elements + varargExample(1) // => Argument has 1 elements + varargExample(1, 2, 3) // => Argument has 3 elements + + /* + Коли функція складається з одного виразу, фігурні дужки не є обов'язковими. + Тіло функції вказується після оператора "=". + */ + fun odd(x: Int): Boolean = x % 2 == 1 + println(odd(6)) // => false + println(odd(7)) // => true + + // Якщо тип значення, що повертається функцією, може бути однозначно визначено, + // його непотрібно вказувати. + fun even(x: Int) = x % 2 == 0 + println(even(6)) // => true + println(even(7)) // => false + + // Функції можуть приймати інші функції як аргументи, а також повертати інші функції. + fun not(f: (Int) -> Boolean): (Int) -> Boolean { + return {n -> !f.invoke(n)} + } + // Іменовані функції можуть бути вказані як аргументи за допомогою оператора "::". + val notOdd = not(::odd) + val notEven = not(::even) + // Лямбда-вирази також можуть бути аргументами функції. + val notZero = not {n -> n == 0} + /* + Якщо лямбда-вираз приймає лише один параметр, його оголошення може бути пропущене + (разом із ->). Всередині виразу до цього параметра можна звернутись через + змінну "it". + */ + val notPositive = not {it > 0} + for (i in 0..4) { + println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}") + } + + // Ключове слово class використовується для оголошення класів. + class ExampleClass(val x: Int) { + fun memberFunction(y: Int): Int { + return x + y + } + + infix fun infixMemberFunction(y: Int): Int { + return x * y + } + } + /* + Щоб створити новий об'єкт, потрібно викликати конструктор класу. + Зазначте, що в Kotlin немає ключового слова new. + */ + val fooExampleClass = ExampleClass(7) + // Методи класу викликаються через крапку. + println(fooExampleClass.memberFunction(4)) // => 11 + /* + Якщо функція була позначена ключовим словом infix, тоді її можна викликати через + інфіксну нотацію. + */ + println(fooExampleClass infixMemberFunction 4) // => 28 + + /* + Класи даних - це лаконічний спосіб створювати класи, що містимуть тільки дані. + Методи "hashCode"/"equals" та "toString" автоматично генеруються. + */ + data class DataClassExample (val x: Int, val y: Int, val z: Int) + val fooData = DataClassExample(1, 2, 4) + println(fooData) // => DataClassExample(x=1, y=2, z=4) + + // Класи даних також мають функцію "copy". + val fooCopy = fooData.copy(y = 100) + println(fooCopy) // => DataClassExample(x=1, y=100, z=4) + + // Об'єкти можуть бути деструктурувані кількома способами. + val (a, b, c) = fooCopy + println("$a $b $c") // => 1 100 4 + + // деструктурування у циклі for + for ((a, b, c) in listOf(fooData)) { + println("$a $b $c") // => 1 100 4 + } + + val mapData = mapOf("a" to 1, "b" to 2) + // Map.Entry також деструктурувуються + for ((key, value) in mapData) { + println("$key -> $value") + } + + // Функція із "with" працює майже так само як це ж твердження у JavaScript. + data class MutableDataClassExample (var x: Int, var y: Int, var z: Int) + val fooMutableData = MutableDataClassExample(7, 4, 9) + with (fooMutableData) { + x -= 2 + y += 2 + z-- + } + println(fooMutableData) // => MutableDataClassExample(x=5, y=6, z=8) + + /* + Список можна створити використовуючи функцію listOf. + Список буде незмінним, тобто елементи не можна буде додавати або видаляти. + */ + val fooList = listOf("a", "b", "c") + println(fooList.size) // => 3 + println(fooList.first()) // => a + println(fooList.last()) // => c + // доступ до елементів здійснюється через їхні порядковий номер. + println(fooList[1]) // => b + + // Змінні списки можна створити використовуючи функцію mutableListOf. + val fooMutableList = mutableListOf("a", "b", "c") + fooMutableList.add("d") + println(fooMutableList.last()) // => d + println(fooMutableList.size) // => 4 + + // Функція setOf створює об'єкт типу множина. + val fooSet = setOf("a", "b", "c") + println(fooSet.contains("a")) // => true + println(fooSet.contains("z")) // => false + + // mapOf створює асоціативний масив. + val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9) + // Доступ до значень в асоціативних масивах здійснюється через їхні ключі. + println(fooMap["a"]) // => 8 + + /* + Послідовності представлені як колекції лінивих обчислень. Функція generateSequence + створює послідовність. + */ + val fooSequence = generateSequence(1, { it + 1 }) + val x = fooSequence.take(10).toList() + println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + + // Приклад використання послідовностей, генерація чисел Фібоначчі: + fun fibonacciSequence(): Sequence<Long> { + var a = 0L + var b = 1L + + fun next(): Long { + val result = a + b + a = b + b = result + return a + } + + return generateSequence(::next) + } + val y = fibonacciSequence().take(10).toList() + println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] + + // Kotlin має функції вищого порядку для роботи з колекціями. + val z = (1..9).map {it * 3} + .filter {it < 20} + .groupBy {it % 2 == 0} + .mapKeys {if (it.key) "even" else "odd"} + println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]} + + // Цикл for може використовуватись з будь-чим, що має ітератор. + for (c in "hello") { + println(c) + } + + // Принцип роботи циклів "while" не відрізняється від інших мов програмування. + var ctr = 0 + while (ctr < 5) { + println(ctr) + ctr++ + } + do { + println(ctr) + ctr++ + } while (ctr < 10) + + /* + if може бути використаний як вираз, що повертає значення. Тому тернарний + оператор ?: не потрібний в Kotlin. + */ + val num = 5 + val message = if (num % 2 == 0) "even" else "odd" + println("$num is $message") // => 5 is odd + + // "when" використовується як альтернатива ланцюгам "if-else if". + val i = 10 + when { + i < 7 -> println("first block") + fooString.startsWith("hello") -> println("second block") + else -> println("else block") + } + + // "when" може приймати аргумент. + when (i) { + 0, 21 -> println("0 or 21") + in 1..20 -> println("in the range 1 to 20") + else -> println("none of the above") + } + + // "when" також може використовуватись як функція, що повертає значення. + var result = when (i) { + 0, 21 -> "0 or 21" + in 1..20 -> "in the range 1 to 20" + else -> "none of the above" + } + println(result) + + /* + Тип об'єкта можна перевірити використавши оператор is. Якщо перевірка проходить + успішно, тоді можна використовувати об'єкт як данний тип не приводячи до нього + додатково. + */ + fun smartCastExample(x: Any) : Boolean { + if (x is Boolean) { + // x тепер має тип Boolean + return x + } else if (x is Int) { + // x тепер має тип Int + return x > 0 + } else if (x is String) { + // x тепер має тип String + return x.isNotEmpty() + } else { + return false + } + } + println(smartCastExample("Hello, world!")) // => true + println(smartCastExample("")) // => false + println(smartCastExample(5)) // => true + println(smartCastExample(0)) // => false + println(smartCastExample(true)) // => true + + // Smartcast (розумне приведення) також працює з блоком when + fun smartCastWhenExample(x: Any) = when (x) { + is Boolean -> x + is Int -> x > 0 + is String -> x.isNotEmpty() + else -> false + } + + /* + Розширення - це ще один спосіб розширити функціонал класу. + Подібні методи розширення реалізовані у С#. + */ + fun String.remove(c: Char): String { + return this.filter {it != c} + } + println("Hello, world!".remove('l')) // => Heo, word! +} + +// Класи перелічення також подібні до тих типів, що і в Java. +enum class EnumExample { + A, B, C // Константи перелічення розділені комами. +} +fun printEnum() = println(EnumExample.A) // => A + +// Оскільки кожне перелічення - це об'єкт класу enum, воно може бути +// проініціалізоване наступним чином: +enum class EnumExample(val value: Int) { + A(value = 1), + B(value = 2), + C(value = 3) +} +fun printProperty() = println(EnumExample.A.value) // => 1 + +// Кожне перелічення має властивості, які дозволяють отримати його ім'я +// та порядок (позицію) в класі enum: +fun printName() = println(EnumExample.A.name) // => A +fun printPosition() = println(EnumExample.A.ordinal) // => 0 + +/* +Ключове слово object можна використати для створення об'єкту сінглтону. Об'єкт не +можна інстанціювати, проте на його унікальний екземпляр можна посилатись за іменем. +Подібна можливість є в сінглтон об'єктах у Scala. +*/ +object ObjectExample { + fun hello(): String { + return "hello" + } + + override fun toString(): String { + return "Hello, it's me, ${ObjectExample::class.simpleName}" + } +} + + +fun useSingletonObject() { + println(ObjectExample.hello()) // => hello + // В Kotlin, "Any" - це корінь ієрархії класів, так само, як і "Object" у Java. + val someRef: Any = ObjectExample + println(someRef) // => Hello, it's me, ObjectExample +} + + +/* +Оператор перевірки на те, що об'єкт не рівний null, (!!) перетворює будь-яке значення в ненульовий тип і кидає виняток, якщо значення рівне null. +*/ +var b: String? = "abc" +val l = b!!.length + +// Далі - приклади перевизначення методів класу Any в класі-насліднику +data class Counter(var value: Int) { + // перевизначити Counter += Int + operator fun plusAssign(increment: Int) { + this.value += increment + } + + // перевизначити Counter++ та ++Counter + operator fun inc() = Counter(value + 1) + + // перевизначити Counter + Counter + operator fun plus(other: Counter) = Counter(this.value + other.value) + + // перевизначити Counter * Counter + operator fun times(other: Counter) = Counter(this.value * other.value) + + // перевизначити Counter * Int + operator fun times(value: Int) = Counter(this.value * value) + + // перевизначити Counter in Counter + operator fun contains(other: Counter) = other.value == this.value + + // перевизначити Counter[Int] = Int + operator fun set(index: Int, value: Int) { + this.value = index + value + } + + // перевизначити виклик екземпляру Counter + operator fun invoke() = println("The value of the counter is $value") + +} +// Можна також перевизначити оператори через методи розширення. +// перевизначити -Counter +operator fun Counter.unaryMinus() = Counter(-this.value) + +fun operatorOverloadingDemo() { + var counter1 = Counter(0) + var counter2 = Counter(5) + counter1 += 7 + println(counter1) // => Counter(value=7) + println(counter1 + counter2) // => Counter(value=12) + println(counter1 * counter2) // => Counter(value=35) + println(counter2 * 2) // => Counter(value=10) + println(counter1 in Counter(5)) // => false + println(counter1 in Counter(7)) // => true + counter1[26] = 10 + println(counter1) // => Counter(value=36) + counter1() // => The value of the counter is 36 + println(-counter2) // => Counter(value=-5) +} +``` + +### Подальше вивчення + +* [Уроки Kotlin](https://kotlinlang.org/docs/tutorials/) +* [Спробувати попрацювати з Kotlin в браузері](https://play.kotlinlang.org/) +* [Список корисних посилань](http://kotlin.link/) diff --git a/uk-ua/mips-ua.html.markdown b/uk-ua/mips-ua.html.markdown new file mode 100644 index 00000000..2d42e85d --- /dev/null +++ b/uk-ua/mips-ua.html.markdown @@ -0,0 +1,366 @@ +--- +language: "MIPS Assembly" +filename: MIPS.asm +contributors: + - ["Stanley Lim", "https://github.com/Spiderpig86"] +translators: + - ["AstiaSun", "https://github.com/AstiaSun"] +lang: uk-ua +--- + +Мова ассемблера MIPS (англ. Microprocessor without Interlocked Pipeline Stages) була написана для роботи з мікропроцесорами MIPS, парадигма яких була описана в 1981 році [Джоном Геннессі](https://uk.wikipedia.org/wiki/Джон_Лерой_Геннессі). Ці RISC процесори використовуються у таких вбудованих системах, як маршрутизатори та мережеві шлюзи. + +[Детальніше](https://en.wikipedia.org/wiki/MIPS_architecture) + +```asm +# Коментарі позначені як'#' + +# Всі символи після '#' ігноруються лексичним аналізатором асемблера. + +# Зазвичай програми поділяються на .data та .text частини + +.data # У цьому розділі дані зберігаються у пам'яті, виділеній в RAM, подібно до змінних + # в мовах програмування вищого рівня + + # Змінна оголошується наступним чином: [назва]: .[тип] [значення] + # Наприклад: + hello_world: .asciiz "Hello World\n" # Оголосити текстову змінну + num1: .word 42 # word - це чисельний тип 32-бітного розряду + + arr1: .word 1, 2, 3, 4, 5 # Масив чисел + arr2: .byte 'a', 'b' # Масив буквених символів (розмір кожного - 1 байт) + buffer: .space 60 # Виділити місце в RAM + # (не очищується, тобто не заповнюється 0) + + # Розміри типів даних + _byte: .byte 'a' # 1 байт + _halfword: .half 53 # 2 байти + _word: .word 3 # 4 байти + _float: .float 3.14 # 4 байти + _double: .double 7.0 # 8 байтів + + .align 2 # Вирівнювання пам'яті даних, де число + # показує кількість байтів, вирівнених + # у степені 2. (.align 2 означає + # чисельне (word) вирівнювання оскільки + # 2^2 = 4 байти) + +.text # Розділ, що містить інструкції та + # логіку програми + +.globl _main # Оголошує назву інструкції як + # глобальну, тобто, яка є доступною для + # всіх інших файлів + + _main: # програми MIPS виконують інструкції + # послідовно, тобто першочергово код + # буде виконуватись після цієї позначки + + # Виведемо на екран "hello world" + la $a0, hello_world # Завантажує адресу тексту у пам'яті + li $v0, 4 # Завантажує значення системної + # команди (вказуючи тип функціоналу) + syscall # Виконує зазначену системну команду + # з обраним аргументом ($a0) + + # Регістри (використовуються, щоб тримати дані протягом виконання програми) + # $t0 - $t9 # Тимчасові регістри використовуються + # для проміжних обчислень всередині + # підпрограм (не зберігаються між + # викликами функцій) + + # $s0 - $s7 # Збережені регістри, у яких значення + # зберігаються між викликами підпрограм. + # Зазвичай зберігаються у стеку. + + # $a0 - $a3 # Регістри для передачі аргументів для + # підпрограм + # $v0 - $v1 # Регістри для значень, що повертаються + # від викликаної функції + + # Типи інструкції завантаження / збереження + la $t0, label # Скопіювати адресу в пам'яті, де + # зберігається значення змінної label + # в регістр $t0 + lw $t0, label # Скопіювати чисельне значення з пам'яті + lw $t1, 4($s0) # Скопіювати чисельне значення з адреси + # пам'яті регістра зі зміщенням в + # 4 байти (адреса + 4) + lb $t2, label # Скопіювати буквений символ в частину + # нижчого порядку регістра $t2 + lb $t2, 0($s0) # Скопіювати буквений символ з адреси + # в $s0 із зсувом 0 + # Подібне використання і 'lh' для halfwords + + sw $t0, label # Зберегти чисельне значення в адресу в + # пам'яті, що відповідає змінній label + sw $t0, 8($s0) # Зберегти чисельне значення в адресу, + # що зазначена у $s0, та зі зсувом у 8 байтів + # Така ж ідея використання 'sb' та 'sh' для буквених символів та halfwords. + # 'sa' не існує + + +### Математичні операції ### + _math: + # Пам'ятаємо, що попередньо потрібно завантажити дані в пам'ять + lw $t0, num # Із розділа з даними + li $t0, 5 # Або безпосередньо з константи + li $t1, 6 + add $t2, $t0, $t1 # $t2 = $t0 + $t1 + sub $t2, $t0, $t1 # $t2 = $t0 - $t1 + mul $t2, $t0, $t1 # $t2 = $t0 * $t1 + div $t2, $t0, $t1 # $t2 = $t0 / $t1 (Може не підтримуватись + # деякими версіями MARS) + div $t0, $t1 # Виконує $t0 / $t1. Отримати частку можна + # за допомогою команди 'mflo', остаток - 'mfhi' + + # Бітовий зсув + sll $t0, $t0, 2 # Побітовий зсув вліво на 2. Біти вищого порядку + # не зберігаються, нищого - заповнюються 0 + sllv $t0, $t1, $t2 # Зсув вліво зі змінною кількістю у + # регістрі + srl $t0, $t0, 5 # Побітовий зсув вправо на 5 (не зберігає + # біти, біти зліва заповнюються 0) + srlv $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у + # регістрі + sra $t0, $t0, 7 # Побітовий арифметичний зсув вправо + # (зберігає біти) + srav $t0, $t1, $t2 # Зсув вправо зі змінною кількістю у + # регістрі зі збереження значеннь бітів + + # Побітові операції + and $t0, $t1, $t2 # Побітове І (AND) + andi $t0, $t1, 0xFFF # Побітове І з безпосереднім значенням + or $t0, $t1, $t2 # Побітове АБО (OR) + ori $t0, $t1, 0xFFF # Побітове АБО з безпосереднім значенням + xor $t0, $t1, $t2 # Побітова виключна диз'юнкція (XOR) + xori $t0, $t1, 0xFFF # Побітове XOR з безпосереднім значенням + nor $t0, $t1, $t2 # Побітова стрілка Пірса (NOR) + +## Розгалуження ## + _branching: + # В основному інструкції розгалуження мають наступну форму: + # <instr> <reg1> <reg2> <label> + # де label - це назва змінної, в яку ми хочемо перейти, якщо зазначене твердження + # правдиве + + beq $t0, $t1, reg_eq # Перейдемо у розгалуження reg_eq + # якщо $t0 == $t1, інакше - + # виконати наступний рядок + bne $t0, $t1, reg_neq # Розгалужується, якщо $t0 != $t1 + b branch_target # Розгалуження без умови завжди виконується + beqz $t0, req_eq_zero # Розгалужується, якщо $t0 == 0 + bnez $t0, req_neq_zero # Розгалужується, якщо $t0 != 0 + bgt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 > $t1 + bge $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 >= $t1 + bgtz $t0, t0_gt0 # Розгалужується, якщо $t0 > 0 + blt $t0, $t1, t0_gt_t1 # Розгалужується, якщо $t0 < $t1 + ble $t0, $t1, t0_gte_t1 # Розгалужується, якщо $t0 <= $t1 + bltz $t0, t0_lt0 # Розгалужується, якщо $t0 < 0 + slt $s0, $t0, $t1 # Інструкція, що посилає сигнал коли + # $t0 < $t1, результат зберігається в $s0 + # (1 - правдиве твердження) + + # Просте твердження якщо (if) + # if (i == j) + # f = g + h; + # f = f - i; + + # Нехай $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j + bne $s3, $s4, L1 # if (i !=j) + add $s0, $s1, $s2 # f = g + h + + L1: + sub $s0, $s0, $s3 # f = f - i + + # Нижче наведений приклад знаходження максимального значення з 3 чисел + # Пряма трансляція в Java з логіки MIPS: + # if (a > b) + # if (a > c) + # max = a; + # else + # max = c; + # else + # max = b; + # else + # max = c; + + # Нехай $s0 = a, $s1 = b, $s2 = c, $v0 = повернути регістр + ble $s0, $s1, a_LTE_b # якщо (a <= b) розгалуження(a_LTE_b) + ble $s0, $s2, max_C # якщо (a > b && a <=c) розгалуження(max_C) + move $v0, $s0 # інакше [a > b && a > c] max = a + j done # Перейти в кінець програми + + a_LTE_b: # Мітка розгалуження, коли a <= b + ble $s1, $s2, max_C # якщо (a <= b && b <= c) розгалуження(max_C) + move $v0, $s1 # якщо (a <= b && b > c) max = b + j done # Перейти в кінець програми + + max_C: + move $v0, $s2 # max = c + + done: # Кінець програми + +## Цикли ## + _loops: + # Цикл складається з умови виходу та з інструкції переходу після його завершення + li $t0, 0 + while: + bgt $t0, 10, end_while # Коли $t0 менше 10, продовжувати ітерації + addi $t0, $t0, 1 # Збільшити значення + j while # Перейти на початок циклу + end_while: + + # Транспонування 2D матриці + # Припустимо, що $a0 зберігає адресу цілочисельної матриці розмірністю 3 x 3 + li $t0, 0 # Лічильник для i + li $t1, 0 # Лічильник для j + matrix_row: + bgt $t0, 3, matrix_row_end + + matrix_col: + bgt $t1, 3, matrix_col_end + + # ... + + addi $t1, $t1, 1 # Збільшити лічильник стовпця (col) + matrix_col_end: + + # ... + + addi $t0, $t0, 1 + matrix_row_end: + +## Функції ## + _functions: + # Функції - це процедури, що викликаються, приймають аргументи та повертають значення + + main: # Програма починається з головної функції + jal return_1 # jal збереже поточний ПЦ (програмний центр) в $ra, + # а потім перейде до return_1 + + # Як передати аргументи? + # По-перше, ми маємо передати значення аргументів у регістри аргументів + li $a0, 1 + li $a1, 2 + jal sum # Тепер ми можемо викликати функцію + + # Як щодо рекурсії? + # Тут потрібно дещо більше роботи оскільки ми маємо впевнитись, що ми збережемо + # та зчитаємо попередній ПЦ в $ra, оскільки jal автоматично перепише її при виклику + li $a0, 3 + jal fact + + li $v0, 10 + syscall + + # Ця функція повертає 1 + return_1: + li $v0, 1 # Завантажити val в регіст $v0 + jr $ra # Повернутись до попереднього ПЦ і продовжити виконання + + + # Функція з двома аргументами + sum: + add $v0, $a0, $a1 + jr $ra # Повернутись + + # Рекурсивна функція, яка знаходить факторіал + fact: + addi $sp, $sp, -8 # Виділити місце в стеку + sw $s0, ($sp) # Зберегти регістр, що містить поточне число + sw $ra, 4($sp) # Зберегти попередній ПЦ + + li $v0, 1 # Проініціалізувати значення, що повертатиметься + beq $a0, 0, fact_done # Закінчити, якщо параметр 0 + + # Інакше, продовжити рекурсію + move $s0, $a0 # Скопіювати $a0 в $s0 + sub $a0, $a0, 1 + jal fact + + mul $v0, $s0, $v0 # Множення + + fact_done: + lw $s0, ($sp) + lw $ra, ($sp) # Відновити ПЦ + addi $sp, $sp, 8 + + jr $ra + +## Макроси ## + _macros: + # Макроси надзвичайно корисні для заміни блоків коду, що повторюються, за допомогою + # однієї змінної, для покращення читабельності + # Це не заміна функцій. + # Вони мають бути оголошені перед використанням + + # Макрос для виведення нових рядків (оскільки операція досить часто виконується) + .macro println() + la $a0, newline # Значення нового рядка зберігатиметься тут + li $v0, 4 + syscall + .end_macro + + println() # Асемблер скопіює цей блок коду сюди + # перед тим, як виконувати його + + # Можна передавати параметри у макроси. + # Параметри позначаються знаком '%' з довільною назвою + .macro print_int(%num) + li $v0, 1 + lw $a0, %num + syscall + .end_macro + + li $t0, 1 + print_int($t0) + + # Значення також можна передавати безпосередньо в макроси + .macro immediates(%a, %b) + add $t0, %a, %b + .end_macro + + immediates(3, 5) + + # Одночасно із назвами змінних + .macro print(%string) + la $a0, %string + li $v0, 4 + syscall + .end_macro + + print(hello_world) + +## Масиви ## +.data + list: .word 3, 0, 1, 2, 6 # Це масив чисел + char_arr: .asciiz "hello" # Це текстовий масив + buffer: .space 128 # Виділяє блок пам'яті, що + # автоматично не очищується + # Ці блоки пам'яті вирівнені + # вирівнені поруч один з одним + +.text + la $s0, list # Завантажити адресу списку + li $t0, 0 # Лічильник + li $t1, 5 # Довжина списку + + loop: + bgt $t0, $t1, end_loop + + lw $a0, ($s0) + li $v0, 1 + syscall # Вивести число + + addi $s0, $s0, 4 # Розмір числа - 4 байти + addi $t0, $t0, 1 # Збільшити + j loop + end_loop: + +## Включення ## +# Потрібно для імпорту сторонніх файлів у програму (насправді, код з цього файлу +# копіюється та вставляється в місце, де оголошений імпорт) +.include "somefile.asm" + +``` diff --git a/uk-ua/python-ua.html.markdown b/uk-ua/pythonlegacy-ua.html.markdown index 4091e433..e2a6d19e 100644 --- a/uk-ua/python-ua.html.markdown +++ b/uk-ua/pythonlegacy-ua.html.markdown @@ -1,5 +1,5 @@ --- -language: python +language: Python 2 (legacy) lang: uk-ua contributors: - ["Louie Dinh", "http://ldinh.ca"] @@ -10,7 +10,7 @@ contributors: - ["habi", "http://github.com/habi"] translators: - ["Oleh Hromiak", "https://github.com/ogroleg"] -filename: learnpython-ua.py +filename: learnpythonlegacy-ua.py --- Мову Python створив Гвідо ван Россум на початку 90-х. Наразі це одна з diff --git a/uk-ua/ruby-ua.html.markdown b/uk-ua/ruby-ua.html.markdown index 74346dfe..a71c30bc 100644 --- a/uk-ua/ruby-ua.html.markdown +++ b/uk-ua/ruby-ua.html.markdown @@ -622,4 +622,4 @@ Something.new.qux # => 'qux' - [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. +- [Try Ruby](https://try.ruby-lang.org/) - Learn the basic of Ruby programming language, interactive in the browser. diff --git a/uk-ua/rust-ua.html.markdown b/uk-ua/rust-ua.html.markdown index 4ec2b7c9..4aad0cbb 100644 --- a/uk-ua/rust-ua.html.markdown +++ b/uk-ua/rust-ua.html.markdown @@ -1,5 +1,5 @@ --- -language: rust +language: Rust contributors: - ["P1start", "http://p1start.github.io/"] translators: @@ -233,7 +233,7 @@ fn main() { // Цикл `for` let array = [1, 2, 3]; - for i in array.iter() { + for i in array { println!("{}", i); } |