Lawlyet Terramel

Ok! Tomei coragem e deixei a preguiça de lado! Quando comecei a escrever este post eu estava meio gripado e de saco cheio de ficar ouvindo minha mãe falando que estou perdendo meu tempo com a internet, que isso não me leva a nada, que eu deveria pensar no mercado de trabalho e estudar a matéria (chata e retrógrada) da faculdade, que eu preciso crescer e blá blá blá! Mas tudo bem! Não quero nem saber quem pintou a zebra! Eis que apresento-lhes… A primeira aula de Ruby deste blog:

Interactive Ruby Shel (irb)

Vamos começar as aulas usando o irb. Um shell interativo no mesmo estilo do shell do Python. Ele vai ser útil para podermos testar os comandos e códigos para irmos aprendendo de forma mais fácil e divertida

No livro do Ruby – Conhecendo a Linguagem, do TaQ (que eu estou seguindo para fazer essas aulas), ele recomenda que edite o arquivo .irbrc, que pode ser encontrado no diretório home (no Linux), e insira a seguinte linha:

require 'irb/completion'

Feito isso, vamos executar o irb, digitando (tcham, tcham, tcham, tcham….) irb no terminal (ou em um prompt do DOS -.-):

[saibot@upson saibot]$ irb

E com isso seremos recebidos com uma tela onde estará escrito o seguinte:

irb(main):001:0>

Certinho… Vou botar um pequeno codigozinho aqui como exemplo para explicar um pouco sobre a estrutura do irb:

irb(main):001:0> x = 5
=> 5
irb(main):002:0> if x != 5
irb(main):003:1>        puts “Diferente de 5″
irb(main):004:1> else
irb(main):005:1*        puts “Igual a 5″
irb(main):006:1> end
Igual a 5=> nil
irb(main):007:0>

Como pode ser visto, o prompt é separado por dois pontos (:). Com isso, temos o seguinte:

1. Nome do programa (main)
2. Número de linhas que digitamos (e estamos) no irb.
3. Nível de profundidade

Sobre a profundidade, podemos dizer que é a que estamos quando abrimos ou fechamos uma expressão. Isso pode ser observado no próprio exemplo. Na linha 002, estamos começando a usar o if e o nível de profundidade é 0. Já na linha 003, uma linha depois do if, já entramos no nível de profundidade 1 ;D Na linha 006, fechamos o if com o end, por isso na linha 007 voltamos ao nível 0 de profundidade. Entendido?

Mais uma coisa, observe a linha 005 e perceberá um asterisco (*). Isso ocorre porque o irb “sabe” que o if precisa ser fechado com um end

“Olá Mundo!” no irb

Vamos agora começar fazendo o mais básico que existe em qualquer linguagem (exceto em, digamos…. …Java! Ahueahuaehuaeuae!!!!!!!). O “Hello World!” ou “Olá Mundo!”

Dentro do irb (óbvio O.o) digite:

irb(main):001:0> puts “Olá Mundo!”
Olá Mundo!
=> nil
irb(main):002:0>

Como pode ver, a frase “Olá Mundo!” foi escrita na tela O puts é o comando (um dos) para imprimir coisas na tela…

Da mesma forma que usamos o puts para isso, podemos também usar o print:

irb(main):002:0> print “Olá Mundo!”
Olá Mundo!=> nil
irb(main):003:0>

Como podemos ver, apesar de parecer fazer exatamente o mesmo que o puts, o print apenas imprime na tela e não pula linha nenhuma, enquanto o puts pula uma linha cada vez que é usado.

Variáveis

Apesar de dizerem que tudo em Ruby é um objeto, as variáveis são excessões, sendo apenas referências para estes.

São bem simples de serem utilizadas em Ruby pelo fato de usarem duck typing (uma forma como é chamada a tipagem dinâmica do Ruby).

Exemplo:

