آموزش ساختار های کنترلی کاتلین

شرط‌ها (if-else):

کاتلین از شرایط منطقی ریاضی معمول پشتیبانی می‌کند:

– کمتر از: `a < b`
– کمتر یا مساوی: `a <= b`
– بزرگتر از: `a > b`
– بزرگتر یا مساوی: `a >= b`
– مساوی: `a == b`
– نامساوی: `a != b`

می‌توانید از این شرایط برای انجام اقدامات مختلف در تصمیم‌گیری‌ها استفاده کنید.

کاتلین از ساختارهای زیر برای کنترل جریان برنامه استفاده می‌کند:

– از `if` برای اجرای یک بلوک کد در صورتی که شرط مورد نظر برقرار باشد.
– اگر شرط برقرار نبود، از `else` برای اجرای یک بلوک کد جایگزین استفاده کنید.
– در صورتی که شرط اول برقرار نبود و می‌خواهید شرط دیگری را بررسی کنید، از `else if` استفاده کنید.
– از ساختار `when` برای تعیین و اجرای چندین بلوک کد جایگزین استفاده کنید.

نکته: برخلاف جاوا، در کاتلین از `if..else` می‌توان هم به‌عنوان دستور و هم به‌عنوان عبارت (برای اختصاص یک مقدار به یک متغیر) استفاده کرد. برای درک بهتر، می‌توانید مثالی در پایین صفحه مشاهده کنید.

### شرط if در کاتلین

از `if` برای تعیین یک بلوک کد استفاده کنید که در صورت صحیح بودن یک شرط، اجرا شود.

fun main() {
    val number = 10

    if (number > 0) {
        println("عدد مثبت است.")
    } else if (number < 0) {
        println("عدد منفی است.")
    } else {
        println("عدد صفر است.")
    }
}

در این مثال، اگر مقدار number بزرگتر از صفر باشد، برنامه پیام “عدد مثبت است.” را چاپ می‌کند. اگر number کمتر از صفر باشد، پیام “عدد منفی است.” چاپ می‌شود. در غیر این صورت، یعنی زمانی که number برابر با صفر باشد، پیام “عدد صفر است.” چاپ خواهد شد.

در کاتلین، از `else` برای تعیین یک بلوک کد استفاده کنید که در صورت نادرست بودن شرط اجرا شود.

fun main() {
    val age = 16

    if (age >= 18) {
        println("شما می‌توانید رأی دهید.")
    } else {
        println("شما نمی‌توانید رأی دهید.")
    }
}

در کاتلین، اگر شرط اول نادرست باشد، از `else if` برای تعیین یک شرط جدید استفاده کنید. این ساختار به شما امکان می‌دهد چندین شرط را به صورت پی‌درپی بررسی کنید.

در اینجا یک مثال ساده از استفاده از `else if` آورده شده است:

fun main() {
    val score = 75

    if (score >= 90) {
        println("عالی!")
    } else if (score >= 75) {
        println("خوب")
    } else if (score >= 50) {
        println("متوسط")
    } else {
        println("نیاز به تلاش بیشتر")
    }
}

در این مثال:
– اگر `score` برابر یا بیشتر از ۹۰ باشد، پیام “عالی!” چاپ می‌شود.
– اگر `score` کمتر از ۹۰ و برابر یا بیشتر از ۷۵ باشد، پیام “خوب” چاپ می‌شود.
– اگر `score` کمتر از ۷۵ و برابر یا بیشتر از ۵۰ باشد، پیام “متوسط” چاپ می‌شود.
– اگر هیچ‌یک از شرایط بالا برقرار نباشد، پیام “نیاز به تلاش بیشتر” چاپ می‌شود.

توجه: اگر فقط یک عبارت درون هر بلوک `if` یا `else` وجود داشته باشد، می‌توانید پرانتزهای مجعد `{}` را حذف کنید. در این صورت، کد ساده‌تر و خواناتر خواهد شد.

برای مثال:

fun main() {
    val score = 85

    if (score >= 90)
        println("عالی!")
    else if (score >= 75)
        println("خوب")
    else if (score >= 50)
        println("متوسط")
    else
        println("نیاز به تلاش بیشتر")
}

در این مثال، چون هر بلوک تنها یک عبارت دارد، از پرانتزهای `{}` استفاده نشده است.

عبارات when

در کاتلین، به جای استفاده از چندین عبارت `if..else`، می‌توانید از عبارت `when` استفاده کنید که خواندن آن بسیار آسان‌تر است. عبارت `when` برای انتخاب و اجرای یکی از بسیاری از بلوک‌های کد استفاده می‌شود.

مثال زیر نشان می‌دهد که چگونه می‌توانید از `when` استفاده کنید:

fun main() {
    val day = 3

    when (day) {
        1 -> println("یکشنبه")
        2 -> println("دوشنبه")
        3 -> println("سه‌شنبه")
        4 -> println("چهارشنبه")
        5 -> println("پنج‌شنبه")
        6 -> println("جمعه")
        7 -> println("شنبه")
        else -> println("روز نامعتبر")
    }
}

این روش به این صورت کار می‌کند:

