Untitled

package nowiwr01p.daily.doctor.server.main.igor

import java.util.Locale
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
import kotlin.math.pow

fun main() {
//    Variables()
//    Types()
//    Types1()
//    BaseOperations()
//    Strings()
    Lists()
//    Cycles()
}

private fun Variables() {
    val x = 0
//    x += 1 --- !!! Ошибка !!!
    println("Если попытаемся изменить x, то получим ошибку")
    println("Дело в том, что [val] = неизменяемая переменная, а [var] = изменяемая")
    println("Поэтому, чтобы банально увеличивать счётчик, нам нужна [var] переменная")
    var x1 = 0
    x1 += 1
}

/**
 * Обычно мы работаем только с этими типами
 * Штуки по типу UInt (unsigned int), в отличии от C++, в Kotlin нужны оч редко
 */
private fun Types() {
    val x = 2 // Int
    println("1) Явное приведение типов")
    println("- x type = ${x::class.simpleName}")
    val x1 = x.toLong()
    println("- x1 type = ${x1::class.simpleName}")
    val x2 = x.toFloat()
    println("- x2 type = ${x2::class.simpleName}")
    val x3 = x.toDouble()
    println("- x3 type = ${x3::class.simpleName}")
    val x4 = x.toString()
    println("- x4 type = ${x4::class.simpleName}")
}

private fun Types1() {
    val x = 2 // Int
    println("2) Неявное приведение типов")
    val y1 = x * 5 // Int * Int = Int
    println("- y1 = ${y1::class.simpleName}")
    val y2 = x * 5L // Int * Long = Long
    println("- y2 = ${y2::class.simpleName}")
    val y3 = x * 5f // Any type * Float = Float
    println("- y3 = ${y3::class.simpleName}")
    val y4 = x * 5f * 10L // Even if we add multiple to Long, it's still a Float, but...
    println("- y4 = ${y4::class.simpleName}")
    val y5 = x * 5L * 10.toDouble() / 0.5f // ...except Double. Any type * Double = Double
    println("- y5 = ${y5::class.simpleName}")
    println("Такая логика работает со всеми видами арифметических операций. Кстати, про операции")
}

private fun BaseOperations() {
    println("3) Другие операции")
    val t1 = min(2, 5)
    println("- t1 = $t1")
    val t2 = max(2, 5)
    println("- t2 = $t2")
    val t3 = abs(-5)
    println("- t3 = $t3")
    val t4 = 2.toDouble().pow(3).toLong() // This shit works only if the first number ("2" here) is a Double
    println("- t4 = $t4")
}

private fun Strings() {
    println("4) Операции со строками")
    val string = "hi, this is a string"
    println(string.length)
    println(string.drop(7)) // cut "string" suffix
    println(string.take(2)) // tale "hi" prefix
    println(string.substring(startIndex = 3)) // " this is a string"
    println(string.substring(startIndex = 3).trim()) // "this is a string" (without start and end whitespaces)
    println(string.substring(startIndex = 4, endIndex = 11)) // "this is" (11 index is exclusive)
    println(string.dropWhile { it.isLetter() }) // ", this is a string"
    println(string.takeWhile { it.isLetter() }) // "hi"
    println(string.takeWhile { it.isDigit() }) // empty string

    println("$string, but this is my dick") // concat

    println(string.split(" ")) // ["hi,", "this", "is", "a", "string"]
    println(string.split(",")) // ["hi", " this is a string"]
    println(string.split(" is ")) // ["hi, this", "a string"]

    println(string.toCharArray().toList()) // each symbol

    val stringWithPattern = "my dick is %s, exactly %d cm"
    val dickStringWithoutNamedParameters = String.format(
        Locale.getDefault(), stringWithPattern, "big", 9
    )
    val dickStringWithNamedParameters = String.format(
        locale = Locale.getDefault(),
        format = stringWithPattern,
        args = arrayOf("small", 228)
    )
    println(dickStringWithNamedParameters)
    println(dickStringWithoutNamedParameters)
    println("Когда речь идет о Kotlin, то тут все любят именованные параметры")
    println("Если у функции 1 аргумент, то можно и без этого. Если 2 - то 50/50, но лучше именованные. Если 3 и не именованные - то ты пидарас")
    println("Зачем использовать именованные параметры - станет понятнее, когда напишем классы")
}

private fun Lists() {
    println("5) Массивы")
    println("В основном все используют List<T>, реже Array<T>")
    val emptyList = listOf<Int>() // Пустой список, в котором могли бы храниться числа
    println("emptyList.size = ${emptyList.size}")
    println("Если попытаемся вызвать [emptyList.first()] или [emptyList[anyIndex]], то будет краш")
    val initializedList = listOf("Однажды", "Миксер", "шел", "домой...")
    println("initializedList = $initializedList")
    println("Если мы попытаемся изменить элемент такого списка через initializedList[1] = \"huj\", то получим ошибку")
    println("Почему? У нас же с переменными всё работало")
    println("А тут есть такое понятие, как [MutableList] и [ImmutableList]")
    println("Если хотим изменять или добавлять элементы, то нам нужен [MutableList], для которого есть красивый синтаксический сахар")
    val mutableList = mutableListOf(1, 2, 3)
    println("mutableList = $mutableList")
    mutableList[1] = 228
    println("changed mutableList = $mutableList")
    println("Так же мы можем превращать [ImmutableList aka listOf()] в [MutableList]")
    val transformedImmutableList = initializedList.toMutableList().apply {
        add("и оказался голубой")
    }
    println("transformedImmutableList = $transformedImmutableList")
}

private fun Cycles() {
    println("6) Циклы")
    println("Ну тут в консоли ничего не будет, ха-ха")
    /**
     * Обычный цикл for. В основном, такой синтаксис используют геи и деды
     * Но иногда, очень-очень редко, бывает нужен
     */
    println("Наебал)0))0")
    println("Вот дедовский for")
    for (number in 100 downTo 0 step 2) {
        print("$number ")
    }
    println()
    for (number in 15 until 100 step 5) {
        print("$number ")
    }
    println()
    for (number in 10..20) {
        print("$number ")
    }
    println()
    for ((index, number) in (10..15).withIndex()) {
        print("$index = $number, ")
    }
    println()
    /**
     * Синтаксически красивый for
     */
    println("А теперь красивый for")
    (1..10).forEach {
        print("$it ") // it = дефолтное имя аргумента. Но его можно указать
    }
    println()
    (1..10).forEach { number ->
        print("$number ")
    }
    /**
     * Указывать имя аргумента или нет - дело каждого
     * Иногда прям надо, потому что может быть несколько вложенных [it], а иногда
     * для красоты можно обойтись и без него
     */
    println()
    (1..10).forEachIndexed { index, number ->
        print("$index = $number, ")
    }

    println("Есть ещё всякие [do] и [do-while] циклы, но я их использовал ровно 1 раз за 5 лет")
    println("поэтому я бы на них забил хуй")
}