מה זה קוטלין? חלופת Java הסבירה

Kotlin הוא שפת תכנות "פרגמטית", קוד פתוח, חופשי, קוד פתוח, שתוכנן במקור עבור ה- JVM (Java Virtual Machine) ו- Android המשלבת תכונות תכנות מונחות עצמים ופונקציונליות. הוא מתמקד בתאימות, בטיחות, בהירות ותמיכה בכלים. גרסאות Kotlin הממוקדות JavaScript ES5.1 וקוד מקורי (באמצעות LLVM) עבור מספר מעבדים גם כן בהפקה.

מקורו של קוטלין ב- JetBrains, החברה שעומדת מאחורי IntelliJ IDEA, בשנת 2010, והיה קוד פתוח מאז 2012. צוות Kotlin מונה כיום למעלה מ- 90 חברים במשרה מלאה מ- JetBrains, ולפרויקט קוטלין ב- GitHub יש יותר מ -300 תורמים. JetBrains משתמשת בקוטלין ברבים ממוצריה, כולל ספינת הדגל שלה IntelliJ IDEA.

קוטלין כשפת ג'אווה תמציתית יותר

במבט ראשון, קוטלין נראה כמו גרסה תמציתית ויעילה יותר של Java. שקול את צילום המסך לעיל, שם המרת אוטומטית דוגמת קוד Java (משמאל) לקוטלין. שים לב שהחזרה חסרת הדעת הטמונה באינסטינציה של משתני ג'אווה נעלמה. ניב הג'אווה

StringBuilder sb = StringBuilder חדש ();

הופך לקוטלין

val sb = StringBuilder ()

אתה יכול לראות שהפונקציות מוגדרות באמצעות funמילת המפתח, וכי נקודה-פסיק היא כעת אופציונלית כאשר קיימות שורות חדשות. valמילת מצהיר נכס לקריאה בלבד או משתנה מקומי. באופן דומה, varמילת המפתח מכריזה על מאפיין משתנה או על משתנה מקומי.

אף על פי כן, קוטלין מודפס מאוד. valואת varמילות מפתח ניתן להשתמש רק כאשר הסוג ניתן להסיק. אחרת אתה צריך להכריז על הסוג. נראה כי הסקת סוג משתפרת עם כל מהדורה של Kotlin.

בדוק את הצהרת הפונקציה בחלק העליון של שני החלונות. סוג ההחזרה בג'אווה קודם לאב הטיפוס, אך בקוטלין הוא מצליח לאב הטיפוס, שתוחם במעי הגס כמו בפסקל.

זה לא ברור מאליו מהדוגמה הזו, אך קוטלין הרפה את דרישת ג'אווה לפונקציות להיות חברי כיתה. בקוטלין, ניתן להכריז על פונקציות ברמה העליונה בקובץ, באופן מקומי בתוך פונקציות אחרות, כפונקציה של חבר בתוך מחלקה או אובייקט וכפונקציה של הרחבה. פונקציות הרחבה מספקות יכולת דמוית C # להרחיב כיתה עם פונקציונליות חדשה ללא צורך בירושה מהכיתה או להשתמש בכל סוג של תבנית עיצוב כגון Decorator.

עבור אוהדי גרובי, קוטלין מיישם בונים; למעשה, ניתן לבדוק סוג בוני קוטלין. Kotlin תומך במאפיינים המואצלים, אשר באמצעותם ניתן ליישם מאפיינים עצלים, מאפיינים נצפים, מאפיינים הניתנים לווטו ומאפיינים ממופים.

ניתן להטמיע מנגנונים אסינכרוניים רבים הזמינים בשפות אחרות כספריות המשתמשות בקורות קורוטלין. זה כולל async/ awaitמ- C # ו- ECMAScript, ערוצים ובחר מ- Go, ו generators/ yieldמ C # ו- Python.

תכנות פונקציונלי בקוטלין

התרת פונקציות ברמה העליונה היא רק ההתחלה של סיפור התכנות הפונקציונלי עבור קוטלין. השפה תומכת גם בפונקציות מסדר גבוה יותר, פונקציות אנונימיות, lambdas, פונקציות מוטבעות, סגירות, רקורסיביות זנב וגנריות. במילים אחרות, לקוטלין יש את כל התכונות והיתרונות של שפה פונקציונלית. לדוגמה, שקול את המינוחים הפונקציונליים הבאים של קוטלין.

סינון רשימה בקוטלין

val positives = list.filter {x -> x> 0}

לביטוי קצר עוד יותר, השתמש itכשיש רק פרמטר יחיד בפונקציה למבדה:

val positives = list.filter {it> 0}

חוצה מפה / רשימת זוגות בקוטלין

עבור ((k, v) במפה) {println ("$ k -> $ v")}

kו  v יכול להיקרא כלום.

שימוש בטווחים בקוטלין

עבור (i ב-  1..100) {...} // טווח סגור: כולל 100

