Scala for Backend Engineering & Functional Programming · Aula

Sintaxe e tipos básicos

Compreenda a sintaxe fundamental do Scala, as declarações de variáveis (val/var), os tipos de dados comuns e os operadores básicos.

Sintaxe e tipos básicos é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 2 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.

A sintaxe limpa do Scala

Boas-vindas à sintaxe básica do Scala! Scala foi projetado para ser conciso e expressivo, permitindo muitas vezes que você escreva menos código para alcançar mais.

Ao contrário de algumas linguagens, os pontos e vírgulas geralmente são opcionais no final de uma linha quando há apenas uma instrução. Isso ajuda a manter seu código limpo.

Expressões são fundamentais

Em Scala, quase tudo é uma expressão, ou seja, é avaliado e produz um valor. Esse é um conceito poderoso que torna seu código mais funcional e previsível.

Até mesmo um cálculo simples ou um bloco condicional pode retornar um valor.

Tente executar este exemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val x = 5 + 3
    println(s"The value of x is: $x")

    val message = if (x > 7) "Greater than 7" else "Not greater than 7"
    println(message)
  }
}

`val`: valores imutáveis

Ao declarar uma variável usando val, você cria um valor imutável. Isso significa que, depois de atribuído, seu valor não pode ser alterado.

A imutabilidade é um dos pilares da programação funcional e ajuda a evitar efeitos colaterais inesperados, tornando seu código mais seguro e fácil de compreender.

Experimente:

object Main {
  def main(args: Array[String]): Unit = {
    val greeting = "Hello, Coddy!"
    println(greeting)
    // greeting = "New message" // This would cause a compile error!
  }
}

`var`: variáveis mutáveis

Às vezes, você precisa de uma variável cujo valor possa mudar. Para isso, Scala oferece var, usado para variáveis mutáveis.

Embora seja útil, uma boa prática em Scala é preferir val a var sempre que possível, adotando a imutabilidade e o estilo funcional.

Veja como `var` funciona:

object Main {
  def main(args: Array[String]): Unit = {
    var counter = 0
    println(s"Initial counter: $counter")
    counter = counter + 1
    println(s"New counter: $counter")
  }
}

Números: Int, Long, Double

Scala oferece suporte a tipos numéricos comuns. O compilador geralmente infere o tipo, mas você pode especificá-lo.

Int: para números inteiros (por exemplo, 10)
Long: para números inteiros maiores (sufixo L, por exemplo, 10000000000L)
Double: para números de ponto flutuante (decimais, por exemplo, 3.14)

Veja um exemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val anInt = 42
    val aLong = 1234567890123L
    val aDouble = 3.14159

    println(s"Int: $anInt")
    println(s"Long: $aLong")
    println(s"Double: $aDouble")
  }
}

Tipos Boolean e Char

Além dos números, Scala possui tipos para valores lógicos e caracteres individuais:

Boolean: representa valores lógicos, seja true ou false.
Char: armazena um único caractere, delimitado por aspas simples (por exemplo, 'A').

Eles são fundamentais para lógica e processamento de texto.

Exemplo:

object Main {
  def main(args: Array[String]): Unit = {
    val isActive = true
    val initial = 'C'

    println(s"Is active? $isActive")
    println(s"Initial character: $initial")
  }
}

Strings e texto

O tipo String é usado para sequências de caracteres, ou texto. Strings são imutáveis em Scala, assim como em Java.

Um recurso muito útil é a interpolação de strings, que permite inserir expressões diretamente em literais de string usando o prefixo s e $ para variáveis.

Confira:

object Main {
  def main(args: Array[String]): Unit = {
    val name = "Coddy"
    val age = 3

    val greeting = s"Hello, my name is $name and I am $age years old."
    println(greeting)

    val mathResult = s"Two plus two is ${2 + 2}"
    println(mathResult)
  }
}

Operadores aritméticos básicos

Scala oferece operadores aritméticos padrão para realizar cálculos com números:

+ (adição)
- (subtração)
* (multiplicação)
/ (divisão)
% (módulo — resto da divisão)

Esses operadores funcionam como esperado, retornando um novo valor numérico.

Vamos fazer alguns cálculos:

object Main {
  def main(args: Array[String]): Unit = {
    val a = 10
    val b = 3

    println(s"Addition: ${a + b}")
    println(s"Subtraction: ${a - b}")
    println(s"Multiplication: ${a * b}")
    println(s"Division: ${a / b} (integer division)")
    println(s"Modulo: ${a % b}")

    val c = 10.0
    val d = 3.0
    println(s"Float Division: ${c / d}")
  }
}

Operadores de comparação

Os operadores de comparação são usados para comparar dois valores e sempre retornam um Boolean (true ou false).

== (igual a)
!= (diferente de)
< (menor que)
> (maior que)
<= (menor ou igual a)
>= (maior ou igual a)

Eles são essenciais para o fluxo de controle e a tomada de decisões.

object Main {
  def main(args: Array[String]): Unit = {
    val x = 10
    val y = 5

    println(s"x == y: ${x == y}")
    println(s"x != y: ${x != y}")
    println(s"x > y: ${x > y}")
    println(s"x <= y: ${x <= y}")
  }
}

Verificação rápida: variáveis e operadores

Considere o seguinte trecho de código Scala:

object Main {
  def main(args: Array[String]): Unit = {
    val num1 = 7
    var num2 = 3
    num2 = num1 * 2
    val finalResult = num1 + num2 - 5
    println(finalResult)
  }
}

Recapitulação: sintaxe e tipos

Parabéns! Nesta lição, você aprendeu os fundamentos da sintaxe básica do Scala, incluindo o uso de expressões e o caráter opcional dos pontos e vírgulas.

Exploramos como declarar variáveis usando val para valores imutáveis e var para valores mutáveis. Você também se familiarizou com tipos de dados comuns, como Int, Long, Double, Boolean, Char e String, incluindo a prática interpolação de strings.

Por fim, você praticou o uso de operadores aritméticos e de comparação básicos para realizar cálculos e verificações lógicas. Continue praticando esses fundamentos, pois eles são a base para programas Scala mais complexos!

Perguntas Frequentes

A aula “Sintaxe e tipos básicos” é grátis?

Sim — o texto completo de “Sintaxe e tipos básicos” é 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 “Sintaxe e tipos básicos”?

Compreenda a sintaxe fundamental do Scala, as declarações de variáveis (val/var), os tipos de dados comuns e os operadores básicos. 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 2 de 3.

Quanto tempo leva a aula “Sintaxe e tipos básicos”?

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