آموزشِ زبانِ کاتلین (درس ۱: آشناییِ اولیه)

نویسنده : سید ایوب کوکبی ۳۱ شهریور ۱۳۹۸
آموزشِ زبانِ کاتلین (درس 1: آشناییِ اولیه)

از زمانِ اعلامِ رسمیِ حمایتِ گوگل از زبانِ کاتلین، استقبال از آن افزایش یافت و روز به روز بر تعدادِ پروژه‌هایِ نوشته شده با کاتلین یا پروژه‌هایِ مهاجرت شده از جاوا به کاتلین افزوده می‌شود. نظر به اهمیتِ این موضوع تصمیم گرفتیم تا برای اولین بار ترجمۀ کتاب Kotlin In Action را در اسکارپ منتشر کنیم. نویسندگانِ این کتاب Dmitry Jemerov و Svetlana Isakova هستند که هر دو از کارمندان JetBrain و از توسعه‌دهندگانِ اصلیِ این زبان هستند. مطالبِ این کتاب پیش‌نیازِ خوبی برای آموزشِ پروژه‌محورِ برنامه‌نویسی اندروید است. توصیه می‌کنیم برایِ آشنایی دقیق با زبانِ کاتلین، دروسِ این دوره را دنبال کنید.

مباحثی که در این درس خواهید آموخت:

  • مختصری دربارۀ کاتلین؛
  • ویژگی‌های اصلیِ زبانِ کاتلین؛
  • کاربردِ کاتلین در توسعۀ برنامه‌های اندروید و توسعۀ سمتِ سرور (Server-Side)؛
  • خصوصیاتِ متمایزِ زبانِ کاتلین نسبت به سایرِ زبان‌های برنامه‌نویسی؛
  • کدنویسی و اجرای کدها در زبانِ کاتلین.

۱٫۱ مختصریِ دربارۀ کاتلین

کاتلین زبانِ برنامه‌نویسیِ جدیدی بر مبنایِ جاوا است. این زبان، مختصر، ایمن و پراگماتیک است و به شدت روی سازگاری با زبانِ جاوا تمرکز کرده و تقریباً هر جایی که جاوا قابل استفاده باشد کاتلین نیز قابل استفاده است. از ساختِ اپلیکیشن‌های اندروید گرفته تا نوشتنِ برنامه‌های Server-Side و … همگی را می‌توان با این زبان انجام داد. در کاتلین به خوبی می‌توان از کتابخانه‌ها و فریم‌ورک‌هایِ جاوا استفاده کرد. این زبان پرفرمنسِ مشابهی با زبانِ جاوا دارد.

با یک مثالِ ساده نحوۀ کدنویسی در این زبان را بررسی می‌کنیم. در این مثال ابتدا یک کلاسِ Person تعریف می‌کنیم. سپس مجموعه‌ای از افراد می‌سازیم و نهایتاً مسن‌ترین شخص را در خروجی چاپ می‌کنیم. در همین مثالِ ساده می‌توان بسیاری از ویژگی‌هایِ زبانِ کاتلین را دید. احیاناً اگر قسمتی برایتان نامفهوم بود نگران نشوید؛ در درس‌های آینده به طورِ مفصل توضیح خواهیم داد. برای اجرایِ کدها می‌توانید از نسخۀ برخطِ try.kotl.in یا از IDE ای مثلِ IntelliJ IDEA استفاده کنید.

data class Person(val name: String,
    val age: Int ? = null)
fun main(args: Array < String > ) {
    val persons = listOf(Person("Alice"),
        Person("Bob", age = 29))
    val oldest = persons.maxBy {
        it.age ? : 0
    }
    println("The oldest is: $oldest")
}
// The oldest is: Person(name=Bob, age=29)
  • خط ۱: data class
  • خط ۲: nullable type (Int?); default value for argument
  • خط ۳: top-level function
  • خط ۵: named argument
  • خط ۶: lambda expression; “elvis” operator
  • خط ۹: string template
  • خط ۱۱: autogenerated ‘toString’

همانطور که می‌بینید در خطِ اول یک کلاس تعریف کرده‌ایم؛ البته نه یک کلاسِ معمولی؛ یک Data Class یا کلاسِ داده. کلاس داده نوعِ جدیدی از کلاس‌ها در زبانِ کاتلین است که همانطور که از نامش پیداست فقط برای ذخیرۀ مقادیر به کار می‌رود. این کلاس دو پراپرتیِ name و age دارد. پراپرتیِ age را به صورتِ پیش‌فرض null انتخاب کرده‌ایم تا اگر سن وارد نشد به صورت خودکار null مقداردهی می‌شود.

