יום שישי, 21 ביולי 2017

קוטלין (Kotlin) למפתחי ג'אווה ותיקים - חלק ב': פונקציות

המשך לחלק א': קוטלין (Kotlin) למפתחי ג'אווה ותיקים - חלק א': הבסיס


בפוסט הזה אני רוצה להסביר על פונקציות וכמה תכונות של השפה מסביבן.

כרגיל, ננסה ללמוד עוד קצת על הדרך:


  1. הנה כמה קל להשתמש בקוד ג'אווה: אני מבצע import מתוך java.lang.Math לפונקציית החזקה (power).
    בג'אווה, בכדי לייבא מתודה הייתי צריך להדגיש: import static. בקוטלין - ויתרו על התחביר המיותר.
    שווה לציין שכל שלכל קובץ של קוטלין מתבצע מאחורי הקלעים import לשורה של חבילות: *.java.lang וכמה חבילות של קוטלין.
  2. כאשר מספר הוא עשרוני, הקומפיילר אוטומטית מניח שהוא מסוג Double. לא צריך לכתוב d בסוף המספר (אבל כן צריך לכתוב F אם אתם רוצים שיוגדר Float).
  3. כך נראית פונקציה - שוב: מאוד דומה ל Go, מאוד "מודרני".
    שימו לב לטבעיות בשימוש בפונקציה pow שהגיעה מספריה בג'אווה.
  4. הדרך להפעיל (invoke) פונקציה - היא כמו בג'אווה.
  5. זו הדרך הפשוטה להציג רק 2 ספרות עשרוניות למספר - בעזרת פונקציית format של ג'אווה.
  6. אני יכול לקרוא לפונקציה תוך כדי שאני מציין את שמות הפרמטרים כמו שהוגדרו בפונקציה (ואז סדר הארגומנטים לא משנה).
    זה אולי קריא יותר, אבל ה IntelliJ מוסיף תגיות מאוד דומות בכל מקרה (כיביתי אותן כרגע).
  7. זו הדרך לבצע formatting לאלפים + 0 ספרות לאחר הנקודה - שוב, בעזרת פונקציית format של ג'אווה.

הנה הפלט:




Nullable Types

בוודאי אתם מכירים שה Exception הנפוץ ביותר בג'אווה הוא NullPointerExcpetion.

כמו שפות מודרניות אחרות, יוצרי קוטלין החליטו להגדיר את השפה כ "null-safe by default". כעיקרון, אין nulls, אלא אם אתם מתירים אותם.


  1. זו תהיה שגיאת קומפליציה. מה פתאום לקבוע ערך null? אין מצב!
  2. אם אנחנו מגדירים ש y הוא מסוג Nullable String - אז אפשר לקבוע בו ערך null. בסדר.
  3. גם זו שגיאת קומפילציה: השתגעתם? לקרוא למתודה ()length למשהו שעשוי להיות null? אנחנו לא רוצים nullpointerException!
  4. פה הקומפיילר חכם: אם כבר בדקתי שהערך איננו null - אז יאפשרו לי לקרוא למתודות על האובייקט ה nullable.
  5. דרך אחר לעשות זאת, להשתמש באופרטור ?. במקום . - שמגן עלי בפני nullPointerException.
    אם y הוא null - אזי תוצאות כל הביטוי תהיה גם היא null.
  6. מה קורה עם מחלקה שאני מביא מג'אווה? בג'אווה - כל האובייקטים הם Nullable.
    אתם רואים שאני צריך לבנות מבנה דיי מורכב (ולא מעניין) על מנת להגן על עצמי מ NullPointerException.
    החלטה תכנונית של שפת קוטלין היא לא להגן עלי בכוח בפני אובייקטים של ג'אווה - כי כך אני רגיל. ההגנה ברמת הקומפילציה היא רק בפני אובייקטים של קוטלין שהם Nullable.
  7. בכל זאת, קוטלין מספקת לי תחביר מקוצר ובטוח לעבודה עם אובייקטים שהם Nullable. התחביר הזה תופס גם לאובייקטים של ג'אווה, וגם לאובייקטים של קוטלין שהם Nullable (ואולי יש להם פונקציה שערך ההחזרה שלה הוא Nullable).
    במקרה הזה, מכיוון ש ()getExtID מחזיר null (נניח), כל הביטוי יוערך כ null - ולא ייזרק NullPointerException.
  8. לקוטלין יש כמה כלים לעבוד עם רשימות שחלק מהאיברים בהן עשוי להיות null.
    גישה ראשונה היא השימוש בפונקציה let שתפעל רק אם הערך הוא לא null.
    אפשר להשתמש ב let גם ללא קשר לרשימת איברים.
  9. גישה שניה, היא להשתמש בפונקציה / פילטר בשם ()filterNotNull, כלומר: להשאיר רשימה הכוללת רק איברים שאינם null.
  10. אני יכול לבדוק אם משתנה הוא null ולהגיב בהתאם.
  11. או בגלל שזו פעולה שכיחה, להשתמש באופרטור ה :? (נקרא Elvis Operator) - בכדי להשיג בדיוק אותו הדבר בכתיבה מקוצרת.
  12. אם אני ממש מתעקש, אני לומר לקומפיילר: "עזוב אותי באמאשלך! אני אסתדר עם ה null-ים שלי בעצמי", בעזרת אופרטור ה .!!
    1. שימו לב שאת האופרטור הזה אפשר להפעיל רק על משתנים שהם immutable (למשל: val) - אחרת, יכול תאורטית thread אחר להיכנס בין "שורות" ההפעלה שלי - ולשים בו null.
      1. אופס!, חטפתי KotlinNullPointerException.


