Kotlin: شرح بنية كوتلن الأساسية

// سيئ: حالة مشتركة قابلة للتغيير
var orderCount = 0  // سباق شرطي!

// جيد: ثابت + خط أنابيب وظيفي
val processedOrders = orders
    .filter { it.status == "CONFIRMED" }
    .also { println("Processed ${it.size} orders") }

// val: للقراءة فقط (مرجع ثابت) - مُفضَّل
val orderId = "ORD-001"         // نوع مستدل كـ String
val total: Double = 299.99      // نوع صريح

// var: قابل للتغيير (قابل لإعادة التعيين) - استخدم باعتدال
var status = "PENDING"          // يمكن إعادة تعيينه
status = "CONFIRMED"            // موافق

// val لا يعني أن الكائن ثابت
val items = mutableListOf<Order>()  // المرجع val، القائمة قابلة للتغيير
items.add(Order("ORD-002", 150.0, "NEW"))  // موافق - تعديل القائمة
// items = mutableListOf()  // خطأ - لا يمكن إعادة تعيين val

val orderId = "ORD-001"
val total = 299.99

// إشارة متغيرة بسيطة
println("Order: $orderId")

// تعبير في القالب
println("Total: \$$total USD")
println("Tax: \$${total * 0.08} USD")

// أي تعبير مع ${}
val items = listOf("Widget", "Gadget")
println("Item count: ${items.size}, First: ${items[0]}")

val receipt = """
    |Order ID: ORD-001
    |Total: $299.99 USD
    |Status: CONFIRMED
""".trimMargin()

// بديل: trimIndent
val json = """
    {
      "order_id": "ORD-001",
      "total": 299.99
    }
""".trimIndent()

// when كتعبير (يجب أن يكون شاملاً)
val status = "CONFIRMED"
val label = when (status) {
    "PENDING" -> "Waiting for payment"
    "CONFIRMED" -> "Payment received"
    "SHIPPED" -> "In transit"
    "CANCELLED" -> "Order cancelled"
    else -> "Unknown status"
}

// قيم متعددة
when (status) {
    "PENDING", "NEW" -> processNewOrder()
    in listOf("CONFIRMED", "PAID") -> shipOrder()
    else -> handleOther()
}

// مطابقة النطاق
val quantity = 150
when (quantity) {
    in 1..10 -> println("Small order")
    in 11..100 -> println("Medium order")
    in 101..1_000 -> println("Large order")
    else -> println("Bulk order")
}

// مطابقة النوع
fun describe(obj: Any): String = when (obj) {
    is String -> "String of length ${obj.length}"
    is Int -> "Integer: $obj"
    is List<*> -> "List with ${obj.size} elements"
    else -> "Unknown type"
}

// نطاق مغلق: يشمل كلا الطرفين
for (i in 1..5) print("$i ")  // 1 2 3 4 5

// نطاق نصف مفتوح: يستبعد الطرف
for (i in 1 until 5) print("$i ")  // 1 2 3 4

// خطوة
for (i in 1..10 step 2) print("$i ")  // 1 3 5 7 9

// تنازلي
for (i in 5 downTo 1) print("$i ")  // 5 4 3 2 1

// نطاق أحرف
for (c in 'A'..'E') print("$c ")  // A B C D E

val orders = listOf(
    Order("ORD-001", 299.99),
    Order("ORD-002", 1_500.00),
    Order("ORD-003", 45.50)
)

// تكرار مع فهرس
for ((index, order) in orders.withIndex()) {
    println("[$index] ${order.id}: \$${order.total} USD")
}

// تكرار الخريطة
val statusMap = mapOf("ORD-001" to "SHIPPED", "ORD-002" to "PENDING")
for ((id, status) in statusMap) {
    println("$id -> $status")
}

// جسم كتلة
fun calculateTax(total: Double): Double {
    return total * 0.08
}

// جسم تعبير (أكثر إيجازًا)
fun calculateTax(total: Double): Double = total * 0.08

// استدلال النوع مع جسم التعبير
fun calculateTax(total: Double) = total * 0.08

// 1. الفواصل المنقوطة اختيارية
val x = 1  // لا حاجة لفاصلة منقوطة

// 2. اصطلاح lambda الخلفي
orders.filter { it.total > 1_000 }  // lambda خارج الأقواس

// 3. كلمة it لـ lambda ذات المعامل الواحد
orders.map { it.id }  // 'it' = معامل ضمني

// 4. قالب سلسلة بدلاً من الوصل
val msg = "Order $orderId confirmed"  // ليس "Order " + orderId + " confirmed"

// 5. جسم تعبير للدوال البسيطة
fun isHighValue(order: Order) = order.total > 10_000

// ============================================
// OrderProcessor - محرك توجيه الطلبات
// الميزة: توجيه الطلبات بناءً على الحالة والقيمة
// ============================================

data class Order(val id: String, val total: Double, val status: String)