[saibot@upson saibot]$ irb
irb(main):001:0> x = “terramel”
=> “terramel”
irb(main):002:0> x.class
=> String
irb(main):003:0> x = 1
=> 1
irb(main):004:0> x.class
=> Fixnum
irb(main):005:0> x = 1.2
=> 1.2
irb(main):006:0> x.class
=> Float
irb(main):007:0>

Ruby também tem tipagem forte, como pode ser observado a seguir:

[saibot@upson saibot]$ irb
irb(main):001:0> x = 1
=> 1
irb(main):002:0> y = “oi”
=> “oi”
irb(main):003:0> z = x + y  
TypeError: String can’t be coerced into Fixnum
        from (irb):3:in `+’
        from (irb):3
        from :0
irb(main):004:0>

Quando tentamos somar um número com uma string recebemos um erro (óbvio), já que não  é possível somar essas dois coisas diferentes…

Claro que podemos converter o x para String (usando o método .to_s) para concatenarmos os valores das duas variáveis:

irb(main):004:0> z = x.to_s + y
=> “1oi”
irb(main):005:0>

Mais para frente veremos um pouco mais sobre este e outros métodos. Por enquanto, lembrando o que Matz disse que tudo é objeto em Ruby, dê uma olhada nisso:

[saibot@upson saibot]$ irbirb(main):001:0> x = 1
=> 1
irb(main):002:0> x.methods
=> ["to_a", "%", "<<", "respond_to?", ">>", "divmod", "&", "type", "integer?", "chr", "protected_methods", "eql?", "to_sym", "*", "instance_variable_set", "+", "is_a?", "truncate", "hash", "send", "to_s", "-", "between?", "modulo", "singleton_method_added", "prec", "zero?", "/", "size", "class", "tainted?", "private_methods", "__send__", "next", "|", "untaint", "~", "id", "step", "to_i", "inspect", "instance_eval", "prec_i", "remainder", "clone", "nonzero?", "public_methods", "^", "+@", "floor", "extend", "freeze", "-@", "display", "**", "quo", "__id__", "<=>", "downto", "to_f", "<", "methods", "method", "==", "===", "prec_f", "abs", ">", "to_int", "nil?", "dup", "instance_variables", "coerce", ">=", "instance_of?", "ceil", "<=", "upto", "div", "times", "object_id", "=~", "singleton_methods", "equal?", "succ", "taint", "id2name", "[]“, “frozen?”, “instance_variable_get”, “kind_of?”, “round”]
irb(main):003:0>

Esses são os métodos públicos da instância da classe. Teriamos o mesmo resultado usando x.public_methods.

Podemos ver os métodos privados da instância da classe usando x.private_methods:

irb(main):003:0> x.private_methods
=> ["select", "lambda", "local_variables", "chomp", "raise", "print", "sub!", "Array", "method_missing", "format", "trap", "at_exit", "exit!", "readlines", "autoload", "system", "set_trace_func", "getc", "initialize_copy", "split", "fail", "putc", "gsub!", "iterator?", "catch", "p", "remove_instance_variable", "sub", "sleep", "syscall", "callcc", "Integer", "fork", "srand", "singleton_method_removed", "caller", "puts", "chop!", "irb_binding", "scan", "block_given?", "autoload?", "binding", "throw", "warn", "`", "gsub", "loop", "open", "Float", "singleton_method_undefined", "rand", "exit", "chomp!", "gets", "load", "exec", "trace_var", "global_variables", "proc", "initialize", "chop", "printf", "String", "test", "sprintf", "abort", "readline", "untrace_var", "require", "eval"]
irb(main):004:0>

Por enquanto é só… Sei que demorei para postar essa primeira aula, mas com paciência e sempre em frente vamos andando ;D Na próxima aula explicarei um pouco mais sobre varíaveis, os tipos, variáveis públicas, blocos etc. Aguardem! Vou ver se começo a postar as aulas com mais freqüência ;D

Leia Também:

• Aulas de Ruby – Uma Breve Introdução
• Python vs Java
• Java: Primeira Aula
• Meu Aniversário (parte 2)
• Linux Perfeito: Openbox humilhando MacOS e Vista