הנה הפלט:




ערכי החזרה מיוחדים


שימו לב לחבר'ה הבאים:



1. לפונקציה foo לא הגדרנו ערך החזרה. היא בעצם בעלת ערך החזרה מטיפוס Unit (בצורה לא מפורשת).


    Unit הוא כמו void בג'אווה - אבל ניתן לשמור את הערך (עבור גנריות של הקוד).
    אם יופיע בלוג "kotlin.Unit" - מכאן זה מגיע.

2. ניתן להגדיר את אותה הפונקציה כ Unit בצורה מפורשת.
3. הפונקציה fail היא מסוג Unit, אבל בעצם היא לעולם לא תחזיר Unit - כי תמיד היא זורקת Exception (שימו לב שבקוטלין לא משתמשים ב new).
4. ניתן להגדיר פונקציה שלעולם לא תגיע ל return - כבעלת ערך החזרה מטיפוס Nothing.


את Nothing לא ניתן להציב במשתנה - זו בעצם הערה לקומפיילר.

5. כאן נקבל שגיאת קומפליציה מסוג Conflicting declaration - הקומפיילר לא יודע איזה טיפוס להגדיר ל data:
    Int - בגלל Zoo?
    או אולי Any (ה root בהיררכיית האובייקטים בקוטלין, כולל null) - בגלל ש fail הוא מטיפוס Unit?

6. במקרה הזה הקופיילר רגוע: מ ()gail לא יכול לחזור ערך (הוא מסוג Nothing), ולכן data יוגדר כטיפוס Int.


מעניין אולי לציין ש null הוא singleton מטיפוס ?Nothing.





