Cap. 1 - Strings e métodos

Strings, Números, Métodos e Condicionais

Pelo fato de você estar acompanhando este tutorial, eu acho que é seguro deduzir que você quer programar em Ruby - e, se você for como eu, você estará impaciente para por a mão na massa. Ok, então não vamos ficar esperando, vamos ao trabalho. Eu assumirei que você já tem o Ruby instalado. Se não, você precisa fazer isto antes de mais nada, como explicado na Introdução...

Vamos começar a codificar. Abra o seu editor e escreva o seguinte:

puts 'Alô Mundo'

Salve o programa como 'alo_mundo.rb' e agora rode o programa ( como explicado em 'Rodando Programas Ruby'. Se tudo correu bem, o Ruby deveria mostrar "Alô Mundo" no terminal.

Este deve ser o menor 'alô mundo' 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('Escreva seu nome: ' )
nome = gets()
puts( "Olá #{nome}" )

O programa alo_mundo.rb pergunta ao usuário o seu nome - vamos supor que seja "Pedro" e então mostra uma saudação: "Olá Pedro".

Este é um exemplo 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 em uma 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.

   puts( "Alô Mundo".upcase )

   Alô Mundo

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 deve 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 ola_nome.rb é bem interessante:

puts( "Olá #{nome}" )

Aqui a variável nome 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, 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 mostrar_nome, que retorna a string "Pedro". A string seguinte deveria, no processo de avaliação, chamar o método mostrar_nome e, como resultado, mostrar a string "Olá Pedro":

puts "Olá #{mostrar_nome}"

def mostrar_nome
   return "Pedro"
end
  
puts "Olá #{mostrar_nome}"
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 metodo_show_name.rb e você verá a seguinte saída:

Saída

Hello Pedro

        9

puts "Olá #{mostrar_nome}"

puts 'Olá #{mostrar_nome}'

Olá #{mostrar_nome}

# Isto é um comentário

Métodos

No exemplo anterior, eu introduzi um método Ruby sem explicar precisamente qual é a sintaxe necessária para criá-­lo. Vou corrigir essa omissão agora :).

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 mostrar_string
      puts( "Olá" )
end

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

def mostrar_nome( nome )
   puts( "Olá #{nome}" )
end

def nome_completo( primeiro_nome, segundo_nome )
   return "Olá #{primeiro_nome} #{segundo_nome}"
end

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

def nome_completo primeiro_nome, segundo_nome
      return "Olá #{primeiro_nome} #{segundo_nome}"
end

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

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 obj o qual possui um método chamado diga_algo, esta é a forma que você deveria enviar-­lhe uma mensagem diga_algo:

   obj.diga_algo

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

def diga_algo
   puts( "Olá Mundo" )
end

Quando você envia a mensagem diga_algo para o objeto obj ele responde com o método diga_algo e mostra "Olá Mundo".

OK, esta é a forma 'OOP pura' de descrever este processo. Uma forma OOP não tão pura de descrever isso seria dizer que diga_algo é como uma função que é ligada ao objeto e pode ser chamada usando a "notação de ponto":

   obj.diga_algo

Segue abaixo existe um código fonte de um programa Ruby que utiliza os exemplos citados anteriormente.

class MinhaClasse
        def diga_algo
                puts( "Este é o método da classe MinhaClasse" )
        end
end

obj = MinhaClasse.new

obj.diga_algo

def mostrar_string
       puts( "Oi a todos" )
end

def mostrar_nome( primeiro_nome )
       puts( "Oi #{primeiro_nome}" )
end

def retorna_nome( primeiro_nome )
       return "Oi #{primeiro_nome}"
end

def retorna_nome_completo( primeiro_nome, segundo_nome )
       return "Oi #{primeiro_nome} #{segundo_nome}"
end

mostrar_string

mostrar_nome( "Pedro" )

puts( retorna_nome( "Leandro" ) )

puts( retorna_nome_completo( "Leandro", "Nunes"  ) )

A saída deste programa é:

   Este é o método da classe MinhaClasse
   Oi a todos
   Oi Pedro
   Oi Leandro
   Oi Leandro Nunes

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.

Se você não acredita no que eu estou dizendo faça o seguinte teste:

class MinhaClasse
  def minha_classe
    puts( self )
    puts( self.class )
  end

end

obj = MinhaClasse.new
obj.minha_classe

puts( self )
puts( self.class )

Este programa tem como saída:

   #<MinhaClasse:0xb7d0ea78>
   MinhaClasse
   main
   Object

O método self ele se refere à classe corrente de onde o método foi chamado. Então quando chamamos self dentro da classe MinhaClasse com:

  def minha_classe
    puts( self )
    puts( self.class )
  end

ele retorna a classe corrente que neste caso é: MinhaClasse

Ao chamarmos o método self fora da classe MinhaClasse ele também retorna a classe corrente que neste caso é: main

Os detalhes sobre a definição de classes e objetos serão observados no próximo capítulo.

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 de alguns itens partindo do valor do produto e da taxa de imposto sobre o mesmo.

Para fazer isto você precisaria multiplicar o valor do produto pela taxa de imposto e adicionar o valor ao valor do produto. Assumindo que o valor do produto é 100,00 reais e a taxa de imposto é de 17.5%, o código Ruby abaixo faz o cálculo e mostra o resultado:

preco_produto = 100.00
taxa = 0.175
valor_taxa = preco_produto * taxa
puts "O imposto em $#{preco_produto} é $#{taxa}, então o preço de venda é $#{preco_produto + valor_taxa}"

Obviamente, seria mais útil se pudéssemos efetuar o cálculo de vários produtos sem precisar modificar o código para cada produto.

Aqui está uma versão simples da "Calculadora de Preço" que pergunta ao usuário o valor do produto:

taxa = 0.175
print "Entre com o preço do produto: "
str = gets
preco_produto = str.to_f
valor_taxa = preco_produto * taxa
puts "O imposto em $#{preco_produto} é $#{taxa}, então o preço de venda é $#{valor_taxa + preco_produto}"

O 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, "Alô Mundo".to_f retornaria 0.0.

Testando uma Condição: if ... then

O problema com o código da "Calculadora de Preço" mostrado acima é que ele aceita preços negativos, gerando consequentemente uma valor negativo de venda de produto. Como iso não deve ser do agrado no comerciante que irá vender o seu produto vamos melhorar um pouco o nosso programa

Precisamos então checar os valores negativos e, quando encontrá­-los, zerá-­los. A nova versão do código é:

imposto = 0.175 
print "Entre com o preço do produto: "
str = gets
preco_produto = str.to_f
if (preco_produto < 0.0) then
        preco_produto = 0.0 
end
valor_taxa = preco_produto * imposto
puts "O imposto em $#{preco_produto} é $#{imposto}, então o preço de venda é $#{preco_produto + valor_taxa}"

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 (preco_produto < 0.0) then preco_produto = 0.0 end

Note que a palavra-­chave end que termina o bloco if não é opcional. Não esqueça de colocá-­la senão o seu código não irá rodar.

Códigos Fontes

Clique aqui para baixar ao códigos fontes utilizados neste capítulo do tutorial.

-- LeandroNunes - 18 Oct 2006