عرض مصدر Kotlin/basic types

<noinclude>{{DISPLAYTITLE:أنواع البيانات (Data Types) في Kotlin}}</noinclude>
إن كلَّ عنصرٍ في Kotlin يعد كائنًا إذ يمكن استدعاء الدوال (member functions) والخاصّيّات (properties) عبر أي متغيِّر (variable)، ولبعض الأنواع تمثيلها الداخلي الخاص بها؛ فعلى سبيل المثال تُمثَّل الأعداد والمحارف والقيم المنطقية (boolean) كقيمٍ أساسيّةٍ أثناء التشغيل (runtime) ولكنها بالنسبة للمستخدم مجرّد أصنافٍ عادية، وتناقش هذه الصفحة الأنواع الرئيسيّة للبيانات في Kotlin وهي: الأعداد، والمحارف، والقيم المنطقية (boolean)، والمصفوفات، والسلاسل النصيّة.

== الأعداد (Numbers) ==
تتعامل لغة Kotlin مع البيانات العدديّة بطريقةٍ مماثلةٍ للغة Java ولكن بفوارق بسيطة، فلا تدعم مثلًا لغة Kotlin التحويل الضمني (implicit) (من نوع البيانات الأصغر إلى الأكبر [widening]) للأعداد وتختلف القيم المباشرة (literals) في بعض الحالات.

توفِّر Kotlin الأنواع الأساسيّة الآتية للتعبير عن الأعداد (وهي مشابهةٌ لما في لغة Java):
{| class="wikitable"
!النوع
!سعته (bit)
|-
|Double
|64
|-
|Float
|32
|-
|Long
|64
|-
|Int
|32
|-
|Short
|16
|-
|Byte
|8
|}
ولا تُعدُّ المحارفُ أرقامًا في Kotlin.

=== القيم المباشرة الثابتة (Literal Constants) ===
ولها الأنواع الآتية للأعداد الصحيحة:
* الأعداد العشرية (decimals) مثل: <code>123</code> وتُميَّز الأعداد العشرية الطويلة بالحرف <code>L</code> (بحالته الكبيرة فقط) لتصبح بالشكل: <code>123L</code>

* الأعداد الست عشرية (hexadecimal) مثل <code>0x0F</code>
* الأعداد الثنائية (binaries) مثل <code>0b00001011</code>
ولا تدعم لغة Kotlin القيم الثمانيّة (octal)، لكنّها تدعم التسمية الاصطلاحيّة (conventional notation) للأعداد ذات الفاصلة العائمة:
* من نوع Double (وهي الحالة الافتراضية) مثل: <code>123.5</code> و <code>123.5e10</code>
* من نوع Float (والتي تُلحَق بالحرف <code>f</code> أو <code>F</code>) مثل: <code>123.5f</code>

=== الشرطة السفلية (Underscore) في القيم العدديّة المباشرة (Numeric Literals) بدءًا من الإصدار 1.1 ===
تُستخدم الشرطة السفلية لتسهيل قراءة الأعداد الكبيرة مثل:<syntaxhighlight lang="kotlin">
val oneMillion = 1_000_000
val creditCardNumber = 1234_5678_9012_3456L
val socialSecurityNumber = 999_99_9999L
val hexBytes = 0xFF_EC_DE_5E
val bytes = 0b11010010_01101001_10010100_10010010
</syntaxhighlight>

=== تمثيل الأعداد (Representation) ===
تُخزَّن الأعداد فيزيائيًا في منصّة Java كأنواعٍ أساسيّة في JVM ما لم يكن هناك مرجعيّة nullable للعدد (مثل: Int?‎ ) أو لم يكن النوع generics مضمّنًا، حينئذٍ يتم تغليف الأعداد (boxed numbers) وهذا لا يحافظ بالضرورة على ماهيتها (identity)، كما في الشيفرة:<syntaxhighlight lang="kotlin">
val a: Int = 10000
print(a === a) // سيطبع true
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA === anotherBoxedA) // سيطبع false
</syntaxhighlight>ولكنه يحافظ  على التساوي بالقيمة (equality) (بالرمز <code>==</code>):<syntaxhighlight lang="kotlin">
val a: Int = 10000
print(a == a) // سيطبع true
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // أيضًا سيطبع true
</syntaxhighlight>

