Função de fatiamento em Scala

Hoje vamos olhar para a função de fatiamento do Scala.

Scala slice

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

• API de Array do Scala
• API de String
• API de Collection do Scala

Vamos pegar cada API e discuti-las em detalhes com exemplos adequados na próxima seção.

Uso da função de fatiamento do Scala

No API do Scala, a função ‘slice’ é utilizada para selecionar um intervalo de elementos. Ela recebe dois parâmetros do tipo “Int” e retorna um subconjunto, a coleção completa ou nenhum elemento da coleção original (ou String ou Array). Cenário de uso do slice no mundo real:- Podemos usar essa função de slice em nossa vida cotidiana, como mostrado abaixo. Aqui, Bread.slice(0,10) significa pegar fatias de pão de 0 a 9, totalizando 10 fatias de pão. (Apenas para se assemelhar à função slice do Scala, estou usando zero aqui, mas considere isso como um.) Sintaxe da função slice: Na Biblioteca Padrão do 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 com base em índice, como Seq, List, etc.), classes String, Array. Exemplo:- A seguinte função está definida na classe Seq da API do 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 tabela a seguir:

A função slice extrai elementos começando pelo ‘primeiro índice’ (inclusive) até o ‘índice até’ (exclusivo). Aqui, os números dos elementos referem-se a um Array de Números, caracteres para uma String, um objeto para uma Coleção.

Recorte de Array em Scala

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

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

Aqui ‘de’ é o índice inicial (inclusive) do Array e ‘até’ é o índice final (exclusivo) do Array. Exemplos de Função de Fatia 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 são criados, então o valor do índice de início é 0 e o valor do índice final é 4. Seu comprimento = 5 Vamos brincar com a função de fatia 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 significa índice = 1 é por isso que obtemos o elemento 0 e o elemento 1 aqui.

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

Podemos acessar com qualquer intervalo 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 um array de 3 a 2 índices, certo?

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

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

scala> marksArray.slice(0,5)

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

Se dermos valor para o segundo parâmetro além do índice disponível conforme 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. OBSERVAÇÃO: – Ao contrário do Java, ele não lança nenhuma ArrayIndexOutOfBoundsException.

Fatia de Coleção Scala

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

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

Exemplos da 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 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, muitas outras. Consulte a API Scala para obter 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, from-index = 6 significa until-index = 9 (É exclusivo, então precisamos considerar até o índice = 8 apenas) A função de subcadeia 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 de subcadeia da classe String

• Em termos de funcionalidade e sintaxe, não há diferença
• O desempenho é quase similar e desprezível.

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 de uma String retorna um Char, enquanto as funções 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” do Scala. Discutiremos mais alguns conceitos do Scala em minhas próximas postagens. Referência: Documentação da API do Scala