آموزش توابع و اصول برنامه‌نویسی تابعی

آموزش توابع در کاتلین، توابع (Functions) بخش‌هایی از کد هستند که می‌توانند برای انجام یک عملیات خاص نوشته شوند و تنها زمانی اجرا می‌شوند که فراخوانی شوند. توابع به ما این امکان را می‌دهند که کدهای تکراری را به بخش‌های کوچک‌تر تقسیم کرده و هر بار که نیاز داشتیم، آن‌ها را فراخوانی کنیم. همچنین می‌توانیم داده‌ها (یا پارامترها) را به توابع ارسال کنیم تا با استفاده از آن‌ها عملیات مشخصی انجام دهند.

تعریف و استفاده از توابع

تعریف توابع در کاتلین

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

fun functionName(parameters): ReturnType {
    // کدی که باید اجرا شود
}

functionName: نام تابع.
parameters: پارامترهایی که به تابع ارسال می‌شوند.
ReturnType: نوع خروجی تابع (در صورتی که تابع مقداری برنگرداند، از Unit استفاده می‌شود).
مثال ساده از یک تابع در کاتلین
در اینجا یک تابع به نام sayHello تعریف می‌کنیم که پیامی را در خروجی چاپ می‌کند:

fun sayHello() {
    println("سلام!")
}

fun main() {
    sayHello()
}

سلام!

توابع با پارامتر

می‌توانیم توابعی تعریف کنیم که پارامترهایی دریافت کنند. در این مثال، تابع greet یک نام به عنوان پارامتر دریافت کرده و آن را در پیام خوش‌آمدگویی چاپ می‌کند.

fun greet(name: String) {
    println("سلام، $name!")
}

fun main() {
    greet("علی")
    greet("سارا")
}

سلام، علی!
سلام، سارا!

توابع با مقدار بازگشتی

در کاتلین، می‌توان توابعی تعریف کرد که یک مقدار را به عنوان نتیجه برگردانند. به عنوان مثال، تابع زیر دو عدد را به عنوان ورودی می‌گیرد و مجموع آن‌ها را برمی‌گرداند:

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    val sum = add(5, 3)
    println("مجموع: $sum")
}

مجموع: 8

توابع از پیش تعریف شده در کاتلین

در کاتلین، توابعی از پیش تعریف شده وجود دارند که کاتلین به صورت پیش‌فرض ارائه داده است. برخی از این توابع شامل println، toString، maxOf و غیره هستند. برای مثال، تابع println یک رشته را در کنسول چاپ می‌کند و maxOf بیشترین مقدار را بین دو عدد بازمی‌گرداند:

fun main() {
    println("این یک پیام است.")

    val max = maxOf(10, 20)
    println("بیشترین عدد: $max")
}

این یک پیام است.
بیشترین عدد: 20

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

 

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

 

توابع داخلی (Standard Library Functions)

 

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

مثال‌هایی از توابع داخلی در کاتلین

تابع `println`

تابع `println` یک رشته یا مقدار را در خروجی چاپ می‌کند و سپس به خط بعدی می‌رود:

fun main() {
    println("سلام، کاتلین!")
}

سلام، کاتلین!

توابع ریاضی (Math Functions)

کاتلین شامل مجموعه‌ای از توابع داخلی ریاضی است که در عملیات محاسباتی کمک می‌کند:

– `maxOf(a, b)`: بزرگترین مقدار بین `a` و `b` را برمی‌گرداند.
– `minOf(a, b)`: کوچکترین مقدار بین `a` و `b` را برمی‌گرداند.
– `sqrt(x)`: جذر عدد `x` را برمی‌گرداند.

import kotlin.math.sqrt

fun main() {
    val max = maxOf(10, 20)
    println("بزرگترین عدد: $max")

    val min = minOf(5, 8)
    println("کوچکترین عدد: $min")

    val root = sqrt(25.0)
    println("جذر عدد 25: $root")
}