fun routeOrder(order: Order): String = when {
    order.status == "CANCELLED" -> "REFUND_QUEUE"
    order.total > 10_000 -> "VIP_PIPELINE"
    order.total > 1_000 -> "PRIORITY_PIPELINE"
    order.status == "CONFIRMED" -> "STANDARD_PIPELINE"
    order.status in listOf("PENDING", "NEW") -> "WAITING_QUEUE"
    else -> "MANUAL_REVIEW"
}

fun processBatch(orders: List<Order>) {
    for ((index, order) in orders.withIndex()) {
        val pipeline = routeOrder(order)
        val priority = when (pipeline) {
            "VIP_PIPELINE" -> "CRITICAL"
            "PRIORITY_PIPELINE" -> "HIGH"
            "STANDARD_PIPELINE" -> "NORMAL"
            else -> "LOW"
        }
        println("[${index + 1}] ${order.id} -> $pipeline (Priority: $priority)")
    }
}

fun main() {
    val orders = listOf(
        Order("ORD-001", 299.99, "CONFIRMED"),
        Order("ORD-002", 15_000.00, "CONFIRMED"),
        Order("ORD-003", 2_500.00, "PENDING"),
        Order("ORD-004", 45.50, "CANCELLED"),
        Order("ORD-005", 750.00, "NEW")
    )

    println("=== Order Routing Report ===")
    processBatch(orders)

    // ملخص مع خط أنابيب وظيفي
    val pipelineCounts = orders
        .map { routeOrder(it) }
        .groupingBy { it }
        .eachCount()

    println("\n=== Pipeline Distribution ===")
    for ((pipeline, count) in pipelineCounts) {
        println("  $pipeline: $count orders")
    }
}

=== Order Routing Report ===
[1] ORD-001 -> STANDARD_PIPELINE (Priority: NORMAL)
[2] ORD-002 -> VIP_PIPELINE (Priority: CRITICAL)
[3] ORD-003 -> PRIORITY_PIPELINE (Priority: HIGH)
[4] ORD-004 -> REFUND_QUEUE (Priority: LOW)
[5] ORD-005 -> WAITING_QUEUE (Priority: LOW)

=== Pipeline Distribution ===
  STANDARD_PIPELINE: 1 orders
  VIP_PIPELINE: 1 orders
  PRIORITY_PIPELINE: 1 orders
  REFUND_QUEUE: 1 orders
  WAITING_QUEUE: 1 orders

val name = "Alice"  // ثابت
var age = 30        // قابل للتغيير
age = 31            // موافق
// name = "Bob"     // خطأ ترجمة

يُترجَل؛ إعادة تعيين name تفشل

val score = 85
val grade = when {
    score >= 90 -> "A"
    score >= 80 -> "B"
    else -> "C"
}
println(grade)

B

for (i in 1..3) println(i)
for (s in listOf("a", "b")) println(s)

1
2
3
a
b

val name = "Alice"
val orders = 1500
val revenue = 89500.50

val summary = """
    |== تقرير المستخدم ==
    |  الاسم    : $name
    |  الطلبات  : $orders
    |  الإيراد  : \$${revenue} USD
    |  المتوسط  : \$${revenue / orders} USD
    |================
""".trimMargin()
println(summary)

|== تقرير المستخدم ==
|  الاسم    : Alice
|  الطلبات  : 1500
|  الإيراد  : $89500.5 USD
|  المتوسط  : $59.66699999999999 USD
|================

// نطاق تصاعدي مع step
for (i in 1..10 step 2) print("$i ")
println()

// نطاق تنازلي
for (i in 5 downTo 1) print("$i ")
println()

// نصف مفتوح مع until
for (i in 0 until 5) print("$i ")

1 3 5 7 9
5 4 3 2 1
0 1 2 3 4

// جسم كتلة — متعدد الأسطر
fun describeOrder(status: String): String {
    return when (status) {
        "CONFIRMED" -> "تم التأكيد"
        "SHIPPED" -> "تم الشحن"
        "DELIVERED" -> "تم التسليم"
        "CANCELLED" -> "ملغي"
        else -> "غير معروف"
    }
}

// جسم تعبير — سطر واحد
fun isVip(total: Double) = total > 10_000

// دالة بدون قيمة مرجعة (Unit)
fun logOrder(id: String): Unit = println("Logged: $id")

println(describeOrder("CONFIRMED"))
println("VIP: ${isVip(15_000.0)}")
logOrder("ORD-001")

تم التأكيد
VIP: true
Logged: ORD-001

fun describeValue(v: Any?): String = when (v) {
    null -> "القيمة فارغة"
    is String -> "نص بطول ${v.length}: $v"
    is Int -> if (v > 0) "عدد موجب" else "عدد غير موجب"
    is List<*> -> "قائمة بـ ${v.size} عناصر"
    else -> "نوع غير معروف: ${v::class.simpleName}"
}

println(describeValue(null))
println(describeValue("مرحبا"))
println(describeValue(42))
println(describeValue(listOf(1, 2, 3)))

القيمة فارغة
نص بطول 6: مرحبا
عدد موجب
قائمة بـ 3 عناصر