שאלות ותשובות בראיון על Scala

מדריכים
Scala

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

שאלות ראיון בסקאלה

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

הקדמה

I’m going to deliver Scala/Play/Akka Interview Questions and Answers in three parts:

  1. שאלות ראיון ותשובות בסקאלה:
    נדבר כאן על כמה שאלות ראיון בסקאלה, שיהיו שימושיות למתחילים או למפתחי Java שרוצים לעבור לפיתוח בסקאלה או שיש להם שנה או יותר של ניסיון כמפתחי סקאלה.2. שאלות ראיון בסקאלה לרמה בינונית ותשובות:-
    נדבר על כמה שאלות ראיון שיהיו שימושיות למפתחים עם 2 שנים או יותר של ניסיון כמפתחי Scala/Java.3. שאלות ראיון מתקדמות בסקאלה ותשובות:-
    נדבר על כמה שאלות ראיון שיהיו שימושיות למפתחים בסקאלה/Java עם 5 שנים או יותר של ניסיון.4. שאלות ראיון על קונקורנציה ופרלליזם בסקאלה/Java ותשובות:-
    נדבר על שאלות ראיון בנוגע לקונקורנציה ופרלליזם בסקאלה/Java ותשובות, שיהיו שימושיות למפתחים בסקאלה/Java עם 5 שנים או יותר של ניסיון.

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

שאלות ראיון בסקאלה בסיסיות

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

  1. מהו Scala? האם זו שפה או פלטפורמה? האם היא תומכת ב־OOP או FP? מי הוא אבי Scala?
  2. האם Scala היא שפת טיפוסים סטטיים? מהו שפת טיפוסים סטטיים ומהו שפת טיפוסים דינמיים? מה ההבדל בין שפות סטטיות לשפות דינמיות?
  3. האם Scala היא שפת OOP טהורה? האם Java היא שפת OOP טהורה?
  4. האם Scala תומכת בכל המושגים של תכנות פונקציונלי? האם Java 8 תומכת בכל המושגים של תכנות פונקציונלי?
  5. מהם היתרונות העיקריים של שפת Scala? האם יש חסרונות לשפת Scala?
  6. מהו החסרון העיקרי של שפת Scala?
  7. מהו המטרה העיקרית של שפת Scala?
  8. מהם שפות JVM הפופולריות הזמינות כעת?
  9. כמו במחלקת java.lang.Object של Java, מהו מחלקת העל של כל המחלקות ב־Scala?
  10. מהו מודיפייר הגישה הדיפולטיבי ב־Scala? האם Scala כוללת מילת מפתח "ציבור"?
  11. מהו "היסטור טיפוסים" ב־Scala?
  12. מה ההבדל בין Int של Scala ל־java.lang.Integer של Java? מה הקשר בין Int ל־RichInt ב־Scala?
  13. מהו Nothing ב־Scala? מהו Nil ב־Scala? מה הקשר בין Nothing ל־Nil ב־Scala?
  14. מהו Null ב־Scala? מהו null ב־Scala? מה ההבדל בין Null ל־null ב־Scala?
  15. מהו Unit ב־Scala? מה ההבדל בין void של Java ל־Unit של Scala?
  16. מה ההבדל בין `val` ו-`var` ב־Scala?
  17. מהו REPL ב־Scala? מהו השימוש ב־REPL של Scala? איך לגשת אל REPL של Scala מהפקודה CMD?
  18. מהם תכונות Scala?
  19. כיצד אנו מיישמים לולאות בצורה פונקציונלית? מה ההבדל בין לולאות בסגנון OOP ו־FP?
  20. מהו "אפליקציה" ב־Scala או מהו Scala Application? מהו "App" ב־Scala? מהו השימוש ב־App של Scala?
  21. האם Scala תומך בהעמסת אופרטורים? האם Java תומכת בהעמסת אופרטורים?
  22. מהו ביטוי? מהו הצהרה? מה ההבדל בין ביטוי להצהרה?
  23. מה ההבדל בין "If…Else" של Java ל־"If…Else" של Scala?
  24. האם Scala היא שפת תכנות מבוססת על ביטויים או על הצהרות? האם Java היא שפת תכנות מבוססת על ביטויים או על הצהרות?
  25. ספר לי כמה תכונות נתמכות ב־Java אך לא ב־Scala ולהפך.
  26. מה ההבדל בין פונקציה לבין שיטה ב־Scala?
  27. כמה קבצי כתובת ציבור ניתן להגדיר בקובץ מקור של Scala?
  28. כמו ב־Java, מהם היבואים הברירתיים בשפת Scala?
  29. כמה אופרטורים יש ב־Scala ולמה?
  30. ציין כמה מילות מפתח שמשמשות ב־Java ואינן דרושות ב־Scala. למה Scala אינה זקוקה להן?
  31. מהו PreDef ב־Scala?

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

שאלות ראיון ותשובות ב־Scala

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

מהו Scala? האם זו שפה או פלטפורמה? האם היא תומכת ב־OOP או FP? מי הוא אבי Scala?

שקאלה מתייחסת ל־שפת התכנות SCAlable LAnguage. מרטין אודרסקי הוא אבי של שקאלה. שקאלה היא שפת תכנות מרוב־פרדיגמית, התומכת במושגים של תכנות עצמאי ותכנות פונקציונאלי. היא נוצרה ופותחה על ידי מרטין אודרסקי. שקאלה היא שפת תכנות מסוג Type-Safe Object-Functional הרצה על JVM (Java Virtual Machine). היא משלבת באופן הולם תכנות פונקציונאלי עם תכנות עצמאי וכן מונה על ידי המכונה הווירטואלית של ג'אווה. שקאלה היא שפת תכנות המשלבת באופן הולם בין גישות התכנות הפונקציונאלית והתכנות העצמאית. השפה מצויה עם מערכת טיפוסים יציבה וסטטית, אשר בודקת את כל סוגי הטיפוסים בזמן הקמילה.

האם שקאלה היא שפת תכנות בעלת טיפוסים סטטיים? מהו טיפוס סטטי ומהו טיפוס דינמי? מה ההבחנה בין שפות תכנות בעלות טיפוסים סטטיים לבין אלו בעלות טיפוסים דינמיים?

כן, Scala היא שפת תכנות מסוג סטטי. סוג התכנית בשפה סטטית מתבצע בזמן הקמת הקוד על ידי המהדר, ולא בזמן הרצה. היתרון העיקרי של שפות כאלו הוא שכמתכנתים, עלינו להקפיד על כתיבת קוד נכון כדי למנוע שגיאות בזמן הקמה. מאחר שהמהדר בודק רבות מתקופה זו, אנו נמנעים מבעיות או באגים רבים בזמן הרצה. דוגמאות: Java, Scala, C, C++, Haskell ועוד. שפת תכנות דינמית משמעה שבדיקת הסוגים נעשית בזמן הרצה ולא בזמן הקמת הקוד על ידי המהדר. כשהמהדר אינו בודק סוגים בזמן הקמה, יש יותר סיכוי לבעיות או באגים בזמן ריצה. דוגמא: Groovy, JavaScript, Ruby, Python, Smalltalk ועוד.

האם Scala היא שפת תכנות עם תכנות עצמאי יזומן (Pure OOP)? האם Java היא שפת תכנות עם תכנות עצמאי יזומן (Pure OOP)?

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

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

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

האם Scala תומך בכל המושגים של תכנות פונקציונלי? האם Java 8 תומך בכל המושגים של תכנות פונקציונלי?

כן, Scala תומך בכל המושגים של תכנות פונקציונלי (FP). Java 8 הכניסה מספר מבנים לתכנות פונקציונלי, אך היא **אינה** תומכת בכל המושגים של תכנות פונקציונלי. לדוגמה, ב-Java 8 אין תמיכה בהתאמת תבנית, בקינור של פונקציות, בהצטרפות כבילות וכדומה.

מהם יתרונותיה העיקריים של שפת Scala? האם ישנם חסרונות בשפת Scala?

