--- filename: LearnKotlin-uk.kt 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) { /* Оголошення змінних відбувається за допомогою ключових слів 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 { 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/)