کار با رشته‌ها (Strings)

تعریف و استفاده از رشته‌ها

در کاتلین، رشته‌ها(Strings) نوعی از داده‌ها هستند که برای ذخیره و کار با متن استفاده می‌شوند. رشته‌ها در کاتلین با نقل‌قول‌های دوتایی (`” “`) تعریف می‌شوند و شامل مجموعه‌ای از کاراکترها هستند.

تعریف رشته در کاتلین

در کاتلین، رشته‌ها می‌توانند ثابت یا متغیر باشند. برای تعریف رشته ثابت از `val` و برای رشته متغیر از `var` استفاده می‌شود.

fun main() {
    val greeting: String = "Hello, Kotlin!"
    println(greeting)
}

در این مثال، `greeting` یک رشته است که مقدار `”Hello, Kotlin!”` به آن اختصاص داده شده است.

دسترسی به کاراکترهای یک رشته
هر کاراکتر در رشته دارای یک **اندیس** است که از ۰ شروع می‌شود. می‌توان با استفاده از اندیس به هر کاراکتر در رشته دسترسی داشت.

fun main() {
    val text = "Kotlin"
    println(text[0])  // خروجی: K
    println(text[1])  // خروجی: o
}

طول یک رشته

برای به دست آوردن تعداد کاراکترهای یک رشته، می‌توان از ویژگی `length` استفاده کرد.

fun main() {
    val text = "Kotlin"
    println("Length of text: ${text.length}") // خروجی: 6
}

الحاق رشته‌ها (String Concatenation)

برای الحاق یا ترکیب دو رشته می‌توان از عملگر `+` استفاده کرد.

fun main() {
    val firstName = "John"
    val lastName = "Doe"
    val fullName = firstName + " " + lastName
    println(fullName) // خروجی: John Doe
}

 رشته‌های چندخطی (Multiline Strings)

در کاتلین، می‌توان از رشته‌های چندخطی با استفاده از نقل‌قول‌های سه‌گانه (`””” “””`) استفاده کرد. این نوع رشته‌ها به شما اجازه می‌دهند تا متن را بدون نیاز به نویسه‌های فرار (Escape) در چند خط بنویسید.

fun main() {
    val multilineText = """
        Kotlin is a modern, concise language.
        It is designed for interoperation with Java.
    """
    println(multilineText)
}

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

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

1. `uppercase()` و `lowercase()`: برای تبدیل تمام حروف رشته به حروف بزرگ یا کوچک.

fun main() {
    val text = "Kotlin"
    println(text.uppercase()) // خروجی: KOTLIN
    println(text.lowercase()) // خروجی: kotlin
}

2. `substring(startIndex, endIndex)`: برای استخراج قسمتی از رشته با استفاده از اندیس‌ها.

fun main() {
    val text = "Kotlin Language"
    println(text.substring(0, 6)) // خروجی: Kotlin
}

3. `contains(substring)`: بررسی می‌کند که آیا رشته حاوی زیررشته مشخصی است یا خیر.

fun main() {
    val text = "Hello Kotlin"
    println(text.contains("Kotlin")) // خروجی: true
}

4.`replace(oldValue, newValue)`: جایگزینی قسمتی از رشته با یک مقدار جدید.

fun main() {
    val text = "Hello Kotlin"
    println(text.replace("Kotlin", "World")) // خروجی: Hello World
}

