Ruby: Introdu��o ao recursos b�sicos

Ruby � uma linguagem consistente, orientada � objeto e din�mica, ou seja, voc� receber� um feedback a cada comando. Nesse artigo ser� mostrado seus conceitos, como fazer e utilizar suas classes e m�todos.

Guia do artigo:

Sintaxe da linguagem
Vari�veis
Operadores
Tipos de dados Ruby
String
N�meros
Symbol
Array
Hash
L�gica
Blocos e Iteraç�es
Classes, M�todos e Objetos
M�todos
Objetos
Classe
Fazendo uma Classe

Ao baixar seu pacote, um interpretador interativo chamado irb � instalado. Utilizando este no prompt de comando (cmd ou Terminal) voc� poder� executar os c�digos. Para iniciar uma sess�o abra seu prompt e digite:


        $ irb
        irb(main):001:0>

Agora voc� est� dentro do Ruby.

Caso voc� ainda n�o tenha nenhum conhecimento da linguagem, aconselho que primeiro veja uma introduç�o sobre o Framework Ruby on Rails e caso j� tenha um certo conhecimento e gostaria de se aprofundar ainda mais, sugiro que faça esse curso online de Ruby on Rails.

Sintaxe da linguagem

Vari�veis

Vari�veis s�o usadas para guardar valores enquanto h� um processamento de dados. Em Ruby, como j� deve ter sido notado, n�o � necess�rio definir tipos, apenas � necess�rio que a vari�vel tenha um nome e um valor atribu�do, depois disso o trabalho ser� do interpretador.

S�o quatro tipos de vari�veis:

Vari�veis Locais: Apenas existem no m�todo ou bloco de c�digo que foram atribu�dos. Os valores s�o atribu�dos enquanto o programa roda. A escrita dessas vari�veis � sempre com letra min�scula.
Exemplo: meu_nome
Vari�veis Instanciadas:Começam com @. S�o as �nicas vari�veis que d�o uma inst�ncia � classe.
Exemplo: @usuario
Vari�veis da Classe: Começam com @@. Existem no escopo da classe, ent�o todas as inst�ncias de uma classe espec�fica t�m um valor para a vari�vel da classe.
Exemplo: @@usuarios
Vari�veis constantes: S�o aquelas que n�o mudam durante a execuç�o do programa. Em Ruby, elas podem ser realocadas, mas ser� recebido um aviso do interpretador. Al�m disso, s�o escritas em letra mai�scula.
Exemplo: IP_SERVER

Operadores

Para fazer operaç�es com valores � necess�rio uma s�rie de sinais, como os mostrados a seguir:

Aritm�tico:*, /, %, +, **
Atribuiç�o: []=, =
Comparaç�o: <=, >=, <, >
L�gico:&, ^, |
E, OU:||, &&

Na documentaç�o do Ruby voc� consegue maior conhecimento da aplicaç�o desses conceitos, sen�o, o artigo ficaria muito extenso. Mas veremos exemplos a seguir da utilizaç�o de alguns deles.

Tipos de dados Ruby

Um tipo de dado � uma limitaç�o colocada no interpretador, por exemplo, n�meros e textos s�o dois tipos diferentes. Como em outras linguagens, no Ruby existe essa distinç�o.

String

Esse ser� uma sequ�ncia de caracteres representados por uma palavra ou alguma forma de texto. No Ruby, qualquer dado entre ap�strofo ou aspas ser� do tipo string.

Para testar, como o irb j� est� na sua tela de comando, digite:


        2.0.0-p451 :001> �Ruby � uma linguagem diferente�

O irb ir� responder:

=> �Ruby � uma linguagem diferente�

A principal diferença entre usar delimitaç�es do string com ap�strofo (��) ou aspas (��) � que ap�strofos s�o sujeitos � alteraç�es ou erros como, por exemplo:

2.0.0-p451 :002> �King�s Boulevard�
        2.0.0-p451 :003�> ' SyntaxError: (irb):12: syntax error, unexpected tIDENTIFIER, expecting end-of-input
        'Kings's boulevard'
        ^