=== التحويل الصريح (Explicit Conversion) ===
لا تُعدُّ الأنواع الأصغر في لغة Kotlin أنواعًا فرعيةً (subtypes) من الأنواع الأكبر بسبب اختلاف طرائق تمثيل البيانات العددية بينها، وإن كانت كذلك فستنجم المشاكل الآتية:<syntaxhighlight lang="kotlin">
// هذه شيفرة وهمية ولن تعمل بشكل صحيح
val a: Int? = 1 // عدد صحيح مُغلَّف (java.lang.Integer)
val b: Long? = a // تحويل ضمني ينتج عنه نوع مغلَّف بنوع Long (java.lang.Long)
print(a == b)‎ // هذا سينتج عنه نتيجة false

</syntaxhighlight>والسبب بظهور نتيجة <code>false</code> في السطر الأخير من الشيفرة السابقة هو أنّ الدالة <code>equals</code> تتحقّق من كون المتغيِّر الآخر من نوع <code>Long</code> أيضًا وهذا غير محقّق، وبهذا فإننا لم نفقد فقط الماهيّة (identity) بل التساوي (equality) أيضًا، ولذلك لا تُحوَّل الأنواع الأصغر ضمنيًّا إلى الأنواع الأكبر، وبالتالي لا يُمكن إسناد قيمة من نوع <code>Byte</code> مثلًا إلى قيمة من نوع <code>Int</code> بدون التصريح عن ذلك التحويل، مثل:<syntaxhighlight lang="kotlin">
val b: Byte = 1 // لا مشكلة هنا
val i: Int = b // إسناد خاطئ
</syntaxhighlight>وبإضافة التحويل الصريح تصبح الشيفرة بالشكل:<syntaxhighlight lang="kotlin">
val i: Int = b.toInt() // تحويل صريح من النوع الأصغر للنوع الأكبر
</syntaxhighlight>ويمكن استخدام أيّ من التحويلات الآتية على الأعداد:
* <code>toByte()</code>‎: للتحويل إلى نوع <code>Byte</code>
* <code>toShort()‎</code>: للتحويل إلى نوع <code>Short</code>
* <code>toInt()</code>‎: للتحويل إلى نوع <code>Int</code>
* <code>toLong()‎</code>: للتحويل إلى نوع <code>Long</code>
* <code>toFloat()‎</code>: للتحويل إلى نوع <code>Float</code>
* <code>toDouble()‎</code>: للتحويل إلى نوع <code>Double</code>
* <code>toChar()‎</code>: للتحويل إلى نوع <code>Char</code>
وليس غياب التحويلات الضمنية (implicit) بمشكلة؛ لأنّ النوع يُخمَّن من خلال السياق، وكذلك لوجود زيادة تحميل (overloading) في العمليات الحسابية (arithmetical operations) بما يتوافق مع التحويل الأنسب لها، مثل:<syntaxhighlight lang="kotlin">
val l = 1L + 3 // Long + Int => Long
</syntaxhighlight>

=== العمليات (Operations) ===
تدعم Kotlin مجموعة العمليات الحسابيّة القياسيّة على الأعداد وهي مُعرَّفة كعناصر (members) في الأصناف المناسبة إذ يُؤقلِم المُترجم (compiler) الاستدعاءات بحسب التعليمات الموافقة. (راجع [[Kotlin/operator overloading|التحميل الزائد للمعاملات [Operator overloading]]])

