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

למה קוטלין?

קוטלין הוצגה במקור בשנת 2011, והגרסה 1.0 שלה יצאה בשנת 2016. היא פותחה על ידי JetBrains, חברה שמתמחה בכלי פיתוח למפתחים.
כמו ש-C++ במקור הייתה אמורה להיות גרסה משופרת של C, ככה גם קוטלין במקור הייתה אמורה להיות גרסה משופרת של Java. אבל מאז קוטלין התפתחה להיות הרבה יותר מזה.

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

קריאות Readability

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

תמיכה בפרדיגמות מרובות

קוטלין תומכת בפרדיגמות מרובות:

• תכנות אימפרטיבי

• תכנות פונקציונאלי

• תכנות מונחה עצמים

תמיכה בפלטפורמות מרובות

אפשר לקמפל את קוטלין לכמה פלטפורמות שונות

• JVM - הקוד של קוטלין יכול להיות מקומפל ל-bytecode (קבצי .class) מה שמאפשר לקוטלין לרוץ על כל JVM

• Android - לאנדרואיד יש סביבת ריצה משלו - ART ואפשר לקמפל את קוטלין לקבצי .dex

• JavaScript - על מנת להריץ בדפדפנים

• Native Binaries - לקמפל את הקוד עבור CPU ספציפי

Hello, World!

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

הפונקציה println() היא פונקציה מהספריה הסטנדרטית אשר מקבלת פרמטר בודד מסוג String (אם פרמטר אשר יכול להפוך להיות String). היא מדפיסה למסך את ה-String ויורדת שורה.
אם אנחנו לא רוצים לרדת שורה אנחנו יכולים להשתמש בפונקציה print()

קוטלין לא דורשת שימוש ב-; בסוף כל שורה. אנחנו נשתמש בו רק כאשר אנחנו רצה להפריץ בין כמה הצהרות באותה שורה

משתנים קבועים, משתנים וסוגי משתנים

על מנת ליצור משתנה קבוע, אשר אי אשפר לשנות את הערך ההתחלתי שהוא קיבל, אנחנו יכולים להשתמש ב-val.
המבנה הצהרה של משתנים קבועים בקוטלין נראה כך

val identifier: Type = value

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

val identifier = value

שתי הדוגמאות הבאות הן תקינות בקוטלין

val daysInFebruary = 28
val daysInMarch: Int =31

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

var identifire1 = value
var indentifier2: Type = value

ובניגוד ל-val אנחנו יכולים לשנות את הערך של var

var hoursSpent = 20
hourSpent = 25

אבל אנחנו לא יכולים לשנות את ה-type של המשתנה שלו.
הקוד הבא יזרוק שגיאה

hoursSpent = 30.5

כיוון ש-hoursSpent הוגדר להיות Int ואי אפשר לשנות אותו להיות Float

פונקציות

ככה נראה הסינטקס של פונקציות

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

יש עוד סינטקס לכתוב פונקציות, קצרה יותר עבור פונקציות עם ביטוי בודד.
היא נקראת expression body והיא נראית כך

fun functionName(arg1: Type1, arg2: Type2, ..): ReturnType = result

בדוגמה הבאה יש לנו את כל סוגי הפונקציות

הפונקציה cube() היא מהסוג הראשון, עם שימוש ב-return.
קוטלין מתייחסת לערך החזרה של bang() בתור String

משתנים בוליאנים

עבור אלגברה של בוליאנים קוטלין מספקת לנו אופרטורים כמו:

• ! - שלילה

• && - וגם

• || - או

בואו נסתכל על דוגמה

כשאנחנו מאתחלים את isOpen אנחנו משתמשים ב-&&. התנאי הראשון בודק האם hour >= opens שהוא false אז כל התוצאה של כל התנאי הוא false.

כשאנחנו מאתחלים את isClosed אנחנו משתמשים ב-|| והתוצאה היא true כיוון שהתנאי hour < opens הוא אמת

ביטויי if

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

כאן הקוד הוא מאוד פשוט, אבל חשוב לשים לב שה-if מחזיר ערך.

כאן כבר יש לנו קוד כבר יותר מורכב.
המשתנים activity, hour הם משתנים שמוגדרים מחוץ לבלוק של ה-if ולכן הם נגישים בתוך הבלוק.
המשתנים שאנחנו מגדירים בתוך הבלוג של ה-if כמו opens, closes נגישים רק בתוך הבלוק עצמו.
התוצאה של הבלוק היא true כיוון שהתנאי בשורה 14 מתקיים.

מחרוזות

