Ruby - Variáveis, Constantes e Literais

As variáveis ​​são os locais da memória, que contêm todos os dados a serem usados ​​por qualquer programa.

Existem cinco tipos de variáveis ​​suportadas por Ruby. Você também já fez uma pequena descrição dessas variáveis ​​no capítulo anterior. Esses cinco tipos de variáveis ​​são explicados neste capítulo.

Variáveis ​​Globais Ruby

Variáveis ​​globais começam com $. Variáveis ​​globais não inicializadas têm o valor nil e produzem avisos com a opção -w.

A atribuição a variáveis ​​globais altera o status global. Não é recomendado usar variáveis ​​globais. Eles tornam os programas enigmáticos.

Aqui está um exemplo que mostra o uso da variável global.

#!/usr/bin/ruby

$global_variable = 10
class Class1
   def print_global
      puts "Global variable in Class1 is #$global_variable"
   end
end
class Class2
   def print_global
      puts "Global variable in Class2 is #$global_variable"
   end
end

class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global

Aqui $ global_variable é uma variável global. Isso produzirá o seguinte resultado -

NOTE - Em Ruby, você PODE acessar o valor de qualquer variável ou constante colocando um caractere hash (#) antes dessa variável ou constante.

Global variable in Class1 is 10
Global variable in Class2 is 10

Variáveis ​​de instância Ruby

Variáveis ​​de instância começam com @. Variáveis ​​de instância não inicializadas têm o valor nil e produzem avisos com a opção -w.

Aqui está um exemplo que mostra o uso de Variáveis ​​de instância.

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.display_details()
cust2.display_details()

Aqui, @cust_id, @cust_name e @cust_addr são variáveis ​​de instância. Isso produzirá o seguinte resultado -

Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala

Variáveis ​​de classe Ruby

Variáveis ​​de classe começam com @@ e devem ser inicializadas antes que possam ser usadas nas definições de método.

Fazer referência a uma variável de classe não inicializada produz um erro. Variáveis ​​de classe são compartilhadas entre descendentes da classe ou módulo em que as variáveis ​​de classe são definidas.

Substituir variáveis ​​de classe produz avisos com a opção -w.

Aqui está um exemplo que mostra o uso da variável de classe -

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
   def display_details()
      puts "Customer id #@cust_id"
      puts "Customer name #@cust_name"
      puts "Customer address #@cust_addr"
   end
   def total_no_of_customers()
      @@no_of_customers += 1
      puts "Total number of customers: #@@no_of_customers"
   end
end

# Create Objects
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()

Aqui @@ no_of_customers é uma variável de classe. Isso produzirá o seguinte resultado -

Total number of customers: 1
Total number of customers: 2

Variáveis ​​locais Ruby

Variáveis ​​locais começam com uma letra minúscula ou _. O escopo de uma variável local varia de class, module, def ou do até o final correspondente ou da chave de abertura de um bloco até sua chave de fechamento {}.

Quando uma variável local não inicializada é referenciada, ela é interpretada como uma chamada a um método sem argumentos.

A atribuição a variáveis ​​locais não inicializadas também serve como declaração de variável. As variáveis ​​passam a existir até que o final do escopo atual seja alcançado. O tempo de vida das variáveis ​​locais é determinado quando Ruby analisa o programa.

No exemplo acima, as variáveis ​​locais são id, name e addr.

Ruby Constants

As constantes começam com uma letra maiúscula. As constantes definidas em uma classe ou módulo podem ser acessadas de dentro dessa classe ou módulo, e aquelas definidas fora de uma classe ou módulo podem ser acessadas globalmente.

As constantes não podem ser definidas nos métodos. Fazer referência a uma constante não inicializada produz um erro. Fazer uma atribuição a uma constante que já foi inicializada produz um aviso.

#!/usr/bin/ruby

class Example
   VAR1 = 100
   VAR2 = 200
   def show
      puts "Value of first Constant is #{VAR1}"
      puts "Value of second Constant is #{VAR2}"
   end
end

# Create Objects
object = Example.new()
object.show

Aqui VAR1 e VAR2 são constantes. Isso produzirá o seguinte resultado -

Value of first Constant is 100
Value of second Constant is 200

Pseudo-variáveis ​​Ruby

São variáveis ​​especiais que têm a aparência de variáveis ​​locais, mas se comportam como constantes. Você não pode atribuir nenhum valor a essas variáveis.

• self - O objeto receptor do método atual.

• true - Valor que representa verdadeiro.

• false - Valor que representa falso.

• nil - Valor que representa indefinido.

• __FILE__ - O nome do arquivo de origem atual.

• __LINE__ - O número da linha atual no arquivo de origem.

Literais básicos de Ruby

As regras que Ruby usa para literais são simples e intuitivas. Esta seção explica todos os literais básicos do Ruby.

Números inteiros

Ruby suporta números inteiros. Um número inteiro pode variar de -2 ³⁰ a 2 ^30-1 ou -2 ⁶² a 2 ^62-1 . Os inteiros dentro deste intervalo são objetos da classe Fixnum e os inteiros fora deste intervalo são armazenados em objetos da classe Bignum .

Você escreve números inteiros usando um sinal opcional, um indicador de base opcional (0 para octal, 0x para hex ou 0b para binário), seguido por uma sequência de dígitos na base apropriada. Os caracteres sublinhados são ignorados na sequência de dígitos.

Você também pode obter o valor inteiro, correspondendo a um caractere ASCII ou escapar da sequência precedendo-o com um ponto de interrogação.

Exemplo

123                  # Fixnum decimal
1_234                # Fixnum decimal with underline
-500                 # Negative Fixnum
0377                 # octal
0xff                 # hexadecimal
0b1011               # binary
?a                   # character code for 'a'
?\n                  # code for a newline (0x0a)
12345678901234567890 # Bignum

NOTE - Classe e objetos são explicados em um capítulo separado deste tutorial.

Números Flutuantes

Ruby suporta números flutuantes. Eles também são números, mas com decimais. Os números de ponto flutuante são objetos da classe Float e podem ser qualquer um dos seguintes -

Exemplo

123.4                # floating point value
1.0e6                # scientific notation
4E20                 # dot not required
4e+20                # sign before exponential

Literais de string

As strings Ruby são simplesmente sequências de bytes de 8 bits e são objetos da classe String. Strings entre aspas duplas permitem substituição e notação de barra invertida, mas strings entre aspas simples não permitem substituição e permitem notação de barra invertida apenas para \\ e \ '

Exemplo

#!/usr/bin/ruby -w

puts 'escape using "\\"';
puts 'That\'s right';

Isso produzirá o seguinte resultado -

escape using "\"
That's right

Você pode substituir o valor de qualquer expressão Ruby em uma string usando a sequência #{ expr }. Aqui, expr pode ser qualquer expressão rubi.

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

Isso produzirá o seguinte resultado -

Multiplication Value : 86400

Notações de barra invertida

A seguir está a lista de notações de barra invertida suportadas por Ruby -

Notação	Personagem representado
\ n	Nova linha (0x0a)
\ r	Retorno de carro (0x0d)
\ f	Formfeed (0x0c)
\ b	Backspace (0x08)
\uma	Bell (0x07)
\ e	Escape (0x1b)
\ s	Espaço (0x20)
\ nnn	Notação octal (n sendo 0-7)
\ xnn	Notação hexadecimal (n sendo 0-9, af ou AF)
\ cx, \ Cx	Control-x
\ Mx	Meta-x (c | 0x80)
\ M- \ Cx	Meta-Control-x
\ x	Personagem x

Para obter mais detalhes sobre Ruby Strings, leia Ruby Strings .

Ruby Arrays

Literais de Ruby Array são criados colocando uma série separada por vírgulas de referências de objetos entre os colchetes. Uma vírgula final é ignorada.

Exemplo

#!/usr/bin/ruby

ary = [  "fred", 10, 3.14, "This is a string", "last element", ]
ary.each do |i|
   puts i
end

Isso produzirá o seguinte resultado -

fred
10
3.14
This is a string
last element

Para obter mais detalhes sobre Ruby Arrays, consulte Ruby Arrays .

Ruby Hashes

Um Ruby Hash literal é criado colocando uma lista de pares de chave / valor entre colchetes, com uma vírgula ou a sequência => entre a chave e o valor. Uma vírgula final é ignorada.

Exemplo

#!/usr/bin/ruby

hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
   print key, " is ", value, "\n"
end

Isso produzirá o seguinte resultado -

red is 3840
green is 240
blue is 15

Para obter mais detalhes sobre Ruby Hashes, vá até Ruby Hashes .

Ruby Ranges

Um intervalo representa um intervalo que é um conjunto de valores com um início e um fim. Os intervalos podem ser construídos usando os literais s..e e s ... e, ou com Range.new.

Faixas construídas usando .. vão do início ao fim inclusive. Aqueles criados usando ... excluem o valor final. Quando usado como um iterador, os intervalos retornam cada valor na sequência.

Um intervalo (1..5) significa que inclui 1, 2, 3, 4, 5 valores e um intervalo (1 ... 5) significa que inclui 1, 2, 3, 4 valores.

Exemplo

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

Isso produzirá o seguinte resultado -

10 11 12 13 14 15

Para obter mais detalhes sobre Ruby Ranges, vá até Ruby Ranges .