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

Constantes em Ruby

O primeiro tipo de variável que comentarei, no entanto, 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. Por exemplo:

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 é incrementada 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. A partir disso, 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, atribui-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. Sendo assim, 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 novidade.

Na sequência (entre as linhas 10 e 16), declara-se uma classe PostgresConf, que 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, permite sobrescrever 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, confira este outro artigo sobre o tema ElasticSearch com Ruby on Rails, aqui do Blog da Impulso, e aprenda como programar com mais agilidade.

Até a próxima! 😉