در خطِ چهارم یک لیست از اشیاء Person ایجاد کرده‌ایم. اینجا چون برای Alice سن وارد نکردیم مقدارِ age برابرِ تهی یا null در نظر گرفته می‌شود. سپس با متدِ maxBy مسن‌ترین شخص را پیدا می‌کنیم. lambda exporession ارسال شده به تابع فقط یک پارامتر دارد و شما از it به عنوانِ نامِ پیش‌فرضِ پارامتر استفاده می‌کنید. در عملگر Elvis (:?) اگر مقدارِ age برابرِ null باشد صفر برمی‌گرداند. از آنجا که سنِ Alice وارد نشده مقدارش پیش‌فرض یعنی null در نظر گرفته می‌شود و در نتیجه خروجیِ عملگرِ یاد شده صفر خواهد شد. در نهایت Bob به عنوان مسن‌ترین شخص در خروجی چاپ می‌شود. می‌بینید چقدر زبانِ زیبایی است.

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

۱٫۲ ویژگی‌هایِ اصلیِ زبانِ کاتلین

احتمالاً تا الان با کم و کیفِ این زبان تا حدودی آشنا شده‌اید. اما اجازه دهید قابلیت‌هایِ اصلی‌اش را با جزئیاتِ بیشتری بررسی کنیم.

۱٫۲٫۱ پلتفرم‌هایِ هدف: برنامه‌هایِ سمتِ سرور، اندروید و هر جایی که جاوا اجرا می‌شود

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

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

  • کدنویسیِ سرور ساید (معمولاً کدهای بکند)؛
  • ساختِ اپلیکیشن‌های اندروید که روی دیوایس‌های اندرویدی اجرا می‌شود.

اما کاتلین محدود به این‌ها نیست. برایِ مثال شما می‌توانید از Intel Mutli-OS Engine برای اجرایِ کدهای کاتلین روی دستگاه‌های iOS استفاده کنید. یا برایِ ساختِ اپلیکیشن‌های دسکتاپ از کاتلین و JavaFX استفاده کنید.

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

۱٫۲٫۲ Statically types

کاتلین همانندِ جاوا یک زبانِ Statically typed است. یعنی انواع در زمانِ کامپایل بررسی می‌شوند. کامپایلر می‌تواند تشخصی دهد متدها و فیلدهایی که می‌خواهید از آن‌ها استفاده کنید وجود دارند یا نه. این برخلافِ زبان‌های dynamically typed مثل Groovy و JRuby است. در زبان‌های داینامیک می‌توان متغیرها و توابعی تعریف کرد که هر مقداری را ذخیره یا برگردانند. همچنین ارجاع به فیلدها و متدها در زمان اجرا (Run-time) صورت می‌گیرد. این ویژگی باعث کوتاه‌تر شدن کدها و انعطاف بیشترِ ساختارهای داده‌ای می‌شود؛ ولی مشکلش اینجاست که خطا در نام‌گذاری‌ها تا زمانِ اجرا به تعویق افتاده و مسببِ مشکلاتِ فراوانی است. این موضوع دیباگ یا اشکال‌زداییِ برنامه را سخت می‌کند.

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

val x = 1

در متغیرِ بالا، کاتلین از روی مقدارِ ذخیرهِ شده در متغیر تشخیص می‌دهد که نوعش Int است. در طراحیِ زبان‌هایِ برنامه‌نویسی به این ویژگی که از روی Context، نوعِ متغیر تشخیص داده می‌شود اصطلاحاً type inference گفته می‌شود.

تعدادی از مزایایِ زبان‌های statically typed:

  • پرفرمنسِ بالا. فراخوانیِ متدها سریع‌تر انجام می‌شود؛ چرا که لازم نیست در زمانِ اجرا متدی که باید فراخوانی شود را تشخیص داد؛
  • قابلیتِ اطمینانِ بالا. کامپایلر، بیشترِ خطاها را در زمانِ کامپایل تشخیص می‌دهد؛ بنابراین شانسِ کمتری وجود دارد که در زمانِ اجرا با خطایی مواجه شوید؛
  • نگهداریِ آسان. نگهداریِ کدها در این زبان‌ها به مراتب راحت‌تر از زبان‌های داینامیک است؛
  • پشتیبانی از ابزارها. زبان‌های statically typed ابزارهایِ بیشتری برای ریفکتور، تکمیلِ خودکارِ کد و سایر قابلیت‌هایِ IDE در اختیارِ توسعه‌دهنده قرار می‌دهد.

به لطفِ قابلیتِ type inference دیگر نیازی به تعریفِ مستقیمِ نوعِ متغیرها نیست؛ بنابراین سریع‌تر و کوتاه‌تر می‌توانید کد بنویسید. با نگاهی به سیستمِ نوع (type system) در کاتلین متوجه خواهید شد که بسیاری از قابلیت‌هایِ زبانِ جاوا از جمله کلاس، اینترفیس، جنریک به همان صورتی که قبلاِ استفاده می‌شده اینجا هم قابلِ استفاده است. بنابراین دانشِ جاوای شما بدونِ هیچ تغییری به این زبان منتقل می‌شود؛ البته به جز چند ویژگیِ جدید که به زودی خواهید آموخت.

بخوانید  آموزش زبان کاتلین – درس 10 (حلقۀ while و do...while)

