Ruby: Lição 1
Autor: 4luada | Publicado: 2014-07-02T00:40:00-03:00



Por causa de uma vaga de estágio, resolvi aprender Ruby on Rails. Já estava na minha lista, mas acabei puxando mais pra frente.

Como sempre, começo procurando por diversos tutoriais pela internet. Dou preferência aos tutoriais em inglês. Por algum motivo me dou melhor com eles. De início, escolhi um que parecia bem básico, e tratava os tópicos iniciais com bastante detalhes:&nbsp;Ruby Learning.com.

Ruby in Rails

Antes de tudo, o que é Ruby? É uma linguagem de programação interpretada multiparadigma orientada a objetos. Uma linguagem interpretada é tal cujo código fonte é executado por um programa - o interpretador -, e em seguida executado pelo sistema operacional ou processador. Ruby foi criado em cima do "Principle of least surprise" (Princípio de mínimas surpresas, em tradução livre), por Yukihiro Matsumoto (Matz).

Ruby é uma linguagem open-source, e funciona em diversas plataformas e arquiteturas. Portanto, assim como no tutorial, eu tratarei de Ruby no Windows, mas pouca coisa muda no Mac ou Linux.

Antes de tudo, será necessario fazer download do Ruby. No Windows, o modo mais fácil é fazer download do Ruby Installer. Depois do download, basta instalar o Ruby, preferencialmente com as configurações padrão. Você encontrará, então, dois executáveis (na distribuição para Windows) na pasta /bin de onde você instalou o Ruby (se usou as configurações padrões, provavelmente estará no "Local Disc", ou C: uma pasta com nome Ruby&lt;version&gt;). Um deles, o ruby.exe&nbsp;abre uma janela de DOS Shell de Prompt de Comando - pode ser usado para aplicações que lêem ou escrevem no input&nbsp;ou output&nbsp;padrões, mas não é recomendável para aplicações que, por exemplo, possuem uma interface gráfica, ou se o Ruby é usado por outro programa. Nesses casos é preferível usar o executável rubyw.exe, que é basicamente a mesma coisa que o anterior, mas sem a entrada e saída padrões, nem abre uma janela DOS Shell quando é executado.

Contudo, inicialmente, não usaremos nenhum desses executáveis, mas, sim, um outro executável chamado "Start Command Prompt with Ruby".

Para escrever os códigos-fonte você pode usar qualquer editor de texto-puro (não usar processadores de texto, como Microsoft Word), como Gedit, Sublime Text ou até o Bloco de Notas.

É recomendável criar uma pasta para os programas em ruby que seja próxima da pasta "Home", a pasta inicial. No Windows normalmente é o "C:\Users\&lt;usuario&gt;". Para ter certeza, abra o&nbsp;"Start Command Prompt with Ruby" e veja o endereço da pasta inicial.

Meu Primeiro Programa em Ruby

A primeira coisa a se fazer após abrir o editor de texto é determinar o tamanho do TAB para 2 espaços. Na prática, a indentação não afeta o programa, mas é o padrão utilizado pela comunidade e será melhor caso você planeja distribuir seu código.

Por convenção, os arquivos-fonte de Ruby têm a extensão .rb. No Windows também é comum usar a extensão .rbw. Convencionou-se que toda pasta/diretório e todo arquivo são nomes de classes/módulos com apenas letras minúsculas e extensão .rb.

Comecemos nosso primeiro programa. Escreva o seguinte no seu editor:


p001hello.rb

# p001hello.rb
puts 'Hello world!'



E salve ("Salve como...") com o nome p001hello.rb&nbsp;e salve na sua pasta.

Para rodar o programa, abra o "Start Command Promt with Ruby", navegue até a pasta onde você salvou o arquivo-fonte, e digite o seguinte comando:


Command Prompt with Ruby

c:\Users\Me\rubyprograms&gt; ruby p001hello.rb
Hello world!
c:\Users\Me\rubyprograms&gt; 



OBS: para navegar entre pastas, você pode usar os seguintes comandos:


cd &lt;nome_da_pasta&gt;&nbsp;: esse comando vai para a pasta escolhida
cd..&nbsp;: esse comando navega para a pasta acima da atual
dir&nbsp;: esse comando lista os arquivos e sub-pastas da pasta atual


O método puts&nbsp;simplesmente escreve uma string (que vem logo em seguida - um parâmetro) na tela.

Note que:&nbsp;Em Ruby não existe um método main&nbsp;por onde a execução se inicia. O interpretador recebe um script de comandos, e os executa a partir da primeira linha até a última. Além disso, tudo em Ruby é um objeto, e cada um possui métodos (funções). E existem funções que independem de Objetos - ou melhor, são métodos da classe Object, portanto, está disponível para todos os objetos. É o caso dos métodos puts&nbsp;e gets.