אם נשתמש בשפת Scala לפיתוח האפליקציות שלנו, ניתן לקבל את היתרונות הבאים והחסרונות: יתרונות של שפת Scala:-

  • קוד פשוט ומרוכז
  • קוד מאוד ביטויי
  • קוד קריא יותר
  • שפת תכנות בעלת אבטחת טיפוסים של 100%
  • אי השפעה ואין תופעות צד
  • קוד ניתן לשימוש יותר
  • יותר אפשרויות למודולריות
  • עשה יותר עם פחות קוד
  • תחביב גמיש מאוד
  • תומך בכל התכונות של OOP
  • תומך בכל תכונות FP. פונקציונליות גבוהה מאוד
  • קוד פחות נוטה לשגיאות
  • תכנות צמוד ומרובה טרייה טוב יותר
  • קוד קל לשקילה ותחזוקה ברמה גבוהה
  • יעילות גבוהה מאוד
  • יישומים מבוזרים
  • אינטרופרביליות מלאה של Java
  • DSL חזק של Scala זמין
  • REPL כדי ללמוד בסיסים של Scala

חסרונות של שפת Scala:-

  • קוד פחות קריא
  • קצת קשה להבין את הקוד למתחילים
  • תחביב מורכב ללמוד
  • פחות תאימות לאחור

הערה:- אנו יכולים לכתוב קוד Scala בדרך שקריאה יותר או פחות קריאה.

מהו החסרון העיקרי של שפת Scala?

למעט היתרונות הרבים של Scala, יש לה את אחת החסרונות המרכזיים: בעיה בתאימות לאחור. אם נרצה לשדרג לגרסה האחרונה של Scala, אז עלינו לטפל בשינוי שמות החבילות, שמות המחלקות, שמות השיטות והפונקציות וכדומה. לדוגמה, אם אתה משתמש בגרסה ישנה של Scala והפרויקט שלך משתמש בהערכת BeanProperty, היא הייתה זמינה ב- "scala.reflect" כמו "scala.reflect.BeanProperty" בגרסאות ישנות. אם נרצה לשדרג לגרסאות החדשות, עלינו לשנות את החבילה הזו מ- "scala.reflect" ל- "scala.beans".

מהו הסלגן המרכזי של שפת Scala?

כמו במוטו של Java "כתוב פעם אחת, הרץ בכל מקום", ל-Scala יש את המוטו "עשה יותר עם פחות" או "עשה יותר עם קוד פחות". "עשה יותר עם פחות" אומר שאנו יכולים לפתח תכנית או לוגיקה מורכבת יותר עם קוד פחות.

java, scala, groovy ו־closure הם השפות הנפוצות ביותר ב-jvm (java virtual machine). שפות ה-jvm scala, groovy ו־closure תומכות בשני תכנותים, אובייקט-אוריינטד ופונקציונלי. java se 8 תומכת בכל תכנות האובייקט-אוריינטד. אולם, היא תומכת במעט מאוד בתכנות הפונקציונלי כמו ביטויי lambda, פונקציות, השמה אוטומטית של טיפוסים, ופונקציות מדרג גבוה.

כמו במחלקת java.lang.object של java, מהו המחלקה האב של כל המחלקות ב-scala?

כפי שאנו יודעים ב-java, המחלקה האב של כל המחלקות (מחלקות api של java או מחלקות שמוגדרות על ידי המשתמש) היא java.lang.object. באותו אופן ב-scala, המחלקה האב של כל המחלקות או התכונות היא המחלקה "any". המחלקה any מוגדרת בחבילה של scala כמו "scala.any".

מהו מחלקת הגישה הדיפולטית ב-scala? האם יש ל-scala מילה "public"?

בִּסְקָאְלָה, אִם אֵין לָנוּ מוֹדִיפִּיקֵר גִּישָן לְשֵׁם, פוּנְקְצִיָּה, מַאֲפֶה, אוֹבְיֶקט אוֹ דַרְךְ, מַאֲפֶה הַגִּישָן הָרַגְלִי הוּא "צִיבּוּר". גַּם עַל יְדֵי שְׂדוֹת, "צִיבּוּר" הוּא הַגִּישָׁן הָרַגְלִי. בִּשְׁלִיחוּתָם הָרַגְלִיָּה, סְקָאְלָה אֵין לָהּ אֶת הַמִּילָּה "צִיבּוּר".

מַהוּ "הַשְׁקָפָה מִסוֹג" בְּסְקָאְלָה?

