Entendendo Tipos de Dados em Ruby

Introdução

Ao escrever programas, você usa tipos de dados para classificar dados. Os tipos de dados dizem ao computador como lidar com os dados em seu programa. Eles também determinam o que você pode fazer com os dados, incluindo quais operações você pode realizar.

Uma maneira de pensar sobre os tipos de dados é considerar os diferentes tipos de dados que usamos no mundo real. Por exemplo, usamos números inteiros (0, 1, 2, …), números inteiros (…, -1, 0, 1, …), e números irracionais (π).

Geralmente, na matemática, podemos combinar números de diferentes tipos e obter algum tipo de resposta. Por exemplo, podemos querer adicionar 5 a π:

5 + π

Podemos manter a equação como resposta para considerar o número irracional, ou podemos arredondar π para um número com um número breve de casas decimais e depois somar os números juntos:

5 + π = 5 + 3.14 = 8.14

Mas se tentarmos avaliar números com outro tipo de dados, como palavras, as coisas começam a não fazer tanto sentido. Como resolveríamos a seguinte equação?

sky + 8

Isso não é algo que sabemos imediatamente como resolver. O computador também não pode porque os dados são de dois tipos diferentes. “Céu” é uma palavra, e 8 é um número inteiro. Quando escrevemos programas, temos que ter cuidado com como atribuímos valores e como os manipulamos através de operações como adição, subtração, multiplicação e outras.

Neste tutorial, você aprenderá sobre os tipos de dados mais importantes nativos do Ruby: inteiros, números de ponto flutuante, strings, símbolos, arrays e hashes. Esta não é uma investigação exaustiva de tipos de dados, mas ajudará você a se familiarizar com as opções disponíveis em seus programas.

Em seguida, você explorará a tipagem dinâmica. Os programas Ruby determinam os tipos de dados com base no conteúdo das variáveis, então entender como a tipagem dinâmica funciona ajudará a evitar situações complicadas em seus próprios programas. E como as variáveis podem conter qualquer valor, você aprenderá a identificar o tipo de dados de uma variável.

Vamos começar olhando como trabalhar com números inteiros no Ruby.

Inteiros

Assim como na matemática, inteiros na programação de computadores são números inteiros que podem ser positivos, negativos ou 0 (…, -1, 0, 1, …). Um número inteiro é também conhecido como int.

Você pode imprimir um número inteiro assim:

print -25

Output
-25

Você também pode armazenar o número inteiro em uma variável e depois imprimir o valor referenciando a variável:

my_int = -25
print my_int

Output
-25

Você também pode realizar operações matemáticas com inteiros. Por exemplo, você pode calcular a soma de dois números e imprimir o resultado:

sum = 116 - 68
print sum

Output
48

Quando escrevemos números maiores, tendemos a usar vírgulas para torná-los mais fáceis de ler. Por exemplo, escreveríamos 1.000.000 para “um milhão”. Você não pode usar vírgulas em seu código, mas o Ruby permite que você use o caractere de sublinhado (_) para tornar os números grandes mais legíveis.

Tente isso:

large_number = 1_234_567
print large_number

Você verá o inteiro impresso sem os sublinhados:

Output
1234567

Os sublinhados permitem que você escreva um código mais legível se precisar representar números grandes em seus programas.

À medida que você aprende mais sobre a linguagem Ruby, terá muitas outras oportunidades de trabalhar com inteiros. Vamos ver como trabalhar com números reais.

Números de Ponto Flutuante

A floating-point number or a float represents a real number. Real numbers can be either a rational or an irrational number; numbers that contain a fractional part, such as 9.0 or -116.42. In other words, a float in a Ruby program is a number that contains a decimal point.

Você pode imprimir floats em Ruby da mesma forma que imprime inteiros:

print 17.3

Output
17.3

Você também pode declarar uma variável e atribuir um float:

my_float = 17.3
print my_float

Output
17.3

E, assim como com inteiros, você pode fazer cálculos com floats em Ruby também:

sum = 564.0 + 365.24
print sum

Output
929.24

Se você adicionar um float a um inteiro em Ruby, obterá um float:

sum = 564 + 365.24
print sum

Output
929.24

O Ruby considerará qualquer número escrito sem decimais como um inteiro (como em 138) e qualquer número escrito com decimais como um float (como em 138.0).

Em seguida, vamos dar uma olhada nos booleanos em Ruby.

Tipos de Dados Booleanos

Booleanos são usados para representar os valores lógicos associados ao ramo da lógica matemática, que informa algoritmos em ciência da computação. Em Ruby, representamos esse tipo de dado com um dos dois valores, seja true ou false.

Muitas operações matemáticas nos dão respostas que se avaliam como verdadeiras ou falsas:

• maior que
• 500 > 100 true
• 1 > 5 false
• menor que
• 200 < 400 true
• 4 < 2 false
• igual
• 5 = 5 true
• 500 = 400 false

