Fonction de tranche Scala

Aujourd’hui, nous examinerons la fonction slice de Scala.

Scala slice

La fonction slice de Scala est disponible dans les classes d’API suivantes :

• Scala Array API
• String API
• Scala Collection API

Nous examinerons chaque API et les discuterons en détail avec des exemples appropriés dans la section suivante.

Utilisation de la fonction slice de Scala

Dans l’API Scala, la fonction ‘slice’ est utilisée pour sélectionner un intervalle d’éléments. Elle prend deux paramètres de type « Int » et renvoie un sous-ensemble ou aucun élément de la Collection d’origine (ou String ou Array). Scénario de découpage réel: Nous pouvons également utiliser cette fonction de découpage dans notre vie quotidienne, comme indiqué ci-dessous. Ici, Bread.slice(0,10) signifie prendre des tranches de pain de 0 à 9, donc au total 10 tranches de pain. (Juste pour ressembler à la fonction slice de Scala, j’utilise zéro ici, mais supposez que ce soit un.) Syntaxe de la fonction de découpage: Dans la bibliothèque standard Scala (API), cette fonction de découpage est définie comme suit:

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

Ici, « ScalaAPIClass » signifie n’importe quelle classe de Collection Scala (qui prend en charge l’accès basé sur l’index comme Seq, List, etc.), les classes String, Array. Exemple: La fonction suivante est définie dans la classe Seq de l’API Scala.

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

Paramètres de la fonction de découpage: L’utilisation des paramètres de la fonction « slice » est décrite dans le tableau suivant:

La fonction de découpage extrait des éléments à partir du ‘premier-index’ (inclus) jusqu’au ‘until-index’ (exclusif). Ici, les numéros d’éléments pour un tableau de nombres, les caractères pour une chaîne, un objet pour une Collection.

Découpe de tableau Scala

Dans l’API Scala, la classe Array définit la fonction de découpage comme suit:

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

Ici ‘from’ est l’indice de début (inclusif) du tableau et ‘until’ est l’indice de fin (exclusif) du tableau. Exemples de la fonction de découpe de tableau:

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

Un tableau d’entiers avec 5 valeurs est créé, donc son indice de début est 0 et son indice de fin est 4. Sa longueur est de 5. Jouons maintenant avec la fonction de découpe.

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

Elle commence avec l’indice 0, c’est-à-dire le premier élément, et récupère tous les éléments jusqu’à 2, ce qui signifie que l’indice est 1, c’est pourquoi nous obtenons ici le 0e et le 1er élément.

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

Nous pouvons accéder à n’importe quelle plage d’indices.

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

Si nous donnons les mêmes valeurs pour le début et la fin comme ci-dessus, nous obtiendrons un tableau vide. Pourquoi ? L’indice de début est 3, l’indice de fin est 3 – 1 = 2. Il n’est pas possible de récupérer un ensemble d’éléments d’un tableau des indices 3 à 2, n’est-ce pas ?

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

Si nous donnons des valeurs négatives, cela commence simplement avec l’indice disponible comme indiqué ci-dessus.

scala> marksArray.slice(0,5)

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

Si nous donnons une valeur de 2e paramètre au-delà de son indice disponible comme indiqué ci-dessus (l’indice maximal disponible dans marksArray est seulement 4 car sa longueur est de 5), il ignore simplement cette valeur et renvoie jusqu’à l’indice disponible uniquement. NOTE : Contrairement à Java, il ne lance aucune ArrayIndexOutOfBoundsException.

Découpe de collection Scala

Dans l’API standard de Scala, la plupart des classes définissent cette fonction de découpe qui prend en charge l’accès aux éléments basé sur les indices. Par exemple, la classe List définit cette fonction comme indiqué ci-dessous:

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

Exemples de fonction de découpage de liste :- Tout comme les exemples de tableau, nous obtiendrons les mêmes résultats pour n’importe quelle API de collection.

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)

Si nous accédons à une liste vide, nous obtiendrons uniquement une liste vide comme indiqué ci-dessous

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

scala> list2.slice(0,1)

res10: List[Nothing] = List()

Découpage de chaîne Scala

Dans l’API Scala, la classe « StringOps » est définie dans le package scala.collection.immutable. Elle définit la fonction de découpage comme indiqué ci-dessous :

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

REMARQUE :- En Scala, nous utilisons la classe String de Java. Mais cette classe N’A PAS de fonction de découpage. Lorsque nous utilisons la fonction de découpage sur des objets String de Java, le compilateur Scala convertit internement cet objet String en objet de classe StringOps pour utiliser cette fonction de découpage. (Non seulement la fonction de découpage, mais bien plus encore. Voir l’API Scala pour plus d’informations.) Cela signifie que « StringOps » est une classe implicite de la classe String. Exemples de fonction de découpage de chaîne :

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

Comme nous le savons, l’indice de la chaîne commence par zéro. Ici, à partir de l’indice = 6 signifie jusqu’à l’indice = 9 (c’est exclusif donc nous devons considérer jusqu’à l’indice = 8 seulement) La fonction de sous-chaîne de la chaîne fonctionne de la même manière que sa fonction de découpage comme indiqué ci-dessous :

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

Ici, les deux str.slice(6,9) et str.substring(6,9) retournent la même valeur. Découpage Vs sous-chaîne Différence entre les fonctions de découpage et de sous-chaîne de la classe String

• En termes de fonctionnalité et de syntaxe, il n’y a pas de différence
• Les performances sont presque similaires et négligeables.

NOTE:- En Scala, nous pouvons accéder aux caractères de chaîne de la même manière que les éléments d’un tableau, comme indiqué ci-dessous:

scala> str(0)
res0: Char = H

Ici, cela renvoie un Char, mais pas une chaîne de caractères

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

NOTE:- Si nous essayons d’accéder aux caractères de chaîne en dehors de la plage, nous obtenons StringIndexOutOfBoundsException comme indiqué ci-dessus. L’accès aux caractères de la chaîne renvoie Char tandis que les fonctions de sous-chaîne et de tranche renvoient String comme indiqué ci-dessous.

scala> str(0)
res4: Char = H

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

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

C’est tout ce qu’il y a à savoir sur l’utilisation de la fonction « slice » de Scala. Nous discuterons de quelques autres concepts Scala dans mes prochains messages. Référence : Scala API Doc