default value ו vararg



  1. אני יכול להגדיר בפונקציה פרמטרים עם ערך ברירת מחדל - למשל: cores.
  2. אני יכול לקרוא לפונקציה עם כל הארגומנטים (ה annotations הם של ה IDE).
  3. אני יכול לקרוא לפונקציה ולהשמיט את הארגומנט - ואז לקבל את ערך ברירת המחדל.
  4. הנה הגדרתי פונקציה לחישוב ממוצע ה CPU utilization במכונה - ע"י חישוב הממוצע של ה cores.
    שימו לב שניתן להשתמש בכתיב מקוצר (=), אם הפונקציה גוף הפונקציה הוא ביטוי (expression) בודד - גם אם אין ערך החזרה. הגדרה כזו נקראת shorthand function.
  5. אני יכול גם להגדיר מספר משתנה של פרמטרים - בעזרת המילה vararg (המקבילה של ... בג'אווה).
    המשתנה core הוא מטיפוס <Array<out T  - אסביר את הנושא של out, כשנגיע ל Generics.

    אם יקראו ל printStats עם 2 פרמטרים - הפונקציה הראשונה תופעל.
    אם ל printStats עם מספר שונה של פרמטרים - הפונקציה השנייה תופעל.


התוצאה:




פונקציות מסדר גבוה

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


  1. הנה אנחנו מגדירים פונקציה בשם profile המקבלת פונקציה אחרת (func) כפרמטר.
    התחביר הוא סוגריים עם רשימת משתנים, חץ (<-) וערך החזרה.
    מעבר לכך, זהו פרמטר לכל דבר.
  2. בכדי להוסיף ערך מוסף כלשהו, השתמשתי בפונקציית ה profiling של ג'אווה, המחזירה את הזמן הנוכחי בננו-שניות.
  3. הפעלה של הפונקציה func נעשית בצורה טבעית למדי.
  4. עכשיו אגדיר 2 פונקציות דומות המתאימות בחתימה לפרמטר func של profile: מקבלות 2 מספרים שלמים - ומחזירות ערך של מספר שלם
  5. כעת אני סקרן לדעת איזו פונקציה יעילה יותר מבחינת ביצועים!
    כך אני מפעיל את הפונקציה "הגבוהה" profile:
    הקומפיילר צריך לדעת שאני רוצה לשלוח רפרנס לפונקציה ולא להפעיל אותה, את זה עושים בעזרת האופרטור :: - המחזיר reference לפנוקציה.
    הקפדתי על ארגומטים עם ערך זהה, על מנת לא להטות את בדיקת הביצועים 😉
    אם אני רוצה רפרנס למתודה של אובייקט, התחביר הוא object::method.
  6. מה קורה כאשר אני רוצה להגדיר חתימה של פונקציה שלא מחזירה כלום?
    אם אגדיר רק (Int) - הקומפיילר יתעלם מהסוגריים ויניח שמדובר בפרמטר מסוג Int.
    עלי לציין ערך החזרה מסוג Unit (כפי שראינו מוקדם יותר בפוסט) - ואז הקוד יתנהג כמצופה.

הנה הפלט:


אלף ננו-שניות הן מיקרו-שניה (ולא מילי-שניה, לא לבלבל!).
הממ... משהו מוזר לי בזמנים של הפונקציה add - הייתי מצפה לכ 50,000 ננו-שניות (5 הפעלות של פונקציה) ומטה (אופטימיזציות של הקומפיילר)...


Lambda Expressions

בואו נסתכל שוב על הפונקציות add ו addFast שלמעלה. עבור שימוש חד פעמי - הייתי צריך להגדיר פונקציה, מה שלוקח עוד קצת מקום אבל בעיקר - מנתק את הקוד מההקשר.

לא היה נחמד יותר לכתוב את גוף הפונקציה inline?



  1. הנה אני יכול לכתוב את הפונקציה inline, כ anonymous function. זה התחביר - ללא שם. זה עדיין לא מאוד אלגנטי.
  2. יותר אלגנטי יהיה לכתוב את אותה הפונקציה inline כ lambda expression. זה התחביר.
  3. מכיוון שהקומפיילר יודע מה החתימה של profile - זה מיותר לציין לו טיפוסים על הפרמטרים, ולכן ניתן לכתוב את הפונקציה בצורה קצרה יותר.
  4. חשוב לציין שאם אני עושה extract variable ל lambda expression, והיא כבר לא inline - הקומפיילר לא יידע להסיק את הטיפוסים של הפרמטרים - ויש לציין אותם בחזרה.
  5. לצורך ההסבר, נעבור לעבוד עכשיו עם פונקציה דומה ל profile בשם profileOne, המצפה לפרמטר אחד בלבד.
    שימו לב שהחלפתי את סדר הפרמטרים בפונקציה, כאשר func הוא הפרמטר האחרון. מייד אסביר מדוע זאת היא הקונבנציה ב higher order functions בקוטלין.
  6. כאשר יש פרמטר יחיד לפונקציה, לא צריך להגדיר אותו. אפשר להשתמש בצורה מקוצרת המדלגת על ההגדרה (<- num) ישר לגוף הפונקציה. אם לא הוגדר שם משתנה - ההתייחסות אליו תהיה כ it.
    זה יכול להיות קיצור נחמד, אבל הייתי ממליץ לכם להימנע ממנו כאשר יש פונקציות מקוננות - אז זה נהיה מבלבל.
  7. הנה הסיבה מדוע הקונבנציה בקוטלין היא שהפונקציה תהיה הפרמטר האחרון: אם ורק אם הפונקציה היא הפרמטר האחרון, אפשר לכתוב את גוף הפונקציה מחוץ לסוגריים.
  8. למה זה טוב? זה שימושי אם אתם רוצים לייצר משהו שדומה ל DSL (יש עוד מה להרחיב בנושא בפוסטי המשך).
    למשל: הגדרתי את הפונקציה enhance (שאולי מוסיפה לוגים, בדיקות אבטחה, ניטור, וכיוצ"ב) ואז אני פשוט שולח לה קוד. זה דומה מאוד ל DSL.
  9. אשנה קצת את ה layout של הקוד בכדי להדגיש: אתם יכולים להגדיר פונקציות שלכם, שנראות "כמו" מילה בשפה. כמה מבלבל הוא לראות enhance שכזה (מבלי להכיר את קוטלין) - ולא למצוא בגוגל מה הוא עושה 😏

אז עם כל התחביר הנחמד הזה של למבדה, מה הטעם להשאיר את ה Anonymous Function?
יש מקרים שבהם הוא בכל זאת שימושי, למשל: כאשר אתם רוצים לעשות return מתוך מקומות שונים בתוך הפונקציה.
מקרה אחר: אני יכול להגדיר return type - שאולי הוא subtype של מה שמגדירה הפונקציה מסדר-גבוה, המארחת.



Closures

פונקציה אנונימית ו lambda expression מסוגלים לגשת למשתנים של הפונקציה שעוטפת אותם - וגם לשנות אותם (זה שוני מג'אווה).


הנה דוגמה פשוטה עבור ההסבר.
למשתנה n, שנמצא באותו ה closure עם הלמבדה - אני יכול לגשת.
למשתנה m, שנמצא בפונקציה עוטפת, אך לא בתוך ה closure - אני לא יכול לגשת.

משתנה שניגשנו אליו בתוך Closure לא "יוקפא הערך שלו" - כמו בג'אווהסקיפט, למשל.

לאחר הסרת השורה הבעייתית, הנה הפלט:





סיכום


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

האם סיימנו לכסות את נושא הפונקציות?
עוד לא.

יש עוד Local Function, Infix Functions, Inline Functions, Extension Functions - ואולי עוד שכחתי משהו.

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

הנה פוסט ההמשך.


שיהיה בהצלחה!



אין תגובות:

הוסף רשומת תגובה