1. متغیر `day` تنها یک بار توسط عبارت `when` ارزیابی می‌شود.
2. مقدار متغیر `day` با مقادیر هر “شاخه” مقایسه می‌شود.
3. هر شاخه با یک مقدار شروع می‌شود و پس از آن یک فلش (`->`) و سپس نتیجه قرار می‌گیرد.
4. اگر تطابقی پیدا شود، بلوک کد مرتبط با آن شاخه اجرا می‌شود.
5. از `else` برای تعیین بلوک کدی استفاده می‌شود که در صورت عدم تطابق اجرا خواهد شد.

در مثال بالا، مقدار متغیر `day` برابر با ۴ است، بنابراین پیام “چهارشنبه” چاپ می‌شود، چون مقدار ۴ در شاخه مربوط به “چهارشنبه” قرار دارد.

حلقه‌( while)

حلقه while در برنامه‌نویسی، یک حلقه تکرار است که تا زمانی که یک شرط مشخص درست باشد، به اجرای بلوک کدی که داخل حلقه است، ادامه می‌دهد. وقتی شرط غلط شود، حلقه متوقف می‌شود و کنترل به خط بعد از حلقه منتقل می‌شود.

ساختار کلی حلقه while به شکل زیر است:

while شرط:
    # بلوک کد که اجرا می‌شود تا زمانی که شرط برقرار است

در کاتلین، حلقه‌ی do..while نوعی از حلقه‌ی while است که همیشه حداقل یک‌بار اجرا می‌شود، زیرا ابتدا کد داخل بلوک do اجرا می‌شود و سپس شرط بررسی می‌گردد. این ساختار برای مواردی که می‌خواهیم یک عمل حداقل یک بار انجام شود، مناسب است.

ساختار کلی حلقه do..while در کاتلین

do {
    // بلوک کد که حداقل یک بار اجرا می‌شود
} while (شرط)

مراحل اجرای حلقه
ابتدا کد داخل do اجرا می‌شود.
سپس شرط بررسی می‌شود.
اگر شرط برقرار باشد (true)، کد داخل بلوک دوباره اجرا می‌شود.
این فرایند تا زمانی ادامه می‌یابد که شرط نادرست (false) شود و حلقه متوقف گردد.
مثال ۱: چاپ اعداد از ۱ تا ۵
در این مثال، حلقه‌ی do..while برای شمارش و چاپ اعداد از ۱ تا ۵ استفاده می‌شود.

fun main() {
    var number = 1

    do {
        println(number)
        number++
    } while (number <= 5)
}

حلقه‌(for)

در کاتلین، زمانی که با آرایه‌ها کار می‌کنیم، اغلب نیاز داریم که تمام عناصر آن را مرور کنیم. برای این منظور، می‌توانیم از حلقه for همراه با عملگر in استفاده کنیم. این حلقه به طور خودکار از ابتدای آرایه تا انتها حرکت کرده و هر عنصر را به صورت جداگانه دسترسی می‌دهد.

ساختار کلی حلقه for همراه با عملگر in برای آرایه‌ها

for (element in array) {
    // کدی که روی هر عنصر اعمال می‌شود
}

مثال: چاپ عناصر یک آرایه از اعداد صحیح
در این مثال، یک آرایه از اعداد تعریف شده و با استفاده از حلقه for و عملگر in، تمام عناصر آن چاپ می‌شوند.

fun main() {
    val numbers = arrayOf(1, 2, 3, 4, 5)

    for (number in numbers) {
        println(number)
    }
}

در کاتلین، حلقه‌ی for با شکل سنتی که در برخی از زبان‌ها (مثل جاوا) وجود دارد، یعنی حلقه‌ای با شمارنده‌ی قابل افزایش/کاهش (for (int i = 0; i < n; i++)) وجود ندارد. در عوض، در کاتلین از حلقه‌ی for به روشی ساده‌تر و خواناتر برای پیمایش بر روی مجموعه‌های قابل شمارش استفاده می‌شود، مانند آرایه‌ها، لیست‌ها، محدوده‌ها و سایر ساختارهای داده.

پیمایش با استفاده از حلقه for
در کاتلین، حلقه‌ی for به شکل زیر برای مرور بر روی عناصر استفاده می‌شود:

for (item in collection) {
    // کدی که روی هر عنصر اعمال می‌شود
}

در اینجا، collection می‌تواند یک آرایه، لیست، محدوده (رنج) و یا هر مجموعه‌ای باشد که قابلیت شمارش داشته باشد.

پیمایش بر روی آرایه‌ها و لیست‌ها
در مثال‌های زیر از حلقه for برای مرور بر روی عناصر یک آرایه و لیست استفاده شده است

fun main() {
    val numbers = arrayOf(10, 20, 30, 40, 50)

    for (number in numbers) {
        println(number)
    }
}

در این مثال، متغیر number در هر تکرار به یکی از عناصر آرایه مقداردهی می‌شود و سپس مقدار آن چاپ می‌گردد.

10
20
30
40
50

پیمایش معکوس با downTo
می‌توان با downTo یک محدوده معکوس تعریف کرد:

for (i in 5 downTo 1) {
    println(i)
}

5
4
3
2
1

پیمایش با گام مشخص با step
با استفاده از step می‌توان گام (تعداد تغییرات در هر مرحله) را مشخص کرد:

kotlin

نام در ایندکس 0: علی
نام در ایندکس 1: رضا
نام در ایندکس 2: سارا

 

for (i in 1..10 step 2) {
    println(i)
}

1
3
5
7
9

دسترسی به ایندکس و مقدار به طور همزمان با withIndex
در کاتلین، با استفاده از withIndex می‌توان هم به ایندکس و هم به مقدار هر عنصر به صورت هم‌زمان دسترسی داشت.

val names = arrayOf("علی", "رضا", "سارا")

for ((index, name) in names.withIndex()) {
    println("نام در ایندکس $index: $name")
}

نام در ایندکس 0: علی
نام در ایندکس 1: رضا
نام در ایندکس 2: سارا

در کاتلین از حلقه for برای پیمایش مستقیم بر روی آرایه‌ها، لیست‌ها، و محدوده‌ها استفاده می‌شود.
برای محدوده‌ها از ..، downTo و step می‌توان استفاده کرد تا شرایط خاصی را برای پیمایش تنظیم کنیم.
با withIndex می‌توان هم‌زمان به ایندکس و مقدار عناصر دسترسی داشت.

استفاده از کنترل‌کننده‌های حلقه (break، continue)

break

در کاتلین، دستور break برای خروج زودهنگام از یک حلقه (مانند for, while, یا do..while) به کار می‌رود. وقتی برنامه به دستور break می‌رسد، اجرای حلقه بلافاصله متوقف شده و برنامه به خط بعد از حلقه منتقل می‌شود. این دستور معمولاً در شرایطی استفاده می‌شود که بخواهیم وقتی شرط خاصی در حلقه برقرار شد، ادامه حلقه را نادیده بگیریم و زودتر از حلقه خارج شویم.

مثال: استفاده از break در حلقه for
در این مثال، می‌خواهیم از یک آرایه تا زمانی که عدد 30 یافت نشده است، عناصر آن را چاپ کنیم. به محض این که به 30 برسیم، با استفاده از break از حلقه خارج می‌شویم.

fun main() {
    val numbers = arrayOf(10, 20, 30, 40, 50)

    for (number in numbers) {
        if (number == 30) {
            break
        }
        println(number)
    }

    println("حلقه به پایان رسید.")
}

10
20
حلقه به پایان رسید.

استفاده از break در حلقه while
در این مثال، از حلقه while استفاده می‌کنیم تا اعداد ۱ تا ۱۰ را بشماریم و به محض این که عدد 5 برسد، با break از حلقه خارج می‌شویم.

fun main() {
    var i = 1

    while (i <= 10) {
        if (i == 5) {
            break
        }
        println(i)
        i++
    }

    println("حلقه متوقف شد.")
}

1
2
3
4
حلقه متوقف شد.

دستور break می‌تواند در هر جایی از حلقه قرار بگیرد و معمولاً در یک شرط خاص استفاده می‌شود تا زمانی که شرایط خاصی برقرار است، حلقه اجرا شده و در غیر این صورت متوقف شود.

continue

در کاتلین، دستور continue برای پرش از اجرای بخش باقی‌مانده‌ی کد در یک تکرار خاص از حلقه استفاده می‌شود. وقتی برنامه به دستور continue می‌رسد، اجرای آن تکرار از حلقه متوقف می‌شود و برنامه به تکرار بعدی حلقه منتقل می‌شود. این دستور معمولاً در مواردی استفاده می‌شود که بخواهیم زمانی که یک شرط خاص برقرار است، بعضی از مراحل را نادیده بگیریم و مستقیماً به تکرار بعدی برویم.

مثال: استفاده از continue در حلقه for
در این مثال، می‌خواهیم تمام اعداد آرایه را به جز عدد 30 چاپ کنیم. هر زمان که به 30 برسیم، با استفاده از continue آن تکرار را نادیده گرفته و به تکرار بعدی می‌رویم.

fun main() {
    val numbers = arrayOf(10, 20, 30, 40, 50)

    for (number in numbers) {
        if (number == 30) {
            continue
        }
        println(number)
    }

    println("حلقه به پایان رسید.")
}

10
20
40
50
حلقه به پایان رسید.

: استفاده از continue در حلقه while
در این مثال، حلقه while از ۱ تا ۱۰ را شمارش می‌کند، اما هر زمان که به عدد 5 برسد، آن را نادیده می‌گیرد و به تکرار بعدی می‌رود.

fun main() {
    var i = 1

    while (i <= 10) {
        if (i == 5) {
            i++
            continue
        }
        println(i)
        i++
    }

    println("حلقه متوقف شد.")
}

1
2
3
4
6
7
8
9
10
حلقه متوقف شد.

استفاده از continue به ما این امکان را می‌دهد که در صورت بروز شرایط خاصی، بخش باقی‌مانده‌ی کد یک تکرار را نادیده گرفته و به تکرار بعدی برویم.