Tipos de Variáveis no Ruby

Pra quem está iniciando os estudos na linguagem Ruby, uma das coisas que muitas vezes podem confundir é a nomeclatura do uso de variáveis, então, dessa vez vamos comentar um pouco sobre isso. Vamos lá!

Constantes

O primeiro tipo de variável que comentarei na verdade não é uma variável… 🙂 é uma constante.

As constantes por definição iniciam com letras maiúsculas e só podem ter um valor atribuído uma única vez. Veja:

2.5.1 :001 > Nome = "Jackson"
2.5.1 :002 > Nome = "Pires"
(irb):2: warning: already initialized constant Nome
(irb):1: warning: previous definition of Nome was here

Perceba que quando tentamos atribuir um novo valor somos alertados de que a constante já foi anteriormente iniciada, mas que passará a ter o novo valor informado. Nesse ponto é comum que se ache estranho o Ruby deixar que um novo valor seja atribuído pois é algo que a maioria das linguagens não permite, mas, por outro lado, ele levanta um warning (não um erro)nos avisando da mudança.

Por convenção geralmente definimos constantes com todas as letras maiúsculas, ou seja, todas as atribuições do exemplo abaixo são constantes válidas.

2.5.1 :001 > Nome = “Jackson”
2.5.1 :002 > CURSO = “Ruby on Rails”
2.5.1 :003 > NomeComposto = “Jackson Pires”

Variáveis Locais

As variáveis locais são as mais comuns quando estamos utilizando o Ruby. Para usá-la basta que seja atribuído um valor à variável desejada. Veja o exemplo:

2.5.1 :001 > a = “curso”

O que é importante conhecer das variáveis locais é a atuação do seu escopo, ou seja, uma variável local exercerá seu papel apenas “no local” onde foi definida. Veja o exemplo abaixo:

2.5.1 :001 > a = “olá”
2.5.1 :002 > def somar_dois(x)
2.5.1 :003?> y = 2
2.5.1 :004?> puts x + y
2.5.1 :005?> end
2.5.1 :006 > puts a
olá
2.5.1 :007 > somar_dois(3)
5
2.5.1 :008 > puts y
Traceback (most recent call last):
2: from /usr/local/rvm/rubies/ruby-2.5.1/bin/irb:11:in `<main>’
1: from (irb):8
NameError (undefined local variable or method `y’ for main:Object)

Analisando o código acima temos a atribuição da variável “a” logo no início do código. Entre as linhas 2 e 5 declara-se um método somar_dois() o qual na linha 3 declara uma variável “y” e atribui o valor 2. Continuando, observa-se que é impresso o valor de “a” na linha 6, chama-se o método somar_dois() na linha 7 que usa internamente a variável “y”, mas na linha 8 ao tentar usar a variável “y” um erro é levantado indicando que ela não existe. Isso ocorre porque a variável “y”, diferentemente da variável “a”, “só existe” no escopo do método somar_dois(), ou seja dentro dele.

Sendo assim, variáveis locais tem o poder de se isolar no escopo o qual está se trabalhando, ou seja, nosso exemplo, “y” só existe dentro do método somar_dois() e “a” está disponível para todo o algoritmo já que não foi definido dentro de um método, ou seja, fora do escopo de um método.

Variáveis Globais $

Variáveis globais possuem um nome bem sugestivo, mas devemos ter cuidado para não nos confundir.

Essas variáveis se propõe a serem “compartilhadas” entre todas as instâncias de uma classe. Veja o exemplo:

2.5.1 :001 > class Pessoa
2.5.1 :002?> $qtd = 0
2.5.1 :003?>
2.5.1 :004?> def initialize
2.5.1 :005?> $qtd += 1
2.5.1 :006?> end
2.5.1 :007?>
2.5.1 :008?> def qtd_pessoas
2.5.1 :009?> puts $qtd
2.5.1 :010?> end
2.5.1 :011?> end
2.5.1 :012 > 
2.5.1 :013 > a = Pessoa.new
2.5.1 :014 > a.qtd_pessoas
1
2.5.1 :015 > 
2.5.1 :016 > b = Pessoa.new
2.5.1 :017 > b.qtd_pessoas
2
2.5.1 :018 > 
2.5.1 :019 > c = Pessoa.new
2.5.1 :020 > c.qtd_pessoas
3

No exemplo acima observa-se que instanciamos 3 vezes a classe Pessoa e sempre que instanciamos a classe o valor da variável $qtd é incrementada. A cada nova instância mostra-se o valor atual através do método “qtd_pessoas()” e assim pode-se observar que a variável $qtd é incrementa a cada nova instância.

