0Pricing
Scala for Backend Engineering & Functional Programming · Aula

Funções como valores de primeira classe

Aprenda a definir e passar funções como argumentos, retorná-las de outras funções e armazená-las em variáveis.

Funções como valores de primeira classe é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 3. 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 3 aulas no total.

Funções como valores de primeira classe

Boas-vindas ao núcleo da programação funcional! Em Scala, funções não são apenas comandos; elas são valores de primeira classe.

Isso significa que você pode tratar funções como qualquer outro tipo de dado, como números ou strings. Esse é um conceito fundamental da programação funcional!

Atribuindo funções a variáveis

Assim como você pode atribuir um número a um val, também pode atribuir uma função a ele. Aqui, greet se torna uma variável que contém nossa função.

Tente executar este exemplo simples:

object Main {
  def main(args: Array[String]): Unit = {
    val greet = (name: String) => s"Hello, $name!"
    println(greet("Alice"))
  }
}

Funções anônimas (lambdas)

A parte (name: String) => s"Hello, $name!" da cena anterior é uma função anônima, também conhecida como expressão lambda.

É uma função sem nome, geralmente definida diretamente no local em que é necessária. Elas são muito úteis para tarefas rápidas e específicas.

object Main {
  def main(args: Array[String]): Unit = {
    val add = (x: Int, y: Int) => x + y
    println(s"5 + 3 = ${add(5, 3)}")

    val subtract = (a: Int, b: Int) => a - b
    println(s"10 - 4 = ${subtract(10, 4)}")
  }
}

Funções como argumentos de métodos

Um dos aspectos mais poderosos é passar funções como argumentos para outras funções. Elas são chamadas de funções de ordem superior.

A função applyOperation abaixo recebe dois números e outra função, op. Em seguida, op é usada para combinar os números.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val result = applyOperation(5, 3, add)
    println(s"Result of addition: $result")
  }
}

Entendendo os tipos de função

Observe a assinatura de tipo op: (Int, Int) => Int na cena anterior.

  • (Int, Int): isso significa que a função recebe dois argumentos Int.
  • => Int: isso significa que a função retorna um Int.

Toda função tem um tipo que descreve suas entradas e sua saída. Isso ajuda o Scala a garantir a segurança de tipos!

Passando funções de forma concisa

Você nem sempre precisa definir primeiro uma função nomeada. Pode passar uma função anônima diretamente onde um argumento de função é esperado.

Isso torna seu código mais compacto e legível, especialmente para operações simples.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val result1 = applyOperation(10, 2, (a: Int, b: Int) => a * b)
    println(s"Multiplication: $result1")

    // Scala can often infer types, making it even shorter!
    val result2 = applyOperation(20, 4, (a, b) => a / b)
    println(s"Division: $result2")
  }
}

Funções como valores de retorno

As funções também podem retornar outras funções. Isso pode parecer surpreendente, mas é extremamente útil para criar código flexível e configurável.

Aqui, makeMultiplier retorna uma nova função que multiplica sua entrada por um fator específico.

object Main {
  def makeMultiplier(factor: Int): Int => Int = {
    (x: Int) => x * factor
  }

  def main(args: Array[String]): Unit = {
    val multiplyByTwo = makeMultiplier(2)
    val multiplyByFive = makeMultiplier(5)

    println(s"5 * 2 = ${multiplyByTwo(5)}")
    println(s"10 * 5 = ${multiplyByFive(10)}")
  }
}

Entendendo os fechamentos

Quando makeMultiplier retorna uma função, essa função retornada "se lembra" do valor de factor do momento em que foi criada. Isso é chamado de fechamento.

Mesmo depois que makeMultiplier termina de ser executada, a função multiplyByTwo ainda "sabe" que seu fator é 2.

Benefícios das funções de primeira classe

Por que é tão importante tratar funções como elementos de primeira classe?

  • Flexibilidade: você pode trocar comportamentos facilmente passando funções diferentes.
  • Reutilização: crie funções genéricas que operem sobre qualquer função fornecida.
  • Concisão: resulta em um código mais curto e expressivo, especialmente com funções anônimas.
  • Estilo funcional: é um pilar da programação funcional, permitindo padrões poderosos.

Teste seus conhecimentos

Vamos verificar sua compreensão das funções como valores de primeira classe.

object Main {
  def execute(x: Int, op: Int => Int): Int = op(x)

  def main(args: Array[String]): Unit = {
    val square = (n: Int) => n * n
    val result = execute(5, square)
    println(result)
  }
}

Funções como valores: recapitulação

Excelente trabalho! Você aprendeu o conceito fundamental de funções como valores de primeira classe em Scala.

  • As funções podem ser atribuídas a variáveis.
  • Podem ser passadas como argumentos para outras funções.
  • Podem ser retornadas como resultados de outras funções.
  • Isso permite padrões poderosos, como funções de ordem superior e fechamentos.

Essa capacidade é essencial para escrever código Scala funcional flexível, reutilizável e expressivo. A seguir, vamos explorar funções de ordem superior mais avançadas e a aplicação parcial!

Perguntas Frequentes

A aula “Funções como valores de primeira classe” é grátis?

Sim — o texto completo de “Funções como valores de primeira classe” é 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 3 aulas no total.

O que vou aprender em “Funções como valores de primeira classe”?

Aprenda a definir e passar funções como argumentos, retorná-las de outras funções e armazená-las em variáveis. 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 1 de 3.

Quanto tempo leva a aula “Funções como valores de primeira classe”?

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

  1. Funções como valores de primeira classe
  2. Funções de ordem superior e currying
  3. Imutabilidade e efeitos colaterais
← Voltar para Scala for Backend Engineering & Functional Programming