أما في العمليات على مستوى الخانة (bitwise operations) فلا توجد محارف خاصةٌ بها بل مجرّد دوال يمكن استدعاؤها بالشكل الداخليّ (infix form)، مثل:<syntaxhighlight lang="kotlin">
val x = (1 shl 2) and 0x000FF000
</syntaxhighlight>وفيما يلي قائمةٌ بالعمليات الثنائيّة بمستوى الخانة (والمتاحة للنوعين <code>Int</code> و <code>Long</code> فقط)
* <code>shl(bits)‎</code> الإزاحة مع إشارة نحو اليسار (مثل المعامل <code>>></code> في Java)
* <code>shr(bits)‎</code> الإزاحة مع إشارة نحو اليمين (مثل المعامل <code><<</code> في Java)
* <code>ushr(bits)‎</code> الإزاحة بدون إشارة نحو اليمين (مثل المعامل <code><<<</code> في Java)
* <code>and(bits)‎</code> العملية المنطقية AND على مستوى الخانة الثنائية
* <code>or(bits)‎</code> العملية المنطقية OR على مستوى الخانة الثنائية
* <code>xor(bits)‎</code> العملية المنطقية XOR على مستوى الخانة الثنائية
* <code>inv()</code>‎ لعكس حالة الخانات الثنائية (NOT)

=== مقارنة الأعداد ذات الفاصلة العائمة (Floating Point Numbers) ===
تناقش هذه الفقرة عمليات المقارنة (بين الأعداد ذات الفاصلة العائمة) الآتية:
* التحقق من التساوي <code>a == b</code> وعدم التساوي <code>a != b</code>
* معاملات المقارنة <code>a < b</code> و <code>a > b</code> و <code>a <= b</code> و <code>a >= b</code>
* تمثيل المجالات والتحقق منها مثل <code>a..b و</code> <code>x in a..b و</code> <code>x !in a..b</code>
إذا كان كلٌّ من المعاملين (operands) على طرفي المعامل (<code>a</code> و<code>b</code>) من نوع <code>Float</code> أو <code>Double</code> أو ما يقابلهما من نوع nullable (يُصرَّح عن النوع أو يُخمَّن كنتيجةٍ عن التحويل [[[Kotlin/typecasts|smart cast]]])  فإن العمليات على الأعداد والمجالات تكون وفقًا للمقاييس IEEE 754 في العمليات الحسابيّة للأعداد ذات الفاصلة العائمة.

أمّا لدعم حالات الاستخدام المُعمّمة (generic use cases) وللتزويد بتنظيمٍ إجمالي عندما لا تكون المعاملات على طرفيّ المُعامِل معرَّفةً كأعدادٍ بفاصلةٍ عائمة (مثل <code>Any</code>أو <code>Comparable<...>‎</code> أو معامل نوع [type parameter]) فإنّ العمليات تعتمد على الدوال <code>equals</code> و <code>compareTo</code> للنوعين <code>Float</code> و <code>Double</code> ، وهذا لا يتوافق مع المعايير القياسيّة، وبالتالي:
* يعد <code>NaN</code> مساويًا لنفسه
* يعد <code>NaN</code> أكبر من أي عنصر آخر يتضمن  <code>POSITIVE_INFINITY</code>
* 0.0- (بقيمة سالبة) أصغر من 0.0 (بالقيمة الموجبة)

== المحارف (Characters) ==
إنّ النوع الذي تُخزَّن به المحارف هو <code>Char</code> ولا يُمكن التعامل معها مباشرةً كما هو الحال في البيانات العدديّة، مثلما في الشيفرة الآتية:<syntaxhighlight lang="kotlin">
fun check(c: Char) {
    if (c == 1) { // الخطأ هنا بعدم التوافق ما بين النوعين
        // ...
    }
}
</syntaxhighlight>يُحاط المحرف دائمًا بإشارتيّ تنصيصٍ أحاديتين مثل القيمة '1'، وتصبح لبعض المحارف دلالةٌ خاصّةٌ إذا سُبِقت بالرمز \ وذلك بهدف جعلها من بين المحارف escape sequence إذ تدعم لغة Kotlin المحارف الخاصّة: <code>‎\t</code> و ‎<code>\b</code> و ‎<code>\n</code> و <code>‎\r</code> و <code>‎\'‎</code> و <code>‎\"‎</code> و <code>\\</code> و <code>‎\$</code>‎، أمّا للتعبير عن شيفرة Unicode لأي محرفٍ آخر يستخدم المحرف ‎\u مثل: <code>‎'\uFF00'</code>‎.

