Cap. 1 - Strings e métodos

Anterior Índice Próximo

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.

Se você estiver usando um editor sem uma console interativa, você deverá rodar seus programas a partir do terminal de comandos do GNU/Linux. Para isto abra um terminal de comandos (EX: gnome-terminal, xterm, etc…) e navegue até o diretório contendo o código fonte e então digite ruby seguido pelo nome do programa, assim:

ruby alo_mundo.rb

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.

ola_nome.rb

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.

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, abaixo eu estou usando o método upcase para mostrar a string "Alô Mundo" em maiúsculas:

alo_mundo_maiuscula.rb

   puts( "Alô Mundo".upcase )

Saida:

   Alô Mundo

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.

Para saber se existe algum método para a sua necessidade você pode acessar a API padrão do ruby aqui:

http://www.ruby-doc.org/core/

e procurar pela classe Kernel.

Case Sensitive

O Ruby é uma linguagem case sensitive - sensível a maiúsculas e minúsculas (caixa alta/baixa). Uma variável chamada minhavariavel é diferente de outra chamada minhaVariavel. Uma variável como 'nome' 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 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}"

metodo_mostrar_nome.rb


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

O Ruby igualmente ao Perl, Bash e PHP só realiza o processamento da string caso esta esteja entre aspas duplas, se uma string que precisa ser processada pelo interpretador ruby estiver entre aspas simples, esta não será processada pelo interpretador e será totalmente impressa.

No exemplo citado anteriormente o resultado da execução do comando:

puts "Olá #{mostrar_nome}"

utilizando aspas simples seria:

puts 'Olá #{mostrar_nome}'

Saída:

Olá #{mostrar_nome}

Comentários

Linhas que começam com o caracter # são tratadas como comentários ( elas são ignoradas pelo interpretador Ruby):

# 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.

objeto_e_metodo.rb

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:

self.rb


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 wink

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

tax_calculator.rb


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.

Anterior Índice Próximo

Códigos Fontes

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

-- LeandroNunes - 18 Oct 2006
Topic revision: r1 - 05 Jul 2008, UnknownUser
This site is powered by FoswikiCopyright © by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding Wiki-Colivre? Send feedback