Algoritmos

Tipos de dados: por que o tipo muda o resultado da conta

Capa do artigo Tipos de dados: por que o tipo muda o resultado da conta
Leitura com foco

Entenda o contexto.
Leve para a prática.

Neste artigo
  1. O que é um tipo de dado?
  2. Quais são os tipos básicos?
  3. Como usar os tipos de dados em Java, C#, Go, Python, PHP, C e JavaScript?
  4. Por que o tipo muda o resultado de uma conta?
  5. Como converter um tipo em outro?
  6. Como descobrir o tipo de um valor?
  7. Aí você pergunta: o que acontece quando misturo texto com número?
  8. Quais são os erros mais comuns com tipos de dados?
  9. 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.
Tabela com os quatro tipos básicos (inteiro, real, texto e lógico), um exemplo de cada e o nome do tipo em Java, C#, Go, Python, PHP, C e JavaScript
Os mesmos quatro tipos existem nas sete linguagens, com nomes parecidos. Em JavaScript, o inteiro e o real são o mesmo tipo.

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.

Duas operações com resultados que dependem do tipo: 7 dividido por 2 dá 3 com inteiros e 3,5 com reais; o texto 25 somado com 5 dá erro, 30 ou o texto 255, conforme a linguagem
Antes de confiar no resultado, confira o tipo dos valores que entraram na conta.

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
Animação da conversão do texto 25 em número inteiro, da soma com 5, da volta para texto, do corte de 3.99 para 3 e da divisão de 7 por 2 com inteiros e com reais
O valor muda de tipo antes de cada operação que exige outro tipo.

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:

Compartilhe este artigo

Sobre quem escreve

Walmir Silva

Olá! Sou Walmir, engenheiro de software com MBA em Engenharia de Software e o cérebro por trás do GrowthCode e autor do livro "Além do Código".

Se você acha que programação é apenas sobre escrever código, prepare-se para expandir seus horizontes. Aqui, nós vamos além do código e exploramos as interseções fascinantes entre tecnologia, negócios, artes e filosofia.

Você está em busca de crescimento na carreira? Quer se destacar em um mercado competitivo? Almeja uma vida mais rica em conhecimento e realização? Então você chegou ao lugar certo. No GrowthCode, oferecemos insights profundos, estratégias comprovadas e um toque de sabedoria filosófica para catalisar seu crescimento pessoal e profissional.

Ver todos os artigos →

Continue a conversa

Compartilhe sua perspectiva

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Guardamos o IP e o navegador de quem comenta por 6 meses, para barrar spam e porque o Marco Civil da Internet pede a guarda dos registros de acesso por esse prazo. Veja como tratamos seus dados.

Encontre sua próxima resposta

O que você quer aprender?

Preferências de cookies

Os cookies opcionais começam desligados. Você pode mudar a escolha a qualquer momento por esta tela.

NecessáriosSempre ativos

Guardam a sua escolha de cookies e o código do registro dela, e mantêm o site funcionando. Não são usados para publicidade.

Contam visitas e mostram como o site é usado: Google Analytics e Microsoft Clarity, carregados pelo Google Tag Manager.

Exibem anúncios do Google AdSense sem personalização. Os cookies desta categoria limitam a repetição dos anúncios e medem o resultado deles.

Usa a sua navegação para escolher anúncios e formar públicos de anúncio: anúncios do Google escolhidos pelos seus interesses e os indicadores do Google no Analytics. Desligado, os anúncios aparecem sem personalização. Depende de Publicidade.

Também é possível bloquear cookies nas configurações do navegador. Detalhes na Política de privacidade.