ويُمكن تحويل المحرف إلى قيمةٍ عدديّةٍ صحيحةٍ <code>Int</code> بشكلٍ صريحٍ، كما هو موضَّح في الشيفرة الآتية:<syntaxhighlight lang="kotlin">
fun decimalDigitValue(c: Char): Int {
    if (c !in '0'..'9')
        throw IllegalArgumentException("Out of range")
    return c.toInt() - '0'.toInt() // تحويل صريح للقيمة العددية
}
</syntaxhighlight>و قد تُغلَّف المحارف (boxed character) -كما هو الحال في القيم العددية- عندما يتطلَّب الأمر وجودَ مرجعيّة nullable، حيث لا تحافظ عملية التغليف هذه على الماهيّة (identity).

== القيم المنطقيّة (Booleans) ==
يُعبِّر نوع البيانات <code>Boolean</code> عن البيانات المنطقية التي لها إحدى القيمتين: <code>true</code> أو <code>false</code>.

ويًمكن تغليف القيمة المنطقية (boxed boolean) عند الحاجة لمرجعيّة nullable.

العمليات الأساسيّة المتاحة للبيانات الثنائية:

- عملية الفصل <code>||</code>

- عملية الوصل <code>&&</code>

- عملية النفي <code>!</code>

== المصفوفات (Arrays) ==
تتمثّل أيّ مصفوفةٍ في لغة Kotlin من خلال صنف المصفوفات <code>Array</code> والذي يحتوي على دالتيّ <code>get</code> و <code>set</code> (واللتان يُستعاض عنهما بالقوسين <code>[ ]</code> عبر التحميل الزائد للمعامل [operator overloading]) إضافةً إلى خاصيّة (property)‏ طول المصفوفة <code>size</code> بالإضافة إلى العديد من الدوال الأخرى مثل:<syntaxhighlight lang="kotlin">
class Array<T> private constructor() {
    val size: Int
    operator fun get(index: Int): T
    operator fun set(index: Int, value: T): Unit

    operator fun iterator(): Iterator<T>
    // ...
}
</syntaxhighlight>وتُستخدم الدالة <code>arrayOf()</code>‎ لإنشاء مصفوفةٍ جديدةٍ إذا تُمرَّرُ قيم عناصرها كوسائط (arguments) لهذه الدالة، فمثلًا؛ لإنشاء المصفوفة  [3, 2, 1]  يكون استدعاء الدالة بالشكل: <code>arrayOf(1, 2, 3)‎</code> ، أما لإنشاء مصفوفةٍ فارغةٍ (قيم عناصرها null) بطولٍ محدَّدٍ (size) تُستخدَم الدالة <code>arrayOfNulls()</code>‎.

أما الطريقة الثانية لإنشاء مصفوفةٍ فهي بالاعتماد على الباني (constructor) الموجود في الصنف <code>Array</code> والذي يتطلَّب حجم المصفوفة والدالة التي تعيد القيمة الابتدائية لكل عنصر موجود في المصفوفة من خلال دليله (index)، مثل:<syntaxhighlight lang="kotlin">
val asc = Array(5, { i -> (i * i).toString() })
</syntaxhighlight>حيث تُنشِئ هذه الشيفرة مصفوفةً من السلاسل النصيّة:   ["16", "9", "4", "1", "0"]، وكما ذكرنا سابقًا فإن استخدام القوسين <code>[ ]</code> يكون فقط لاستدعاء الدالتين <code>get()</code>‎ و<code>set()‎</code>.

ويُلاحَظ بأنه على عكس لغة Java تكون المصفوفات في لغة Kotlin ثابتةً (invariant) وهذا يعني أنّه من غير المسموح إسناد <code>Array<String></code>‎ إلى <code>Array<Any></code>‎، وهذا بدوره يمنع حدوث أي خلل (failure) أثناء التنفيذ، ولكن يمكن استخدام <code>Array<out Any></code>‎  (لمزيدٍ من التفاصيل راجع [[Kotlin/generics|Type Projection]]).