۱٫۲٫۳ فانکشنال و شی‌گرا

به عنوانِ یک توسعه‌دهندۀ جاوا بدون شک با مفاهیمِ شی‌گرایی آشنا هستید. ولی احتمالاً شناختی از برنامه‌نویسیِ فانکشنال یا تابعی (Functional) ندارید.

ویژگی‌هایِ کلیدیِ زبان‌های فانکشنال:

  • First-class function. در این زبان با فانکشن‌ها همچون مقادیر(value) رفتار می‌شود. توابع را می‌توان درونِ متغیرها ذخیره و به عنوانِ آرگومان به توابعِ دیگری ارسال کرد یا حتی به عنوانِ یک مقدار از توابع دیگر return کرد؛
  • Immutability. شما با اشیاء immutable کار می‌کنید که تضمین می‌کند حالتشان بعد از ساخته شدن تغییر نمی‌کند؛
  • بدونِ اثراتِ جانبی (Side Effect). توابع فقط مسئولِ تولیدِ خروجی در قبالِ مقادیرِ ورودی هستند و کاری به سایرِ آبجکت‌ها ندارند.

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

مزیتِ بعدیِ زبان‌های فانکشنال safe multithreading است. یکی از مهم‌ترین دلایلِ بروزِ خطا در برنامه‌هایِ مالتی ترد یا چندنخی، اصلاحِ بخش‌هایِ یکسانی از داده توسطِ چند نخ و بدونِ همگام‌سازیِ آن‌هاست. در صورتِ استفاده از ساختارهایِ داده‌ایِ immutable و برنامه‌نویسیِ فانکشنال می‌توانید مطمئن شوید که چنین اتفاقی بروز نخواهد کرد. بنابراین نیازی به همگام‌سازی‌های (synchronizations) پیچیده نیست.

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

به طورِ کلی در هر زبانِ برنامه‌نویسی حتی آن‌هایی که پاردایمِ اصلی‌شان فانکشنال نیست می‌توان به صورتِ تابعی کد نوشت؛ ولی نکته اینجاست که زبان‌هایِ غیرفانکشنال تمامِ قابلیت‌هایِ موردِ نیاز برای این نوع برنامه‌نویسی را ندارند. به عنوانِ مثال تا پیش از نسخۀ ۸ جاوا به راحتیِ امروز نمی‌توانستید کدهایِ فانکشنال بنویسید. اما کاتلین از اوایلِ پیدایش علاوه بر ویژگی‌های شی‌گرا روی سبکِ فانکشنال هم تمرکز زیادی کرده است. به عنوانِ مثال برای حمایت از این سبک کدنویسی، امکانات زیر در زبانِ کاتلین در نظر گرفته شده:

  • استفاده از تابع به عنوانِ نوع. به توابع اجازه می‌دهد تا همانندِ سایرِ انواع (مثلاً Int) برای آرگومان و مقداری برگشتی توابع استفاده شوند؛
  • عباراتِ لامبدا. سبب می‌شود با کمترینِ میزانِ کدنویسی به هدفتان برسید؛
  • کلاس‌های داده (Data Class). سینتکسِ ساده و مختصری برای ساختِ یک شی داده‌ای حاوی مقادیرِ immutable در اختیار شما قرار می‌دهد؛
  • از طیفِ وسیعی از API ها و کتابخانه‌های استاندارد برای کار با اشیا و کالکشن‌ها در سبکِ فانکشنال برخوردار است.

کاتلین به شما امکانِ برنامه‌نویسیِ فانکشنال می‌دهد ولی مجبورتان نمی‌کند. هر زمان لازم بود می‌توانید از داده‌های mutable (یعنی قابلِ تغییر) استفاده کنید یا توابعی بنویسید که اثراتِ جانبی داشته باشند. در کاتلین به راحتی می‌توانید رویکردِ شی‌گرا و تابعی را با هم مخلوط کرده و از هر روش که برای حل مسئله مناسب‌تر است استفاده کنید.

۱٫۲٫۴ رایگان و متن‌باز

تمامِ متعلقات و ابزارهایِ کاتلین از جمله کامپایلر، کتابخانه‌ها و … به هر منظوری متن باز و رایگان است. شما می‌توانید تحت لایسنس آپاچی ۲ هر طور که دوست دارید این زبان را توسعه دهید. برای ساختِ برنامه با کاتلین سه IDE مطرح وجود دارد: IntelliJ IDEA Community Edition و اندروید استودیو و اکلیپس. البته اکلیپس قدیمی است و چندان توصیه نمی‌شود و برای کاربرانِ ایرانی که محدودیتی در دانلودِ نرم‌افزارهایِ کرک شده ندارند چه بهتر که از نسخۀ IntelliJ IDEA Ultimate استفاده کنند.

اکنون بپردازیم به کاربردهایِ اصلیِ زبان کاتلین.

۱٫۳ کاربردهایِ زبانِ کاتلین

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

