Neste artigo
- O que é um tipo de dado?
- Quais são os tipos básicos?
- Como usar os tipos de dados em Java, C#, Go, Python, PHP, C e JavaScript?
- Por que o tipo muda o resultado de uma conta?
- Como converter um tipo em outro?
- Como descobrir o tipo de um valor?
- Aí você pergunta: o que acontece quando misturo texto com número?
- Quais são os erros mais comuns com tipos de dados?
- Agora é com você!
Tipo de dado é a classificação que diz que espécie de valor uma variável guarda e quais operações podem ser feitas com ele. Os quatro tipos básicos são o inteiro, o real, o texto e o lógico.
No artigo sobre variáveis e constantes, a variável era uma caixa com etiqueta. O tipo é o formato da caixa: ele define o que cabe ali dentro. Não confunda com os tipos de variáveis na estatística, que classificam os dados de uma pesquisa. Aqui a conversa é sobre como o computador guarda cada valor na memória.
Pense em um formulário de cadastro. O campo “idade” só aceita números. O campo “nome” aceita letras. O campo “aceito os termos” é uma caixinha de marcar: sim ou não. Ninguém tenta somar dois nomes nem marcar “sim” em uma idade. Cada campo tem um tipo, e o tipo já diz o que faz sentido fazer com o conteúdo. Com as variáveis de um programa é igual.
O que é um tipo de dado?
O tipo responde a duas perguntas. A primeira: que valores podem ser guardados? A segunda: que operações são permitidas? Os tipos limitam as operações possíveis sobre os valores. Dividir faz sentido para números. Emendar faz sentido para textos.
Há ainda uma terceira consequência, que aparece com clareza em C: o tipo define quanto espaço de memória o valor ocupa.
Quais são os tipos básicos?
- Inteiro: números sem parte decimal, como 42, 0 e -7. Serve para contar.
- Real: números com parte decimal, como 1.75 e 3.14. No código, o separador é o ponto, e não a vírgula. O nome técnico é ponto flutuante.
- Texto: uma sequência de caracteres entre aspas, como “Ana”. O nome técnico é string.
- Lógico: só tem dois valores, verdadeiro e falso. É o tipo do resultado de toda comparação, e é ele que as estruturas condicionais e os laços de repetição testam. O nome técnico é booleano.

