פונקציית חתיכה ב־Scala

היום נסתכל על פונקציית החיתוך ב־Scala.

חיתוך ב־Scala

הפונקציה לחיתוך ב־Scala זמינה במחלקות ה־API הבאות:

• API של מערך Scala
• API של מחרוזת
• API של אוסף Scala

נבחר כל API בנפרד ונדבר עליהם בעומק עם דוגמאות מתאימות בקטע הבא.

שימוש בפונקציית חיתוך ב־Scala

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

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

כאן Bread.slice(0,10) אומר לקחת חתיכות לחם מ-0 עד 9, סה"כ 10 חתיכות לחם. (רק כדי לדמות את פונקציית החיתוך של Scala אני משתמש באפס, אך ניתן להניח זאת כאחד.)

תחביר של פונקציית חיתוך: בספריית התקנים של Scala (API), פונקציית החיתוך מוגדרת כך:

  def slice(from-index: Int, until-index: Int): ScalaAPIClass[A]

כאן "ScalaAPIClass" אומר כל מחלקת אוסף של Scala (שתומכת בגישה על פי אינדקס כמו Seq, List וכו '), מחרוזת, מחלקות מערך.

דוגמה:- הפונקציה הבאה מוגדרת במחלקת Seq של API של Scala.

  def slice(from-index: Int, until-index: Int): Seq[A]

פרמטרים של פונקציית חיתוך: שימוש בפרמטרים של פונקציית "חיתוך" מתואר בטבלה הבאה:

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

חיתוך מערך Scala

ב- API של Scala, מחלקת המערך מגדירה את פונקציית החיתוך כך:

def slice(from: Int, until: Int): Array[T]

שם התחלה (כולל) הוא האינדקס התחילתי של המערך ו-'עד' הוא האינדקס הסופי (לא כולל) של המערך. דוגמאות לפונקציית קיטע מערך:

scala> val marksArray = Array(56,79,60,99,71)
marksArray: Array[Int] = Array(56, 79, 60, 99, 71)

נוצר מערך של מספר שלם עם 5 ערכים, כך שערכו התחילות של האינדקס הוא 0 והערך הסופי הוא 4. אורך המערך הוא 5. בואו נשחק עם פונקציית הקיטע כעת.

scala> marksArray.slice(0,2)
res0: Array[Int] = Array(56, 79)

היא מתחילה עם האינדקס 0, שהוא האיבר הראשון, ומחזירה את כל האיברים עד ל-2, שפירושו אינדקס = 1, ולכן קיבלנו כאן את האיברים 0 ו-1.

scala> marksArray.slice(3,4)
res1: Array[Int] = Array(99)

אפשר לגשת עם כל טווחי האינדקסים.

scala> marksArray.slice(3,3)
res2: Array[Int] = Array()

אם נכניס את אותם ערכים לאינדקסי ההתחלה והסיום כמו שעשינו למעלה, נקבל מערך ריק. למה? אינדקס ההתחלה = 3, אינדקס הסיום = 3 – 1 = 2. אי אפשר לקבל קבוצה של איברים מהמערך מהאינדקס 3 עד 2, נכון?

scala> marksArray.slice(-1,3)
res3: Array[Int] = Array(56, 79, 60)

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

scala> marksArray.slice(0,5)

res4: Array[Int] = Array(56, 79, 60, 99, 71)

אם נכניס ערך שני לפרמטר השני שהוא מעבר לאינדקס הזמין כמו שהוצג למעלה (הערך המקסימלי הזמין ב- marksArray הוא 4, כי אורך המערך הוא 5), הפונקציה פשוט מתעלמת מהערך הזה ומחזירה עד לאינדקס הזמין בלבד. הערה: – בניגוד ל-Java, היא לא זורקת שגיאת ArrayIndexOutOfBoundsException.

חתיכת אוסף ב-Scala

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

def slice(from: Int, until: Int): List[A]

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

scala> val list = List(56, 79, 60, 99, 71)
list: List[Int] = List(56, 79, 60, 99, 71)

scala> list.slice(0,2)
res5: List[Int] = List(56, 79)

scala> list.slice(3,4)
res6: List[Int] = List(99)

scala> list.slice(3,3)
res7: List[Int] = List()

scala> list.slice(-1,3)
res8: List[Int] = List(56, 79, 60)

scala> list.slice(0,5)
res9: List[Int] = List(56, 79, 60, 99, 71)

אם נגיע לרשימה ריקה, נקבל רשימה ריקה כפי שמוצג למטה

scala> val list2 = List()
list2: List[Nothing] = List()

scala> list2.slice(0,1)

res10: List[Nothing] = List()

חתיכת מחרוזת ב־Scala

ב-Scala API, המחלקה "StringOps" מוגדרת בחבילת scala.collection.immutable. היא מגדירה את פונקציית ה־slice כפי שמוצג למטה:

def slice(from: Int, until: Int): String

הערה:- ב־Scala, אנו משתמשים במחלקת ה־String של ג'אווה. אך למחלקה זו אין פונקציית slice. כאשר אנו משתמשים בפונקציית slice על אובייקטים של מחלקת String של ג'אווה, מהדר Scala מעביר פנימית את אובייקט ה־String הזה לאובייקט ממחלקת StringOps כדי להשתמש בפונקציית slice זו. (לא רק פונקציית slice, ישנם עוד. ראה ב-Scala API למידע נוסף.) כלומר, "StringOps" היא מחלקה משולית של מחלקת String. דוגמאות לפונקציית חתיכה של מחרוזת:

scala> val str = "Hello I'm doing good. How are you?"
str: String = Hello I'm doing good. How are you?

scala> str.slice(6,9)

res8: String = I'm

כפי שאנו יודעים, האינדקס של מחרוזת מתחיל באפס. כאן, מאינדקס = 6 אומר עד אינדקס = 9 (זה אקסקלוסיבי, אז עלינו לשקול עד אינדקס = 8 בלבד) פונקציית המחרוזת המחליף עובדת בדיוק כמו פונקציית ה־slice כפי שמוצג למעלה:

scala> str.substring(6,9)
res12: String = I'm

כאן גם str.slice(6,9) וגם str.substring(6,9) מחזירים את אותה הערך. slice נגד substring ההבדל בין פונקציות ה־slice וה־substring של מחלקת String

• מבחינת פונקציונליות ומבחינת תחביר אין הבדל
• הביצועים דומים וניתנים להתעלמות כמעט.

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

scala> str(0)
res0: Char = H

כאן זה מחזיר Char, אך לא String

scala> str(-1)
java.lang.StringIndexOutOfBoundsException: String index out of range: -1
  at java.lang.String.charAt(String.java:658)
  at scala.collection.immutable.StringOps$.apply$extension(StringOps.scala:38)
  ... 33 elided

scala> str.length
res2: Int = 34

scala> str(34)
java.lang.StringIndexOutOfBoundsException: String index out of range: 34
  at java.lang.String.charAt(String.java:658)
  at scala.collection.immutable.StringOps$.apply$extension(StringOps.scala:38)

  ... 33 elided

הערה: – אם ננסה לגשת לתווים במחרוזת מחוץ לטווח, נקבל StringIndexOutOfBoundsException כפי שמוצג למעלה. גישה לתווים במחרוזת מחזירה Char, בעוד שפונקציות החתימה והחתילה מחזירות String כפי שמוצג למטה.

scala> str(0)
res4: Char = H

scala> str.substring(0,1)
res5: String = H

scala> str.slice(0,1)
res6: String = H

זהו הכל לגבי שימוש בפונקציית החתילה של "Scala". נדבר עוד על כמה מושגים נוספים של Scala בפוסטים הבאים שלי. הפנייה: Scala API Doc