بزرگترین عدد: 20
کوچکترین عدد: 5
جذر عدد 25: 5.0

توابع کار با رشته‌ها (String Functions)

کاتلین دارای توابع داخلی مختلفی برای کار با رشته‌ها است:

– `length`: طول یک رشته را برمی‌گرداند.
– `uppercase()`: یک رشته را به حروف بزرگ تبدیل می‌کند.
– `lowercase()`: یک رشته را به حروف کوچک تبدیل می‌کند.
– `contains(substring)`: بررسی می‌کند که آیا یک رشته شامل زیررشته‌ای خاص است یا خیر.

fun main() {
    val text = "Hello, Kotlin!"

    println("طول رشته: ${text.length}")
    println("حروف بزرگ: ${text.uppercase()}")
    println("حروف کوچک: ${text.lowercase()}")
    println("شامل 'Kotlin': ${text.contains("Kotlin")}")
}

طول رشته: 13
حروف بزرگ: HELLO, KOTLIN!
حروف کوچک: hello, kotlin!
شامل 'Kotlin': true

 توابع کار با لیست‌ها (List Functions)

توابع داخلی کاتلین برای کار با لیست‌ها، پردازش داده‌ها را آسان‌تر می‌کنند:

– `listOf(…)`: یک لیست ایجاد می‌کند.

fun main() {
    val numbers = listOf(5, 2, 8, 1, 4)

    println("لیست مرتب شده: ${numbers.sorted()}")
    println("لیست معکوس: ${numbers.reversed()}")
    println("اعداد بزرگتر از 3: ${numbers.filter { it > 3 }}")
}

لیست مرتب شده: [1, 2, 4, 5, 8]
لیست معکوس: [4, 1, 8, 2, 5]
اعداد بزرگتر از 3: [5, 8, 4]

– `sorted()`: لیست را به ترتیب صعودی مرتب می‌کند.
– `reversed()`: لیست را معکوس می‌کند.
– `filter { … }`: فیلتر کردن لیست بر اساس شرطی خاص.

 

 تابع `map`

تابع `map` یکی از توابع پرکاربرد در کاتلین است که روی هر عنصر از مجموعه عملی انجام داده و نتیجه را به صورت لیست برمی‌گرداند:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    val doubled = numbers.map { it * 2 }
    println("دو برابر اعداد: $doubled")
}

دو برابر اعداد: [2, 4, 6, 8, 10]

 

توابع داخلی کاتلین به ما کمک می‌کنند که کارهای متداول و عملیات پردازشی را به صورت کارآمد و ساده انجام دهیم. این توابع شامل توابع ریاضی، رشته‌ای، لیستی، و بسیاری دیگر هستند که باعث می‌شوند کد کوتاه‌تر و خواناتر شود

توابع بالا مرتبه (Higher-Order Functions)

توابعی هستند که می‌توانند دیگر توابع را به عنوان پارامتر بپذیرند یا توابع را به عنوان نتیجه برگردانند. این ویژگی به ما اجازه می‌دهد تا توابع را به شیوه‌ای کارآمد و انعطاف‌پذیرتر استفاده کنیم. توابع بالا مرتبه می‌توانند در طراحی کد و پیاده‌سازی الگوهای برنامه‌نویسی مفید باشند.

تعریف توابع بالا مرتبه
یک تابع بالا مرتبه می‌تواند:

یک یا چند تابع را به عنوان پارامتر بپذیرد.
یک تابع را به عنوان نتیجه برگرداند.
مثال‌های توابع بالا مرتبه

تابعی که دیگر توابع را به عنوان پارامتر می‌پذیرد

در این مثال، تابع operate یک تابع به عنوان پارامتر دریافت می‌کند و روی دو عدد عملیاتی را انجام می‌دهد:

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val sum = operate(10, 5) { x, y -> x + y }
    val product = operate(10, 5) { x, y -> x * y }
    
    println("مجموع: $sum")
    println("محصول: $product")
}

