mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-23 09:41:36 +00:00
Create kotlin-ru.html.markdown (#2698)
This commit is contained in:
Vadim Toptunov
ven
parent
2b47f2f00f
commit
e99782a6ca
372
ru-ru/kotlin-ru.html.markdown
Normal file
372
ru-ru/kotlin-ru.html.markdown
Normal file
@ -0,0 +1,372 @@
|
||||
---
|
||||
language: kotlin
|
||||
translator:
|
||||
- ["Vadim Toptunov", "https://github.com/VadimToptunov"]
|
||||
filename: LearnKotlin-ru.kt
|
||||
---
|
||||
|
||||
Kotlin - статистически типизированный язык для JVM, Android и браузера. Язык полностью cjdvtcnbv c Java.
|
||||
[Более детальная информация здесь.](https://kotlinlang.org/)
|
||||
|
||||
```kotlin
|
||||
// Однострочные комментарии начинаются с //
|
||||
/*
|
||||
А вот так выглядят многострочные комментарии.
|
||||
*/
|
||||
|
||||
// Ключевое слово "package" действует и используется // абсолютно также, как и в Java.
|
||||
package com.learnxinyminutes.kotlin
|
||||
|
||||
/*
|
||||
Точкой входа в программу на языке Kotlin является функция "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)
|
||||
|
||||
/*
|
||||
Необработанная строка разделяется тройной кавычкой (""").
|
||||
Необработанные строки могут содержать символы новой строки и любые другие символы.
|
||||
*/
|
||||
val fooRawString = """
|
||||
fun helloWorld(val name : String) {
|
||||
println("Hello, world!")
|
||||
}
|
||||
"""
|
||||
println(fooRawString)
|
||||
|
||||
/*
|
||||
Строки могут содержать в себе шаблонные выражения.
|
||||
Шаблонные выражения начинаются со знака доллара ($).
|
||||
*/
|
||||
val fooTemplateString = "$fooString has ${fooString.length} characters"
|
||||
println(fooTemplateString)
|
||||
|
||||
/*
|
||||
Переменная, которая содержит null должна быть явно обозначена как nullable.
|
||||
Переменная может быть обозначена как nullable с помощью добавления знака вопроса(?) к ее типу.
|
||||
Мы можем получить доступ к nullable переменной используя оператор ?. .
|
||||
Для того, чтобы указать иное значение, если переменная является 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)
|
||||
// Lambda-выражения могут быть определены в качестве аргументов.
|
||||
val notZero = not {n -> n == 0}
|
||||
/*
|
||||
Если lambda-выражение имеет только один параметр, то ее определение может быть опущено (вместе с ->).
|
||||
Имя этого единственного параметра будет "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
|
||||
|
||||
/*
|
||||
Data-классы - это компактный способ создать классы, которые лишь хранят данные.
|
||||
Методы "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)
|
||||
|
||||
// Data-классы обладают функцией "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" аналогична оператору "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
|
||||
|
||||
// Мы можем создать отображение (map), используя функцию "mapOf".
|
||||
val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
|
||||
// Получить доступ к значениям отображения (map) можно с помощью их ключа.
|
||||
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 is automatically cast to Boolean
|
||||
return x
|
||||
} else if (x is Int) {
|
||||
// x is automatically cast to Int
|
||||
return x > 0
|
||||
} else if (x is String) {
|
||||
// x is automatically cast to 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
|
||||
}
|
||||
|
||||
/*
|
||||
Расширения - это способ добавить новый функционал к классу.
|
||||
Это то же самое, что методы расширений в C#.
|
||||
*/
|
||||
fun String.remove(c: Char): String {
|
||||
return this.filter {it != c}
|
||||
}
|
||||
println("Hello, world!".remove('l')) // => Heo, word!
|
||||
|
||||
println(EnumExample.A) // => A
|
||||
println(ObjectExample.hello()) // => hello
|
||||
}
|
||||
|
||||
// Enum-классы схожи с типами enum в Java.
|
||||
enum class EnumExample {
|
||||
A, B, C
|
||||
}
|
||||
|
||||
/*
|
||||
Ключевое слово "object" может использоваться для создания одноэлементных объектов.
|
||||
Мы не можем его инстанцировать, но можем вызывать его уникальный экземпляр по имени.
|
||||
Это похоже на одиночные объекты Scala.
|
||||
*/
|
||||
object ObjectExample {
|
||||
fun hello(): String {
|
||||
return "hello"
|
||||
}
|
||||
}
|
||||
|
||||
fun useObject() {
|
||||
ObjectExample.hello()
|
||||
val someRef: Any = ObjectExample // we use objects name just as is
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
### Дальнейшее чтение:
|
||||
|
||||
* [Учебные материалы по Kotlin](https://kotlinlang.org/docs/tutorials/)
|
||||
* [TПопробуй Kotlin в своем браузере](http://try.kotlinlang.org/)
|
||||
* [Список ресурсов по языку Kotlin](http://kotlin.link/)
|
||||
Loading…
Reference in New Issue
Block a user