קוטלין מאפשרת לנו לבצע פעולה דומה ל-String.format() של ג'אווה, רק בצורה הרבה יותר נוחה.
על מנת להתחייס לערך של משתנה מסוג String בתוך מחרוזת אחרת, עלינו להשתמש בסימן $.
הפיצ'ר הזה נקרא String Templates
בואו נסתכל על דוגמה

בשורה 3 אנחנו רואים שימוש במשתנה answer על מנת לבנות את המחרוזת להדפסה. אנחנו מחליפים את המשתנה עם הערך שלו, 42
בשורה 5 יש לנו דוגמה יותר מורכבת, כאל אנחנו מבצעים הערכה של if condition על מנת להחליט מה להדפיס (מזכיר קצת את השימוש ב-$ בשפת Bash
בדוגמה השלישית, בשורה 6, אנחנו רואים שמודפס ממש $1, כיוון שקוטלין לא מזהה את 1 בתור משתנה שאפשר למשוך ממנו את הערך.

יש לנו אפשרות גם להכניס מחרוזת עם כמה שורות

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

סוגי מספרים

קוטלין מספקת סוגים של מספרים שלמים (Int, Long) ומספרים עשרוניים (Double).
עבור מספרים שלמים, באופן דיפולטיבי משתמשים ב-Int, אבל אם נוסיף L למספר, הוא יהפוך להיות Long.
אם נוסיף נקודה דסימלית למספר, הוא באופן דיפולטיבי יהיה Double

מספר מסוג Int יכול להחזיק ערכים החל מ- 231- ועד 231-1. בקוטלין אנחנו יכולים ליצור מצב של Overflow, כלומר שאם נוסיף משהו לערך הגבוה ביותר של Int אנחנו נעבור לערך הקטן ביותר

כאשר אנחנו מבצעים חלוקה של Int ב-Int, קוטלין תוציא Int כתוצאה של החילוק, וכל שארית הולכת לאיבוד.
לדוגמה התוצאה של החילוק 1/2 היא 0. אבל אם אנחנו מערבים Double בחילוק, קוטלין תמיר את ה-Int ל-Double לפני ביצוע של החילוק.
לדוגמה 1.0/2 יהיה 0.5
אבל בואו נסתכל על משהו קצת מוזר

אפשר לצפות שגם d1 היה אמור להיות 3.4, אבל כיוון שיש סדר לביצוע פעולות זה לא קורה. קוטלין קודם כל מבצעת את החילוק 2/5, וכיוון ששניהם Int התוצאה היא 0. ואז מגיע החיבור עם ה-Double אבל הפעולה היא 3.0 + 0. במקרה של d2 אנחנו מבצעים חילוק בין Double לבין Int ולכן אנחנו שומרים על השארית, ומכאן ההבדל בתוצאה.

לולאת while

לאלו שלא מכירים, לולאת while ממשיכה כל עוד התנאי הבוליאני שלו ממשיך להיות true
אנחנו בודקים את הערך של התנאי בפעם הראשונה שאנחנו עומדים לבצע את הלולאה, וכל פעם אחרי שהלולאה סיימה את הבלוק שלה.

לולאות וטווחים

שפות תכנות רבות מתשמשות באינדקס על מנת לעבור על כל האיברים ב-iterable, אבל קוטלין מאפשר גישה ישירה יותר

כאן אנחנו יכולים לראות גישה ישירה ל-String כאשר אנחנו עוברים עליו בלולאה.
נקודה חשובה, המשתנה c כאן הוא מסוג val כלומר אי אפשר לתת לו ערך אחר בתוך הגוף של הלולאה. c += 1 יזרוק שגיאה

הנה עוד דוגמה לשימוש במילה in וב-range
בקוטלין על מנת להשתמש ב-range עלינו להשתמש ב..

ביטויים Expression & Statements

ברוב שפות התכנות החלק השמימושי הקטן ביותר נקרא statement או expression
אבל הם לא אותו דבר, יש הבדל

• ה-statement משנה מצב (state)

• ה-expression מחזיר תוצאה חזרה.

כמעט כל דבר בקוטלין הוא expression

val hours = 10
val minutesPerHour = 60
val minutes = hours * minutesPerHour

בכל אחד מהמקרים מה שבא אחרי הסימן = הוא expression שמחזיר ערך ושומר אותו במה שנמצא בצד שמאל
פונקציות כמו println() לא נראות שהם מספקות ערך החזרה, אבל הן עדיין expression, ולכן הן עדיין חייבות צריכות להחזיר ערך.
לקוטלין יש סוג מיוחד בשביל המקרים הללו - Unit