مجموع: 15
محصول: 50

تابع operate سه پارامتر دارد: دو عدد (a و b) و یک تابع (operation) که دو عدد را می‌پذیرد و یک عدد برمی‌گرداند.
در main، ما از operate برای انجام عملیات جمع و ضرب استفاده می‌کنیم و توابع مربوطه را به آن ارسال می‌کنیم.

تابعی که یک تابع را به عنوان نتیجه برمی‌گرداند

در این مثال، تابع createIncrementer یک تابع جدید ایجاد می‌کند که به مقدار ورودی increment اضافه می‌کند:

fun createIncrementer(increment: Int): (Int) -> Int {
    return { number: Int -> number + increment }
}

fun main() {
    val incrementBy2 = createIncrementer(2)
    val incrementBy5 = createIncrementer(5)

    println("2 + 3 = ${incrementBy2(3)}") // 5
    println("5 + 10 = ${incrementBy5(10)}") // 15
}

2 + 3 = 5
5 + 10 = 15

تابع createIncrementer یک تابع داخلی ایجاد می‌کند که مقدار ورودی را با مقدار increment جمع می‌کند.
در main، ما دو تابع جدید (incrementBy2 و incrementBy5) ایجاد می‌کنیم و از آن‌ها برای افزایش اعداد استفاده می‌کنیم.

استفاده از توابع بالا مرتبه با لیست‌ها

کاتلین توابعی مانند map, filter, و fold را برای پردازش مجموعه‌ها به صورت توابع بالا مرتبه ارائه می‌دهد. در اینجا مثالی از استفاده از map و filter آورده شده است:

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

    // استفاده از تابع map برای دو برابر کردن اعداد
    val doubled = numbers.map { it * 2 }
    println("اعداد دو برابر شده: $doubled") // [2, 4, 6, 8, 10, 12]

    // استفاده از تابع filter برای گرفتن اعداد زوج
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("اعداد زوج: $evenNumbers") // [2, 4, 6]
}

اعداد دو برابر شده: [2, 4, 6, 8, 10, 12]
اعداد زوج: [2, 4, 6]

map یک تابع بالا مرتبه است که بر روی هر عنصر از لیست numbers عمل دو برابر کردن را انجام می‌دهد.
filter نیز یک تابع بالا مرتبه است که تنها عناصری را که زوج هستند، به ما برمی‌گرداند.
جمع‌بندی
توابع بالا مرتبه در کاتلین ابزارهای قدرتمندی برای ایجاد کدهای تمیز و قابل استفاده مجدد هستند. آن‌ها به ما این امکان را می‌دهند که از توابع به عنوان پارامترها یا نتایج استفاده کنیم و عملیات مختلف را به راحتی روی مجموعه‌ها انجام دهیم. این ویژگی‌ها به ما کمک می‌کنند تا از کدهای تکراری جلوگیری کنیم و منطق برنامه را بهتر سازماندهی کنیم.

برنامه‌نویسی تابعی (Functional Programming)

یکی از الگوهای برنامه‌نویسی است که در آن محاسبات به صورت توابع تعریف می‌شوند. در کاتلین، شما می‌توانید از این الگو برای نوشتن کدهای تمیزتر و خواناتر استفاده کنید. ویژگی‌های کلیدی برنامه‌نویسی تابعی شامل استفاده از توابع بالا مرتبه، عدم تغییر حالت (Immutable State) و برنامه‌نویسی بر اساس توابع خالص (Pure Functions) است.

ویژگی‌های برنامه‌نویسی تابعی در کاتلین

توابع خالص:

توابعی که برای ورودی‌های یکسان همیشه خروجی یکسانی دارند و هیچ تاثیری بر روی حالت برنامه ندارند.

توابع بالا مرتبه:

توابعی که می‌توانند توابع دیگر را به عنوان پارامتر بپذیرند یا توابعی را به عنوان نتیجه برگردانند.