סוּגִים יְכוֹלִים לְהִסְקִים עַל יְדֵי הַמְּתַמְּשֵׁךְ בְּסְקָאְלָה בְּעֵת הַקוֹמֵפִילַצְיָה. נִכְרָאָה כְּ"הַשְׁקָפָה מִסוֹג". סוּגִים מַשְׁמִיעִים סוֹג־מַעֲרֶךְ אוֹ סוֹג־תּוֹצָאָה. אֲנַחְנוּ מַשְׁתִּמִשִׁים בְּסוּגִים בִּסְקָאְלָה בִּמְקוֹמוֹת רַבִּים כְּדֵי לִקְבוֹעַ סוֹג־מַשְׁתִּמֵשׁ, סוֹג־אוֹבְיֶקט, סוֹג־מַרְפֵּאִים/פוּנְקְצִיּוֹת פָּרָמִטְרֵים, סוֹג־הָשָׁבָה מֵתוֹךְ פּוֹנְקְצִיּוֹת/פוּנְקְצִיּוֹת חֲזִירִיּוֹת וְכוּ'. בְּמִלִּים פְּשׁוּטוֹת, קַבָּלַת הַסוֹג שֶׁל מַשְׁתִּמֵשׁ אוֹ בִּיטוּלִים אוֹ אוֹבְיֶקט וְכוּ' בְּעֵת הַקוֹמֵפִילַצְיָה עַל יְדֵי הַמְּפָעֵל הוּא נִכְרָאָה כְּ"הַשְׁקָפָה מִסוֹג".

מַהן הַדְמוּיוֹת וְהַהַבְדָּלִים בֵּין Int בִּסְקָאְלָה וּבֵּין java.lang.Integer בְּג'אוֹוָה? מַה הַקֶּשֶׁר בֵּין Int וּבֵין RichInt בִּסְקָאְלָה?

דְּמוּיוֹת בֵּין Int בִּסְקָאְלָה וּבֵּין java.lang.Integer בְּג'אוֹוָה:

  • שניהם הם קבוצות.
  • שניהם משמשים לייצוג מספרים שלמים.
  • שניהם הם מספרים שלמים מחוזקים ב-32 ביט.

ההבחנות בין Int ב-Scala ל- java.lang.Integer ב-Java:

  • ה-Int של Scala אינו מיישם את ממשק Comparable.
  • ה-Integer של java.lang מיישם את ממשק Comparable.

ה-Integer של Java דומה ל-Int של Scala ול-RichInt. RichInt הוא מחלקה סופית שמוגדרת בחבילת scala.runtime כמו "scala.runtime.RichInt". ב-Scala, הקשר בין Int ו-RichInt הוא שכאשר אנו משתמשים ב-Int בתוכנית Scala, זה יהפוך אוטומטית ל-RichInt כדי להשתמש בכל השיטות הזמינות במחלקה זו. אנו יכולים לקבוע ש-RichInt הוא מחלקה משנה (Implicit) של Int. (נדבר על "מהו Implicit ועל יתרונות ה-Implicits" בפוסט הבא שלי).