Variáveis de Instância @

As variáveis de instância são aquelas que ficam disponíveis para cada uma das instâncias de uma classe, ou seja, isoladamente em cada objeto. Veja o exemplo:

2.5.1 :001 > class Pessoa
2.5.1 :002?> def initialize
2.5.1 :003?> @nome = “sem nome”
2.5.1 :004?> end
2.5.1 :005?>
2.5.1 :006?> def mostrar_nome
2.5.1 :007?> puts @nome
2.5.1 :008?> end
2.5.1 :009?>
2.5.1 :010?> def guardar_nome(nome)
2.5.1 :011?> @nome = nome
2.5.1 :012?> end
2.5.1 :013?> end

2.5.1 :014 > p1 = Pessoa.new
2.5.1 :015 > p1.mostrar_nome
sem nome
2.5.1 :016 > p1.guardar_nome(“Jackson”)
2.5.1 :017 > p1.mostrar_nome
Jackson
2.5.1 :018 > p2 = Pessoa.new
2.5.1 :019 > p2.mostrar_nome
sem nome
2.5.1 :020 > p2.guardar_nome(“João”)
2.5.1 :021 > p2.mostrar_nome
João
2.5.1 :022 > p1.mostrar_nome
Jackson
2.5.1 :023 > p2.mostrar_nome
João

Observe que declara-se uma classe Pessoa que sempre que for instanciada vai iniciar uma variável @nome com o valor “sem nome”, daí entre as linhas 14 e 17 pode-se ver que instancia-se um objeto p1, mostra-se o nome inicial armazenado na variável @nome, que nesse caso inicialmente é “sem nome”, mas logo na sequência atribuí-se o nome “Jackson” e pode-se observar que a variável agora possui um novo valor.

Entre as linhas 18 e 21 fazemos o mesmo processo e pode-se observar que por se tratar de instâncias diferentes, novos valores são armazenados no novo objeto. Ao final, na linha 22 e 23 observa-se que cada variável ficou com seu valor, ou seja “elas não se misturam”.

Variáveis de Classe @@

Dentre os tipos de variáveis que vamos conhecer hoje, na minha opinião, essa é a menos conhecida e consequentemente menos usada.

O nome “variável de classe” pode dar a entender uma coisa, mas, tome cuidado pois as variáveis de classe basicamente são variáveis que “atravessam” as heranças entre classes. Veja o exemplo:

2.5.1 :001 > class DBConfig
2.5.1 :002?> @@url_conn = 'http://meudbparao.com'
2.5.1 :003?>
2.5.1 :004?> def mostrar_url_conn
2.5.1 :005?> puts @@url_conn
2.5.1 :006?> end
2.5.1 :007?> end

2.5.1 :008 > db1 = DBConfig.new
2.5.1 :009 > db1.mostrar_url_conn
http://meudbparao.com

2.5.1 :010 > class PostgresConf < DBConfig
2.5.1 :011?> @@url_conn = 'http://postgresdb.com'
2.5.1 :012?>
2.5.1 :013?> def mostrar_url_conn
2.5.1 :014?> puts @@url_conn
2.5.1 :015?> end
2.5.1 :016?> end

2.5.1 :017 > db2 = PostgresConf.new
2.5.1 :018 > db2.mostrar_url_conn
http://postgresdb.com

2.5.1 :019 > db1.mostrar_url_conn
http://postgresdb.com
2.5.1 :020 > db2.mostrar_url_conn
http://postgresdb.com

Perceba no exemplo acima que cria-se uma classe DbConfig e cria-se uma variável @@url_conn que recebe o valor “http://meudbparao.com”. Instancia-se a classe e mostra-se o valor da variável. Até aí nenhuma novaidade.

Na sequência (entre as linhas 10 e 16) declara-se uma classe PostgresConfque herda da classe DBConfig, e em sua declaração usa-se também a variável @@url_conn, que por se tratar de uma variável de classe sobrescreve o valor inicialmente atribuindo na classe DBConfig.

Ao final, quando mostra-se a url de conexão das instâncias das duas classes, o valor é o mesmo. O importante aqui é notar que a classe herdada alterou o valor de uma variável da classe pai.

Enfim, esse é um breve resumo sobre tipos de variáveis em Ruby. Se você achou interessante ou tem alguma dúvida, não hesite em deixar seu comentário aí embaixo. Ahh, e não esqueça de nos seguir nas mídias sociais, bem como curtir a nossa página no Facebook.

É isso gente, até a próxima! 😉