5. `trim(): حذف فاصله‌های خالی از ابتدا و انتهای رشته.

fun main() {
    val text = "   Kotlin   "
    println(text.trim()) // خروجی: Kotlin
}

 مثال جامع: کار با رشته‌ها

در این مثال، از چندین ویژگی و تابع برای پردازش یک رشته استفاده می‌کنیم:

fun main() {
    val rawText = "   Kotlin Programming Language   "
    val formattedText = rawText.trim().replace(" ", "-").uppercase()

    println("Original Text: '$rawText'")
    println("Formatted Text: '$formattedText'")
}

خروجی:

Original Text: '   Kotlin Programming Language   '
Formatted Text: 'KOTLIN-PROGRAMMING-LANGUAGE'

قالب دهی رشته ها:

الگوهای رشته‌ای (String Templates) در کاتلین: روشی ساده و کارآمد برای مدیریت رشته‌ها

در زبان برنامه‌نویسی کاتلین، برای افزودن متغیرها و عبارات درون یک رشته، روش ساده‌ای به نام *الگوهای رشته‌ای* یا *String Templates* وجود دارد. الگوهای رشته‌ای یکی از قابلیت‌های برجسته و بسیار کارآمد کاتلین است که به برنامه‌نویسان کمک می‌کند تا بدون نیاز به الحاق رشته‌ها (Concatenation)، به راحتی متغیرها و عبارات را درون رشته‌ها قرار دهند. در این مقاله، به طور جامع به معرفی این الگوها و نحوه استفاده از آن‌ها می‌پردازیم.

1. آشنایی با الگوهای رشته‌ای در کاتلین

در زبان‌های برنامه‌نویسی، معمولاً برای اضافه کردن متغیرها به یک رشته از عملگر `+` استفاده می‌شود. این روش معمولاً طولانی و مستعد خطا است. در کاتلین، الگوهای رشته‌ای به شما این امکان را می‌دهد که با قرار دادن نماد `$` قبل از نام متغیر، آن متغیر را درون رشته قرار دهید. این کار خوانایی کد را افزایش می‌دهد و از پیچیدگی آن می‌کاهد.

2. نحوه استفاده از الگوهای رشته‌ای

برای استفاده از الگوهای رشته‌ای، کافی است قبل از نام متغیر، علامت `$` را قرار دهید. در صورتی که بخواهید از یک عبارت کامل استفاده کنید، آن را داخل `{}` قرار می‌دهید. به عنوان مثال، فرض کنید دو متغیر `firstName` و `lastName` داریم که می‌خواهیم نام کامل فرد را در قالب یک رشته نمایش دهیم:

val firstName = "علی"
val lastName = "محمدی"
println("نام کامل: $firstName $lastName")

خروجی:

نام کامل: علی محمدی

 3. استفاده از عبارات در الگوهای رشته‌ای

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

val a = 5
val b = 3
println("مجموع $a و $b برابر است با ${a + b}.")

 4. کاربردهای الگوهای رشته‌ای

الگوهای رشته‌ای در کاتلین کاربردهای متنوعی دارند، از جمله:
– تولید رشته‌های پویا: می‌توانید رشته‌هایی را تولید کنید که بر اساس شرایط مختلف، محتوای متفاوتی داشته باشند.
– افزایش خوانایی کد: با الگوهای رشته‌ای، می‌توانید از الحاق‌های پی‌در‌پی رشته‌ها و استفاده از عملگر `+` اجتناب کنید، که این باعث خواناتر شدن کد می‌شود.
– کاهش خطاهای برنامه‌نویسی: با استفاده از این الگوها، احتمال بروز خطاهایی که معمولاً در الحاق رشته‌ها اتفاق می‌افتد، کاهش می‌یابد.

5. مثال‌های بیشتر از الگوهای رشته‌ای

در این بخش، چند مثال بیشتر از نحوه استفاده از الگوهای رشته‌ای ارائه می‌دهیم:

مثال ۱: رشته پویا بر اساس شرط

val age = 20
println("سن شما ${if (age >= 18) "بزرگسال" else "نوجوان"} است.")

خروجی:

سن شما بزرگسال است.

مثال ۲: استفاده از توابع در رشته

fun greet(name: String) = "سلام، $name!"
println(greet("زهرا"))

خروجی:

سلام، زهرا!

6. تفاوت الگوهای رشته‌ای با الحاق رشته‌ها

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

توابع کار با رشته‌ها (Substring، Replace، Split)

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

1. تابع `length`

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

val text = "Hello, Kotlin!"
println("طول رشته: ${text.length}")

خروجی:

طول رشته: 13

2. تابع `toUpperCase` و `toLowerCase`

این دو تابع برای تبدیل حروف رشته به حروف بزرگ یا کوچک استفاده می‌شوند.

val text = "Hello, World!"
println(text.toUpperCase()) // "HELLO, WORLD!"
println(text.toLowerCase()) // "hello, world!"

 3. تابع `trim`

برای حذف فضاهای خالی از ابتدای و انتهای رشته می‌توانید از `trim` استفاده کنید.

val text = "   Kotlin   "
println("[$text]") // "[   Kotlin   ]"
println("[${text.trim()}]") // "[Kotlin]"

4. تابع `substring`

این تابع برای استخراج زیررشته (Sub-string) از رشته اصلی استفاده می‌شود. شما می‌توانید یک بازه از رشته را مشخص کنید تا فقط آن بخش از رشته بازگردانده شود.

val text = "Hello, Kotlin!"
println(text.replace("Kotlin", "World")) // "Hello, World!"

5. تابع `replace`

برای جایگزینی بخشی از یک رشته با یک متن دیگر می‌توانید از `replace` استفاده کنید.

val text = "Hello, Kotlin!"
println(text.replace("Kotlin", "World")) // "Hello, World!"

6. تابع `contains`

این تابع بررسی می‌کند که آیا رشته‌ای حاوی یک زیررشته خاص است یا خیر. این تابع یک مقدار `Boolean` برمی‌گرداند.

val text = "Hello, Kotlin!"
println(text.contains("Kotlin")) // true
println(text.contains("Java")) // false

7. تابع `startsWith` و `endsWith`

این توابع بررسی می‌کنند که آیا یک رشته با یک زیررشته خاص شروع یا پایان می‌یابد یا خیر.

val text = "Hello, Kotlin!"
println(text.startsWith("Hello")) // true
println(text.endsWith("Kotlin!")) // true

 8. تابع `split`

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

val text = "Kotlin is fun"
val words = text.split(" ")
println(words) // [Kotlin, is, fun]

9. تابع `indexOf`

برای پیدا کردن موقعیت اولین باری که یک زیررشته درون یک رشته ظاهر می‌شود، از `indexOf` استفاده می‌شود. اگر زیررشته یافت نشود، این تابع `-1` برمی‌گرداند.

val text = "Hello, Kotlin!"
println(text.indexOf("Kotlin")) // 7
println(text.indexOf("Java")) // -1

10. تابع `isEmpty` و `isBlank`

این دو تابع بررسی می‌کنند که آیا رشته خالی است یا فقط از فضاهای خالی تشکیل شده است.

val emptyText = ""
val blankText = "   "
println(emptyText.isEmpty()) // true
println(blankText.isBlank()) // true

11. تابع `reversed`

برای برعکس کردن کاراکترهای یک رشته، از `reversed` استفاده می‌شود.

val text = "Kotlin"
println(text.reversed()) // "niltok"

 12. تابع `joinToString`

این تابع برای اتصال عناصر یک لیست یا آرایه به یک رشته استفاده می‌شود. این تابع یک جداکننده به عنوان پارامتر دریافت می‌کند.

val words = listOf("Kotlin", "is", "fun")
println(words.joinToString(" ")) // "Kotlin is fun"

 13. تابع `format`

با استفاده از `String.format`، می‌توانید رشته‌ها را با قالب‌بندی‌های خاص ایجاد کنید.

val name = "Ali"
val age = 25
println("نام: %s و سن: %d".format(name, age)) // "نام: Ali و سن: 25"

14. تابع `repeat`

این تابع رشته را به تعداد مشخصی تکرار می‌کند و رشته‌ای جدید با این تکرارها بازمی‌گرداند.

val text = "Kotlin"
println(text.repeat(3)) // "KotlinKotlinKotlin"