מה זה Nothing ב-Scala? מה זה Nil ב-Scala? מהו הקשר בין Nothing ו-Nil ב-Scala?

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

  • ניל מוגדרת באמצעות Nothing (ראה למטה לדוג'ים).
  • None מוגדרת באמצעות Nothing.
object None extends Option[Nothing]
  • אנו יכולים להשתמש ב-Nothing כסוג החזרה של שיטות שאינן מחזירות אף פעם.
  • אנו יכולים להשתמש ב-Nothing כסוג החזרה של שיטות שמסיימות באופן לא רגיל.

ניל היא אובייקט המשמש לייצוג רשימה ריקה. היא מוגדרת בחבילת "scala.collection.immutable" כמו שמוצג למטה:

object Nil extends List[Nothing]

דוגמה:-

scala> Nil
res5: scala.collection.immutable.Nil.type = List()

scala> Nil.length
res6: Int = 0

מהו Null ב-Scala? מהו null ב-Scala? מה ההבחנה בין Null ו-null ב-Scala?

Null היא סוג (final class) ב-Scala. סוג Null זמין בחבילת "scala" כ-"scala.Null". יש לו מופע אחד ויחיד שהוא null. ב-Scala, "null" הוא מופע של סוג scala.Null. דוגמה:-

scala> val myNullRef : Null = null
myNullRef: Null = null

אין לנו אפשרות להקצות ערכים אחרים להפניות מסוג Null. הוא מקבל רק ערך 'null'. Null היא תת-סוג של כל סוגי ההפניות. Null נמצאת בתחתית מערכת הסוגים של Scala. מכיוון שהוא אינו תת-סוג של סוגי הערכים, אנו יכולים להקצות "null" לכל משתנה של סוג ערך. דוגמה:-

scala> val myInt : Int = null
:10: error: an expression of type Null is ineligible for implicit conversion
       val myInt : Int = null

^ כאן יש שגיאת התאמה בסוג. נמצא : Null(null) אך דרוש : Int. ההמרות המשתמשות בין Null ו-Int אינן יישומות מכיוון שהן מועמדות.

מה זה יחידה ב־Scala? מה ההבדל בין void של Java ל־Unit של Scala?

ב־Scala, יחידה משמשת לייצוג של "אין ערך" או "אין ערך שימושי". יחידה היא מחלקה סופית הוגדרה בחבילת "scala" בשם "scala.Unit". יחידה דומה ל־void ב־Java, אך יש להם כמה הבדלים.

  • void ב־Java אינו מכיל ערך. זה לא כלום.
  • יחידה ב־Scala מכילה ערך אחד ()
  • () הוא הערך היחיד והיחיד של סוג Unit ב־Scala. אולם, לא קיימים ערכים מסוג void ב־Java.
  • void ב־Java הוא מילת מפתח. Unit ב־Scala היא מחלקה סופית.

שני הם משמשים לייצוג שיטה או פונקציה שאינם מחזירים כלום.

מה ההבדל בין val ובין var ב־Scala?

ב־Scala, כמו גם בתכנות פונקציונלי, שני המילים val ו־var משמשים להגדרת משתנים. אך יש להם הבדלים משמעותיים.

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

מהו REPL ב־Scala? מהו השימוש של REPL ב־Scala? כיצד לגשת ל־Scala REPL מקוד מ־CMD?

REPL עומדת על לולאת "קרא-הערך-הדפס-חזור". אנו יכולים להגיה אותו כ'ריפל'. ב־Scala, REPL משמשת כמפרש לביצוע קוד Scala ממסוף הפקודות. לכן REPL ידועה גם כממשק שורת פקודה של Scala או מסוף שורת פקודה של Scala. המטרה העיקרית של REPL היא לפתח ולבדוק קטעי קוד קטנים של Scala לצורך תרגול. זה מאוד שימושי למתחילי Scala לתרגל תוכניות בסיסיות. אנו יכולים לגשת ל־REPL על ידי שימוש בפקודה "scala". כאשר אנו מקלידים את הפקודה "scala" ב-CMD Prompt, נקבל מעטפת REPL בה נוכל להקליד ולבצע קוד Scala.

D:\> scala

scala>

מהם תכונות ה־Scala?

השפה Scala תומכת בתכונות הבאות:

  • תומך בשני סגנונות תכנות – סגנון אובייקט-אוריינטד (סגנון פקודתי) וסגנון פונקציונלי
  • שפת תכנות פורה אובייקט-אוריינטד
  • תומך בכל התכונות הפונקציונליות
  • מפענח REPL (Read-Evaluate-Print Loop)
  • מערכת סוגים חזקה
  • שפה סטטית סוגים
  • השקפת סוגים
  • תומך בפקודות התאמה
  • תומך בסגירות
  • תומך במבני נתונים עמידים
  • משתמש בדוגמא המבוססת על אקטורים לפיתוח יישומי קשר
  • אינטרואפרבלי עם ג'אווה
  • זמין עם כלי פיתוח – סביבות פיתוח, כלים לבניית יישומים, פריימוורקים וכלי פיתוח בדיקות תכנות (TDD ו-BDD)

איך אנו מממשים לולאות בצורה פונקציונלית? מה ההבחנה בין לולאות בסגנון אובייקט-אוריינטד לבין לולאות בסגנון פונקציונלי?

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

  • מבני לולאה
  • הפעלת עדכון
  • השפעות צד

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

  • רקורסיה
  • רקורסיה בזנב
  • בלתי שנוי
  • ללא תופעות צדדיות

מהו "אפליקציה" ב-Scala או מהו Scala Application? מהו "App" ב-Scala? מה השימוש ב-App של Scala?

אפליקציה ב-Scala: ב-Scala, App הוא trait הוגדר בחבילת scala כמו "scala.App". זה מגדיר את השיטה הראשית. אם Object או Class מרחיבים טרייט זה, הם יהפכו לתוכניות Scala ניתנות להרצה אוטומטית מאחר וירשו את השיטה הראשית מ-Application. היתרון העיקרי של שימוש ב-App הוא שאין צורך לכתוב את השיטה הראשית. החסרון העיקרי בשימוש ב-App הוא שעלינו להשתמש באותו שם "args" כדי להתייחס לארגומנטים משורת הפקודה מכיוון ששיטת main() של scala.App משתמשת בשם זה. דוגמה:- בלעדי Scala App:

object MyApp {
    def main( args: Array[String]){
        println("Hello World!")
    }
}

עם Scala App:

object MyApp extends App{
   println("Hello World!")
}

אם נשתף פעולה בין שתי דוגמאות, בדוגמה השנייה לא הגדרנו את השיטה הראשית מאחר והשתמפנו מ-Scala App (Application). לפני Scala 2.9, היה לנו trait scala.Application. אך הוא הוסר משימוש מאז גרסה 2.9 של Scala.

האם Scala תומך בעומס של אופרטורים? האם Java תומכת בעומס של אופרטורים?

Java לא תומכת בעומס של אופרטורים. Scala תומכת בעומס של אופרטורים. הסיבה לכך היא ש-Java אינה רוצה לתמוך בשמות של מתודות מטעמים מטעינים כמו "+*/". Scala נותנת למפתח הגמישות להחליט אילו שמות של מתודות או פונקציות להשתמש בהם. כשאנו קוראים ל-2 + 3, זה אומר ש'+' אינו אופרטור, אלא מתודה הזמינה במחלקת Int (או בסוג המשתנה המשתמש). באופן פנימי, הקריאה הזו מומינת ל-"2.+(3)".

מהו ביטוי? מהו הצהרה? ההבחנה בין ביטוי לבין הצהרה?

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

מה ההבדל בין "If… Else" של Java ל- "If… Else" של Scala?

"If… Else" של Java: ב-Java, "If… Else" הוא הצהרה, ולא ביטוי. הוא לא מחזיר ערך ולא ניתן להקצות אותו למשתנה. לדוגמה: –

 int year;
 if( count == 0) 
   year = 2014;
 else 
   year = 2015;

"If… Else" של Scala: ב-Scala, "If… Else" הוא ביטוי. הוא מעריך ערך, כלומר מחזיר ערך. אנו יכולים להקצות אותו למשתנה.

 val year = if( count == 0) 2014 else 2015

**הערה:-**"If… Else" של Scala עובד דומה לאופרטור טרנרי של Java. אנו יכולים להשתמש ב-"If… Else" של Scala כמו בהצהרת "If… Else" של Java כמוצג למטה:

 val year = 0
 if( count == 0) 
   year = 2014 
 else 
   year = 2015

האם Scala היא שפת תכנות מבוססת על ביטויים או מבוססת על הצהרות? האם Java היא שפת תכנות מבוססת על ביטויים או מבוססת על הצהרות?

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

ספר לי על כמה תכונות שנתמכות ב-Java, אך לא ב-Scala ולהפך?

  • Java לא תומכת בטעינת אופרטורים, אך Scala תומכת בזה.
  • Java תומכת באופרטורים ++ ו־—, אך Scala לא תומכת בהם.
  • Java יש לה חריגות בדיקה וחריגות שאין להן בדיקה, אך Scala אין לה חריגות בדיקה.
  • סקאלה לא תומך בהצהרות של break ו־continue, אך ג'אווה משתמשת בהם.
  • סקאלה אינה תומכת בהמרות טיפוס מפורשות, אך ג'אווה תומכת בתכונה זו.
  • סקאלה תומכת בדימוי תבניות, אך ג'אווה לא.
  • ג'אווה משתמשת בסוגי נתונים פרימיטיביים, אך סקאלה אינה משתמשת בהם.
  • ג'אווה תומכת בחברים סטטיים, אך סקאלה אין לה מושג על חברים סטטיים.
  • סקאלה תומכת במשתנים משתנים ותכונות, ג'אווה לא תומכת בהם.

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

מה ההבדל בין פונקציה ושיטה בסקאלה?

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

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

הערה:- נדבר על Class, Trait, Package, Object וכו 'בפוסטים הבאים שלי.

כמה קבצי מחלקה ציבוריים אפשר להגדיר בקובץ מקור Scala?

ב-Java, אנו יכולים להגדיר לכל היותר מחלקה/ממשק ציבורית אחת בקובץ מקור. להבדיל מ-Java, Scala תומך במספר רב של מחלקות ציבוריות באותו קובץ מקור. אנו יכולים להגדיר כל מספר של מחלקות/ממשקים/תכונות ציבוריות בקובץ מקור Scala.

כמו ב-Java, מהם הייבואים המוגדרים כברירת מחדל בשפת Scala?

אנו יודעים שהחבילה java.lang היא החבילה המובנית שמיובאת לכל תוכניות Java על ידי JVM באופן אוטומטי. אין צורך לייבא את חבילה זו באופן ברור. באותה דרך, הנה הייבואים המוגדרים כברירת מחדל הזמינים בכל תוכניות Scala:

  • חבילת java.lang
  • חבילת scala
  • scala.PreDef

כמה אופרטורים יש ב־Scala ולמה?

בניגוד ל־Java ובדומה ל־C++, ב־Scala תומך בעומסת אופרטורים. ב־Scala יש רק אופרטור אחד שהוא אופרטור השיוויון (=). מלבד זאת, כל השאר הם שיטות בלבד. לדוגמה, 2 + 3, כאן "+" אינו אופרטור ב־Scala. "+" הוא שיטה הזמינה במחלקת Int. מהדמיון, מהדמיין הקודם הוא מוביל להקריאה של השיטה "+" על אובייקט המספר השלם "2" ומעביר לה "3" כפרמטר. שני המקרים "2 + 3" ו-"2.+(3)" שקולים. זהו רק סוכר תחבירי של Scala לכתיבת תוכניות בסגנון פונקציונלי.

ציין כמה מילות מפתח שמשמשות ב־Java ואינן נדרשות ב־Scala? למה Scala לא דורשת אותן?

Java משתמשת במילות המפתח הבאות במקיפות:

  • מילת המפתח 'public' – להגדרת מחלקות, ממשקים, משתנים וכו'.
  • מילת המפתח 'static' – להגדרת חברים סטטיים.

Scala אין צורך בשני מילות המפתח הללו. Scala אין לה מילות מפתח 'public' ו-'static'.

  • ב-Scala, הגישה המוגדרת כברירת מחדל היא 'public' עבור מחלקות, traits, פונקציות/שיטות, שדות וכו'. בשל כך, אין צורך במילת המפתח 'public'.
  • על מנת לתמוך בעקרונות של תכנות מונחה עצמים (OOP), צוות הפיתוח של Scala החליט להימנע משימוש במילת המפתח 'static'. על כן, Scala היא שפת תכנות חד-עצמית מקרטעת. זה מאתגר מאוד להתמודד עם חברים סטטיים ביישומים המשתמשים בזמן ריצה רב לטיפול בקונקורנציה.

מהו PreDef ב-Scala? מהי המטרה העיקרית של PreDef ב-Scala? ב-Scala, PreDef הוא אובייקט שמוגדר בחבילת 'scala' כמו "scala.PreDef". זהו אובייקט שימושי. הוא מגדיר מספר שיטות שימושיות כפי שמוצג להלן:

  • פעולות קונסול (print, println וכו')
  • שיטות שימושיות לאוסף
  • שיטות שימושיות למחרוזות
  • שיטות המרה רמזיות
  • שיטות שימושיות לבדיקות עריכה וכו'

לדוגמה, פעולות כמו print, println, readLine, readInt, require וכו' מוגדרות באובייקט PreDef. ב-Scala, PreDef זמין לשימוש בשיטותיו בלי צורך בייבוא בכל תכניות Scala מכיוון שמהדר Scala מייבא את האובייקט הזה אוטומטית לכל יחידות הקומפילציה כמו מחלקה, אובייקט, trait וכו'. זו הכל בנוגע ל"שאלות ותשובות יסודיות בסקאלה". נדון בשאלות ותשובות בינוניות, מתקדמות ובזמן אמת בפוסטים הבאים שלי. אנא השאירו לי תגובה אם אהבתם את הפוסט או יש לכם איזשהו בעיה/הצעה.

Source:
https://www.digitalocean.com/community/tutorials/scala-interview-questions-answers