Scala for Backend Engineering & Functional Programming · Aula

Métodos de extensão

Adicione métodos a tipos.

Métodos de extensão é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

Adicionando métodos a tipos existentes

Métodos de extensão permitem adicionar novos métodos a um tipo que não pertence a você, como Int ou String, sem modificar seu código-fonte. O Scala 3 tem uma sintaxe simples para isso.

object Main:
  extension (x: Int)
    def squared: Int = x * x
  def main(args: Array[String]): Unit =
    println(5.squared)

A sintaxe de extensão

Escreva extension (param: Type) seguido de uma ou mais definições de métodos. Dentro de cada método, o parâmetro se refere ao valor receptor.

object Main:
  extension (s: String)
    def shout: String = s.toUpperCase + "!"
  def main(args: Array[String]): Unit =
    println("hello".shout)

Vários métodos em um bloco

Uma única cláusula extension pode definir vários métodos que operam todos sobre o mesmo tipo receptor.

object Main:
  extension (x: Int)
    def squared: Int = x * x
    def cubed: Int = x * x * x
    def isEven: Boolean = x % 2 == 0
  def main(args: Array[String]): Unit =
    println(4.squared)
    println(3.cubed)
    println(6.isEven)

Métodos de extensão com parâmetros

Os métodos de extensão podem receber seus próprios parâmetros, além do receptor.

object Main:
  extension (x: Int)
    def times(s: String): String = s * x
  def main(args: Array[String]): Unit =
    println(3.times("ab"))

Métodos de extensão genéricos

As extensões podem ser genéricas, adicionando métodos a toda uma família de tipos, como List[A].

object Main:
  extension [A](xs: List[A])
    def second: A = xs(1)
  def main(args: Array[String]): Unit =
    println(List(10, 20, 30).second)
    println(List("a", "b").second)

Por que as extensões são melhores que as conversões implícitas

Os métodos de extensão alcançam com mais segurança o objetivo antigo do padrão "pimp-my-library": eles apenas adicionam os métodos nomeados, sem risco de conversões silenciosas de tipos em outras partes.

object Main:
  extension (d: Double)
    def percentOf(total: Double): Double = d / total * 100
  def main(args: Array[String]): Unit =
    println(25.0.percentOf(200.0))

Extensões e classes de tipo

Os métodos de extensão combinam muito bem com classes de tipo: defina o comportamento por meio de uma instância given e exponha-o como método usando using.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[Int] with
    def show(a: Int): String = s"<$a>"

  extension [A](a: A)
    def display(using s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit =
    println(42.display)

Definindo operadores

Como os operadores são apenas métodos, as extensões também podem adicionar operadores simbólicos a tipos existentes.

object Main:
  extension (x: Int)
    def **(exp: Int): Int = math.pow(x, exp).toInt
  def main(args: Array[String]): Unit =
    println(2 ** 10)

Escopo e importações

Os métodos de extensão só estão disponíveis onde estão no escopo. Defina-os em um objeto e importe-o para usá-los, mantendo seu alcance sob controle.

object StringOps:
  extension (s: String)
    def reversedWords: String = s.split(" ").reverse.mkString(" ")

object Main:
  import StringOps._
  def main(args: Array[String]): Unit =
    println("hello there world".reversedWords)

Encadeando métodos de extensão

Os métodos de extensão retornam valores comuns, portanto você pode encadeá-los com métodos integrados para formar pipelines fluidos.

object Main:
  extension (s: String)
    def emphasize: String = s"*$s*"
  def main(args: Array[String]): Unit =
    println("scala".toUpperCase.emphasize)

Um auxiliar prático

Os métodos de extensão são perfeitos para pequenos auxiliares de domínio que fazem o código de chamada parecer natural.

object Main:
  extension (n: Int)
    def isPrime: Boolean =
      n > 1 && (2 until n).forall(d => n % d != 0)
  def main(args: Array[String]): Unit =
    println((2 to 12).filter(_.isPrime).toList)

Verificação rápida

Qual é a principal vantagem dos métodos de extensão do Scala 3 em relação às conversões implícitas para adicionar métodos?

Recapitulação

Você aprendeu os métodos de extensão:

extension (x: Type) def ... adiciona métodos a tipos existentes
Um bloco pode definir vários métodos, incluindo operadores
Eles podem ser genéricos e receber parâmetros
Eles combinam naturalmente com classes de tipos por meio de using
São mais seguros que conversões implícitas e precisam ser importados para o escopo

Perguntas Frequentes

A aula “Métodos de extensão” é grátis?

Sim — o texto completo de “Métodos de extensão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 4 aulas no total.

O que vou aprender em “Métodos de extensão”?

Adicione métodos a tipos. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Métodos de extensão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming