Compreensão dos Tipos de Dados em Ruby

Introdução

Ao escrever programas, você utiliza tipos de dados para classificar informações. Os tipos de dados indicam ao computador como lidar com as informações em seu programa. Eles também determinam o que é possível fazer com esses dados, incluindo as operações que podem ser realizadas.

Uma maneira de entender os tipos de dados é considerar os diferentes tipos de informações que usamos no mundo real. Por exemplo, utilizamos números inteiros (0, 1, 2, …), números negativos (…, -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 somar 5 a π:

5 + π

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

5 + π = 5 + 3.14 = 8.14

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

sky + 8

Isso não é algo que sabemos resolver imediatamente. O computador também não pode fazer isso porque os dados são de dois tipos diferentes. “Sky” é uma palavra, e 8 é um número inteiro. Ao escrever programas, é necessário ter cuidado ao atribuir valores e manipulá-los por meio 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, floats, strings, symbols, 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, portanto, 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 inteiro também é comumente conhecido como int.

Você pode imprimir um inteiro assim:

print -25

Output
-25

Também é possível armazenar o 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, pode calcular a soma de dois números e imprimir o resultado:

sum = 116 - 68
print sum

Output
48

Quando escrevemos números grandes, costumamos usar vírgulas para torná-los mais fáceis de ler. Por exemplo, escreveríamos 1,000,000 para “um milhão”. Não é possível usar vírgulas em seu código, mas o Ruby permite o uso do caractere sublinhado (_) para tornar os números grandes mais legíveis.

Experimente:

large_number = 1_234_567
print large_number

Você verá o número inteiro impresso sem os sublinhados:

Output
1234567

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

À medida que você aprende mais sobre a linguagem Ruby, terá muitas oportunidades para 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 no 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 realizar operações matemáticas com floats no Ruby:

sum = 564.0 + 365.24
print sum

Output
929.24

Se você adicionar um float a um inteiro no 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).

A seguir, vamos dar uma olhada nos booleanos em Ruby.

Tipos de Dados Booleanos

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

Muitas operações na matemática nos dão respostas que avaliam para verdadeiro ou falso:

• 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

Então, 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

Ao escrever mais programas em Ruby, você ficará mais familiarizado com o funcionamento dos booleanos e como diferentes funções e operações que avaliam para true ou false podem mudar o curso do programa.

A seguir, 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 “Hello, World!” demonstra como uma string pode ser usada na programação de computadores, pois os caracteres que compõem a frase Hello, World! são 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!

Como os números, existem muitas operações que podemos realizar com strings dentro de nossos programas para manipulá-las a fim de alcançar os resultados que estamos buscando. 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, você precisa trabalhar com listas de dados. É aí que os arrays se tornam úteis.

Arrays

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

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

Uma matriz 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']

Como outros tipos de dados, você pode atribuir uma matriz a uma variável:

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

Se imprimirmos a variável, a saída será exatamente como a matriz que criamos:

print sea_creatures

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

Você acessa elementos individuais em uma matriz 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

As matrizes em Ruby podem ter muitos tipos diferentes de dados. Você pode armazenar strings, símbolos e até outras matrizes em uma matriz:

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

As matrizes em Ruby são mutáveis, o que significa que você pode adicionar valores, remover valores e até modificar entradas na matriz.

À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, normalmente você usa um símbolo para identificar algo importante, enquanto usaria uma string para o texto com o qual precisa trabalhar ou manipular. Cada string em um programa Ruby é um objeto próprio, com sua própria localização única na memória, mesmo que as strings sejam idênticas.

Porém, ao referenciar o mesmo símbolo várias vezes, você 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 ao explorarmos 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 da mesma forma que outros tipos de dados:

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

Para recuperar valores do hash user, você usa a chave correspondente ao valor:

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

Você pode usar símbolos como 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. O uso de símbolos como chaves resulta em um desempenho ligeiramente melhor e menos uso de memória.

Ao usar símbolos como chaves, você também os usa 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 à usada em JavaScript e em outras linguagens. Essa 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ê examinou 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; a atribuição do 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, ao contrário do 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, portanto, para realizar operações matemáticas, você precisa converter os dados da variável length para um número. Em linguagens de tipo estático, onde você precisa declarar o tipo de dados da variável antes de atribuir um valor a ela, seria necessário criar 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.

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

O método to_f converte a string para um número de ponto flutuante. Ruby também fornece o método to_i para converter strings em números 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\"]"

O Ruby é de tipagem dinâmica, 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ê deseja somar os números para obter 10, converta a string para um número inteiro. Se deseja concatená-los para obter "55", converta o inteiro para uma string.

A tipagem dinâmica oferece flexibilidade, mas uma desvantagem é que nem sempre é possível ter certeza sobre o tipo de dados com o qual você está trabalhando, já que a variável pode conter qualquer tipo disponível. O Ruby oferece maneiras de identificar o tipo de dados.

Identificação de Tipos de Dados

No Ruby, quase tudo é um objeto. Inteiro, ponto flutuante, array, símbolo e hash são todos objetos Ruby, e todos eles têm um método chamado class que irá dizer qual tipo eles são. Até os booleanos true e false, e o valor nil são objetos. Experimente por si mesmo:

42.class # Inteiro
(42.2).class # Ponto Flutuante
["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, assim:

42.kind_of?(Integer) # verdadeiro

Isto é especialmente útil quando você tem uma variável e quer determinar o seu tipo:

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

sharks.kind_of?(Hash) # falso
sharks.kind_of?(Array) # verdadeiro

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 correto de dados. À medida que você aprende mais sobre o 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 dos tipos de dados do Ruby:

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