وقد خصّصت لغة Kotlin بعض الأصناف لتمثيل المصفوفات ذات الأنواع الأساسيّة (primitive) دون الحاجة إلى التغليف (boxing)، مثل: <code>ByteArray</code> و <code>ShortArray</code> و <code>IntArray</code> وهكذا. ولا توجد أي علاقة وراثة (inheritance) لهذه الأصناف من الصنف <code>Array</code> ولكنها تحتوي على  مجموعة التوابع (methods) والخصائص (properties) نفسها، ولكلِّ منها أيضًا دالة منتِجة (factory function)، مثال عن استخدام المصفوفات:<syntaxhighlight lang="kotlin">
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]
</syntaxhighlight>

== السلاسل النصية (Strings) ==
يعبِّر النوع <code>String</code> عن السلاسل النصيّة وهي ثابتة (immutable) تحتوي على محارف يُمكن الوصول إليها عبر الدليل (index) مثل: <code>s[i]‎</code>، كما ويمكن استخدام حلقة <code>[[Kotlin/control flow for|for]]</code> مع المحارف  في السلسلة بالشكل الآتي:<syntaxhighlight lang="kotlin">
for (c in str) {
    println(c)
}
</syntaxhighlight>

=== قيم السلاسل النصية (Literals) ===
لها نوعان: السلاسل النصيّة الخامّ والتي قد تحتوي على الانتقال لأسطر جديدةٍ، والسلاسل النصيّة ذات المحارف escape والتي تتشابه لحدٍ كبيرٍ مع السلاسل النصيّة في لغة Java، مثل:<syntaxhighlight lang="kotlin">
val s = "Hello, world!\n"
</syntaxhighlight>إذا تمّ الانتقال للسطر التالي عبر المحرف <code>"n\"</code> ولمعرفة كافة تلك المحارف يمكن الرجوع إلى فقرة Character بنفس الصفحة الحاليّة.

أما السلاسل النصيّة الخامّ فتُحاط بإشارات تنصيصٍ ثلاثيّة <code>"""</code> ولا تحتوي على أي محارف escape و لكن من الممكن أن تتضمن الانتقال لسطرٍ جديدٍ مثل:<syntaxhighlight lang="kotlin">
val text = """
    for (c in "foo")
        print(c)
"""
</syntaxhighlight>ومن السهل إزالة الفراغات المساعدة (بالجهة اليساريّة من كل سطر جديد) عبر استدعاء الدالة <code>trimMargin()‎</code> مثل:<syntaxhighlight lang="kotlin">
val text = """
    |Tell me and I forget.
    |Teach me and I remember.
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()
</syntaxhighlight>إذ يستخدم الرمز <code>|</code> بالحالة الافتراضيّة كبادئ محاذاةٍ، ويمكن اختيار أي محرفٍ آخر وتمريره كمعاملٍ للدالة (parameter) مثل: <code>trimMargin(">")‎</code>.

=== قوالب السلاسل النصية (String Templates) ===
قد تحتوي السلاسل النصيّة أحيانًا على بعض القوالب المخصصة للتعابير (وهي أجزاء من الشيفرة ينتج عنها قيمة تُضاف للسلسلة النصيّة) إذ تبدأ بالرمز <code>$</code> وتتألف من:
* إما اسم بسيط مثل:
<syntaxhighlight lang="kotlin">
val i = 10
val s = "i = $i" // ستحسب بالشكل "i = 10"
</syntaxhighlight>
* أو تعبير واقع ما بين قوسين <code>{ }</code> مثل:
<syntaxhighlight lang="kotlin">
val s = "abc"
val str = "$s.length is ${s.length}" // تُحسب بالشكل "abc.length is 3"
</syntaxhighlight>إذ تُستخدَم هذه القوالب في السلاسل النصيّة بنوعيها، ولدى الحاجة إلى المحرف <code>$</code> كقيمةٍ مباشرةٍ في السلسلة الخامّ (لا للدلالة على قالب تعبيريّ) فيمكن اعتماد الصيغة الآتية:<syntaxhighlight lang="kotlin">
val price = """
${'$'}9.99
"""
</syntaxhighlight>

== مصادر ==
* [https://kotlinlang.org/docs/reference/basic-types.html صفحة أنواع البيانات الأساسية في التوثيق الرسميّ للغة Kotlin]
[[تصنيف:Kotlin]]
[[تصنيف:Kotlin Data Types]]
[[تصنيف:Kotlin Operators]]