summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
authorAstiaSun <anastasiia.bondarenko@ring.com>2019-10-28 21:26:47 +0200
committerAstiaSun <anastasiia.bondarenko@ring.com>2019-10-30 20:06:18 +0200
commitd7af01bda2a7c5cad433502de6780a1ccc05b8aa (patch)
tree9866349df38543588a878c8478aef12a11de4f1a
parentef1ccd2b0f9ca450395b6391b1155c981cd4ad4d (diff)
[go/uk-ua] Add ukrainian translation for Go language
-rw-r--r--uk-ua/go-ua.html.markdown450
1 files changed, 450 insertions, 0 deletions
diff --git a/uk-ua/go-ua.html.markdown b/uk-ua/go-ua.html.markdown
new file mode 100644
index 00000000..8c9e9de7
--- /dev/null
+++ b/uk-ua/go-ua.html.markdown
@@ -0,0 +1,450 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.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 в області видимості if та присвоїти їх значення. Далі
+ // значення змінної проходить перевірку y > x.
+ if y := expensiveComputation(); y > x {
+ x = y
+ }
+ // Літерали функцій та замикання
+ // Function literals are closures.
+ 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 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 залишається [офіційна веб-сторінка](http://golang.org/). Там можна знайти уроки, інтерактивно погратись та багато про що почитати.
+Окрім туру, у [документації](https://golang.org/doc/) міститься інформація як писати чистий та ефективний код на Go, документація пакетів та окремих команд, а також історія релізів.
+
+Надзвичайно рекомендується ознайомитись із визначенням мови. Вона легко читається та на диво коротка (в порівнянні з іншими сучасними мовами).
+
+Можна погратись з кодом вище на [Go playground](https://play.golang.org/p/tnWMjr16Mm). Спробуй змінити його та запустити із свого браузера. Поміть, що можна використовувати [https://play.golang.org](https://play.golang.org) як [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) до тестів та коду в твоєму браузері, без встановлення Go.
+
+В списку для прочитання новичкам в Go - [вихідний код стандартної бібліотеки](http://golang.org/src/pkg/). Код всеосяжно продукоментований, тому є найкращим прикладом з боку зручного для прочитання та швидкості розуміння коду на цій мові програмування. Приведений стиль та ідіоми Go.
+Крім того, можна просто натиснути на назву функції в [документації](http://golang.org/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).