۱٫۳٫۱ کاتلین در برنامه‌هایِ سمتِ سرور

برنامه‌نویسیِ Server-side (سمتِ سرور)، مقولۀ بسیار گسترده‌ای است و تمامِ مواردِ زیر را در بر می‌گیرد:

  • برنامه‌هایِ تحتِ وب؛
  • کدهایِ بکند در برنامه‌های موبایل؛
  • میکروسرویس‌ها.

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

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

بعلاوه این زبان ویژگی‌هایِ جدیدی برای توسعۀ چنین سیستم‌هایی در نظر گرفته است. برای مثال پشتیبانی از الگویِ Builder به شما اجازه می دهد تا هر ترتیبی از اشیا را با سینتکس ساده‌ای بنویسید. یکی از ساده‌ترین کاربردها، کتابخانه‌هایِ HTML Generation هستند که به صورتِ خودکار بر اساسِ یک قالب، خروجیِ HTML تحویل می‌دهند. شما می‌توانید به جایِ استفاده از زبان‌هایِ پیچیدۀ تمپلیت‌نویسی از زبانِ type-safe کاتلین استفاده کنید.

fun renderPersonList(persons: Collection < Person > ) =
    createHTML().table {
        for (person in persons) {
            tr {
                td {
                    +person.name
                }
                td {
                    +person.age
                }
            }
        }
    }
}

همانطور که می‌بینید خیلی ساده می‌توانید توابعی را برای map کردنِ تگ‌های HTML با ساختارهایِ رایجِ زبانِ کاتلین ترکیب کنید. دیگر نیازی به استفاده از یک زبانِ مجزا با سینتکس متفاوت برای نوشتنِ  Templateها نیست.

کاربردِ دیگرِ کاتلین، استفاده در فریم‌ورک‌های ذخیرۀ داده است. برایِ مثالExposed Framework  راهِ ساده‌ای برای خواندنِ DSL به منظورِ شرحِ ساختارِ دیتابیس‌هایِ SQL و اجرایِ کوئری‌ از داخلِ کدهایِ کاتلین پیش پایمان گذاشته است:

object CountryTable: IdTable() {
    val name = varchar("name", 250).uniqueIndex()
    val iso = varchar("iso", 2).uniqueIndex()
}
class Country(id: EntityID): Entity(id) {
    var name: String by
    CountryTable.name
    var iso: String by
    CountryTable.iso
}
val russia = Country.find {
        CountryTable.iso.eq("ru
            ")
        }.first()

به این جزئیات بعداً خواهیم پرداخت.

۱٫۳٫۲ کاتلین در اندروید

اپلیکیشن‌هایِ موبایل بسیار متفاوت از برنامه‌هایِ بزرگ هستند. این اپلیکیشن‌ها کوچک بوده و بایست با سرعتِ بیشتری روی طیفِ گسترده‌ای از دستگاه‌ها توسعه داده شوند. کاتلین برای این منظور مناسب است. ویژگی‌هایِ خاصِ این زبان در کنارِ کامپایلرِ منحصر به فردِ فریم‌ورک اندروید آن را به انتخابِ مناسبی برای توسعه در این محیط تبدیل کرده است. با کاتلین انجامِ کارهایی مثل اضافه کردن listener  به کنترل‌ها یا بایند کردن عناصرِ layout به سادگی میسر است . و گاهی حتی خودِ کامپایلر برای شما این کدها را تولید می‌کند.

کتابخانۀ Anko که توسطِ تیمِ کاتلین نوشته شده، با اضافه کردن آداپتورهای کاربرپسند به اغلبِ APIهای اندروید حتی کدنویسی را بیشتر از چیزی که گفتیم ساده و لذت‌بخش کرده است. در کدِ پایین مثالی از کاربردِ این کتابخانه را می‌بینید. با کپی کردن این کدِ ساده در یک اکتیویتی، یک برنامۀ ساده نوشته‌اید:

verticalLayout {
    val name = editText()
    button("Say Hello") {
        onClick {
            toast("Hello, ${name.text}!")
        }
    }
}

مزیتِ دیگرِ زبانِ کاتلین، قابلیتِ اطمینان (Reliability) آن است. اگر قبلاِ با زبان جاوا کار کرده باشید احتمالاً بارها با پیامِ Proccess Has Stopped مواجه شده‌اید. این خطا زمانی ظاهر می‌شود که استثنایی رخ دهد که غالباً NullPointerException است. سیستمِ نوع (Type System) در کاتلین به گونه‌ای طراحی شده که به ندرت خطایِ null در آن اتفاق می‌افتد. به همین خاطر آن قسمت از کدهای جاوا که بیمِ صدورِ چنین استثنایی می‌رود در هنگامِ مهاجرت به زبان کاتلین باید رفعِ عیب شوند؛ در غیرِ این صورت برنامه کامپایل نخواهد شد.

کاتلین به صورتِ کامل با زبانِ جاوا سازگار است. بنابراین می‌توانید ویژگی‌هایِ جدیدِ زبانِ کاتلین را در کنارِ قابلیت‌های پیشینِ جاوا تجربه کنید. کاربرانِ شما هیچ تفاوتی در خروجی احساس نمی‌کنند. کدها به همان صورت که قبلاً اجرا می‌شده اجرا می‌شوند.

بخوانید  بهینه‌سازی بازیهای اندروید در یونیتی

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

اکنون به این مسئله بپردازیم که اساساً فلسفۀ وجودیِ کاتلین چه بوده و بر چه ارکانی استوار است. این زبان با چه ویژگی‌هایی به مقابله با زبان‌هایِ برنامه‌نویسی آمده است.

۱٫۴ فلسفۀ کاتلین

وقتی در موردِ کاتلین حرف می‌زنیم دوست داریم بگوییم که این زبان یک زبانِ Pragmatic, Concise و Safe است و تأکید ویژه‌ای رویِ قابلیتِ همکاری با زبانِ جاوا دارد. اما هر یک از این ویژگی‌ها چه هستند؟ بیایید هر یک را به صورتِ جداگانه بررسی کنیم.

۱٫۴٫۱ Pragmatic

پراگماتیک بودن به این معنی است که کاتلین یک زبانِ Practical است یعنی مردِ عمل است. کاتلین آمده تا با مسائلِ دنیایِ واقعی را حل کند. این یک زبان تحقیقاتی یا مدلِ مفهومی نیست که فقط در تئوری جای داشته باشد یا متعلق به کتاب‌ها درسی باشد. کاتلین زبانِ صنعت است و برای ساختِ سیستم‌هایی در ابعادِ بزرگ خلق شده است. بعلاوه توسعه‌دهندگانِ زبانِ کاتلین در JetBrain پیش از عرضۀ عمومیِ آن سال‌ها با این زبان کار کرده‌اند و بازخوردِ کارمندان، نسخۀ ابتداییِ آن را شکل داده است. این موضوع به ما اطمینان می‌دهد تا با خیالِ راحت این زبان را برای پروژه‌های واقعی معرفی کنیم.

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

از منظرِ دیگری هم می‌توان به پراگماتیک بودنِ زبانِ کاتلین توجه کرد و آن تمرکزِ بر ابزار است. توسعه‌دهندگان معمولاً به امکاناتِ IDE وابسته هستند. دیر یا زود برای افزایش سرعت و بهره‌وری، به استفاده از ابزارها رو خواهید آورد. و از آنجا که کاتلین در تعاملِ نزدیک با IntelliJ IDEA بوده، توسعه‌دهندگانش با در نظر گرفتن ابزارها و قابلیت‌هایِ این محیط زبانِ کاتلین را ساخته‌اند. به زبانِ ساده‌تر کاتلین را همان‌ها ساخته‌اند که پیش‌تر IntelliJ IDEA را ساخته‌اند. مسلماً هیچ کسی بهتر از JetBrain نمی‌تواند کاتلین را هماهنگ با این ابزار بسازد.

IDE نقش عمده‌ای در یادگیریِ زبان دارد. در بسیاری از موارد IntelliJ IDEA به صورتِ خودکار الگوهایی را تشخیص و به شما پیشنهادِ اصلاح می‌دهد. یا خطاهایتان را در حینِ کدنویسی گوشزد می‌کند. با بررسیِ این پیشنهادات می‌توانید به تدریج با امکاناتِ مختلفِ زبان کاتلین آشنا شوید.

۱٫۴٫۲ خلاصه و موجز

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

هرچه کد ساده‌تر و کوتاه‌تر باشد، سریع‌تر می‌توانید بررسی کنید. نام‌گذاریِ درست، تأثیرِ زیادی روی فهم کدها دارد ولی انتخابِ زبان و سینتکسِ زبان نیز بی‌تأثیر نیست. به زبانی که به راحتی از رویِ سینتکس می‌توان به مفهومِ کدها پی برد، موجز یا اصطلاحاً Concise گفته می‌شود. یک زبانِ موجز هیچ چیزی را از شما مخفی نمی‌کنید. همه چیز به همان صورتی که می‌نویسید قابلِ درک است.

در کاتلین هیچ چیز از نظرتان پنهان نمی‌ماند و بدونِ هیچ قراردادی می‌توانید کدها را درک کنید. بسیاری از قابلیت‌هایِ استانداردِ زبانِ جاوا همچون getter, setter و روشی که برای مقداردهی پارامترهایِ سازنده و فیلدهایِ یک کلاس استفاده می‌شود در زبانِ کاتلین به صورت ضمنی انجام می‌شود تا کدِ شما شلخته و گیج‌کننده به نظر نرسد.

درست مانند هر زبانِ مدرنِ دیگری، کاتلین نیز کتابخانۀ قدرتمندی برای جایگزین کردن قسمت‌های تکراری و طولانی با متدهای ساده و کوتاه فراهم کرده است. این کار باعث می‌شود تا پیچیدگی‌های فنی مخفی شده و فقط قسمت‌هایِ لازم نمایش داده شود.

کدهای خلاصه‌ در زمانِ کمتری خوانده و نوشته می‌شوند. بهره‌وری را بالا می‌برند و سطحِ اشتباهات را کاهش می‌دهند.

۱٫۴٫۳ ایمن (Safe)

عموماً منظور از ایمن بودن یک زبان، نوعِ طراحیِ آن است که باعث می‌شود جلویِ برخی از خطاهایِ مهم گرفته شود. و طبیعی است که امنیت مطلق نیست. هیچ زبانی نمی‌تواند از همۀ خطاها جلوگیری کند. بعلاوه، پرهیز از خطاها، هزینه دارد. لازم است تا اطلاعاتِ اضافه‌ای در اختیار کامپایلر قرار گیرد تا صحتِ آن ارزیابی شود و این موضوع می‌تواند تأثیرِ نامطلوبی رویِ سرعتِ کامپایل و دیگر عملکردهای آن بگذارد. بنابراین انتخابِ بینِ سطحِ ایمنیِ زبان و بهره‌وری آن موضوعِ حساسی است.

در کاتلین سعی شده تا با کمترین هزینه، ایمنیِ زبان افزایش یابد. همینکه کاتلین مبتنی بر JVM طراحی شده تضمین می‌کند بسیاری از مشکلات بروز نخواهد کرد. به عنوانِ مثال امنیتِ حافظه، جلوگیری از سرریزِ بافر و سایرِ مشکلاتِ ناشی از کاربستِ اشتباهِ حافظه، جایی در این زبان ندارد.

البته کاتلین پا را فراتر نهاده و اشتباهاتِ بیشتری از جاوا در زمانِ کامپایل به شما گزارش می‌دهد. مهم‌ترین ویژگی‌اش جلوگیری از بروزِ خطایِ NullPointerException است. تایپ سیستمِ کاتلین به گونه‌ای طراحی شده که مقادیر را برای بررسیِ احتمالِ null بودنشان پیش از کامپایلِ چک کرده و به شما گوشزد می‌کند. هزینۀ سربار برای پیاده‌سازیِ این ویژگی ناچیز است. تبدیل یک نوع به nullable به سادگیِ اضافه کردنِ یک علامتِ سوال به انتهایِ آن است:

val s: String? = null
val s2: String = ""

علاوه بر این، روش‌های آسانی برای هندل کردن داده‌هایِ nullable در اختیارِ شماست. این موضوع کمک می‌کند تا جلویِ کرش شدنِ برنامه را بگیرید.

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

if (value is String)
    println(value.toUpperCase())

۱٫۴٫۴ قابلیتِ همکاری (Interoperable)

به عنوانِ یک برنامه‌نویسِ جاوا، احتمالاً اولینِ سوال شما این است که آیا می‌توانم از کتابخانه‌هایِ قبلی‌ام استفاده کنم؟ برای کاتلین پاسخ مثبت است. صرفنظر از اینکه از چه کتابخانه و API ای استفاده می‌کنید، از هر دو زبان می‌توانید در کنارِ هم استفاده کنید. می‌توانید متدهایِ جاوا را فرخوانی کنید، کلاس‌هایش را گسترش داده یا اینترفیس‌هایِ جاوا را پیاده‌سازی کنید. همچنین امکانِ استفاده از java annotationها در کلاس‌های کاتلین وجود دارد.

کاتلین برخلاف سایرِ زبان‌هایِ JVM تأکید زیادی رویِ قابلیت همکاریِ زبان با جاوا دارد. شما قادر هستید بدونِ هیچ تلاشِ اضافه‌ای کدهایِ کاتلین را از درونِ کدهای جاوا فراخوانی کنید. برای این کار از تکنیک یا ترفندِ خاصی استفاده نمی‌‌کنید. کلاس‌ها و متدهایِ کاتلین را به همان صورتی که در جاوا صدا می‌زدید فراخوانی می‌کنید. ترکیبِ جاوا و کاتلین به شما انعطافِ زیادی می‌دهد. افرادی که تازه شروع به یادگرفتنِ زبانِ کاتلین گرفته‌اند به راحتی می‌توانند بخشی از کد را مثلاً یک کلاسِ جاوا را با ابزارِ مبدل به جاوا تبدیل و مابقیِ کد را به همان صورتِ سابق رها کنند. این کد بدونِ هیچ مشکلی کامپایل می‌شود و مابقیِ کد نیازی به اصلاح ندارد. هر کلاسی را می‌توانید از زبانِ جاوا به کاتلین بیاورید.

بخوانید  آموزش زبان کاتلین - درس 5 (دستورات، عبارات و بلاک‌ها)

کاتلین به صورتِ گسترده‌ای از کتابخانه‌هایِ قبلیِ جاوا استفاده می‌کند. به عنوانِ مثال در این زبان هیچ کتابخانۀ جدیدی برای کالکشن‌ها وجود ندارد. همه چیز وابسته به کلاس‌هایِ استانداردِ جاوا است و هر جایی لازم باشد با extend کردنِ کلاس‌ها کار را برای مصرف‌کننده تسهیل کرده است (در این موضوع بعداً توضیحات بیشتری می‌دهیم.) این یعنی نیازی نیست که برایِ استفاده از Java API در کاتلین یا بالعکس، اشیاء را wrap یا تبدیل کنید.

افزون بر این، توجهِ خاصِ کاتلین به ابزار باعث شده تا به هر صورتی که دوست دارید سورس‌کدهایِ جاوا و کاتلین را با هم ترکیب کرده و از ابزارهایی که IDE در اختیار شما قرار می‌دهد برای مقاصدِ مختلف استفاده کنید؛ از جمله:

  • پیمایشِ آسان بین فایل‌هایِ جاوا و کاتلین؛
  • اشکال‌زداییِ پروژه‌هایی که در زبان‌های مختلف نوشته شده؛
  • ریفکتور کردن متدهایِ جاوا برایِ استفاده در کاتلین و بالعکس.

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

۱٫۵ اجرایِ کدهایِ کاتلین

همانند جاوا، کاتلین نیز یک زبانِ کامپایلری است. این یعنی قبل از اجرایِ کدهایِ کاتلین باید کامپایل کنید. ابتدا فرایندِ کامپایل و چگونگیِ انجامِ این کار را بررسی کنیم و در ادامه به بررسیِ ابزارهایِ کامپایل بپردازیم. برای اطلاعاتِ مفصل‌تر به قسمتِ Tutorial در سایتِ کاتلین مراجعه کنید.

۱٫۵٫۱ کامپایلِ کدهایِ کاتلین

سورس‌کدهایِ کاتلین معمولاً در فایلی با پسوندِ kt. ذخیره می‌شوند. کامپایلر، سورس‌کدها را آنالیز و همانندِ جاوا، فایل‌هایِ class. تولید می‌کند. سپس فایل‌های class. درونِ پکیجی متناسب با پلتفرمی که این کدها در آن اجرا می‌شوند قرار می‌گیرد. در ساده‌ترین حالت می‌توانید با دستورِ kotlinc عملِ کامپایل را در خطِ فرمان انجام داده و از دستورِ java برای اجرایِ آن استفاده کنید.

kotlinc <source file or directory> -include-runtime -d <jar name>
java -jar <jar name>

در تصویرِ زیر، فرایندِ یاد شده را می‌توانید ببینید:

فرایندِ کامپایل در کاتلین

کدِ کامپایل شده در کاتلین وابسته به Kotlin Runtime Library است که مجموعه‌ای از کلاس‌هایِ استاندارد کاتلین بعلاوۀ کلاس‌های اکستند شدۀ جاواست. کتابخانۀ runtime باید همراهِ برنامه توزیع شود.

معمولاً برای کامپایل از build system هایی مثل Maven, Gradle یا Ant استفاده می‌شود. کاتلین با تمامِ این سیستم‌ها سازگار بوده و بعداً در این مورد بیشتر صحبت خواهیم کرد. تمامِ این بیلد سیستم‌ها از ترکیبِ دو زبانِ جاوا و کاتلین حمایت می‌کنند؛ بنابراین پروژۀ شما می‌تواند همزمان دارای سورس‌کدهایی در هر دو زبان باشد. از بین این‌ها ماوِن و گریدل خودشان حواسشان هست که kotlin runtime library را به عنوانِ یک dependency در پکیجِ برنامه قرار دهند.

۱٫۵٫۲ پلاگینِ کاتلین برای IntelliJ IDEA و اندروید استودیو

IntelliJ IDEA همزمان با کاتلین به صورتِ موازی توسعه یافته است. بنابراین بیشترین سطحِ سازگاری با این زبان را دارد. ابزارهایی که در این IDE برای کار با کاتلین در نظر گرفته شده در هیچ IDE دیگری وجود ندارد؛ یا حداقل این پایداری و جامعیتِ ابزارها در هیچ جایِ دیگری وجود ندارد.

پلاگینِ کاتلین به صورتِ خودکار در نسخه‌های IntelliJ IDEA 15 و بالاتر قرار گرفته است؛ بنابراین نیازی به تنظیماتِ اضافه نیست. شما می‌توانید از نسخۀ Community این IDE به رایگان استفاده کنید و در صفحۀ پروژۀ جدید، زبان را کاتلین انتخاب کنید.

در نسخه‌هایِ جدیدِ اندروید استودیو نیز این پلاگین به صورت built-in قرار گرفته و در صفحۀ پروژه به راحتی می‌توانید زبانِ پروژه را کاتلین انتخاب کنید. در صورتی که این پلاگین وجود نداشت می‌توانید از قسمتِ پلاگین‌ها آن را دانلود و نصب کنید. برای اعمالِ تنظیمات حتماً لازم است یکبار IDE را بسته و مجدداً باز کنید.

۱٫۵٫۳ Interactive Shell

اگر می‌خواهید بخشِ کوچکی از کدهایِ کاتلین را سریعاً اجرا کنید، می‌توانید از interactive shell استفاده کنید که به REPL مشهور است. در REPL می‌توانید کدهای کاتلین را خط به خط اجرا کرده و بلافاصله نتیجه را در خروجی ببینید. برای اجرایِ آن می‌توانید دستورِ kotlinc را بدونِ هیچ آرگومانی به کار برید یا از منویِ پلاگینِ IntelliJ IDEA استفاده کنید.

۱٫۵٫۴ پلاگینِ اکلیپس

اگر از کاربرانِ اکلیپس هستید با افزونه‌ای که برای این محیط در نظر گرفته شده می‌توانید کدهایتان را به زبانِ کاتلین بنویسید. این پلاگین قابلیت‌های زیادی را در اختیارِ شما قرار می‌دهد؛ از جمله ویژگی‌هایی برای پیمایش و تکمیلِ خودکارِ کدها. پلاگین را می‌توانید از فروشگاه اکلیپس دانلود کنید. برای نصبِ آن از منویِ Help گزینۀ Eclipse Marketpace را انتخاب و Kotlin را جستجو کنید.

۱٫۵٫۵ اجرا به صورتِ آنلاین

راحت‌ترین روش برای اجرایِ کدهایِ کاتلین استفاده از کامپایلرِ آنلاین است. به سایتِ https://try.kotl.in مراجعه کرده و کدهایِ ساده و کوچکِ خود را اجرا کنید. در این ادیتور تعدادی مثال و آموزش قرار گرفته تا با ویژگی‌هایِ زبانِ کاتلین آشنا شوید.

۱٫۵٫۶ مبدل جاوا به کاتلین

مهاجرت و استفاده از یک زبانِ جدید کارِ بی‌زحمتی نیست. خوشبختانه برنامه‌نویسانِ جاوا مسیرِ میانبری برای یادگیریِ آسان‌ترِ زبانِ کاتلین در نظر گرفته‌اند و آن استفاده از ابزاری تحتِ عنوانِ Java-to-Kotlin converter است.

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

استفاده از مبدل مزیتِ دیگری هم دارد. شما می‌توانید کلاس‌هایِ جدید را از همان ابتدا به زبانِ کاتلین بنویسید. ولی اگر لازم به تغییرات گسترده‌ای در کلاس‌هایِ جاوا بود چه؟ باز هم می‌توانید از مبدل استفاده کنید. به این صورت که ابتدا کدها را به زبانِ کاتلین نوشته و سپس اقدام به گسترشِ آن کنید. استفاده از مبدل در IntelliJ IDEA بسیار راحت است. می‌توانید با کپی کردنِ کدهای جاوا در یک فایلِ کاتلین عملِ تبدیل را انجام دهید. این مبدل در اکلیپس و نسخۀ آنلاین نیز وجود دارد.

۱٫۶ خلاصه

  • کاتلین یک زبانِ statically typed است و با پشتیبانی از type inference می‌توان کدها را کوتاه و با اشکالاتِ کمتر و نگه‌داریِ ساده‌تر نوشت؛
  • کاتلین هم از پارادایم شی گرا و هم از برنامه‌نویسی تابعی حمایت می‌کند. این زبان با پشتیبانی از برنامه‌نویسی فانکشنال سطحِ جدیدی از abstraction تعریف کرده و فرایندِ تست را بسیار ساده‌ کرده است. همچنین توسعۀ برنامه‌هایِ چند نخی در این پارادایم ساده‌تر است؛
  • این زبان برای برنامه‌نویسی server-side کاربرد دارد. از تمامِ فریم‌ورک‌هایِ جاوا حمایت می‌کند و با فراهم کردنِ ابزارهای جدید به شما این امکان را می‌دهد تا کارهایی مثل HTML Generation و نگه‌داریِ داده‌ها را با سهولتِ بیشتری انجام دهید؛
  • همچنین برای اندروید هم کاربرد دارد. رانتایمِ فشردۀ kotlin باعث شده تا انتخابِ مناسبی برای توسعۀ اپلیکیشن‌های Android باشد. به لطفِ کتابخانۀ غنیِ این زبان، وظایفِ رایج در توسعۀ اندروید را راحت‌تر از گذشته می‌توانید انجام دهید؛
  • کاتلین رایگان و متن‌باز بوده و از بیشترِ IDE ها و Build System ها پشتیبانی می‌کند؛
  • کاتلین یک زبانِ پراگماتیک، ایمن و موجز است و از خطاهایِ رایجی مثل NullPointerExceptions جلوگیری می‌کند؛
  • این زبان به راحتی در کنارِ جاوا قابلِ استفاده است.

سید ایوب کوکبی

نویسنده و مترجم...

0 دیدگاه

نشانی ایمیل شما منتشر نخواهد شد. بخش‌های موردنیاز علامت‌گذاری شده‌اند *