Eu assumirei que você já tem o Ruby instalado. Se não, você precisa fazer isto antes de mais nada. Vamos começar a codificar. Abra o seu editor e escreva o seguinte:

puts ‘hello world’

Salve o programa como ‘helloworld.rb’ e agora rode o programa. Se tudo ocorreu bem, o Ruby deveria mostrar “hello world”. Se você estiver usando um editor sem uma console interativa, você deverá rodar seus programas a partir do prompt de comandos do sistema operacional. Para isto abra um prompt de comandos (Windows) ou um terminal (Linux) e navegue até o diretório contendo o código fonte e então digite ruby seguido pelo nome do programa, assim: ruby helloworld.rb

puts( “hello world”.upcase )

Este deve ser o menor ‘hello world’ programa da história da programação, então vamos avançar modificando-o para pedir que o usuário digite algo …
O próximo passo, então, é ’solicitar’ ao usuário uma string (conjunto de caracteres). O método para fazer isso em Ruby é gets.

print(’Enter your name: ‘ )
name = gets()
puts( “Hello #{name}” )

O programa helloname.rb pergunta ao usuário o seu nome – vamos supor que é “Fred” -e então mostra uma saudação: “Hello Fred”.
Enquanto isso ainda é muito simples, existem alguns detalhes importantes que precisam ser explicados. Primeiro, note que eu usei print em vez de puts para mostrar a pergunta. Isto foi feito porque o puts adiciona uma nova linha no final e o print não; neste exemplo eu quero que o cursor permaneça na mesma linha da pergunta.

Na linha seguinte eu usei o gets() para ler a informação digitada pelo usuário emuma string quando for pressionada a tecla Enter. Esta string é armazenada na variável, name. Eu não pré-declarei esta variável, nem especifiquei seu tipo. Em Ruby você pode criar variáveis como e quando precisar delas e o Ruby deduz o tipo correspondente. Neste caso eu atribui uma string para a variável name, logo o Ruby sabe que o tipo de name deve ser uma string.

Objetos e Métodos

Ruby é uma linguagem altamente OOP (Programação Orientada por Objetos). Tudo desde um inteiro até uma string é considerado um objeto. E cada objeto é constituído de ‘métodos’ os quais podem fazer muitas coisas. Para usar um método, você precisa colocar um ponto após o objeto, então adicionar o nome do método. Por exemplo, aqui eu estou usando o método

upcase para mostrar a string “hello world” em maiúsculas:
puts( “hello world”.upcase )

Alguns métodos como o puts e o gets estão disponíveis em todo o lugar e não necessitam ser associados a um objeto específico. Tecnicamente falando, estes métodos são fornecidos pelo módulo Kernel do Ruby e eles estão presentes em todos os objetos Ruby. Quando você roda uma aplicação Ruby, um objeto chamado main é automaticamente criado e este objeto fornece acesso aos métodos do Kernel.

Nota: O Ruby é sensível a maiúsculas e minúsculas (caixa alta/baixa).
Uma variável chamada myvar é diferente de outra chamada myVar.
Uma variável como ‘name’ no nosso exemplo deve iniciar com uma
letra minúscula ( em caixa baixa )

O símbolo de parênteses no final de gets() é opcional assim como os parênteses que envolvem as strings após o print e o puts; o código deveria rodar igualmente se você removesse os parênteses. Contudo, o Ruby está movendo-se gradualmente na direção do uso dos parênteses – particularmente quando passa-se argumentos para métodos. Os parênteses ajudam a evitar possíveis ambigüidades no código e , em alguns casos, o interpretador do Ruby irá avisá-lo se você omiti-los.

Strings e Avaliação embutida

A última linha no programa helloname.rb é bem interessante:

puts( “Hello #{name}” )

Aqui a variável name está embutida numa string. Isto é feito colocando a variável dentro do sinal de chaves {} precedido do caracter #, assim: #{variável}. Este tipo de avaliação embutida somente funciona com strings delimitadas por aspas (“”). E não é somente variáveis que podem ser embutidas entre as aspas. Você pode pode, também, embutir caracteres não imprimíveis como nova linha “\n” e tabs “\t” em strings delimitadas por aspas. Você pode até embutir pequenos códigos de programa e expressões matemáticas. Vamos assumir que você tem um método chamado showname, que retorna a string ‘Fred’. A string seguinte deveria, no processo de avaliação, chamar o método showname e, como resultado, mostrar a string “Hello Fred”:

puts “Hello #{showname}”

def showname
return “Fred”
end

puts “Hello #{showname}”
puts( “\n\t#{(1+2) * 3}” )

Veja se você consegue acertar o que seria mostrado pelo código seguinte:

puts( “\n\t#{(1 + 2) * 3}” )

Execute o programa string_eval.rb para ver se você está certo.
Comentários…
Linhas que começam com o caracter # são tratadas como comentários(elas são ignoradas pelo interpretador Ruby):

# This is a comment – Isto é um comentário

Métodos

No exemplo anterior, eu introduzi um método Ruby sem explicar precisamente o que é e a sintaxe necessária para criá-lo. Vejamos isso agora.

class MyClass
def saysomething
puts( “Hello” )
end
end

ob = MyClass.new
ob.saysomething

Um método é assim chamado porque ele fornece um método ( isto é, ‘uma forma’) para um objeto responder a mensagens. Na terminologia OOP, você envia uma mensagem para um objeto pedindo que ele faça algo. Vamos imaginar que você tem um objeto chamado ob o qual possui um método chamado saysomething, esta é a forma que você deveria enviar-lhe uma mensagem saysomething:

ob.saysomething

Vamos supor que o método saysomething seja o seguinte:

def saysomething
puts( “Hello” )
end

Quando você envia a mensagem saysomething para o objeto ob ele responde com o método saysomething e mostra “Hello”. OK, esta a é forma ‘OOP pura’ de descrever este processo. Uma forma OOP não tão pura de descrever isso seria dizer que saysomething é como uma função que é ligada ao objeto e pode ser chamada usando a “notação de ponto”:

ob.saysomething.

def showstring
puts( “Hello” )
end
def showname( aName )
puts( “Hello #{aName}” )
end
def return_name( aFirstName, aSecondName )
return “Hello #{aFirstName} #{aSecondName}”
end
def return_name2 aFirstName, aSecondName
return “Hello #{aFirstName} #{aSecondName}”
end
showstring
showname( “Fred” )
puts( return_name( “Mary Mary”, “Quite-Contrary” ) )
puts( return_name( “Little Jack”, “Horner” ) )

No Ruby um método é declarado com a palavra-chave def seguida do nome do método o qual
deveria iniciar com uma letra minúscula, como este:

def showstring
puts( “Hello” )
end

Você pode, opcionalmente, colocar um ou mais argumentos, separados por vírgula, após o nome do
método:

def showname( aName )
puts( “Hello #{aName}” )
end
def return_name( aFirstName, aSecondName )
return “Hello #{aFirstName} #{aSecondName}”
end

Os parênteses em volta dos argumentos são opcionais. A seguinte sintaxe também é permitida:

def return_name2 aFirstName, aSecondName
return “Hello #{aFirstName} #{aSecondName}”
end

Como explicado anteriormente, eu sou mais favorável a usar os parênteses mas você pode omiti-los
se quiser.

def showstring
puts( “Hello” )
end
def showname( aName )
puts( “Hello #{aName}” )
end
def return_name( aFirstName, aSecondName )
return “Hello #{aFirstName} #{aSecondName}”
end
def return_name2 aFirstName, aSecondName
return “Hello #{aFirstName} #{aSecondName}”
end

# so which object owns these methods, anyhow?
# The following test reveals all…
print( “The ‘free standing methods’ in this code belong to an
object named: ” )
puts( self )
print( “which is an instance of the class: ” )
puts( self.class )
#Free-standing methods (like those above which are not defined
within a
#specific class) are methods (strictly speaking, ‘private’
methods) of
#the main object which Ruby creates automtically. The following
code
#displays a list of the main object’s private methods. Look
carefully and
#you will find showname, return_name and return_name2 in that list
puts( “It contains these private methods: ” )
puts( self.private_methods )

Se os métodos se ligam aos objetos, qual objeto possui os métodos “independentes” que você escreve no seu código? Como mencionado antes, o Ruby cria automaticamente um objeto chamado main quando você executa um programa e é a esse objeto que os métodos “independentes” se ligam.

Números

Números são tão fáceis de usar quanto as strings. Por exemplo, vamos supor que você quer calcular o preço de venda e o total geral de alguns itens partindo do subtotal e da taxa de imposto.Para fazer isto você precisaria multiplicar o subtotal pela taxa de imposto e adicionar o valor ao subtotal. Assumindo que o subtotal é $100 e a taxa de imposto é de 17.5%, este código Ruby faz o cálculo e mostra o resultado:

subtotal = 100.00
taxrate = 0.175
tax = subtotal * taxrate
puts “Tax on $#{subtotal} is $#{tax}, so grand total is
$#{subtotal+tax}”

Obviamente, seria mais útil se pudéssemos efetuar o cálculo de vários subtotais em vez de ficar fazendo o mesmo cálculo toda vez. Aqui está uma versão simples da “Calculadora de Impostos” que pergunta ao usuário o subtotal:

taxrate = 0.175
print “Enter price (ex tax): ”
s = gets
subtotal = s.to_f
tax = subtotal * taxrate
puts “Tax on $#{subtotal} is $#{tax}, so grand total is
$#{subtotal+tax}”

Aqui s.to_f é um método da classe String. Este método tenta converter a string para um número de ponto flutuante. Por exemplo, a string “145.45” seria convertida para o número de ponto flutuante 145.45. Se a string não pode ser convertida, 0.0 é retornado. Assim, por exemplo, “Hello

world”.to_f retornaria 0.0.

Testando uma Condição: if … then

O problema com o código da “Calculadora de Impostos” mostrado acima é que ele aceita subtotais negativos e calcula imposto negativo sobre eles. Eu, por essa razão, preciso checar os valores negativos e, quando encontrá-los, zerá-los.
Esta é minha nova versão do código:

taxrate = 0.175
print “Enter price (ex tax): ”
s = gets
subtotal = s.to_f
if (subtotal < 0.0) then
subtotal = 0.0
end
tax = subtotal * taxrate
puts "Tax on $#{subtotal} is $#{tax}, so grand total is
$#{subtotal+tax}"

O teste Ruby if é semelhante a um teste if em outras linguagens de programação . Note que os parênteses, mais uma vez, são opcionais, assim como a palavra-chave then. Entretanto, se você for escrever o seguinte, sem quebra de linha após a condição de teste, o then é obrigatório:

if (subtotal < 0.0) then subtotal = 0.0 end

Obs: Note que a palavra-chave end que termina o bloco if não é opcional. Esqueça de colocá-la e o seu código não irá rodar.

Esse post foi escrito em segunda-feira, março 15th, 2010 por Lino na categoria Desenvolvimento, Sem Categoria. Você pode acompanhar os comentários atraves do link RSS 2.0.