عدم تغییر حالت:

استفاده از داده‌های غیر قابل تغییر (Immutable Data) که باعث کاهش خطاهای ناشی از تغییر ناخواسته داده‌ها می‌شود.

عملگرها و توابع کاربردی:

توابعی که می‌توانند روی داده‌ها اعمال شوند، مانند map, filter, و reduce.

مثال‌هایی از برنامه‌نویسی تابعی در کاتلین
توابع خالص
یک تابع خالص مثالی از جمع دو عدد است:

fun add(a: Int, b: Int): Int {
    return a + b
}

fun main() {
    println("جمع 2 و 3: ${add(2, 3)}") // 5
    println("جمع 2 و 3: ${add(2, 3)}") // 5
}

 

این تابع برای ورودی‌های یکسان (۲ و ۳) همیشه خروجی یکسانی (۵) خواهد داشت و هیچ تاثیری بر روی حالت برنامه ندارد.

توابع بالا مرتبه
در این مثال، یک تابع بالا مرتبه برای اعمال یک عمل خاص به لیست اعداد ایجاد می‌کنیم

fun applyOperation(numbers: List<Int>, operation: (Int) -> Int): List<Int> {
    return numbers.map(operation)
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)
    
    // افزایش هر عدد به ۱۰
    val increased = applyOperation(numbers) { it + 10 }
    println("اعداد افزایش یافته: $increased") // [11, 12, 13, 14, 15]
}

در اینجا:

تابع applyOperation یک لیست از اعداد و یک تابع به عنوان پارامتر می‌گیرد و آن تابع را به هر عنصر لیست اعمال می‌کند.
استفاده از توابع map، filter و reduce
کاتلین به طور پیش‌فرض توابع مفیدی برای پردازش مجموعه‌ها ارائه می‌دهد

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

    // استفاده از map برای دو برابر کردن اعداد
    val doubled = numbers.map { it * 2 }
    println("اعداد دو برابر شده: $doubled") // [2, 4, 6, 8, 10, 12]

    // استفاده از filter برای گرفتن اعداد زوج
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("اعداد زوج: $evenNumbers") // [2, 4, 6]

    // استفاده از reduce برای محاسبه مجموع
    val sum = numbers.reduce { acc, number -> acc + number }
    println("مجموع اعداد: $sum") // 21
}

map برای دو برابر کردن اعداد استفاده می‌شود.
filter تنها اعداد زوج را بازمی‌گرداند.
reduce برای محاسبه مجموع تمامی اعداد استفاده می‌شود.
داده‌های غیر قابل تغییر (Immutable Data)
در برنامه‌نویسی تابعی، معمولاً از داده‌های غیر قابل تغییر استفاده می‌شود. به عنوان مثال، ما می‌توانیم لیستی از اعداد را ایجاد کرده و سپس بدون تغییر آن، لیست جدیدی ایجاد کنیم:

fun main() {
    val originalList = listOf(1, 2, 3)

    // ایجاد یک لیست جدید با افزودن یک عنصر
    val newList = originalList + 4

    println("لیست اصلی: $originalList") // [1, 2, 3]
    println("لیست جدید: $newList") // [1, 2, 3, 4]
}

originalList تغییر نمی‌کند و ما یک لیست جدید newList ایجاد می‌کنیم.

برنامه‌نویسی تابعی در کاتلین به ما این امکان را می‌دهد که کدهای قابل فهم‌تر و تست‌پذیرتری بنویسیم. با استفاده از توابع خالص، توابع بالا مرتبه، و داده‌های غیر قابل تغییر، می‌توانیم از خطاهای ناشی از تغییر ناخواسته داده‌ها جلوگیری کنیم و کدهای خود را به صورت کارآمد و منظم‌تری سازمان‌دهی کنیم. این الگو به ویژه در توسعه نرم‌افزارهای بزرگ و پیچیده بسیار مفید است.