Note que: É opcional o uso de parêntesis ao chamar métodos. São válidos:


Chamada de métodos

funcao
funcao()
funcao(a. b)
funcao a, b



Note que: Como Ruby é uma linguagem interpretada, ela não precisa ser compilada para ser executada.

Recursos do Ruby

Você pode começar a escrever seu programa a partir de qualquer linha.

O Ruby é "case-sensitive", ou seja, letras minúsculas e letras maiúsculas são distintas. Por exemplo, a palavra-chave end&nbsp;é completamente diferente da palavra-chave END.

Para se comentar uma linha, basta colocar um caractere '#' no antes do comentário. Tudo a seguir do caractere até a quebra da linha será ignorado pelo interpretador. Já para blocos de comentários que abrange várias linhas, comece com uma linha iniciada por =begin e termine com =end. Cuidado: isso só funciona se o sinal = for o primeiro caracteres de suas linhas.

É possível escrever vários comandos em uma mesma linha, separados por ponto-vírgula. Mas a pontuação não é necessária nos finais das linhas - uma quebra de linha é tratada como um ponto-vírgula. Se uma linha termina com uma '\', a quebra de linha seguinte é ignorada, de forma a ser possível ter um comando que se estende por várias linhas.

As palavras-chave, consideradas palavras reservadas, não podem ser usadas para outros propósitos além das já designadas a elas, portanto não podem ser usadas como identificadores (variáveis) - em compensação você pode prefixá-las com @, @@ ou $ para usá-las como instâncias, classes ou nome de variáveis globais. Mas a melhor práticas é tratar essas palavras-chave como reservadas.

Tudo tem valor true, exceto as palavras reservadas false e nil. Ou seja, 0 (zero) e null têm valor true.

Números

Em Ruby, números sem pontos decimais são inteiros, caso contrário, são pontos flutuantes (float) - é necessário colocar pelo menos um dígito antes do ponto. Um número inteiro pode ser determinado por uma sequência de dígitos numéricos (underscore&nbsp;podem ser incluídos no meio - não no começo nem no fim -, normalmente para separar cada três casas decimais, os underscores&nbsp;serão ignorados).

Os principais operadores aritméticos são:


+ : soma
- : subtração
* : multiplicação
/ ou %&nbsp;: divisão (% = módulo, divisão inteira)


O operador módulo tem como resultado o resto da divisão do primeiro operando pelo segundo - mas o sinal do resultado é sempre igual ao sinal do segundo operando.

Os inteiros do Ruby são objetos das classes Fixnum&nbsp;ou Bignum, cada um representa inteiros de diferentes tamanhos. Ambos descendem da classe Integer, que por sua vez descende da classe Numeric. Já os pontos flutuantes são objetos da classe Float. As outras classes Complex, BigDecimal, e Rational&nbsp;não fazem parte do Ruby, são incluídos nele pela biblioteca padrão (standard).

A lista dos operadores, na ordem de precedência (do menor para maior):


Blocos: begin&nbsp;(início de bloco), end (fim de bloco)
Modificadores:&nbsp;if&nbsp;, unless&nbsp;, while&nbsp;, until
Operadores lógicos:&nbsp;or&nbsp;("ou"), and ("e")
Negação:&nbsp;not
Definição:&nbsp;defined?&nbsp;(checa se argumento especificado foi definido)
Atribuição:&nbsp;= , += , -= , *= , /= , %= , &amp;= , |= , &gt;&gt;= , &lt;&lt;= , &amp;&amp;= , ||= , **= , ^=
Ternário:&nbsp;? [...] : [...] (if-then-else)
Alcance:&nbsp;.. (inclusivo), ... (exclusivo)
"Ou" lógico:&nbsp;||
"E" lógico:&nbsp;&amp;&amp;
Comparações de Igualdade/Correspondências:&nbsp;&lt;=&gt; (0 se a=b, 1 se a&gt;b, e -1 se a&lt;b), == (igual), === (igualdade numa cláusula 'when' de uma instrução 'case'), !=&nbsp;(diferente), =~ (retorna posição de "/&lt;expressão_regular/" em uma string*), !~
Comparação: &lt;= , &lt; , &gt; , &gt;=
"Ou" (bit a bit p/ inteiros):&nbsp;^ ("ou" exclusivo), | ("ou" regular)
"E" (bit a bit p/ inteiros):&nbsp;&amp;
Shift:&nbsp;&lt;&lt; (shift para a esquerda, ou append), &gt;&gt; (shift para a direita)
Operadores aritméticos:&nbsp;+ (soma), - (subtração)
Operadores aritméticos:&nbsp;* (multiplicação), / (divisão), % (módulo)
ETC:&nbsp;! ("não"), ~ (complemento, inverte bit a bit), + (+@, mais unário), - (-@, menos unário)
Exponenciação:&nbsp;**
Elemento(s): [] , []=
Resolução constante:&nbsp;:: (permite que constantes/instâncias/métodos sejam acessados fora da classe/módulo onde foi definido**)