Assim como com números, você pode armazenar um valor true ou false em uma variável:

result = 5 > 8

Em seguida, você pode imprimir o valor booleano com uma chamada para a função print():

print result

Como 5 não é maior que 8, você verá o seguinte resultado:

Output
false

À medida que você escreve mais programas em Ruby, ficará mais familiarizado com o funcionamento dos booleanos e como diferentes funções e operações que se avaliam como true ou false podem alterar o curso do programa.

Em seguida, vamos explorar o trabalho com texto em nossos programas.

Strings

A string is a sequence of one or more characters, such as letters, numbers, and symbols. Strings primarily exist within either single quotes (') or double quotes (") in Ruby, so to create a string, enclose a sequence of characters in quotes, like this:

"This is a string in double quotes."

O pequeno programa “Olá, Mundo!” demonstra como uma string pode ser utilizada na programação de computadores, já que os caracteres que compõem a frase Olá, Mundo! formam uma string.

print "Hello, World!"

Assim como outros tipos de dados, você pode armazenar strings em variáveis:

output = "Hello, World!"

E imprimir a string chamando a variável:

print output

Output
Hello, World!

Assim como os números, existem muitas operações que podemos realizar em strings dentro de nossos programas para manipulá-las e obter os resultados desejados. Strings são importantes para comunicar informações ao usuário e para o usuário comunicar informações de volta ao programa.

Às vezes, é necessário trabalhar com listas de dados. É aí que as arrays entram em jogo.

Arrays

Uma array pode conter múltiplos valores dentro de uma única variável. Isso significa que você pode armazenar uma lista de valores dentro de uma array e iterar por eles. Cada item ou valor dentro de uma array é chamado de elemento.

Arrays são definidas especificando valores entre colchetes [ ], separados por vírgulas.

Um array de inteiros parece assim:

[-3, -2, -1, 0, 1, 2, 3]

A array of floats looks like this:

[3.14, 9.23, 111.11, 312.12, 1.05]

Aqui está uma lista de strings:

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Assim como outros tipos de dados, você pode atribuir um array a uma variável:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Se nós imprimirmos a variável, a saída parece exatamente como o array que criamos:

print sea_creatures

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

Você acessa elementos individuais em um array usando um número de índice, começando em 0.

puts sea_creatures[0] # tubarão
puts sea_creatures[2] # lula

Para imprimir o último valor, você pode usar o índice -1. Ruby também fornece os métodos .first e .last para pegar o primeiro e o último elemento, respectivamente:

puts sea_creatures.first # tubarão
puts sea_creatures.last # camarão-mantis

Arrays em Ruby podem ter muitos tipos diferentes de dados. Você pode armazenar strings, símbolos e até outros arrays em um array:

record = [
:en,
"Sammy",
42,
[
"coral",
"reef"
]
]

Arrays em Ruby são mutáveis, o que significa que você pode adicionar valores, remover valores e até modificar entradas no array.

Às vezes, precisamos de uma maneira de rotular coisas em um programa. Para isso, existem os símbolos.

Símbolos

A symbol is a special data type that acts like a label or an identifier in a Ruby program. Symbols are immutable, which means that they cannot be changed. A symbol looks like a variable declaration without a value. Here’s an example of a symbol:

:time_zone

Em Ruby, você normalmente usa um símbolo para identificar algo de importância, enquanto usaria uma string para o texto com o qual precisa trabalhar ou manipular. Cada string em um programa Ruby é seu próprio objeto, com sua própria localização única na memória, mesmo que as strings sejam idênticas.

Mas se você referenciar o mesmo símbolo várias vezes, está referenciando o mesmo objeto em todo o seu programa, o que significa que está referenciando a mesma localização de memória.

Você verá esse conceito em ação enquanto examinamos hashes, que permitem associar chaves a valores.

Hashes

A hash is a dictionary-like collection of keys and values. These key-value pairs provide a useful way to store and access data. Hashes are often used to hold data that are related, such as the information about a user. You define a hash like this:

{"first_name" => "Sammy", "last_name" => "Shark"}

Você pode atribuir hashes a variáveis assim como outros tipos de dados:

user = {"first_name" => "Sammy", "last_name" => "Shark"}

Para recuperar valores do hash user, você usa a chave para o valor:

print user["first_name"] # "Sammy"
print user["last_name"] # "Shark"

Você pode usar símbolos como as chaves em seu hash em vez de strings:

user = {:first_name => "Sammy", :last_name => "Shark"}

O uso de símbolos como chaves de hash é preferível sempre que possível. Cada instância de um símbolo aponta para o mesmo objeto, enquanto cada instância de uma string se refere a um objeto único. Usar símbolos como chaves resulta em um desempenho ligeiramente melhor e menos uso de memória.

Quando você usa símbolos como chaves, você usa símbolos para recuperar os valores:

print user[:first_name] # "Sammy"
print user[:last_name] # "Shark"

Você também pode usar uma sintaxe ligeiramente diferente ao definir o hash:

user = {first_name: "Sammy", last_name: "Shark"}

Esta sintaxe é semelhante à sintaxe usada em JavaScript e outras linguagens. Esta sintaxe define as chaves como Símbolos, então você acessaria as entradas usando :first_name e :last_name em vez das strings "first_name" e "last_name".

Você olhou para vários tipos de dados, então vamos ver como o Ruby trabalha com esses tipos.

Tipagem Dinâmica

No Ruby, você não declara explicitamente um tipo de dado antes de atribuir um valor; atribuir o valor determina o tipo de dado. O Ruby usa tipagem dinâmica, o que significa que a verificação de tipo é feita em tempo de execução em vez de tempo de compilação, como em linguagens que usam tipagem estática. O Ruby determina o tipo de dado a partir dos dados armazenados na variável. Isso é semelhante aos tipos de dados em Python e aos tipos de dados em JavaScript.

A variável t no exemplo a seguir pode ser definida para qualquer tipo de dado disponível:

t = 42 # t is an Integer
t = "Sammy" # t is a String
t = :sammy # t is a Symbol
t = true # t is a boolean (true)
t # t is nil

Com linguagens de tipagem dinâmica, você pode reutilizar uma variável existente para armazenar diferentes tipos de dados.

Isso é útil ao converter dados de um tipo para outro. Por exemplo, você pode ter este código que pede ao usuário um valor numérico:

print "Please enter the length of the room: "
length = gets.chop

Os dados que você obtém do teclado são sempre uma string, então, para realizar operações matemáticas, você precisa converter os dados da variável length para um número. Em linguagens de tipagem estática, onde você precisa declarar o tipo de dados da variável antes de atribuir um valor a ela, você precisaria de uma nova variável para armazenar os dados convertidos. Mas em Ruby, como é uma linguagem de tipagem dinâmica, você pode reutilizar a variável length se desejar.

# Converta o valor para um Float.
length = length.to_f

O método to_f converte a string para um float. Ruby também fornece o método to_i para converter strings em inteiros, e a maioria dos objetos pode ser convertida em strings usando o método to_s:

42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"

Ruby é tipada dinamicamente, mas não permite que você realize operações em diferentes tipos de dados sem convertê-los para o mesmo tipo. Por exemplo, este código resultará em um erro:

print 5 + "5"

Output
TypeError: String can't be coerced into Integer

Assim como este código:

print "5" + 5

Output
TypeError: no implicit conversion of Integer into String

Se você quiser somar os números para obter 10, converta a string para um inteiro. Se você quiser concatená-los para obter "55", converta o inteiro para uma string.

A tipagem dinâmica oferece flexibilidade, mas uma desvantagem é que você nem sempre pode ter certeza que tipo de dados está manipulando, já que a variável pode conter qualquer tipo disponível. Ruby fornece formas para você identificar o tipo de dado.

Identificando Tipos de Dados

No Ruby, quase tudo é um objeto. Integer, float, array, symbol e hash são todos objetos Ruby, e todos eles têm um método chamado class que dirá qual tipo são. Até mesmo os booleanos true e false, e o valor nil são objetos. Experimente por si mesmo:

42.class # Integer
(42.2).class # Float
["Sammy", "Shark"].class # Array
true.class # TrueClass
nil.class # NilClass

Além disso, você pode usar o método kind_of? para verificar um certo tipo de dado, como este:

42.kind_of?(Integer) # true

Isso é especialmente útil quando você tem uma variável e deseja determinar seu tipo:

# em algum lugar no código...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# em outro lugar...

sharks.kind_of?(Hash) # false
sharks.kind_of?(Array) # true

Você também pode usar isso para verificar se os dados provenientes de uma fonte externa estão corretos:

if data.kind_of? String
data = data.to_f
end

Ruby também fornece o método is_a?, que faz a mesma coisa que kind_of?, mas pode ser um pouco mais fácil de ler para alguns desenvolvedores:

if data.is_a? String
data = data.to_f
end

O uso de class, kind_of? e is_a? pode ajudar a garantir que você esteja trabalhando com o tipo certo de dados. À medida que você aprende mais sobre Ruby, descobrirá outras maneiras de lidar com dados que não envolvem verificar explicitamente o tipo de dados.

Conclusão

Você usará muitos tipos diferentes de dados em seus programas Ruby. Agora você tem uma compreensão melhor dos principais tipos de dados disponíveis em programas Ruby.

Dê uma olhada nesses tutoriais para continuar sua exploração sobre os tipos de dados em Ruby:

• Como Trabalhar com Strings em Ruby
• Como Trabalhar com Arrays em Ruby
• Como Converter Tipos de Dados em Ruby