עבור (אני ב-  1 עד 100) {...} // טווח פתוח למחצה: אינו כולל 100

עבור (x ב  2..10 שלב 2) {...}

עבור (x ב  10 למטה עד 1) {...}

אם (x ב-  1..10) {...}

הדוגמאות לעיל מציגות את  for מילת המפתח וכן את השימוש בטווחים.

למרות שקוטלין היא שפת תכנות פונקציונאלית מן המניין, היא שומרת על רוב האופי המכוון של האובייקטים של ג'אווה כסגנון תכנות חלופי, וזה מאוד שימושי בעת המרת קוד Java קיים. יש Kotlin כיתות עם בנאים, יחד עם כיתות פנימיות מקוננות, פנימיות, ואנונימי, ויש לה ממשקים כמו Java 8. Kotlin אין לא קיימים newמילה. כדי ליצור מופע כיתתי, התקשר לבנאי בדיוק כמו פונקציה רגילה. ראינו את זה בצילום המסך לעיל.

לקוטלין יש ירושה יחידה ממעמד סופר-שם בשם, ולכל מחלקות קוטלין יש מעמד-על ברירת מחדל Any, שאינו זהה למחלקת הבסיס של ג'אווה java.lang.Object. Anyמכיל רק שלוש פונקציות חבר מוגדרות מראש: equals(), hashCode(), ו toString().

יש לסמן שיעורי קוטלין openבמילת המפתח על מנת לאפשר למחלקות אחרות לרשת מהם; שיעורי Java הם סוג של ההפך מכיוון שהם עוברים בתורשה אלא אם כן מסומנים finalבמילת המפתח. כדי לעקוף שיטת superclass, יש לסמן את השיטה עצמה openולסמן את שיטת subclass override. כל זה חלק מהפילוסופיה של קוטלין להפוך את הדברים למפורשים ולא להסתמך על ברירות מחדל. במקרה הספציפי הזה, אני יכול לראות היכן דרכו של קוטלין לסמן במפורש את חברי כיתת הבסיס כפתוחים לירושה וחברי כיתות נגזרים כעקיפות נמנעת מכמה סוגים של שגיאות Java נפוצות.

מאפייני בטיחות בקוטלין

אם כבר מדברים על הימנעות משגיאות נפוצות, קוטלין נועד למנוע את הסכנה של הפניות למצביע אפס ולייעל את הטיפול בערכי null. היא עושה זאת על ידי הפיכת חוק nullלא חוקי לסוגים סטנדרטיים, הוספת סוגים בטלים והטמעת סימני קיצור לטיפול בבדיקות לאפס.

לדוגמה, משתנה רגיל מסוג  אינו יכול להחזיק  :String null

var a: מחרוזת = "abc"

a = null // שגיאת אוסף

אם אתה צריך לאפשר אפסות, למשל להחזיק תוצאות שאילתות SQL, אתה יכול להכריז על סוג אפס על ידי הוספת סימן שאלה לסוג, למשל String?.

var  b: מחרוזת?

b = null  // בסדר

ההגנות מרחיקות לכת קצת יותר. אתה יכול להשתמש בסוג שאינו מבוטל ללא עונש, אך עליך לבדוק סוג של ביטול עבור ערכי null לפני השימוש בו.

כדי למנוע את הדקדוק המילולי הנחוץ בדרך כלל לבדיקת אפס, קוטלין מציג שיחה בטוחה , כתובה ?.. לדוגמה, מחזיר אם לא , ואחרת. סוג הביטוי הזה הוא .b?.length b.lengthbnullnullInt?

במילים אחרות, b?.lengthהוא קיצור דרך עבור if (b != null) b.length else null. התחביר הזה משתלב יפה, ומבטל די הרבה הגיוני פרוליקס, במיוחד כאשר אובייקט אכלס מתוך סדרה של שאילתות מסדי נתונים, שכל אחד מהם עלול היה להיכשל. למשל, bob?.department?.head?.nameהיה מחזיר את שמו של ראש המחלקה של בוב אם בוב, המחלקה וראש המחלקה אינם אפסים.

כדי לבצע פעולה מסוימת רק עבור ערכים שאינם אפס, אתה יכול להשתמש במפעיל השיחות הבטוחות ?.יחד עם  let:

val listWithNulls: List = listOf ("A", null)