* Um exemplo de uso do operador '=~' :



/mi/ =~ "hi mike"&nbsp;&nbsp;&nbsp;&nbsp;# retorna: 3
"hi mike" =~ /mi/&nbsp;&nbsp;&nbsp;&nbsp;# retorna: 3
"hi mike" =~ /hello/&nbsp;# retorna: nil



** Um exemplo de uso do operador '::' :


GLOBAL_VAR = 0
module Foo
&nbsp; LOCAL_VAR = 0
&nbsp; ::GLOBAL_VAR = 1 #Set the Global variable to 1
end
puts Foo::LOCAL_VAR #Prints the local "Foo" constant



Os operadores dos itens 10 a 19 são, na verdade, chamadas de métodos.

Parêntesis funcionam normalmente como na aritmética, ou seja, as operações dentro de parêntesis têm maior precedência. Notem que: não há operadores de incremento (++) ou decremento (--), nem formas "pre" ou "post".

Ambos or e ||&nbsp;retornam o primeiro argumento, a não ser que este seja falso - neste caso eles avaliam e retornam o segundo argumento. A única diferença entre eles é a precedência (o segundo tem maior precedência que o primeiro). É comum usar o operador || para atribuir um valor a uma variável apenas se aquela variável já não possuir um valor. Ex:



@variable = @variable || "other value"
@variable ||= "other value"



Já o operador alternativo, or, tem a vantagem de ter precedência menor que o operador de atribuição, de forma a poder usar diversas expressões booleanas para se "encontrar" o valor de uma variável. Ex:



# Método 'g' que aceita 1/+ argumentos, em formato de Array
def g *args
&nbsp; args # retorna array
end
&nbsp;
def f arg
&nbsp; arg
end
&nbsp;
x,y,z = [true, 'two', false] # atribuição paralela
&nbsp;
if a = f(x) and b = f(y) and c = f(z) then
&nbsp; d = g(a,b,c)
end
&nbsp;
# Imprimir e inspecionar d
p d



Strings

Strings literais são sequências de caracteres (ou nada - para dar uma string vazia) entre aspas simples ou duplas. Portanto "Hello" e 'Hello' são strings idênticas, apesar da segunda ser mais eficiente.

É bom saber que existe um tipo de string especial que é delimitada pelo acento grave (`). No caso de uma instrução do tipo:



puts `dir`



A string é enviada e executada pelo sistema operacional como um comando, e o output do comando (no caso, uma lista de sub-pastas e arquivos da pasta atual) será impresso por puts. Para o mesmo propósito também existe o método system, que executa o comando num sub-processo e retorna true&nbsp;se o comando foi encontrado e executado com sucesso, ou false&nbsp;se o comando terminou com um status diferente de zero, ou nil&nbsp;se o comando falhou em ser executado. E o output do comando irá para o mesmo destino que o output do seu programa. Ex:



system("dir")



Outros métodos interessantes com strings são:



# Concatenando strings
puts 'I like ' + 'Ruby'
&nbsp;
# Appending a uma string
a = 'I like '
a&lt;&lt;'Ruby'
&nbsp;
# String de várias linhas
b = &lt;&lt;END_STR
A partir daqui se inicia uma string de várias linhas, e
é delimitado por &lt;&lt;+[delimitador]) e pela repetição do
delimitador logo abaixo, portanto acaba nesta linha
END_STR
&nbsp;
# Imprimindo aspas e outros caracteres especiais
puts 'It\'s Ruby'
puts 3.1416
&nbsp;
# Imprimindo a string três vezes
puts 'Hello' * 3




Note que: se o argumento de puts&nbsp;não for uma string, puts&nbsp;chama o método to_s&nbsp;do objeto enviado como argumento e imprime a string retornada.

Variáveis e Atribuições

Uma variável passa a existir a partir do momento em que o interpretador vê uma atribuição à essa variável. Variáveis só podem ter letras, números e underscores, e não podem começar com um número ou uma letra maiúscula. Palavras-chave (keywords) não podem ser usadas como nomes de variáveis.

Constantes começam com letras maiúsculas.

Alguns métodos comuns são:



5 + '2'.to_i&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;# .to_i converte para integer
5.1 + '2.3'.to_f # .to_f converte para float
200.to_s&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;# .to_s converte para string



Fim da primeira lição de Ruby. Nem essa lição nem o tutorial que usei como base são muito amigáveis para iniciantes. Deve-se ter noção de outras linguagens básicas para entender meu resumo completamente...

Na lição seguinte vou estudar Scope, Inputs e possivelmente outras coisas. Até!