O que aconteceu � que o interpretador n�o soube onde era o t�rmino do c�digo e continuou sem dar o feedback, mesmo com o s�mbolo do ap�strofo do lado do n�mero, at� que a frase fosse terminada.

Outro exemplo:

 2.0.0-p451 :004> �Agora � #{Time.now}�
        => �Agora � \#{Time.now}�

No string acima foi utilizado o construtor #{}, que serve para substituiç�es de var�veis. Essa t�cnica � conhecida como interpolation. Como a substituiç�o foi feita com ��, a resposta foi inesperada. Se as aspas tivessem sido usadas, o retorno seria algo do g�nero:

=> �Agora � 2014-09-10 18:28:09 -0300�

Quando voc� utiliza a hastag (#) com as chaves, o Ruby entende que deve-se avaliar o que est� ali dentro. Por�m, quando voc� usa o ap�strofo,a substituiç�o n�o � checada.

Existem v�rios m�todos para fazer uma manipulaç�o string como, por exemplo, aumentara letra ou deixar apenas a primeira letra em mai�scula. Para isso, digite no seu prompt:

2.0.0-p451 :005>�Bras�lia-Brasil�.upcase
        => �BRAS�LIA-BRASIL�
        2.0.0-p 451 :006> �RUBY ON RAILS�.capitalize
        => "Ruby on rails"

Esses s�o alguns dos v�rios exemplos e se voc� quiser, pode testar com outros m�todos, como downcase e .length.

N�meros

Em Ruby, os n�meros possuem algumas classes para os representarem como: Fixnum, Bignum e Float.

O Fixnume Bignum fazem parte dos n�meros inteiros e o Floatos n�meros reais, ou seja, fracion�rios. Como em outras linguagens, voc� pode fazer contas aritm�ticas como faria na calculadora no Terminal. Por exemplo:

 2.0.0-p451 :001 > 1+2
        => 3

Ao utilizar inteiros, se divid�-los, o resultado mostrado ser� um do mesmo tipo. Para obter um resultado decimal � preciso indicar tal fato. Por exemplo:

2.0.0-p451 :002 > 3/5
        => 0

        2.0.0-p451 :003 > 3.0/5
        => 0.6

Symbol

Os s�mbolos n�o s�o muito comuns nas linguagens de programaç�o. Por�m, s�o extremamente �teis. Eles s�o um tipo de dado que começam com dois pontos(:), como :nome. Estes s�o objetos usados para apontar alguma data que n�o � tradicionalmente um objeto String. A diferença � que um Symbol � imut�vel, enquanto que um String � mut�vel e pode ter problemas com resultados inesperados e desempenho reduzido. Vejamos um exemplo:


        2.0.0-p451 :001 > module One
        2.0.0-p451 :002?> class Fred
        2.0.0-p451 :003?> end
        2.0.0-p451 :004?> $f1 = :Fred
        2.0.0-p451 :005?> end
        => :Fred
        2.0.0-p451 :006 > module Two
        2.0.0-p451 :007?> Fred = 1
        2.0.0-p451 :008?> $f2 = :Fred
        2.0.0-p451 :009?> end
        => :Fred
        2.0.0-p451 :010 > $f1.object_id
        => 538668
        2.0.0-p451 :011 > $f2.object_id
        => 538668

Nesse trecho fica claro que, independentemente das mudanças, o valor do s�mbolo continua retornando o mesmo n�mero.

Array

Arrays s�o parte de quase todas as linguagens de programaç�o. Eles mantem a informaç�o em ordem e s�o definidos com a utilizaç�o de colchetes [ ]. Os primeiros elementos sempre t�m �ndice zero. Alguns exemplos a seguir deixar�o mais claro como funcionam no Ruby.


        (1) 2.0.0-p451 :012 > array_cidades = ["Rio de Janeiro", "Salvador", "S�o Paulo"]
        =>["Rio de Janeiro", "Salvador", "S�o Paulo"]

        (2) 2.0.0-p451 :013 > array_cidades[0]
        => "Rio de Janeiro"

        (3) 2.0.0-p451 :014 > array_cidades[2] = "Cuiab�"
        => "Cuiab�"

        (4) 2.0.0-p451 :015 > array_cidades << "Bras�lia"
        => ["Rio de Janeiro", "Salvador", "Cuiab�", "Bras�lia"]

        (5) 2.0.0-p451 :016 > array_cidades + ["Fortaleza"]
        => ["Rio de Janeiro", "Salvador", "Cuiab�", "Bras�lia", "Fortaleza"]

No primeiro exemplo foi definido o array das cidades com tr�s elementos. No segundo a cidade com �ndice 0 foi refer�ncia para a resposta do irb: �Rio de Janeiro�. No terceiro exemplo substitui-se o objeto de �ndice 2, �S�o Paulo�, por �Cuiab�. No quarto exemplo temos o operador conhecido como shovel, que adiciona um novo objeto � lista, assim como o �ltimo exemplo, que utiliza uma forma diferente para colocar um novo item no array.

Hash

Um Hash oferece uma forma diferente de representar uma coleç�o em relaç�o ao array, pois ele utiliza uma chave (key). Em Ruby, frequentemente utiliza-se um s�mbolo como chave. Na verdade, qualquer objeto pode ter a funç�o de uma key. A forma de escrever um Hash em Ruby � hash = {key: �value�}. Para ficar mais claro, seguem alguns exemplos:


        (1) 2.0.0-p451 :008 > meu_hash = {nome: "Jo�o", idade: 12, estado: "GO"}
        => {:nome=>"Jo�o", :idade=>12, :estado=>"GO"}

        (2) 2.0.0-p451 :009 > meu_hash[:nome]
        => "Jo�o"

        (3) 2.0.0-p451 :013 > meu_hash.first
        => [:nome, "Jo�o"]

        (4) 2.0.0-p451 :014 > meu_hash.keys
        => [:nome, :idade, :estado]

        (5) 2.0.0-p451 :015 > meu_hash[:cidade] = "Florian�polis"
        => "Florian�polis"

        (6)2.0.0-p451 :016 > meu_hash[:estado] = "SC"
        => "SC"

        2.0.0-p451 :019 > meu_hash[:estado]
        => "SC"

No exemplo n�mero 1 o hash foi criado. No segundo exemplo a key �nome� � colocada para descobrir seu valor (value). No exemplo 3, o primeiro da lista � mostrado. No quarto exemplo � mostrado apenas os s�mbolos pedidos. No exemplo n�mero 5 cria-se um novo objeto e no exemplo 6 substitui-se um valor existente por um novo na chave (key) de �:estado�.

NOTA:

Para vers�es de Ruby abaixo de 1.9, a representaç�o de um hash ser�: exemplo = {:key=> �value�}.

L�gica

O Ruby possui todas as estruturas l�gicas mais comuns, como while e if, mas enquanto os programadores de Java, C e Perl se perdem nas chaves, a estrutura aqui � muito mais simples.

Vejamos a seguir alguns exemplos de Estruturas de Controle:


        2.0.0-p451 :020 > count = gets.to_i
        3
        => 3
        2.0.0-p451 :021 > if count == 3
        2.0.0-p451 :022?> puts "Voce acertou!"
        2.0.0-p451 :023?> else
        2.0.0-p451 :024 > puts "Digite novamente"
        2.0.0-p451 :025?> end
        => Voce acertou!

Na primeira linha, uma vari�vel � criada e � transformada em inteiro (to_i) para receber um valor pedido pelo comando gets. Ap�s isso, uma estrutura if e else � definida e o usu�rio recebe o valor que a l�gica promove. O else if tamb�m existe no Ruby, por�m, � escrito elsif e n�o utiliza o end no final.

Outra forma � o unless e � utilizado para fazer uma exceç�o com um apenas um if, como mostra o exemplo a seguir:


        2.0.0-p451 :050 > a = 5
        2.0.0-p451 :058 > unless a > 5
        2.0.0-p451 :059?> puts "N�o � maior que 5"
        2.0.0-p451 :060?> end
        N�o � maior que 5
        => nil

A estrutura while tamb�m � terminada com end e tem formato comum de outras linguagens:

while condiç�o

l�gica

end

Um exemplo feito no terminal �:


        2.0.0-p451 :041 > a = 5
        => 5
        2.0.0-p451 :042 > b = 10
        => 10
        2.0.0-p451 :043 > while a < b
        2.0.0-p451 :044?> puts "a � #"
        2.0.0-p451 :045?> a += 1
        2.0.0-p451 :046?> end
        a � 5
        a � 6
        a � 7
        a � 8
        a � 9
        => nil

Nesse c�digo foram definidas duas vari�veis para descobrir os n�meros que ser�o mostrados enquanto �b� for maior que �a�.

Blocos e Iteraç�es

O fragmento de c�digo entre chaves ou a palavra do...end determinar� a quantidade de vezes que o objeto ou vari�vel ser� lido pelo interpretador e repetido no programa. Em Ruby, o for utilizado em muitas linguagens tamb�m existe, por�m o mais comum � o each.

O times � uma forma de entender o funcionamento do each, apesar de n�o utilizado frequentemente por precisar de uma quantidade espec�fica. Para melhor compreens�o, seguem os exemplos:


        3.times { puts "Ol�!" }
        Ol�!
        Ol�!
        Ol�!
        => 3

� f�cil de perceber que a palavra entre as chaves sobre o comando puts ser� mostrado tr�s vezes e pulando linhas. Caso tivesse sido utilizado p ou print, a palavra seria mostrada na mesma linha, como � demonstrado a seguir:


        2.0.0-p451 :062 > 3.times { print "Oi! "}
        Oi! Oi! Oi! => 3

O bloco each tem a mesma l�gica para ler toda a coleç�o, por�m, seu formato pode ser de duas maneiras:

(1) exemplos.each {|exemplo| puts exemplo}

(2) exemplos.each do |exemplo|

puts exemplo

end

Alguns exemplos abaixo podem deixar mais claro o funcionamento da estrutura:


        (1)
        2.0.0-p451 :063 > numeros = [1, 2, 3]
        2.0.0-p451 :065 > numeros.each {|numero| puts numero}
        1
        2
        3
        => [1, 2, 3]

        (2)
        2.0.0-p451 :063 > numeros = [1, 2, 3]
        2.0.0-p451 :066 > numeros.each do |numero|
        2.0.0-p451 :067 > puts numero
        2.0.0-p451 :068?> end
        1
        2
        3
        => [1, 2, 3]
        (3)
        2.0.0-p451 :063 > numeros = [1, 2, 3]
        2.0.0-p451 :072 > numeros.each_with_index do |numero, index|
        2.0.0-p451 :073 > puts "Valor: #, �ndice: #"
        2.0.0-p451 :074?> end
        Valor: 1, �ndice: 0
        Valor: 2, �ndice: 1
        Valor: 3, �ndice: 2
        => [1, 2, 3]

O primeiro e segundo exemplos seguem a estrutura j� mostrada. Por�m, no terceiro exemplo � utilizado each_with_index que ir� fazer uma leitura no array e estabelecer� o n�mero do �ndice, representado porindex.

Classes, M�todos e Objetos

Ap�s demonstrar uma parte inicial da linguagem, � preciso introduzir a parte mais importante dela: a orientaç�o a objetos (OO).

Orientaç�o a objetos � dividida, basicamente, em: classes, m�todos e objetos, onde a classe � a ess�ncia - a representaç�o de um conjunto de objetos, enquanto o m�todo � a aç�o e o objeto � uma refer�ncia a um local da mem�ria que possui um valor. Esses conceitos ser�o aprofundados a seguir para um maior entendimento desse funcionamento no Ruby.

M�todos

S�o aç�es program�veis que voc� pode definir para facilitar o desenvolvimento do seu projeto. A estruturados m�todos na linguagem Ruby �:


        def nomedom�todo(par�metros)
        c�digo
        end

Um outro exemplo:


        def saudacao(nome)
        "Oi, #!"
        end
        puts saudacao("Paula")

Os m�todos podem ser muito mais complexos, incluir criaç�o de vari�veis e condiç�es. Mas, por agora, o bom � o entendimento da estrutura,do funcionamento e sua import�ncia para as, futuramente introduzidas, classes.

Objetos

O objeto � a inst�ncia de uma classe. A inst�ncia representa o objeto concretizado a partir de uma classe inicializada e alocada na mem�ria do computador.A classe � apenas uma matriz, que especifica objetos, mas que n�o pode ser utilizada diretamente.

Basicamente, objetos s�o formas f�ceis de separar seu c�digo e os dados que este cont�m. Eles podem ser mudados, deletados, criados, movidos e outros. Na programaç�o OO, utiliza-se objetos para chamar m�todos ou pass�-los para outros m�todos. Isso ficar� mais claro com os com explicaç�es a seguir:


        2.0.0-p451 :001 > time = [[10, "Atacante", "Pedro"], [8, "Meio de Campo", "Henrique"], [3, "Zagueiro",
        "David"]]

        => [[10, "Atacante", "Pedro"], [8, "Meio de Campo", "Henrique"], [3, "Zagueiro", "David"]]

Esse � um array multidimensional, ou seja, simplesmente cont�m dentro mais de um array como elemento. O exemplo acima � sobre um time de futebol onde [n�mero da camisa, funç�o, nome] s�o componentes. Essa forma de representaç�o agora funciona, mas � f�cil de confundir, especialmente se continuarmos a adicionar novos times.

O estilo de c�digo mostrado � processual e n�o orientado � objeto. Os dados mantidos na coleç�o s�o muitos e feitos com tipos simples. Para melhorar o c�digo � necess�rio a organizaç�o, fazer um padr�o para o objeto, conhecido como classe.

Classe

Uma classe � uma entidade, ou seja, abstrai um conjunto de caracter�sticas similares. Atrav�s de m�todos, nela definidos, ser� poss�vel fazer os comportamentos de seus objetos.

Em Ruby, sem saber, j� trabalhamos com classes, como Array e String. Afinal, tudo nessa linguagem tem orientaç�o a objetos. Agora, criaremos uma classe, conforme a Listagem 1, em um editor de texto, como exemplo para os conceitos ficarem mais claros.

NOTA:

Sempre salve um arquivo na linguagem Ruby com .rb no final.

Listagem 1. Jogador.rb


        class Jogador
        attr_acessor :primeiro_nome, :ultimo_nome, :numero

        def initialize (prim_nome, ult_nome, numero)
        @primeiro_nome = prim_nome
        @ultimo_nome = ult_nome
        @numero = numero
        end

        def nome_completo
        �#{ultimo_nome.capitalize}, #{primeiro_nome.capitalize}�
        end

        def posiç�o
        while @numero == 0 || @numero < 0
        puts �Coloque novamente um n�mero poss�vel: �
        @numero = gets.to_i
        end
        if @numero < 6 && @numero <0
        return �Zaga�
        elsif @numero >= 6 && @numero <=10
        return �Meio Campo�
        else
        return �Ataque�
        end
        end
        end
        jogador = jogador .new(gets.chomp, gets.chomp, gets.to_i)
        p �#{jogador.nome_completo} � Funç�o no(a): #{jogador.posicao}�

Para checar se o c�digo est� funcionando, entre no terminal ou CMD, na pasta onde est� o arquivo e digite: ruby nomedoarquivo.rb. Ap�s, basta colocar os dados na sequ�ncia do programa.

No c�digo acima foi criado uma classe jogador de futebol na qual cada um tem primeiro nome, �ltimo nome e n�mero da camisa. O initialize � o construtor, ou seja, atrav�s do formato dele criaremos o objeto e os valores recebidos nos par�metros ser�o iguais aos campos da classe. O m�todo �nome� coloca o �ultimo_nome� na frente na hora de imprimir e os dois campos com letra inicial mai�scula, atrav�s do capitalize.

No m�todo �posicao� foi criado uma l�gica para a numeraç�o das camisas. As regras s�o: o jogador com camisa de 1 at� 5 ter� sua funç�o na zaga do time; os com camisa n�mero 6 � 10 estar�o no meio de campo; os com n�meros maiores ser�o os atacantes; e no time n�o � poss�vel ter uma camisa com numeraç�o igual ou menor que 0, sendo assim, enquanto esse valor for colocado, o c�digo rodar� novamente pedindo um n�mero poss�vel.

Quando a classe termina, um objeto � criado com a palavra new, respons�vel por chamar um construtor de uma classe e � salvo na vari�vel �jogador�. O m�todo gets foi usado para o usu�rio digitar os valores do initialize no terminal ou cmd. A diferença � que no primeiro e �ltimo nome os valores recebidos ser�o strings (e como s�o atribu�dos em nova linha, precisam do chomp para n�o ter um \n no final da palavra (aparece sempre que aperta-se Enter)) e no n�mero, obviamente, um int (to_i).

No in�cio da classe foi utilizado o attr_accessor para definir os campos. Ele � respons�vel por ler e escrever uma vari�vel instanciada, ou seja, atrav�s dele � poss�vel que o interpretador Ruby consiga permitir uma atribuiç�o de valor e ler esse valor. Se, por exemplo, ele n�o tivesse sido usado para criar a inst�ncia �primeiro_nome�, seria necess�rio o seguinte c�digo:


        class Jogador
        attr_accessor :ultimo_nome, :numero
        def primeiro_nome=(value)
        @primeiro_nome = value
        end
        def primeiro_nome
        @primeiro_nome
        end
        ...
        end

No primeiro m�todo, a vari�vel instanciada pode receber um valor e no segundo � poss�vel ler esse valor. Existem o attr_reader e o attr_writer, que unidos, s�o o attr_accessor que, como o nome j� diz, far� o acesso � inst�ncia.

Fazendo uma Classe

Para entender melhor uma linguagem de programaç�o, � necess�rio pratic�-la. Baseando-se no exemplo do jogador de futebol, ser� criada uma classe Time, conforme o c�digo da Listagem 2. Afinal, os n�meros das camisas seriam repetidos e utilizando apenas a classe Jogador assume-se que est� se referindo apenas � um time, ou ent�o, teria mais jogadores do que o comum.

O que � preciso fazer?

Chamar a classe jogador;
Estabelecer um nome para cada time;
Ter uma lista dos jogadores de cada time;
Poder adicionar mais jogadores � lista;
Mostrar todos os jogadores de cada time.

Listagem 2. Time.rb


        require_relative �Jogador�

        class Time
        attr_accessor :nome_time, :jogadores

        def initialize(nome_time)
        @nome_time = nome_time
        @jogadores = [ ]
        end

        def adiciona_jogador(primeiro_nome, ultimo_nome,numero)
        jogador = Jogador.new(primeiro_nome,ultimo_nome,numero)
        @jogadores << jogador
        end

        def print_time
        puts �#{nome_time.capitalize}�
        @jogadores.each do |jogador|
        puts �#{jogador.numero} � �{jogador.nome_completo} (#{jogador.posicao}
        end
        end
        end
        time = Time.new(gets.chomp)
        time.adiciona_jogador(�John�,�Smith�, 10)
        time.adiciona_jogador(�Henrique�,�Carvalho�,5)
        time.print_time

        time2 = Time.new(gets.chomp)
        time2.adiciona_jogador(�Alberto�, �Silva�,6)
        time2.adiciona_jogador(�Vicente�, �Souza�,1)
        time2.print_time

Com o require_relative foi chamado a classe jogador de outro arquivo para a classe Time. Para n�o precisar escrever um novo jogador antes de rodar o programa Time (porque o interpretador ir� rodar primeiro a classe Jogador), comente tudo que est� al�m da classe no outro arquivo.

No m�todo initialize, o construtor recebe o nome do time e cria um array para receber os jogadores. O m�todo seguinte adiciona novos jogadores e eles s�o alocados pela shovel no array . No �ltimo m�todo, o nome do time � printado e depois todos os seus jogadores s�o mostrados atrav�s do each. Quando a classe acaba, o objeto � criado e os valores atribu�dos. Mostra-se tudo, ao chamar o m�todo �print_time�.

Para entender melhor o exemplo criado nesse artigo, na opç�o c�digo-fonte, no topo do post, voc� pode baixar o c�digo-fonte completo.

Introdu��o ao recursos b�sicos da linguagem Ruby

Conheça os recursos básicos do Ruby e comece a criar seus primeiros blocos de código com essa linguagem