עבור (פריט ב- listWithNulls) {

      פריט? .let {println (it)} // מדפיס A ומתעלם מאפס}

לעתים קרובות אתה רוצה להחזיר ערך תקף אך מיוחד מביטוי בטל, בדרך כלל כדי שתוכל לשמור אותו בסוג שאינו בטל. יש תחביר מיוחד לזה שנקרא מפעיל אלביס (אני לא ילד אותך), כתוב ?:.

val l = b?. אורך?: -1

שווה ערך ל- 

val l: Int = if (b! = null) b. אורך אחר -1

באותה הרוח, Kotlin משמיט Java של הבדק חריג, אשר הם תנאים ניתנים להשלכה כי חייב להיתפס. לדוגמא, חתימת JDK

נספח נספח (CharSequence csq) זורק  IOException;

מחייב אותך לתפוס IOExceptionבכל פעם שאתה קורא appendלשיטה:

נסה {

  log.append (הודעה)

}

לתפוס (IOException e) {

  // לעשות משהו למעט

}

מעצבי ג'אווה חשבו שזה רעיון טוב, וזה היה זכייה נטו לתוכניות צעצועים, כל עוד המתכנתים יישמו משהו הגיוני catchבסעיף. פעמים רבות מדי בתוכניות Java גדולות, לעומת זאת, אתה רואה את קוד שבו חובת catchהסעיף מכיל אך ורק תגובה: //todo: handle this. זה לא עוזר לאף אחד, וחריגים בדוקים התבררו כהפסד נקי לתוכניות גדולות.

קורוטינות קורטלין

קורוטינים בקוטלין הם למעשה חוטים קלים. אתה מתחיל אותם עם launchבונה קורוטין בהקשר של חלקם CoroutineScope. אחד ההיקפים השימושיים ביותר בקורוטין הוא runBlocking{}, אשר חל על היקף בלוק הקוד שלו.

יבוא kotlinx.coroutines. *

fun main () = runBlocking {// זה: CoroutineScope

    השקת {// השקת קורוטין חדש בהיקף runBlocking

        עיכוב (1000 ליטר) // עיכוב שאינו חוסם לשנייה אחת

        println ("עולם!")

    }

    println ("שלום,")

}

קוד זה מייצר את הפלט הבא, עם עיכוב של שנייה אחת בין השורות:

שלום,

עוֹלָם!

קוטלין לאנדרואיד

עד מאי 2017, שפות התכנות היחידות הנתמכות רשמית עבור Android היו Java ו- C ++. גוגל הודיעה על תמיכה רשמית ב- Kotlin ב- Android ב- Google I / O 2017, והחל ב- Android Studio 3.0 Kotlin מובנה בערכת הכלים לפיתוח Android. ניתן להוסיף את Kotlin לגרסאות קודמות של Android Studio עם תוסף.

קוטלין מתכנס לאותו קוד בתים כמו Java, משתף פעולה עם שיעורי Java בדרכים טבעיות ומשתף את הכלים שלו עם Java. מכיוון שאין שום תקורה להתקשרות קדימה ואחורה בין קוטלין לג'אווה, הוספת קוטלין בהדרגה לאפליקציית אנדרואיד הנמצאת כיום בג'אווה הגיונית לחלוטין. במקרים מעטים שבהם אין יכולת פעולה הדדית בין קוד קוטלין לקוד Java, כגון מאפייני הגדרת Java בלבד, הם נתקלים לעתים נדירות ומתקנים בקלות.

Pinterest היה ילד הפוסטר לאפליקציות אנדרואיד שנכתבו בקוטלין כבר בנובמבר 2016, והוא הוזכר באופן בולט ב- Google I / O 2017 כחלק מהודעת קוטלין. בנוסף, צוות קוטלין אוהב לצטט את אפליקציות Evernote, Trello, Square ו- Coursera לאנדרואיד.

קוטלין מול ג'אווה

השאלה אם לבחור בקוטלין או בג'אווה לפיתוח חדש עולה הרבה בקהילת אנדרואיד מאז הכרזת ה- I / O של גוגל, אם כי אנשים כבר שאלו את השאלה בפברואר 2016 כאשר קוטלין 1.0 נשלחה. התשובה הקצרה היא שקוד קוטלין הוא בטוח ותמציתי יותר מקוד ג'אווה, וכי קבצי קוטלין וג'אווה יכולים להתקיים יחד באפליקציות אנדרואיד, כך שקוטלין אינו שימושי רק לאפליקציות חדשות, אלא גם להרחבת אפליקציות Java קיימות.

הטיעון הקוגנטי היחיד שראיתי לבחירת Java על פני Kotlin יהיה במקרה של מתחילים חדשים לחלוטין בפיתוח אנדרואיד. מבחינתם, ייתכן שיש מכשול להתעלות בהתחשב בכך שמבחינה היסטורית, רוב התיעוד והדוגמאות של Android נמצאים ב- Java. מצד שני, המרת Java ל- Kotlin ב- Android Studio היא עניין פשוט של הדבקת קוד Java לקובץ Kotlin.

כמעט עבור כל אחד אחר שעושה פיתוח אנדרואיד, היתרונות של קוטלין הם משכנעים. הזמן האופייני לציטוט של ג'אווה ללמוד קוטלין הוא מספר שעות - מחיר קטן לשלם כדי למנוע שגיאות התייחסות בטלות, לאפשר פונקציות הרחבה, לתמוך בתכנות פונקציונאלי ולהוסיף קוריוטים. ההערכה הגסה האופיינית מצביעה על קיצוץ של כ -40% במספר שורות הקוד מג'אווה לקוטלין.