Função de fatiamento em Scala

Hoje vamos analisar a função slice do Scala.

Scala slice

A função slice do Scala está disponível nas seguintes classes de API:

• API de Array Scala
• API de String
• API de Coleção Scala

Vamos escolher cada API e discuti-las detalhadamente com exemplos adequados na próxima seção.

Uso da função slice do Scala

Na API Scala, a função ‘slice’ é usada para selecionar um intervalo de elementos. Ela recebe dois parâmetros do tipo “Int” e retorna um subconjunto, todo ou nenhum elemento(s) da Coleção original (ou String ou Array). Cenário de uso real do slice:- Podemos usar essa função slice em nossa vida real regular também, como mostrado abaixo. Aqui, Bread.slice(0,10) significa pegar fatias de pão de 0 a 9, então, no total, 10 fatias de pão.(Apenas para assemelhar à função slice do Scala, estou usando zero, mas considere isso como um.) Sintaxe da função slice: Na Biblioteca Padrão Scala (API), essa função slice é definida da seguinte forma:

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

Aqui “ScalaAPIClass” significa qualquer classe de Coleção Scala (que suporta acesso baseado em índice como Seq, Lista etc), classes String, Array. Exemplo:- A seguinte função é definida na classe Seq da API Scala.

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

Parâmetros da função slice: O uso dos parâmetros da função “slice” é descrito na seguinte tabela:

A função slice extrai elementos começando do ‘primeiro-índice’ (Inclusivo) até ‘índice-final’ (exclusivo). Aqui, números de elementos para um Array de Números, Caracteres para uma String, um objeto para uma Coleção.

Slice de Array Scala

Na API Scala, a classe Array define a função slice da seguinte forma:

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

aqui ‘from’ é o índice de início (Inclusivo) do Array e ‘until’ é o índice final (Exclusivo) do Array. Exemplos da Função de Recorte de Array:

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

Int de Array com 5 valores é criado, então o valor de início do índice é 0 e o valor final do índice é 4. Seu comprimento = 5 Vamos brincar com a função de recorte agora.

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

Começa com o índice 0, que é o primeiro elemento, e recupera todos os elementos até 2, ou seja, índice = 1, é por isso que temos o elemento 0 e o elemento 1 aqui.

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

Podemos acessar com qualquer faixa de índices.

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

Se dermos os mesmos valores para início e fim como acima, obteremos uma matriz vazia, por quê? Índice de início = 3 Índice de fim = 3 – 1 = 2 Não é possível recuperar um conjunto de elementos de uma matriz de 3 a 2 índices, certo.

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

Se dermos valores negativos, ele apenas começa com o índice disponível, como mostrado acima.

scala> marksArray.slice(0,5)

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

Se dermos um valor de 2º parâmetro além de seu índice disponível, como mostrado acima (o valor máximo de índice disponível em marksArray é apenas 4, pois seu comprimento = 5), ele simplesmente ignora esse valor e retorna até o índice disponível apenas. NOTA:- Ao contrário do Java, ele não lança ArrayIndexOutOfBoundsException.

Recorte de Coleção Scala

Na API Padrão do Scala, a maioria das classes define essa função de recorte que suporta acesso a elementos com base em índices. Por exemplo, a classe List define esta função como mostrado abaixo:

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

Exemplos de função de fatiamento de lista:- Assim como nos exemplos de Array, obteremos os mesmos resultados para qualquer API de Coleção.

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)

Se acessarmos uma lista vazia, obteremos apenas uma lista vazia, como mostrado abaixo

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

scala> list2.slice(0,1)

res10: List[Nothing] = List()

Fatiamento de String em Scala

Na API do Scala, a classe “StringOps” é definida no pacote scala.collection.immutable. Ela define a função de fatiamento conforme mostrado abaixo:

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

NOTA:- Em Scala, usamos a classe String do Java. Mas essa classe NÃO possui a função de fatiamento. Quando usamos a função de fatiamento em objetos String do Java, o Compilador Scala converte internamente esse objeto String em um objeto da classe StringOps para usar essa função de fatiamento. (Não apenas a função de fatiamento, mas muitas outras. Consulte a API do Scala para mais informações.) Isso significa que “StringOps” é uma classe implícita da classe String. Exemplos da função de fatiamento de 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

Como sabemos, o índice da String começa com zero. Aqui, o índice de início = 6 significa que o índice final = 9 (é exclusivo, então precisamos considerar até o índice = 8 apenas) A função de substring da String funciona da mesma forma que sua função de fatiamento, como mostrado abaixo:

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

Aqui, tanto str.slice(6,9) quanto str.substring(6,9) estão retornando o mesmo valor. Fatiamento Vs substring Diferença entre as funções de fatiamento e substring da classe String

• Em termos de funcionalidade e sintaxe, não há diferença
• O desempenho é quase semelhante e insignificante.

NOTA:- Em Scala, podemos acessar os caracteres de uma String da mesma forma que os elementos de um Array, como mostrado abaixo:

scala> str(0)
res0: Char = H

Aqui, retorna um Char, mas não uma 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

NOTA:- Se tentarmos acessar caracteres de uma String fora do intervalo, obtemos StringIndexOutOfBoundsException, como mostrado acima. O acesso aos caracteres da String retorna um Char, enquanto as funções de substring e slice retornam uma String, como mostrado abaixo.

scala> str(0)
res4: Char = H

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

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

Isso é tudo sobre o uso da “função slice” em Scala. Vamos discutir mais conceitos do Scala em minhas próximas postagens. Referência: Documentação da API do Scala