Em C existe ainda o tipo char, que guarda um único caractere. Um texto, em C, é um vetor de char. As linguagens têm outros tipos além desses, como os vetores.
Como usar os tipos de dados em Java, C#, Go, Python, PHP, C e JavaScript?
O programa cria uma variável de cada tipo e depois mostra, com saídas iguais nas sete linguagens, quatro efeitos do tipo: na divisão, na conversão, no corte da parte decimal e na comparação de números reais. Troque de linguagem nas abas:
// Tipos de dados: inteiro, real, texto e lógico
public class TiposDeDados {
public static void main(String[] args) {
int idade = 42; // inteiro
double altura = 1.75; // real (ponto flutuante)
String nome = "Ana"; // texto (string)
boolean aprovado = 10 > 3; // lógico: o resultado de uma comparação
System.out.println("inteiro: " + idade);
System.out.println("real: " + altura);
System.out.println("texto: " + nome);
System.out.println("lógico: " + (aprovado ? "verdadeiro" : "falso"));
// o tipo muda o resultado da mesma operação
System.out.println("7 dividido por 2, com inteiros: " + (7 / 2));
System.out.println("7 dividido por 2, com reais: " + (7.0 / 2.0));
// conversão de texto para número e de número para texto
String digitado = "25";
int numero = Integer.parseInt(digitado);
System.out.println("texto convertido e somado com 5: " + (numero + 5));
System.out.println("número convertido e emendado: " + String.valueOf(numero) + " anos");
// real para inteiro: a parte decimal é cortada, não arredondada
System.out.println("3.99 como inteiro: " + (int) 3.99);
System.out.println("-3.99 como inteiro: " + (int) -3.99);
// cada caractere é guardado como um número
System.out.println("código da letra A: " + (int) 'A');
// números reais são aproximados
System.out.println("0.1 + 0.2 == 0.3: " + (0.1 + 0.2 == 0.3 ? "verdadeiro" : "falso"));
}
}
// Tipos de dados: inteiro, real, texto e lógico
using System.Globalization;
int idade = 42; // inteiro
double altura = 1.75; // real (ponto flutuante)
string nome = "Ana"; // texto (string)
bool aprovado = 10 > 3; // lógico: o resultado de uma comparação
// InvariantCulture: ponto como separador decimal em qualquer computador
CultureInfo ponto = CultureInfo.InvariantCulture;
Console.WriteLine("inteiro: " + idade);
Console.WriteLine("real: " + altura.ToString("F2", ponto));
Console.WriteLine("texto: " + nome);
Console.WriteLine("lógico: " + (aprovado ? "verdadeiro" : "falso"));
// o tipo muda o resultado da mesma operação
Console.WriteLine("7 dividido por 2, com inteiros: " + (7 / 2));
Console.WriteLine("7 dividido por 2, com reais: " + (7.0 / 2.0).ToString("F1", ponto));
// conversão de texto para número e de número para texto
string digitado = "25";
int numero = int.Parse(digitado);
Console.WriteLine("texto convertido e somado com 5: " + (numero + 5));
Console.WriteLine("número convertido e emendado: " + numero.ToString() + " anos");
// real para inteiro: a parte decimal é cortada, não arredondada
Console.WriteLine("3.99 como inteiro: " + (int) 3.99);
Console.WriteLine("-3.99 como inteiro: " + (int) -3.99);
// cada caractere é guardado como um número
Console.WriteLine("código da letra A: " + (int) 'A');
// números reais são aproximados
Console.WriteLine("0.1 + 0.2 == 0.3: " + (0.1 + 0.2 == 0.3 ? "verdadeiro" : "falso"));
// Tipos de dados: inteiro, real, texto e lógico
package main
import (
"fmt"
"strconv"
)
func simOuNao(valor bool) string {
if valor {
return "verdadeiro"
}
return "falso"
}
func main() {
var idade int = 42 // inteiro
var altura float64 = 1.75 // real (ponto flutuante)
var nome string = "Ana" // texto (string)
aprovado := 10 > 3 // lógico: o tipo bool é deduzido do valor
fmt.Println("inteiro:", idade)
fmt.Printf("real: %.2f\n", altura)
fmt.Println("texto:", nome)
fmt.Println("lógico:", simOuNao(aprovado))
// o tipo muda o resultado da mesma operação
fmt.Println("7 dividido por 2, com inteiros:", 7/2)
fmt.Printf("7 dividido por 2, com reais: %.1f\n", 7.0/2.0)
// conversão de texto para número e de número para texto
digitado := "25"
numero, _ := strconv.Atoi(digitado)
fmt.Println("texto convertido e somado com 5:", numero+5)
fmt.Println("número convertido e emendado: " + strconv.Itoa(numero) + " anos")
// real para inteiro: a parte decimal é cortada, não arredondada
positivo, negativo := 3.99, -3.99
fmt.Println("3.99 como inteiro:", int(positivo))
fmt.Println("-3.99 como inteiro:", int(negativo))
// cada caractere é guardado como um número
fmt.Println("código da letra A:", 'A')
// números reais são aproximados
a, b := 0.1, 0.2
fmt.Println("0.1 + 0.2 == 0.3:", simOuNao(a+b == 0.3))
}
# Tipos de dados: inteiro, real, texto e lógico
idade = 42 # inteiro
altura = 1.75 # real (ponto flutuante)
nome = "Ana" # texto (string)
aprovado = 10 > 3 # lógico: o resultado de uma comparação
print("inteiro:", idade)
print("real: %.2f" % altura)
print("texto:", nome)
print("lógico:", "verdadeiro" if aprovado else "falso")
# o tipo muda o resultado da mesma operação
print("7 dividido por 2, com inteiros:", 7 // 2)
print("7 dividido por 2, com reais: %.1f" % (7 / 2))
# conversão de texto para número e de número para texto
digitado = "25"
numero = int(digitado)
print("texto convertido e somado com 5:", numero + 5)
print("número convertido e emendado: " + str(numero) + " anos")
# real para inteiro: a parte decimal é cortada, não arredondada
print("3.99 como inteiro:", int(3.99))
print("-3.99 como inteiro:", int(-3.99))
# cada caractere é guardado como um número
print("código da letra A:", ord("A"))
# números reais são aproximados
print("0.1 + 0.2 == 0.3:", "verdadeiro" if 0.1 + 0.2 == 0.3 else "falso")
<?php
// Tipos de dados: inteiro, real, texto e lógico
$idade = 42; // inteiro
$altura = 1.75; // real (ponto flutuante)
$nome = "Ana"; // texto (string)
$aprovado = 10 > 3; // lógico: o resultado de uma comparação
echo "inteiro: $idade\n";
printf("real: %.2f\n", $altura);
echo "texto: $nome\n";
echo "lógico: " . ($aprovado ? "verdadeiro" : "falso") . "\n";
// o tipo muda o resultado da mesma operação
echo "7 dividido por 2, com inteiros: " . intdiv(7, 2) . "\n";
printf("7 dividido por 2, com reais: %.1f\n", 7 / 2);
// conversão de texto para número e de número para texto
$digitado = "25";
$numero = (int) $digitado;
echo "texto convertido e somado com 5: " . ($numero + 5) . "\n";
echo "número convertido e emendado: " . strval($numero) . " anos\n";
// real para inteiro: a parte decimal é cortada, não arredondada
echo "3.99 como inteiro: " . (int) 3.99 . "\n";
echo "-3.99 como inteiro: " . (int) -3.99 . "\n";
// cada caractere é guardado como um número
echo "código da letra A: " . ord("A") . "\n";
// números reais são aproximados
echo "0.1 + 0.2 == 0.3: " . (0.1 + 0.2 == 0.3 ? "verdadeiro" : "falso") . "\n";
/* Tipos de dados: inteiro, real, texto e lógico */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
int main(void) {
int idade = 42; /* inteiro */
double altura = 1.75; /* real (ponto flutuante) */
char nome[] = "Ana"; /* texto: um vetor de caracteres */
bool aprovado = 10 > 3; /* lógico: o resultado de uma comparação */
printf("inteiro: %d\n", idade);
printf("real: %.2f\n", altura);
printf("texto: %s\n", nome);
printf("lógico: %s\n", aprovado ? "verdadeiro" : "falso");
/* o tipo muda o resultado da mesma operação */
printf("7 dividido por 2, com inteiros: %d\n", 7 / 2);
printf("7 dividido por 2, com reais: %.1f\n", 7.0 / 2.0);
/* conversão de texto para número e de número para texto */
char digitado[] = "25";
int numero = atoi(digitado);
char texto[16];
sprintf(texto, "%d", numero);
printf("texto convertido e somado com 5: %d\n", numero + 5);
printf("número convertido e emendado: %s anos\n", texto);
/* real para inteiro: a parte decimal é cortada, não arredondada */
printf("3.99 como inteiro: %d\n", (int) 3.99);
printf("-3.99 como inteiro: %d\n", (int) -3.99);
/* cada caractere é guardado como um número */
printf("código da letra A: %d\n", 'A');
/* números reais são aproximados */
printf("0.1 + 0.2 == 0.3: %s\n", 0.1 + 0.2 == 0.3 ? "verdadeiro" : "falso");
return 0;
}
// Tipos de dados: inteiro, real, texto e lógico
const idade = 42; // número inteiro
const altura = 1.75; // número real (ponto flutuante)
const nome = "Ana"; // texto (string)
const aprovado = 10 > 3; // lógico: o resultado de uma comparação
console.log("inteiro:", idade);
console.log("real: " + altura.toFixed(2));
console.log("texto:", nome);
console.log("lógico:", aprovado ? "verdadeiro" : "falso");
// o tipo muda o resultado da mesma operação
console.log("7 dividido por 2, com inteiros:", Math.trunc(7 / 2));
console.log("7 dividido por 2, com reais: " + (7 / 2).toFixed(1));
// conversão de texto para número e de número para texto
const digitado = "25";
const numero = Number(digitado);
console.log("texto convertido e somado com 5:", numero + 5);
console.log("número convertido e emendado: " + String(numero) + " anos");
// real para inteiro: a parte decimal é cortada, não arredondada
console.log("3.99 como inteiro:", Math.trunc(3.99));
console.log("-3.99 como inteiro:", Math.trunc(-3.99));
// cada caractere é guardado como um número
console.log("código da letra A:", "A".charCodeAt(0));
// números reais são aproximados
console.log("0.1 + 0.2 == 0.3:", 0.1 + 0.2 === 0.3 ? "verdadeiro" : "falso");
Saída:
inteiro: 42 real: 1.75 texto: Ana lógico: verdadeiro 7 dividido por 2, com inteiros: 3 7 dividido por 2, com reais: 3.5 texto convertido e somado com 5: 30 número convertido e emendado: 25 anos 3.99 como inteiro: 3 -3.99 como inteiro: -3 código da letra A: 65 0.1 + 0.2 == 0.3: falso
Mesma saída nas sete. Foque no conceito, e não na linguagem!
Repare na diferença de escrita. Em Java, em C# e em C, o tipo aparece antes do nome de cada variável, porque a declaração é obrigatória. Java e C# também aceitam a palavra var, em que o tipo é deduzido do valor e não muda mais. Em Python e em PHP, você não escreve o tipo: ele é determinado durante a execução, pelo valor que a variável recebe.
Em JavaScript também não se escreve o tipo: a linguagem é de tipagem dinâmica, e a mesma variável pode receber valores de tipos diferentes. Em Go, toda variável tem um tipo que não muda. Você pode escrever o tipo, como em var idade int = 42, ou usar a declaração curta, como em aprovado := 10 > 3, em que o tipo é deduzido do valor. Tentei guardar o texto “Ana” na variável idade, e o compilador do Go recusou:
cannot use "Ana" (untyped string constant) as int value in assignment
Fiz o mesmo teste em Java e em C#, com var idade = 42, e os dois compiladores também recusaram o texto.
Por que o tipo muda o resultado de uma conta?
Porque a mesma operação tem regras diferentes para tipos diferentes. O exemplo mais direto é a divisão. Entre inteiros, 7 dividido por 2 dá 3, e a parte decimal desaparece. Entre reais, dá 3,5.

ATENÇÃO: cada linguagem escreve isso de um jeito. Em C, a barra entre dois inteiros já faz a divisão inteira. Em Python, 7 / 2 devolve o real 3.5, e a divisão inteira usa duas barras. O PHP não tem operador de divisão inteira: 7 / 2 dá 3.5, e para o resultado inteiro existe a função intdiv. Em JavaScript não existe um tipo inteiro separado: 7 / 2 dá 3.5, e para ficar só com a parte inteira usei Math.trunc. Em Java, em C# e em Go, a barra entre dois inteiros deu 3, como em C.
A última linha da saída traz outra surpresa: 0.1 + 0.2 não é igual a 0.3. Os números reais são guardados de forma aproximada. Por enquanto, guarde a regra: não compare dois reais com o sinal de igualdade.
ATENÇÃO: o Go tem uma pegadinha aqui. Escrita direto no código, a comparação 0.1 + 0.2 == 0.3 deu verdadeiro, porque em Go as constantes numéricas são valores exatos. Com variáveis, como no programa, deu falso, igual às outras linguagens.
Como converter um tipo em outro?
No programa, a variável digitado guarda o texto “25”. São dois caracteres, o 2 e o 5, e não o número vinte e cinco. Para fazer conta com ele, é preciso converter.
- Texto para inteiro: Integer.parseInt(“25”) em Java, int.Parse(“25”) em C#, strconv.Atoi(“25”) em Go, int(“25”) em Python, (int) “25” em PHP, atoi(“25”) em C e Number(“25”) em JavaScript.
- Número para texto: String.valueOf(25) em Java, numero.ToString() em C#, strconv.Itoa(25) em Go, str(25) em Python, strval(25) em PHP, sprintf em C e String(25) em JavaScript.
- Real para inteiro: (int) 3.99 em Java, em C#, em PHP e em C, int(x) em Go, em que x é uma variável real, int(3.99) em Python e Math.trunc(3.99) em JavaScript.
Ver a animação das conversões

ATENÇÃO: converter real em inteiro corta a parte decimal. Não arredonda. Na saída, 3.99 virou 3, e -3.99 virou -3. Sacou? Quem quer arredondar precisa pedir o arredondamento.
Dois detalhes do Go. O strconv.Atoi devolve dois valores, o número e um erro. No programa, o sublinhado descarta o erro, porque o texto “25” está fixo no código. E a conversão int(3.99), escrita com o número direto, nem compila: a mensagem é cannot convert 3.99 (untyped float constant) to type int. Com uma variável, a parte decimal é cortada, como nas outras linguagens.
Em Java e em C#, guardar 3.99 direto em uma variável int também não compila. As duas exigem a conversão escrita, com (int) na frente.
Como descobrir o tipo de um valor?
Em Java, o tamanho de cada tipo não depende do computador: quem define é a própria linguagem. O programa mostra os tamanhos e o que acontece no limite do int:
// Java: o tamanho de cada tipo é o mesmo em qualquer computador
public class Limites {
public static void main(String[] args) {
System.out.println("int: " + Integer.SIZE + " bits");
System.out.println("long: " + Long.SIZE + " bits");
System.out.println("double: " + Double.SIZE + " bits");
int maior = Integer.MAX_VALUE;
System.out.println(maior); // o maior int
System.out.println(maior + 1); // passou do limite: o valor dá a volta
}
}
Saída:
int: 32 bits long: 64 bits double: 64 bits 2147483647 -2147483648
O int do Java tem sempre 32 bits. Quando a conta passou do limite, não houve aviso: o valor deu a volta e virou o menor número negativo. Para ser avisado existe o Math.addExact, que parou o programa com a mensagem integer overflow.
Em C#, o método GetType mostra o tipo de qualquer valor:
// C#: GetType mostra o tipo de cada valor
using System.Globalization;
object[] valores = { 42, 1.75, "Ana", true };
foreach (object valor in valores)
{
string texto = Convert.ToString(valor, CultureInfo.InvariantCulture) ?? "";
Console.WriteLine(texto + " -> " + valor.GetType().Name);
}
int maior = int.MaxValue;
Console.WriteLine(maior); // o maior int
Console.WriteLine(maior + 1); // passou do limite: o valor dá a volta
Console.WriteLine(0.1m + 0.2m == 0.3m); // decimal: o m no final pede a conta exata
Saída:
42 -> Int32 1.75 -> Double Ana -> String True -> Boolean 2147483647 -2147483648 True
Int32, Double, String e Boolean são os nomes completos dos tipos: int é um apelido de Int32. O estouro do inteiro também passou sem aviso, e com checked(maior + 1) o programa parou com OverflowException. A última linha é a novidade: no tipo decimal, escrito com um m no final, 0.1 + 0.2 é igual a 0.3. Por isso o decimal é o tipo indicado para contas com dinheiro.
Em Python, a função type mostra o tipo de qualquer valor:
# Python: a função type mostra o tipo de cada valor
for valor in [42, 1.75, "Ana", True]:
print(repr(valor), "->", type(valor).__name__)
print(2 ** 64) # inteiros do Python não têm limite de tamanho
print(7 / 2, 7 // 2) # a barra simples sempre devolve real
Saída:
42 -> int 1.75 -> float 'Ana' -> str True -> bool 18446744073709551616 3.5 3
Os inteiros do Python não têm limite de tamanho: 2 elevado a 64 saiu completo, com 20 algarismos.
Em PHP, a função get_debug_type faz o mesmo papel:
<?php
// PHP: get_debug_type mostra o tipo de cada valor
foreach ([42, 1.75, "Ana", true] as $valor) {
echo var_export($valor, true) . " -> " . get_debug_type($valor) . "\n";
}
var_dump(PHP_INT_MAX); // o maior inteiro nesta plataforma
var_dump(PHP_INT_MAX + 1); // passou do limite: o resultado vira float
var_dump("10" + 5); // texto numérico é convertido na soma
Saída:
42 -> int 1.75 -> float 'Ana' -> string true -> bool int(9223372036854775807) float(9.223372036854776E+18) int(15)
O inteiro do PHP tem limite, que depende da plataforma. Quando uma conta passa do limite, o resultado deixa de ser inteiro e vira float. Olhe a segunda linha com var_dump: o tipo mudou sozinho.
Em C, o tipo de cada variável já está declarado no código. O que se pode medir é o tamanho de cada tipo:
/* C: cada tipo tem um tamanho fixo, medido em bytes */
#include <stdio.h>
#include <limits.h>
int main(void) {
printf("char: %zu byte\n", sizeof(char));
printf("int: %zu bytes\n", sizeof(int));
printf("float: %zu bytes\n", sizeof(float));
printf("double: %zu bytes\n", sizeof(double));
printf("maior int: %d\n", INT_MAX);
printf("menor int: %d\n", INT_MIN);
return 0;
}
Saída:
char: 1 byte int: 4 bytes float: 4 bytes double: 8 bytes maior int: 2147483647 menor int: -2147483648
Esses tamanhos são os do computador em que rodei os exemplos. Com 4 bytes, o int vai de -2.147.483.648 a 2.147.483.647. Quem diria… O mesmo 42 ocupa um espaço fixo em C e pode crescer sem limite em Python.
Em JavaScript, o operador typeof devolve o nome do tipo:
// JavaScript: o operador typeof mostra o tipo de cada valor
for (const valor of [42, 1.75, "Ana", true]) {
console.log(JSON.stringify(valor), "->", typeof valor);
}
console.log(Number.MAX_SAFE_INTEGER); // o maior inteiro seguro
console.log(Number.MAX_SAFE_INTEGER + 2); // passou do limite: o resultado sai errado
console.log(2n ** 64n); // BigInt: inteiro sem limite de tamanho
console.log("25" + 5); // o sinal de mais emenda texto com número
console.log("25" - 5); // o sinal de menos converte o texto em número
Saída:
42 -> number 1.75 -> number "Ana" -> string true -> boolean 9007199254740991 9007199254740992 18446744073709551616n 255 20
Repare que 42 e 1.75 têm o mesmo tipo, number. Em JavaScript não existe um tipo inteiro separado: todo number é um ponto flutuante de 64 bits. Por isso existe um “maior inteiro seguro”, 9007199254740991. Somei 2 a ele e a resposta saiu com final 992, e não 993. Para inteiros maiores existe o tipo BigInt, escrito com um n no final. As duas últimas linhas da saída ficam para a próxima seção.
Em Go, o verbo %T do Printf mostra o tipo:
// Go: o verbo %T mostra o tipo de cada valor
package main
import (
"fmt"
"math"
)
func main() {
fmt.Printf("%v -> %T\n", 42, 42)
fmt.Printf("%v -> %T\n", 1.75, 1.75)
fmt.Printf("%q -> %T\n", "Ana", "Ana")
fmt.Printf("%v -> %T\n", true, true)
var maior int64 = math.MaxInt64
fmt.Println(maior) // o maior inteiro de 64 bits
fmt.Println(maior + 1) // passou do limite: o valor dá a volta
}
Saída:
42 -> int 1.75 -> float64 "Ana" -> string true -> bool 9223372036854775807 -9223372036854775808
Em Go, o int tem 32 ou 64 bits, conforme a plataforma, e existem tipos com o tamanho no nome, como o int64. Quando a conta passou do limite, o Go não avisou e não mudou de tipo: o valor deu a volta e virou o menor número negativo.
Aí você pergunta: o que acontece quando misturo texto com número?
Depende da linguagem, e aqui cada uma se comporta de um jeito. Testei a soma do texto “25” com o número 5.
Em Python, o programa para com erro:
TypeError: can only concatenate str (not "int") to str
Em PHP, quando um valor é usado em uma operação que o tipo dele não suporta, a linguagem tenta converter. O texto “10” tem cara de número, então “10” + 5 deu int(15), como você viu na última linha da saída do PHP. Já com um texto que não é numérico, “abc” + 5, o PHP 8.3 também parou:
Uncaught TypeError: Unsupported operand types: string + int
Em C, um texto é um vetor de caracteres. Tentei guardar digitado + 5 em uma variável inteira, e o compilador avisou:
warning: initialization of 'int' from 'char *' makes integer from pointer without a cast [-Wint-conversion]
A expressão mexe com um endereço de memória, e não com o número 25. Para somar, a conversão com atoi é obrigatória.
Em JavaScript, a soma não dá erro e também não dá 30. Quando um dos lados é texto, o sinal de mais emenda: “25” + 5 deu o texto “255”. Já “25” – 5 deu 20, porque aí o texto foi convertido em número. São as duas últimas linhas da saída do JavaScript, na seção anterior.
Em Java e em C#, que têm tipos declarados, o sinal de mais fez o mesmo que em JavaScript: “25” + 5 deu o texto “255”. Já “25” – 5 nem compilou nas duas. A mensagem do Java:
error: bad operand types for binary operator '-'
Em Go, o programa nem compila:
invalid operation: digitado + 5 (mismatched types string and untyped int)
O Go também não mistura inteiro com real sem conversão. Tentei somar idade, que é int, com altura, que é float64, e a mensagem foi mismatched types int and float64. Java e C# aceitaram essa soma e devolveram um real.
A conversão automática do PHP e do JavaScript é prática, mas pode esconder erros. A recomendação vale para as sete linguagens: converta de forma explícita, no lugar em que o dado entra no programa.
Quais são os erros mais comuns com tipos de dados?
- Fazer conta com texto. Um número entre aspas é texto. Converta antes.
- Somar texto com número em JavaScript, em Java ou em C#. “25” + 5 dá “255”, sem nenhum aviso.
- Esperar decimais de uma divisão entre inteiros. Em C, Java, C# e Go, 7 / 2 é 3.
- Achar que a conversão para inteiro arredonda. Ela corta: 3.99 vira 3.
- Comparar reais com igualdade. 0.1 + 0.2 == 0.3 é falso.
- Escrever número real com vírgula. No código, o separador decimal é o ponto.
- Colocar número entre aspas. “42” é texto, 42 é inteiro.
- Ignorar o limite do inteiro. Em C, o int tem tamanho fixo. Em PHP, ao passar do limite, o valor vira float. Em Java, C# e Go, ele dá a volta sem avisar.
- Guardar como número o que é rótulo. CEP, telefone e CPF não entram em conta. São textos.
Agora é com você!
No papel:
- Diga o tipo de cada valor: 15, 15.0, “15”, verdadeiro, “verdadeiro”, -3, 2.5.
- Quanto vale 9 dividido por 4 com inteiros? E com reais?
- Qual é o resultado de converter 7.8, 7.2 e -7.8 para inteiro?
No computador:
- Guarde o texto “3.5” em uma variável, converta para real e multiplique por 2.
- Calcule a média de 7, 8 e 10 e mostre o resultado com uma casa decimal. Confira se a divisão não foi feita entre inteiros.
- Em Python, mostre o tipo do resultado de 10 / 2, de 10 // 2 e de 10 > 2.
Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!
Até o próximo artigo!
Confiança Sempre!!!
Fontes:
- Manual do PHP, Tipos: Introdução, com a lista de tipos da linguagem, a determinação do tipo em tempo de execução, a função get_debug_type e a conversão automática conforme o contexto.
- Manual do PHP, Inteiros, com o limite do inteiro conforme a plataforma, a mudança para float quando o limite é ultrapassado, a função intdiv e a conversão de float para inteiro por truncamento.
- Documentação do Python, Built-in Types, com os tipos numéricos, os inteiros de precisão ilimitada, os valores True e False, o texto como sequência de caracteres Unicode e a conversão int, que descarta a parte decimal (em inglês).
- Unicamp, Instituto de Computação, MC102, Declaração de Variáveis, com os tipos da linguagem C e a declaração por tipo e nome (PDF, slides de aula).
- Unicamp, Instituto de Computação, MC102, Bits e Base Numérica, Variáveis e Atribuições, com as variáveis inteiras, de caractere e de ponto flutuante em C (PDF, slides de aula).
- Universidade Federal de Pernambuco, Centro de Informática, Introdução a Linguagem C, com a obrigação de informar o tipo de dado na declaração de cada variável (PDF, slides de aula).
- Universidade Federal de Minas Gerais, Curso de Linguagem C, com o capítulo sobre os tipos do C, a declaração e a inicialização de variáveis (PDF, apostila).
- ACM, CS2013, Software Development Fundamentals, com os tipos primitivos, como números, caracteres e booleanos, entre os conceitos fundamentais de programação (em inglês).
- AQA, Computer Science, Fundamentals of programming, com a lista de tipos de dados exigida no currículo: inteiro, real, booleano, caractere e string (em inglês).
- The Go Programming Language Specification, com os tipos básicos, o tamanho do int, a declaração curta, o tipo deduzido do valor inicial, as constantes numéricas de valor exato e a exigência de conversão explícita entre tipos numéricos (em inglês).
- Documentação do Go, pacote strconv, com o Atoi, que converte texto em inteiro e devolve também um erro, e o Itoa, que faz o caminho inverso (em inglês).
- MDN Web Docs, JavaScript data types and data structures, com a tipagem dinâmica, o tipo Number como ponto flutuante de 64 bits sem tipo inteiro separado, o maior inteiro seguro, o BigInt e a conversão implícita do operador de soma (em inglês).
- MDN Web Docs, typeof, com o operador que devolve o tipo de um valor (em inglês).
- MDN Web Docs, Math.trunc, com a função que remove a parte fracionária de um número, positivo ou negativo (em inglês).
- The Java Language Specification, Java SE 21, capítulo 4, Types, Values, and Variables, com o int de 32 bits, as operações com inteiros que não indicam estouro e o sinal de mais que emenda quando um dos lados é String (em inglês).
- Microsoft Learn, C# reference, Integral numeric types, com o int como apelido de System.Int32, um inteiro de 32 bits (em inglês).
- Microsoft Learn, C# reference, checked and unchecked statements, com o contexto padrão, que não verifica o estouro, e a OverflowException do contexto checked (em inglês).
- Microsoft Learn, C# reference, Floating-point numeric types, com o tipo decimal e o sufixo m (em inglês).
- Microsoft Learn, C# fundamentals, Built-in types, com a indicação do decimal para contas financeiras e a palavra var, em que o compilador deduz o tipo (em inglês).
- Os exemplos foram executados em Java 21, C# no .NET 8, Go 1.24, Python 3.13, PHP 8.3, GCC 13 e Node.js 22.

Continue a conversa