Guia Rápido de Ruby


Ruby - Guia rápido

Anúncios
 Página anterior Próxima página 
Ruby - Visão Geral

Ruby é uma linguagem de programação pura orientada a objetos. Foi criado em 1993
por Yukihiro Matsumoto do Japão.
Você pode encontrar o nome Yukihiro Matsumoto na lista de discussão Ruby em

www.ruby-lang.org . Matsumoto também é conhecido como Matz na comunidade
Ruby.
Ruby é "o melhor amigo de um programador".
O Ruby possui recursos semelhantes aos do Smalltalk, Perl e Python. Perl, Python e
Smalltalk são linguagens de script. O Smalltalk é uma verdadeira linguagem orientada a
objetos. Ruby, como o Smalltalk, é uma linguagem perfeita orientada a objetos. Usar a
sintaxe do Ruby é muito mais fácil do que usar a sintaxe do Smalltalk.
Recursos do Ruby
Ruby é um código aberto e está disponível gratuitamente na Web, mas está
sujeito a uma licença.
Ruby é uma linguagem de programação interpretada de propósito geral.
Ruby é uma verdadeira linguagem de programação orientada a objetos.
Ruby é uma linguagem de script do lado do servidor semelhante a Python e

PERL.
Ruby pode ser usado para escrever scripts CGI (Common Gateway Interface).
Ruby pode ser incorporado no HTML (Hypertext Markup Language).
Ruby tem uma sintaxe limpa e fácil que permite que um novo desenvolvedor
aprenda de maneira rápida e fácil.
Ruby tem uma sintaxe semelhante à de muitas linguagens de programação

como C ++ e Perl.
Ruby é muito escalável e grandes programas escritos em Ruby são facilmente

mantidos.
O Ruby pode ser usado para desenvolver aplicativos de Internet e intranet.
O Ruby pode ser instalado em ambientes Windows e POSIX.
O Ruby suporta muitas ferramentas GUI, como Tcl / Tk, GTK e OpenGL.
O Ruby pode ser facilmente conectado ao DB2, MySQL, Oracle e Sybase.
O Ruby possui um rico conjunto de funções internas, que podem ser usadas
diretamente em scripts Ruby.
Ferramentas que você precisará

Para executar os exemplos discutidos neste tutorial, você precisará de um computador
mais recente como o Intel Core i3 ou i5 com um mínimo de 2 GB de RAM (recomenda-
se 4 GB de RAM). Você também precisará do seguinte software -
Sistema operacional Linux ou Windows 95/98/2000 / NT ou Windows 7.
Servidor Web Apache 1.3.19-5.
Navegador da Web do Internet Explorer 5.0 ou superior.
Ruby 1.8.5
Este tutorial fornecerá as habilidades necessárias para criar GUI, rede e aplicativos da
Web usando o Ruby. Ele também falará sobre estender e incorporar aplicativos Ruby.
O que é o próximo?
O próximo capítulo orienta você para onde você pode obter Ruby e sua documentação.
Finalmente, ele instrui sobre como instalar o Ruby e preparar um ambiente para
desenvolver aplicativos Ruby.
Ruby - Configuração do Ambiente

Configuração do ambiente local
Se você ainda estiver disposto a configurar seu ambiente para a linguagem de
programação Ruby, então vamos continuar. Este tutorial ensinará todos os tópicos
importantes relacionados à configuração do ambiente. Recomendamos que você analise
os tópicos a seguir primeiro e, depois, continue.
Instalação Ruby no Linux / Unix - Se você planeja ter seu ambiente de

desenvolvimento no Linux / Unix Machine, siga este capítulo.
Instalação Ruby no Windows - Se você planeja ter seu ambiente de

desenvolvimento no Windows Machine, siga este capítulo.
Ruby Command Line Options - Este capítulo lista todas as opções de linha de
comando, que você pode usar junto com o interpretador Ruby.
Ruby Environment Variables - Este capítulo tem uma lista de todas as
variáveis de ambiente importantes a serem configuradas para fazer o
interpretador de Ruby funcionar.
Editores de rubis populares

Para escrever seus programas Ruby, você precisará de um editor -
Se você estiver trabalhando na máquina Windows, poderá usar qualquer editor

de texto simples como o Notepad ou o Edit plus.
VIM (Vi IMproved) é um editor de texto muito simples. Isso está disponível
em quase todas as máquinas Unix e agora também no Windows. Caso contrário,
você pode usar seu editor vi favorito para escrever programas Ruby.
RubyWin é um Ambiente de Desenvolvimento Integrado (IDE) para Windows.
O Ambiente de Desenvolvimento Ruby (RDE) também é um IDE muito bom

para usuários do Windows.
Ruby Interativo (IRb)

O Ruby Interativo (IRb) fornece um shell para experimentação. Dentro do shell IRb,
você pode visualizar imediatamente os resultados da expressão, linha por linha.
Esta ferramenta vem junto com a instalação do Ruby, então você não tem nada a fazer
para ter o IRb funcionando.
Basta digitar irb no seu prompt de comando e uma Sessão Interativa Ruby iniciará
conforme abaixo:
$irb
irb 0.6.1(99/09/16)
irb(main):001:0> def hello
irb(main):002:1> out = "Hello World"
irb(main):003:1> puts out
irb(main):004:1> end
nil
irb(main):005:0> hello
Hello World
nil
irb(main):006:0>
Não se preocupe com o que fizemos aqui. Você aprenderá todas essas etapas nos
capítulos subseqüentes.
O que é o próximo?
Nós assumimos que agora você tem um Ambiente Ruby funcional e você está pronto
para escrever o primeiro Programa Ruby. O próximo capítulo ensinará como escrever
programas em Ruby.
Ruby - sintaxe
Vamos escrever um programa simples em ruby. Todos os arquivos ruby terão extensão
.rb . Então, coloque o seguinte código-fonte em um arquivo test.rb.
 Demonstração ao vivo
#!/usr/bin/ruby -w
puts "Hello, Ruby!";
Aqui, assumimos que você tem o interpretador Ruby disponível no diretório / usr / bin.
Agora, tente executar este programa da seguinte maneira -
$ ruby test.rb
Isso produzirá o seguinte resultado -
Hello, Ruby!
Você viu um programa Ruby simples, agora vamos ver alguns conceitos básicos
relacionados à sintaxe do Ruby.
Espaço em branco no programa Ruby

Caracteres em branco, como espaços e guias, geralmente são ignorados no código
Ruby, exceto quando aparecem em strings. Às vezes, porém, eles são usados para
interpretar declarações ambíguas. Interpretações desse tipo produzem avisos quando a
opção -w está ativada.
Exemplo
a + b is interpreted as a+b ( Here a is a local variable)
a +b is interpreted as a(+b) ( Here a is a method call)
Endings de linha no programa Ruby

Ruby interpreta ponto-e-vírgula e caracteres de nova linha como o final de uma
instrução. No entanto, se Ruby encontrar operadores, como +, - ou backslash no final
de uma linha, eles indicam a continuação de uma instrução.
Identificadores Ruby
Identificadores são nomes de variáveis, constantes e métodos. Identificadores Ruby
diferenciam maiúsculas de minúsculas. Isso significa que Ram e RAM são dois
identificadores diferentes em Ruby.
Os nomes dos identificadores Ruby podem consistir em caracteres alfanuméricos e o

caractere de sublinhado (_).
Palavras reservadas
A lista a seguir mostra as palavras reservadas em Ruby. Essas palavras reservadas não
podem ser usadas como nomes constantes ou variáveis. Eles podem, no entanto, ser
usados como nomes de métodos.
INÍCIO Faz Próximo então
FIM outro nada verdade
alias elsif não undef
e fim ou a não ser que
início garantir refazer até
pausa falso resgatar quando
caso para tente novamente enquanto
classe E se Retorna enquanto
def em auto __ARQUIVO__
definiram? módulo super __LINHA__
Aqui documento em Ruby

"Aqui documento" refere-se a criar seqüências de várias linhas. Seguindo um << você
pode especificar uma string ou um identificador para finalizar o literal da string, e todas
as linhas seguindo a linha atual até o terminador são o valor da string.
Se o terminador for citado, o tipo de aspas determina o tipo do literal da cadeia

orientada a linhas. Observe que não deve haver espaço entre << e o terminador.
Aqui estão exemplos diferentes -

#!/usr/bin/ruby -w
print <<EOF
This is the first way of creating
here document ie. multiple line string.
EOF
print <<"EOF"; # same as above

This is the second way of creating
here document ie. multiple line string.
EOF
print <<`EOC` # execute commands

echo hi there
echo lo there
EOC
print <<"foo", <<"bar" # you can stack them

I said foo.
foo
I said bar.
bar
This is the first way of creating

her document ie. multiple line string.
This is the second way of creating
her document ie. multiple line string.
hi there
lo there
I said foo.
I said bar.
Ruby BEGIN Statement

Sintaxe
BEGIN {
code
}
Declara o código a ser chamado antes que o programa seja executado.
Exemplo
#!/usr/bin/ruby
puts "This is main Ruby Program"
BEGIN {
puts "Initializing Ruby Program"
}
Initializing Ruby Program

This is main Ruby Program
Declaração Ruby END

Sintaxe
END {
code
}
Declara o código a ser chamado no final do programa.
Exemplo
#!/usr/bin/ruby
puts "This is main Ruby Program"

END {
puts "Terminating Ruby Program"
}
BEGIN {
puts "Initializing Ruby Program"
}
Initializing Ruby Program

This is main Ruby Program
Terminating Ruby Program
Comentários Ruby
Um comentário oculta uma linha, parte de uma linha ou várias linhas do interpretador
Ruby. Você pode usar o caractere hash (#) no início de uma linha -
# I am a comment. Just ignore me.
Ou, um comentário pode estar na mesma linha depois de uma declaração ou expressão
-
name = "Madisetti" # This is again comment
Você pode comentar várias linhas da seguinte maneira -
# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.
Aqui está outra forma. Este comentário do bloco oculta várias linhas do interpretador
com = begin / = end -
= begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
= end
Ruby - Classes e Objetos

Ruby é uma linguagem de programação orientada a objetos perfeita. Os recursos da
linguagem de programação orientada a objetos incluem:
Encapsulamento de dados
Abstração de dados
Polimorfismo
Herança
Esses recursos foram discutidos no capítulo Ruby Orientado a Objetos .
Um programa orientado a objeto envolve classes e objetos. Uma classe é o blueprint do

qual os objetos individuais são criados. Em termos orientados a objetos, dizemos que
sua bicicleta é uma instância da classe de objetos conhecidos como bicicletas.
Tomemos o exemplo de qualquer veículo. É composto por rodas, cavalos de potência e

capacidade do tanque de combustível ou gás. Essas características formam os membros
de dados da classe Vehicle. Você pode diferenciar um veículo do outro com a ajuda
dessas características.
Um veículo também pode ter certas funções, como parar, dirigir e acelerar. Até mesmo
essas funções formam os membros de dados da classe Vehicle. Você pode, portanto,
definir uma classe como uma combinação de características e funções.
Uma classe Veículo pode ser definida como -
Class Vehicle {
Number no_of_wheels
Number horsepower
Characters type_of_tank
Number Capacity
Function speeding {
}
Function driving {
}
Function halting {
}
}
Ao atribuir valores diferentes a esses membros de dados, você pode formar várias
instâncias da classe Vehicle. Por exemplo, um avião tem três rodas, potência de 1.000,
combustível como o tipo de tanque e capacidade de 100 litros. Da mesma forma, um
carro tem quatro rodas, potência de 200, gás como o tipo de tanque e uma capacidade
de 25 litros.
Definindo uma classe em Ruby

Para implementar programação orientada a objetos usando Ruby, primeiro você precisa
aprender como criar objetos e classes em Ruby.
Uma classe em Ruby sempre começa com a classe de palavra-chave seguida pelo nome
da classe. O nome deve estar sempre em maiúsculas iniciais. A classe Cliente pode ser
exibida como -
class Customer
end
Você encerra uma classe usando o final da palavra-chave . Todos os membros de dados
da classe estão entre a definição de classe e a palavra-chave final .
Variáveis em uma classe Ruby
Ruby fornece quatro tipos de variáveis -
Variáveis locais - Variáveis locais são as variáveis definidas em um método.

Variáveis locais não estão disponíveis fora do método. Você verá mais detalhes
sobre o método no capítulo subseqüente. Variáveis locais começam com uma
letra minúscula ou _.
Variáveis de instância - Variáveis de instância estão disponíveis em

métodos para qualquer instância ou objeto específico. Isso significa que as
variáveis de instância mudam de objeto para objeto. Variáveis de instância são
precedidas pelo sinal de arroba (@) seguido pelo nome da variável.
Variáveis de Classe - Variáveis de classe estão disponíveis em diferentes

objetos. Uma variável de classe pertence à classe e é uma característica de uma
classe. Eles são precedidos pelo sinal @@ e são seguidos pelo nome da
variável.
Variáveis globais - as variáveis de classe não estão disponíveis nas classes.

Se você deseja ter uma única variável, que está disponível nas classes, você
precisa definir uma variável global. As variáveis globais são sempre precedidas
pelo cifrão ($).
Exemplo
Usando a variável de classe @@ no_of_customers, você pode determinar o número de
objetos que estão sendo criados. Isso permite derivar o número de clientes.
class Customer
@@no_of_customers = 0
end
Criando Objetos em Ruby usando o novo método

Objetos são instâncias da classe. Agora você aprenderá como criar objetos de uma
classe em Ruby. Você pode criar objetos no Ruby usando o método new da classe.
O método new é um tipo exclusivo de método, que é predefinido na biblioteca Ruby. O

novo método pertence aos métodos de classe .
Aqui está o exemplo para criar dois objetos cust1 e cust2 da classe Customer -
cust1 = Customer. new

cust2 = Customer. new
Aqui, cust1 e cust2 são os nomes de dois objetos. Você escreve o nome do objeto
seguido pelo sinal de igual a (=) após o qual o nome da classe seguirá. Em seguida, o
operador de ponto e a palavra-chave new serão seguidos.
Método Customizado para Criar Objetos Ruby
Você pode passar parâmetros para o método new e esses parâmetros podem ser
usados para inicializar variáveis de classe.
Quando você planeja declarar o novo método com parâmetros, é necessário declarar o
método inicializar no momento da criação da classe.
O método initialize é um tipo especial de método, que será executado quando o novo
método da classe for chamado com parâmetros.
Aqui está o exemplo para criar o método initialize
class Customer
def initialize(id, name, addr)
@cust_id = id
@cust_name = name
@cust_addr = addr
end
end
Neste exemplo, você declara o método initialize com id, name e addr como variáveis
locais. Aqui, def e end são usados para definir uma inicialização do método Ruby . Você
aprenderá mais sobre métodos nos próximos capítulos.
No método initialize , você passa os valores dessas variáveis locais para as variáveis de
instância @cust_id, @cust_name e @cust_addr. Aqui, as variáveis locais mantêm os
valores que são passados junto com o novo método.
Agora, você pode criar objetos da seguinte maneira -
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")

cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")
Funções de membro na classe Ruby

Em Ruby, as funções são chamadas de métodos. Cada método em uma classe começa
com a palavra-chave def seguida do nome do método.
O nome do método sempre preferiu em letras minúsculas . Você finaliza um método

em Ruby usando o final da palavra-chave .
Aqui está o exemplo para definir um método Ruby -
class Sample
def function
statement 1
statement 2
end
end
Aqui, a instrução 1 e a instrução 2 fazem parte do corpo da função do método dentro

da classe Sample. Essas declarações podem ser qualquer declaração Ruby válida. Por
exemplo, podemos colocar um método coloca para imprimir Hello Ruby da seguinte
forma -
class Sample
def hello
puts "Hello Ruby!"
end
end
Agora, no exemplo a seguir, crie um objeto da classe Sample e chame o método hello e
veja o resultado -
#!/usr/bin/ruby
class Sample
def hello
puts "Hello Ruby!"
end
end
# Now using above class to create objects

object = Sample. new
object.hello
Hello Ruby!
Estudo de caso simples

Aqui está um estudo de caso se você quiser praticar mais com classes e objetos.
Estudo de caso da classe Ruby
Ruby - Variáveis, Constantes e Literais

Variáveis são os locais da memória, que contêm todos os dados a serem usados por
qualquer programa.
Existem cinco tipos de variáveis suportadas pelo Ruby. Você já passou por uma
pequena descrição dessas variáveis no capítulo anterior também. Esses cinco tipos de
variáveis são explicados neste capítulo.
Variáveis globais do Ruby

Variáveis globais começam com $. Variáveis globais não inicializadas têm o valor nulo e
produzem avisos com a opção -w.
A atribuição a variáveis globais altera o status global. Não é recomendado usar

variáveis globais. Eles fazem programas enigmáticos.
Aqui está um exemplo mostrando o uso da variável global.

#!/usr/bin/ruby
$global_variable = 10
class Class1
def print_global
puts "Global variable in Class1 is #$global_variable"
end
end
class Class2
def print_global
puts "Global variable in Class2 is #$global_variable"
end
end
class1obj = Class1.new
class1obj.print_global
class2obj = Class2.new
class2obj.print_global
Aqui $ global_variable é uma variável global. Isso produzirá o seguinte resultado -
OBSERVAÇÃO - Em Ruby, você PODE acessar o valor de qualquer variável ou

constante colocando um caractere de hash (#) logo antes dessa variável ou constante.
Global variable in Class1 is 10

Global variable in Class2 is 10
Variáveis de instância do Ruby

Variáveis de instância começam com @. Variáveis de instância não inicializadas têm o
valor nil e produzem avisos com a opção -w.
Aqui está um exemplo mostrando o uso de variáveis de instância.

#!/usr/bin/ruby
class Customer
@cust_id = id
@cust_name = name
@cust_addr = addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
end
end
# Create Objects
# Call Methods
cust1.display_details()
cust2.display_details()
Aqui, @cust_id, @cust_name e @cust_addr são variáveis de instância. Isso produzirá o

seguinte resultado -
Customer id 1
Customer name John
Customer address Wisdom Apartments, Ludhiya
Customer id 2
Customer name Poul
Customer address New Empire road, Khandala
Variáveis de Classe Ruby

As variáveis de classe começam com @@ e devem ser inicializadas antes de poderem
ser usadas nas definições de método.
Fazer referência a uma variável de classe não inicializada produz um erro. As variáveis
de classe são compartilhadas entre os descendentes da classe ou módulo em que as
variáveis de classe são definidas.
Substituir variáveis de classe produz avisos com a opção -w.
Aqui está um exemplo mostrando o uso da variável de classe -

#!/usr/bin/ruby
class Customer
@cust_id = id
@cust_name = name
@cust_addr = addr
end
def display_details()
puts "Customer id #@cust_id"
puts "Customer name #@cust_name"
puts "Customer address #@cust_addr"
end
def total_no_of_customers()
@@no_of_customers += 1
puts "Total number of customers: #@@no_of_customers"
end
end
# Create Objects
# Call Methods
cust1.total_no_of_customers()
cust2.total_no_of_customers()
Aqui @@ no_of_customers é uma variável de classe. Isso produzirá o seguinte

resultado -
Total number of customers: 1

Total number of customers: 2
Variáveis locais do Ruby

Variáveis locais começam com uma letra minúscula ou _. O escopo de uma variável
local varia de classe, módulo, def ou do para o final correspondente ou da chave de
abertura de um bloco para sua chave de fechamento {}.
Quando uma variável local não inicializada é referenciada, ela é interpretada como uma
chamada para um método que não possui argumentos.
A atribuição a variáveis locais não inicializadas também serve como declaração de

variável. As variáveis começam a existir até o final do escopo atual ser atingido. O
tempo de vida de variáveis locais é determinado quando Ruby analisa o programa.
No exemplo acima, as variáveis locais são id, name e addr.
Constantes Ruby
As constantes começam com uma letra maiúscula. Constantes definidas dentro de uma
classe ou módulo podem ser acessadas de dentro dessa classe ou módulo, e aquelas
definidas fora de uma classe ou módulo podem ser acessadas globalmente.
Constantes não podem ser definidas dentro de métodos. Fazer referência a uma
constante não inicializada produz um erro. Fazer uma atribuição a uma constante já
inicializada produz um aviso.
#!/usr/bin/ruby
class Example
VAR1 = 100
VAR2 = 200
def show
puts "Value of first Constant is #{VAR1}"
puts "Value of second Constant is #{VAR2}"
end
end
# Create Objects
object = Example.new()
object.show
Aqui VAR1 e VAR2 são constantes. Isso produzirá o seguinte resultado -
Value of first Constant is 100

Value of second Constant is 200
Pseudo-Variáveis Ruby
Eles são variáveis especiais que têm a aparência de variáveis locais, mas se comportam
como constantes. Você não pode atribuir nenhum valor a essas variáveis.
self - O objeto receptor do método atual.
true - valor representando verdadeiro.
false - Valor representando falso.

nil - Valor representando indefinido.
__FILE__ - O nome do arquivo de origem atual.
__LINE__ - O número da linha atual no arquivo de origem.
Ruby Basic Literais

As regras que o Ruby usa para literais são simples e intuitivas. Esta seção explica todos
os literais básicos de Ruby.
Números inteiros
30 30-1
Ruby suporta números inteiros. Um número inteiro pode variar de -2 a 2 ou -2
62 62-1
a2 . Inteiros dentro deste intervalo são objetos da classe Fixnum e inteiros fora
desse intervalo são armazenados em objetos da classe Bignum .
Você escreve inteiros usando um sinal principal opcional, um indicador de base opcional
(0 para octal, 0x para hexadecimal ou 0b para binário), seguido por uma cadeia de
dígitos na base apropriada. Caracteres de sublinhado são ignorados na seqüência de
dígitos.
Você também pode obter o valor inteiro, correspondente a um caractere ASCII ou

escapar da sequência, precedendo-o com um ponto de interrogação.
Exemplo
123 # Fixnum decimal

1_234 # Fixnum decimal with underline
-500 # Negative Fixnum
0377 # octal
0xff # hexadecimal
0b1011 # binary
?a # character code for 'a'
?\n # code for a newline (0x0a)
12345678901234567890 # Bignum
OBSERVAÇÃO - Classe e Objetos são explicados em um capítulo separado deste

tutorial.
Números Flutuantes
Ruby suporta números flutuantes. Eles também são números, mas com decimais. Os
números de ponto flutuante são objetos da classe Float e podem ser qualquer um dos
seguintes -
Exemplo
123.4 # floating point value

1.0e6 # scientific notation
4E20 # dot not required
4e+20 # sign before exponential
Literais de cordas
Strings Ruby são simplesmente seqüências de bytes de 8 bits e são objetos da classe
String. As cadeias de caracteres com aspas duplas permitem a notação de substituição
e contrabarra, mas as cadeias de caracteres com aspas simples não permitem a
substituição e permitem a notação de contrabarra apenas para \\ e \ '
Exemplo
#!/usr/bin/ruby -w
puts 'escape using "\\"';

puts 'That\'s right';
escape using "\"

That's right
Você pode substituir o valor de qualquer expressão Ruby em uma string usando a
sequência # {expr} . Aqui, expr poderia ser qualquer expressão rubi.
#!/usr/bin/ruby -w
puts "Multiplication Value : #{24*60*60}";
Multiplication Value : 86400
Notações de barra invertida

A seguir está a lista de notações de barra invertida suportadas pelo Ruby -
Notação Personagem representado
\n Newline (0x0a)
\r Retorno de carro (0x0d)
\f Formfeed (0x0c)
\b Backspace (0x08)
\uma Bell (0x07)
\e Escape (0x1b)
\s Espaço (0x20)
\ nnn Notação Octal (n sendo 0-7)

\ xnn Notação hexadecimal (n sendo 0-9, af ou AF)
\ cx, \ Cx Controle-x
\ Mx Meta-x (c | 0x80)
\ M- \ Cx Meta-Control-x
\x Personagem x
Para mais detalhes sobre Ruby Strings, passe por Ruby Strings .
Ruby Arrays
Os literais do Ruby Array são criados colocando-se uma série de referências de objeto
separadas por vírgulas entre os colchetes. Uma vírgula final é ignorada.
Exemplo
#!/usr/bin/ruby
ary = [ "fred", 10, 3.14, "This is a string", "last element", ]

ary.each do |i|
puts i
end
fred
10
3.14
This is a string
last element
Para mais detalhes sobre Ruby Arrays, passe por Ruby Arrays .
Hashes Ruby
Um literal Ruby Hash é criado colocando uma lista de pares chave / valor entre chaves,
com uma vírgula ou a sequência => entre a chave e o valor. Uma vírgula final é
ignorada.
Exemplo
#!/usr/bin/ruby
hsh = colors = { "red" => 0xf00, "green" => 0x0f0, "blue" => 0x00f }
hsh.each do |key, value|
print key, " is ", value, "\n"
end

red is 3840
green is 240
blue is 15
Para mais detalhes sobre Ruby Hashes, passe por Ruby Hashes .
Ruby Ranges
Um intervalo representa um intervalo que é um conjunto de valores com início e fim. Os
intervalos podem ser construídos usando s..e e s ... e literais ou com Range.new.
Intervalos construídos usando .. correr desde o início até o fim, inclusive. Aqueles
criados usando ... excluem o valor final. Quando usado como um iterador, os intervalos
retornam cada valor na sequência.
Um intervalo (1..5) significa que ele inclui 1, 2, 3, 4, 5 valores e um intervalo (1 ... 5)

significa que ele inclui 1, 2, 3, 4 valores.
Exemplo
#!/usr/bin/ruby
(10..15).each do |n|
print n, ' '
end
10 11 12 13 14 15
Para mais detalhes sobre Ruby Ranges, vá até Ruby Ranges .
Ruby - Operadores
Ruby suporta um rico conjunto de operadores, como você esperaria de uma linguagem
moderna. A maioria dos operadores são, na verdade, chamadas de método. Por
exemplo, a + b é interpretada como a + (b), onde o método + no objeto referido pela
variável a é chamado com b como seu argumento.
Para cada operador (+ - * /% ** & | ^ << >> && ||), existe uma forma
correspondente de operador de atribuição abreviado (+ = - = etc.).
Operadores Aritméticos Rubi

Suponha que a variável a detenha 10 e a variável b detenha 20, então -
Operador Descrição Exemplo
+ Adição - Adiciona valores nos dois lados do operador. a + b dará 30
Subtração - Subtrai o operando da mão direita do

- a - b dará -10
operando da esquerda.
* Multiplicação - Multiplica valores em ambos os lados do a * b dará 200
operador.
Divisão - Divide o operando esquerdo pelo operando

/ b / a vai dar 2
direito.
Módulo - Divide o operando esquerdo pelo operando

% b% a dará 0
direito e retorna o restante.
Expoente - Executa o cálculo exponencial (potência) nos a ** b dará 10 à

** operadores. potência 20
Operadores de Comparação Ruby

Verifica se o valor de dois operandos é igual ou

== (a == b) não é verdade.
não, se sim, a condição se torna verdadeira.
Verifica se o valor de dois operandos é igual ou

!= não, se os valores não forem iguais, a condição (a! = b) é verdade.
se tornará verdadeira.
Verifica se o valor do operando esquerdo é

> maior que o valor do operando direito, se sim, a (a> b) não é verdade.
condição se torna verdadeira.

< menor que o valor do operando direito, se sim, (a <b) é verdade.
a condição se torna verdadeira.

>= maior ou igual ao valor do operando direito, se (a> = b) não é verdade.
sim, a condição se torna verdadeira.

<= menor ou igual ao valor do operando direito, se (a <= b) é verdade.
sim, a condição se torna verdadeira.
Operador de comparação combinada. Retorna 0

se primeiro operando for igual a segundo, 1 se
<=> (a <=> b) retorna -1.
primeiro operando for maior que o segundo e -1
se primeiro operando for menor que o segundo.
Usado para testar a igualdade dentro de uma (1 ... 10) === 5 retorna
===
cláusula when de uma instrução case . verdadeiro.
Verdadeiro se o receptor e o argumento tiverem 1 == 1.0 retorna verdadeiro,

.eql
o mesmo tipo e valores iguais. mas 1.eql (1.0) é falso.
igual? Verdadeiro se o receptor e o argumento tiverem Se aObj é duplicata de bObj,
o mesmo id de objeto. então aObj == bObj é
verdadeira, a.equal? bObj é
falsa, mas a.equal? aObj é
verdadeira.
Operadores de atribuição de rubis

Operador de atribuição simples, atribui valores de c = a + b irá

= operandos do lado direito ao operando do lado esquerdo. atribuir o valor
de a + b em c
Adicione o operador AND, adiciona o operando à direita no c+=aé

+= operando à esquerda e atribua o resultado ao operando à equivalente a c =
esquerda. c+a
Subtraia E operador de atribuição, subtrai o operando c-=aé

-= direito do operando esquerdo e atribua o resultado ao equivalente a c =
operando esquerdo. c-a
Multiply AND assignment operator, multiplica o operando à c*=aé

*= direita pelo operando da esquerda e atribui o resultado ao equivalente a c =
operando da esquerda. c*a
Divide AND assignment operator, divide o operando c/=aé

/= esquerdo com o operando da direita e atribui o resultado ao equivalente a c =
operando da esquerda. c/a
Módulo E operador de atribuição, obtém o módulo usando c% = a é

%= dois operandos e atribui o resultado ao operando esquerdo. equivalente a c =
c% a
Expoente E operador de atribuição, realiza cálculos c ** = a é

** = exponenciais (potência) nos operadores e atribui valor ao equivalente a c =
operando esquerdo. c ** a
Atribuição Paralela ao Ruby

Ruby também suporta a atribuição paralela de variáveis. Isso permite que várias
variáveis sejam inicializadas com uma única linha de código Ruby. Por exemplo -
a = 10
b = 20
c = 30
Isso pode ser mais rapidamente declarado usando a atribuição paralela -

a, b, c = 10, 20, 30
A atribuição paralela também é útil para trocar os valores mantidos em duas variáveis -
a, b = b, c
Operadores Bitwise Ruby

Operador bit a bit trabalha em bits e executa operação bit a bit.
Assuma se a = 60; eb = 13; agora em formato binário eles serão os seguintes -
a = 0011 1100
b = 0000 1101
------------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
~a = 1100 0011
Os seguintes operadores Bitwise são suportados pela linguagem Ruby.
Binary AND Operator copia um pouco para o (a & b) dará 12, que é 0000
E resultado, se existir em ambos os operandos. 1100
Operador binário OR copia um bit se existir (a | b) vai dar 61, que é 0011
|
em um dos operandos. 1101
Operador XOR binário copia o bit se estiver (a ^ b) dará 49, que é 0011
^ definido em um operando, mas não em 0001
ambos.
(~ a) dará -61, que é 1100

Binary Ones Complement Operator é unário e 0011 no formulário de
~
tem o efeito de 'flipping' bits. complemento de 2 devido a
um número binário assinado.
Operador Shift Esquerdo. O valor dos

operandos esquerdos é movido para a um << 2 dará 240, que é 1111
<< <<
esquerda pelo número de bits especificado 0000
pelo operando direito.
Operador de deslocamento à direita binário. O

valor dos operandos esquerdos é movido para a >> 2 dará 15, que é 0000
>>
a direita pelo número de bits especificado 1111
pelo operando direito.
Operadores Lógicos Ruby

Os seguintes operadores lógicos são suportados pela linguagem Ruby
Chamado Lógico E operador. Se ambos os operandos forem (aeb) é

e
verdadeiros, a condição se tornará verdadeira. verdade.
Chamado Lógico OU Operador. Se algum dos dois operandos for (a ou b) é

ou diferente de zero, a condição se tornará verdadeira. verdade.
Chamado Lógico E operador. Se ambos os operandos forem (a && b) é

&&
diferentes de zero, a condição se tornará verdadeira. verdade.
Chamado Lógico OU Operador. Se algum dos dois operandos for (a || b) é

||
diferente de zero, a condição se tornará verdadeira. verdadeiro.
Operador NÃO Lógico Chamado. Use para reverter o estado lógico ! (a && b)
! de seu operando. Se uma condição for verdadeira, o operador é falso.
Lógico NOT tornará falso.
Operador NÃO Lógico Chamado. Use para reverter o estado lógico não (a &&
não de seu operando. Se uma condição for verdadeira, o operador b) é falso.
Lógico NOT tornará falso.
Operador Ternário Rubi

Há mais um operador chamado Ternary Operator. Em primeiro lugar, avalia uma
expressão para um valor verdadeiro ou falso e, em seguida, executa uma das duas
instruções dadas, dependendo do resultado da avaliação. O operador condicional tem
essa sintaxe -
Expressão Se a condição é verdadeira? Então, valor X: caso

?:
Condicional contrário, valor Y
Operadores Ruby Range

Os intervalos de sequência em Ruby são usados para criar um intervalo de valores
sucessivos - consistindo de um valor inicial, um valor final e um intervalo de valores
entre eles.
Em Ruby, essas seqüências são criadas usando os operadores "..." e "...". O formulário
de dois pontos cria um intervalo inclusivo, enquanto o formulário de três pontos cria um
intervalo que exclui o valor alto especificado.
.. Cria um intervalo desde o ponto inicial até o 1..10 Cria um intervalo de 1 a

ponto final, inclusive. 10 inclusive.
Cria um intervalo desde o ponto inicial até o 1 ... 10 Cria um intervalo de 1

...
ponto final exclusivo. a 9.
Ruby definido? Operadores

definiram? é um operador especial que assume a forma de uma chamada de método
para determinar se a expressão passada está definida ou não. Ele retorna uma string de
descrição da expressão ou nil se a expressão não estiver definida.
Existem vários usos de definidos? Operador
Uso 1
defined? variable # True if variable is initialized
Por exemplo
foo = 42
defined? foo # => "local-variable"
defined? $_ # => "global-variable"
defined? bar # => nil (undefined)
Uso 2
defined? method_call # True if a method is defined
Por exemplo
defined? puts # => "method"

defined? puts(bar) # => nil (bar is not defined here)
defined? unpack # => nil (not defined here)
Uso 3
# True if a method exists that can be called with super user

defined? super
Por exemplo
defined? super # => "super" (if it can be called)

defined? super # => nil (if it cannot be)
Uso 4
defined? yield # True if a code block has been passed
Por exemplo
defined? yield # => "yield" (if there is a block passed)

defined? yield # => nil (if there is no block)
Ruby Dot "." e duplas cólon "::" operadores
Você chama um método de módulo precedendo seu nome com o nome do módulo e um
ponto, e faz referência a uma constante usando o nome do módulo e dois dois-pontos.
O :: é um operador unário que permite: constantes, métodos de instância e métodos de

classe definidos dentro de uma classe ou módulo, para serem acessados de qualquer
lugar fora da classe ou módulo.
Lembre-se de que Ruby, classes e métodos podem ser considerados constantes

também.
Você precisa apenas prefixar o :: Const_name com uma expressão que retorne a classe
ou objeto de módulo apropriado.
Se nenhuma expressão de prefixo é usada, a classe de objeto principal é usada por

padrão.
Aqui estão dois exemplos -
MR_COUNT = 0 # constant defined on main Object class

module Foo
MR_COUNT = 0
::MR_COUNT = 1 # set global count to 1
MR_COUNT = 2 # set local count to 2
end
puts MR_COUNT # this is the global constant
puts Foo::MR_COUNT # this is the local "Foo" constant
Segundo exemplo
CONST = ' out there'

class Inside_one
CONST = proc {' in there'}
def where_is_my_CONST
::CONST + ' inside one'
end
end
class Inside_two
CONST = ' inside two'
def where_is_my_CONST
CONST
end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST
Precedência de Operadores Ruby

A tabela a seguir lista todos os operadores da maior precedência para a mais baixa.
Método Operador Descrição

sim :: Operador de resolução constante
sim [] [] = Referência de elemento, conjunto de elementos
sim ** Exponenciação (aumentar ao poder)
Não, complemento, unário mais e menos (os

sim !~+- nomes dos métodos para os dois últimos são + @
e - @)
sim * /% Multiplique, divida e modulo
sim +- Adição e subtração
sim >> << Deslocamento bit a bit à direita e à esquerda
sim E Bitwise 'AND'
sim ^| Exclusivo de bits 'OR' e 'OR' regular
sim <= <>> = Operadores de comparação
Operadores de correspondência de igualdade e

sim <=> == ===! = = ~! ~ padrão (! = E! ~ Não podem ser definidos como
métodos)
&& Lógico 'AND'
|| Logical 'OR'
.. ... Faixa (inclusiva e exclusiva)
?: Ternário se-então-mais
=% = {= = - = + = | = & =
>> = << = * = && = || = Tarefa
** =
definiram? Verifique se o símbolo especificado foi definido
não Negação lógica
ou e Composição lógica
NOTA - Os operadores com um Sim na coluna do método são, na verdade, métodos e,

como tal, podem ser substituídos.
Ruby - Comentários
Comentários são linhas de anotações dentro do código Ruby que são ignoradas no
tempo de execução. Um comentário de linha única começa com # caractere e eles se
estendem de # até o final da linha da seguinte forma -
#!/usr/bin/ruby -w
# This is a single line comment.
puts "Hello, Ruby!"
Quando executado, o programa acima produz o seguinte resultado -
Hello, Ruby!
Ruby Multiline Comentários

Você pode comentar várias linhas usando a sintaxe = begin e = end da seguinte
forma -
#!/usr/bin/ruby -w
puts "Hello, Ruby!"
=begin
This is a multiline comment and con spwan as many lines as you
like. But =begin and =end should come in the first line only.
=end
Hello, Ruby!
Certifique-se de que os comentários à direita estejam suficientemente longe do código

e que sejam facilmente distinguidos. Se houver mais de um comentário à direita em um
bloco, alinhe-os. Por exemplo -
@counter # keeps track times page has been hit

@siteCounter # keeps track of times all pages have been hit
Ruby - se ... caso contrário, a menos que

O Ruby oferece estruturas condicionais que são bastante comuns em linguagens
modernas. Aqui, vamos explicar todas as instruções e modificadores condicionais
disponíveis em Ruby.
Ruby if ... else Statement

Sintaxe
if conditional [then]
code...
[elsif conditional [then]
code...]...
[else
code...]
end
se expressões são usadas para execução condicional. Os valores falso e nulo são falsos
e tudo o mais é verdadeiro. Observe que Ruby usa elsif, não mais se nem elif.
Executa o código se a condicional for verdadeira. Se a condicional não for verdadeira, o

código especificado na cláusula else será executado.
A condicional de uma expressão if é separada do código pela palavra reservada , em

seguida , uma nova linha ou um ponto e vírgula.
Exemplo
#!/usr/bin/ruby
x = 1
if x > 2
puts "x is greater than 2"
elsif x <= 2 and x!=0
puts "x is 1"
else
puts "I can't guess the number"
end
x is 1
Ruby se modificador
Sintaxe
code if condition
Executa o código se a condicional for verdadeira.
Exemplo
#!/usr/bin/ruby
$debug = 1
print "debug\n" if $debug
debug
Ruby, a menos que seja uma declaração

Sintaxe
unless conditional [then]
code
[else
code ]
end
Executa o código se condicional for falso. Se a condicional for verdadeira, o código

especificado na cláusula else será executado.
Exemplo
#!/usr/bin/ruby
x = 1
unless x>=2
puts "x is less than 2"
else
puts "x is greater than 2"
end
x is less than 2
Ruby a menos que modificador

Sintaxe
code unless conditional
Executa o código se condicional for falso.
Exemplo
#!/usr/bin/ruby
$var = 1
print "1 -- Value is set\n" if $var
print "2 -- Value is set\n" unless $var
$var = false
print "3 -- Value is set\n" unless $var
1 -- Value is set
3 -- Value is set
Declaração de caso Ruby

Sintaxe
case expression
[when expression [, expression ...] [then]
code ]...
[else
code ]
end
Compara a expressão especificada por maiúsculas e minúsculas e a especificada por

quando se usa o operador === e executa o código da cláusula when correspondente.
A expressão especificada pela cláusula when é avaliada como o operando da esquerda.

Se nenhuma cláusula when for correspondente, o caso executará o código da cláusula
else .
A expressão quando a declaração é separada do código pela palavra reservada, em

seguida, uma nova linha ou um ponto e vírgula. Assim -
case expr0
when expr1, expr2
stmt1
when expr3, expr4
stmt2
else
stmt3
end
é basicamente semelhante ao seguinte -
_tmp = expr0
if expr1 === _tmp || expr2 === _tmp
stmt1
elsif expr3 === _tmp || expr4 === _tmp
stmt2
else
stmt3
end
Exemplo
#!/usr/bin/ruby
$age = 5
case $age
when 0 .. 2
puts "baby"
when 3 .. 6
puts "little child"
when 7 .. 12
puts "child"
when 13 .. 18
puts "youth"
else
puts "adult"
end
little child
Ruby - Loops
Loops em Ruby são usados para executar o mesmo bloco de código em um
determinado número de vezes. Este capítulo detalha todas as instruções de loop
suportadas pelo Ruby.
Ruby enquanto Statement

Sintaxe
while conditional [do]
code
end
Executa o código enquanto a condicional é verdadeira. Um tempo de ciclo condicional é

separado do código pela palavra reservada fazer, uma nova linha, barra invertida \, ou
um ponto e vírgula;.
Exemplo
#!/usr/bin/ruby
$i = 0
$num = 5
while $i < $num do

puts("Inside the loop i = #$i" )
$i +=1
end
Inside the loop i = 0

Ruby enquanto modificador

Sintaxe
code while condition
OR
begin
code
end while conditional
Executa o código enquanto a condicional é verdadeira.
Se um modificador while segue uma instrução begin sem cláusulas rescue ou ensure, o
código é executado uma vez antes da condição ser avaliada.
Exemplo
#!/usr/bin/ruby
$i = 0
$num = 5
begin
$i +=1
end while $i < $num

Ruby até a declaração

until conditional [do]
code
end
Executa o código enquanto condicional é falso. A condicional de uma instrução until é

separada do código pela palavra reservada do , uma nova linha ou um ponto-e-vírgula.
Exemplo
#!/usr/bin/ruby
$i = 0
$num = 5
until $i > $num do

$i +=1;
end

Ruby até modificador

Sintaxe
code until conditional
OR
begin
code
end until conditional
Executa o código enquanto condicional é falso.
Se um modificador until seguir uma instrução begin sem cláusulas rescue ou ensure, o
código será executado uma vez antes da condição ser avaliada.
Exemplo
#!/usr/bin/ruby
$i = 0
$num = 5
begin
$i +=1;
end until $i > $num

Ruby for Statement

Sintaxe
for variable [, variable ...] in expression [do]
code
end
Executa o código uma vez para cada elemento na expressão .
Exemplo
#!/usr/bin/ruby
for i in 0..5
puts "Value of local variable is #{i}"
end
Aqui, definimos o intervalo 0..5. A declaração para i em 0..5 permitirá que eu tome
valores na faixa de 0 a 5 (incluindo 5). Isso produzirá o seguinte resultado -
Value of local variable is 0

Um loop for ... é quase exatamente equivalente ao seguinte -

(expression).each do |variable[, variable...]| code end
Não obstante, um para loop não criar um novo escopo de variáveis locais. Uma para o
circuito de expressão é separado do código pela palavra reservada fazer, uma nova
linha ou um ponto e vírgula.
Exemplo
#!/usr/bin/ruby
(0..5).each do |i|
end

Declaração de quebra de Ruby

Sintaxe
break
Encerra o loop mais interno. Encerra um método com um bloco associado, se chamado
dentro do bloco (com o método retornando nil).
Exemplo
#!/usr/bin/ruby
for i in 0..5
if i > 2 then
break
end
end

Ruby next Statement

Sintaxe
next
Salta para a próxima iteração do loop mais interno. Encerra a execução de um bloco se
chamado dentro de um bloco (com rendimento ou retorno de chamada nulo).
Exemplo
#!/usr/bin/ruby
for i in 0..5
if i < 2 then
next
end
end

Ruby redo Statement

Sintaxe
redo
Reinicia essa iteração do loop mais interno, sem verificar a condição de loop. Reinicia o
rendimento ou chama se chamado dentro de um bloco.
Exemplo
#!/usr/bin/ruby
for i in 0..5
if i < 2 then
redo
end
end
Isso produzirá o seguinte resultado e entrará em um loop infinito -

............................
Declaração de repetição do Ruby

Sintaxe
retry
Se a tentativa aparecer novamente na cláusula rescue da expressão begin, reinicie a

partir do início do corpo inicial.
begin
do_something # exception raised
rescue
# handles error
retry # restart from beginning
end
Se a repetição aparecer no iterador, o bloco ou o corpo da expressão for reinicia a

chamada da chamada do iterador. Argumentos para o iterador são reavaliados.
for i in 1..5
retry if some_condition # restart from i == 1
end
Exemplo
#!/usr/bin/ruby
for i in 0..5
retry if i > 2
end
Isso produzirá o seguinte resultado e entrará em um loop infinito -

............................
Ruby - Métodos
Os métodos Ruby são muito semelhantes às funções em qualquer outra linguagem de
programação. Os métodos Ruby são usados para agrupar uma ou mais instruções
repetidas em uma única unidade.
Os nomes dos métodos devem começar com uma letra minúscula. Se você começar um
nome de método com uma letra maiúscula, Ruby pode pensar que é uma constante e,
portanto, pode analisar a chamada incorretamente.
Os métodos devem ser definidos antes de chamá-los, caso contrário, o Ruby levantará
uma exceção para a invocação do método indefinido.
Sintaxe
def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
expr..
end
Então, você pode definir um método simples como segue -

def method_name
expr..
end
Você pode representar um método que aceita parâmetros como este -
def method_name (var1, var2)

expr..
end
Você pode definir valores padrão para os parâmetros, que serão usados se o método for
chamado sem passar pelos parâmetros necessários -
def method_name (var1 = value1, var2 = value2)

expr..
end
Sempre que você chama o método simples, escreve apenas o nome do método da
seguinte forma -
method_name
No entanto, quando você chama um método com parâmetros, escreve o nome do

método junto com os parâmetros, como -
method_name 25, 30
A desvantagem mais importante de usar métodos com parâmetros é que você precisa
lembrar o número de parâmetros sempre que chamar tais métodos. Por exemplo, se
um método aceita três parâmetros e você passa apenas dois, o Ruby exibe um erro.
Exemplo
#!/usr/bin/ruby
def test(a1 = "Ruby", a2 = "Perl")

puts "The programming language is #{a1}"
puts "The programming language is #{a2}"
end
test "C", "C++"
test
The programming language is C

The programming language is C++
The programming language is Ruby
The programming language is Perl
Retornar valores de métodos

Todo método em Ruby retorna um valor por padrão. Este valor retornado será o valor
da última declaração. Por exemplo -
def test
i = 100
j = 10
k = 0
end
Este método, quando chamado, retornará a última variável declarada k .
Declaração de retorno do Ruby

A declaração de retorno em ruby é usada para retornar um ou mais valores de um
Método Ruby.
Sintaxe
return [expr[`,' expr...]]
Se mais de duas expressões forem fornecidas, a matriz contendo esses valores será o
valor de retorno. Se nenhuma expressão for dada, nil será o valor de retorno.
Exemplo
return
OR
return 12
OR
return 1,2,3
Dê uma olhada neste exemplo -

#!/usr/bin/ruby
def test
i = 100
j = 200
k = 300
return i, j, k
end
var = test
puts var
100
200
300
Número Variável de Parâmetros

Suponha que você declare um método que usa dois parâmetros, sempre que você
chamar esse método, precisará passar dois parâmetros junto com ele.
No entanto, Ruby permite declarar métodos que funcionam com um número variável de
parâmetros. Vamos examinar uma amostra disso -
#!/usr/bin/ruby
def sample (*test)

puts "The number of parameters is #{test.length}"
for i in 0...test.length
puts "The parameters are #{test[i]}"
end
end
sample "Zara", "6", "F"
sample "Mac", "36", "M", "MCA"
Nesse código, você declarou uma amostra de método que aceita um teste de
parâmetro. No entanto, esse parâmetro é um parâmetro variável. Isso significa que
esse parâmetro pode receber qualquer número de variáveis. Então, o código acima irá
produzir o seguinte resultado -
The number of parameters is 3

The parameters are Zara
The parameters are 6
The parameters are F
The number of parameters is 4
The parameters are Mac
The parameters are 36
The parameters are M
The parameters are MCA
Métodos de aula
Quando um método é definido fora da definição da classe, o método é marcado como
privado por padrão. Por outro lado, os métodos definidos na definição de classe são
marcados como públicos por padrão. A visibilidade padrão e a marca privada dos
métodos podem ser alteradas por público ou privado do Módulo.
Sempre que você quiser acessar um método de uma classe, primeiro instancie a classe.
Então, usando o objeto, você pode acessar qualquer membro da classe.
Ruby dá a você uma maneira de acessar um método sem instanciar uma classe. Vamos
ver como um método de classe é declarado e acessado -
class Accounts
def reading_charge
end
def Accounts.return_date
end
end
Veja como o método return_date é declarado. É declarado com o nome da classe

seguido por um período, que é seguido pelo nome do método. Você pode acessar este
método de classe diretamente da seguinte maneira -
Accounts.return_date
Para acessar este método, você não precisa criar objetos da classe Accounts.
Declaração de alias do Ruby

Isto dá alias a métodos ou variáveis globais. Os aliases não podem ser definidos no
corpo do método. O alias do método mantém a definição atual do método, mesmo
quando os métodos são substituídos.
Fazer aliases para as variáveis globais numeradas ($ 1, $ 2, ...) é proibido. Substituir as

variáveis globais internas pode causar sérios problemas.
Sintaxe
alias method-name method-name
alias global-variable-name global-variable-name
Exemplo
alias foo bar
alias $MATCH $&
Aqui nós definimos foo alias para bar, e $ MATCH é um apelido para $ &
Ruby undef Statement

Isso cancela a definição do método. Um undef não pode aparecer no corpo do método.
Ao usar undef e alias , a interface da classe pode ser modificada independentemente da

superclasse, mas observe que ela pode ser quebrada por meio da chamada de método
interno para self.
Sintaxe
undef method-name
Exemplo
Para indefinir um método chamado bar faça o seguinte -
undef bar
Ruby - Blocos
Você viu como o Ruby define os métodos em que você pode colocar o número de
instruções e, em seguida, chama esse método. Da mesma forma, Ruby tem um
conceito de Block.
Um bloco consiste em pedaços de código.
Você atribui um nome a um bloco.
O código no bloco é sempre colocado entre chaves ({}).

Um bloco é sempre chamado de uma função com o mesmo nome do bloco. Isso
significa que, se você tiver um bloco com o nome test , use o teste de função
para chamar este bloco.
Você chama um bloco usando a instrução yield .
Sintaxe
block_name {
statement1
statement2
..........
}
Aqui, você aprenderá a invocar um bloco usando uma declaração de rendimento

simples . Você também aprenderá a usar uma instrução yield com parâmetros para
chamar um bloco. Você verificará o código de amostra com os dois tipos de declarações
de rendimento .
A declaração de rendimento
Vamos ver um exemplo da declaração de rendimento -
#!/usr/bin/ruby
def test
puts "You are in the method"
yield
puts "You are again back to the method"
yield
end
test {puts "You are in the block"}
You are in the method

You are in the block
You are again back to the method
You are in the block
Você também pode passar parâmetros com a declaração de rendimento. Aqui está um
exemplo -
#!/usr/bin/ruby
def test
yield 5
puts "You are in the method test"
yield 100
end
test {|i| puts "You are in the block #{i}"}

You are in the block 5
You are in the method test
Aqui, a declaração de rendimento é escrita seguida por parâmetros. Você pode até
passar mais de um parâmetro. No bloco, você coloca uma variável entre duas linhas
verticais (||) para aceitar os parâmetros. Portanto, no código anterior, a instrução yield
5 passa o valor 5 como um parâmetro para o bloco de teste.
Agora, olhe a seguinte declaração -
test {|i| puts "You are in the block #{i}"}
Aqui, o valor 5 é recebido na variável i . Agora, observe a seguinte declaração de puts -
puts "You are in the block #{i}"
A saída desta declaração de puts é -
Se você quiser passar mais de um parâmetro, a declaração de rendimento se torna -
yield a, b
e o bloco é -
test {|a, b| statement}
Os parâmetros serão separados por vírgulas.
Blocos e Métodos
Você viu como um bloco e um método podem ser associados uns aos outros. Você
normalmente chama um bloco usando a instrução yield de um método que possui o
mesmo nome do bloco. Portanto, você escreve -
#!/usr/bin/ruby
def test
yield
end
test{ puts "Hello world"}
Este exemplo é a maneira mais simples de implementar um bloco. Você chama o bloco
de teste usando a declaração de rendimento .
Mas se o último argumento de um método é precedido por &, então você pode passar
um bloco para este método e este bloco será atribuído ao último parâmetro. No caso de
ambos * e & estarem presentes na lista de argumentos, & devem vir mais tarde.
#!/usr/bin/ruby
def test(&block)
block.call
end
test { puts "Hello World!"}
Hello World!
BEGIN e END Blocks

Todo arquivo fonte do Ruby pode declarar blocos de código a serem executados
enquanto o arquivo está sendo carregado (os blocos BEGIN) e após o programa ter
terminado a execução (os blocos END).
#!/usr/bin/ruby
BEGIN {
# BEGIN block code
puts "BEGIN code block"
}
END {
# END block code
puts "END code block"
}
# MAIN block code
puts "MAIN code block"
Um programa pode incluir vários blocos BEGIN e END. Os blocos BEGIN são executados
na ordem em que são encontrados. Os blocos END são executados na ordem inversa.
BEGIN code block

MAIN code block
END code block
Rubi - Módulos e Mixins

Módulos são uma maneira de agrupar métodos, classes e constantes. Os módulos
oferecem dois grandes benefícios.
Os módulos fornecem um namespace e evitam confrontos de nomes.
Módulos implementam a facilidade mixin .
Os módulos definem um namespace, uma caixa de proteção na qual seus métodos e

constantes podem ser reproduzidos sem ter que se preocupar em ser pisado por outros
métodos e constantes.
Sintaxe
module Identifier
statement1
statement2
...........
end
As constantes de módulo são nomeadas como constantes de classe, com uma letra
maiúscula inicial. As definições do método também são semelhantes: Os métodos do
módulo são definidos exatamente como os métodos de classe.
Como nos métodos de classe, você chama um método de módulo precedendo seu nome
com o nome do módulo e um ponto, e faz referência a uma constante usando o nome
do módulo e dois dois-pontos.
Exemplo
#!/usr/bin/ruby
# Module defined in trig.rb file
module Trig
PI = 3.141592654
def Trig.sin(x)
# ..
end
def Trig.cos(x)
# ..
end
end
Podemos definir mais um módulo com o mesmo nome de função mas funcionalidade
diferente
#!/usr/bin/ruby
# Module defined in moral.rb file
module Moral
VERY_BAD = 0
BAD = 1
def Moral.sin(badness)
# ...
end
end
Como os métodos de classe, sempre que você define um método em um módulo, você
especifica o nome do módulo seguido por um ponto e, em seguida, o nome do método.
Ruby requer declaração

A instrução require é semelhante à instrução include de C e C ++ e a declaração de
importação de Java. Se um terceiro programa quiser usar qualquer módulo definido, ele
pode simplesmente carregar os arquivos do módulo usando a instrução require do Ruby
-
Sintaxe
require filename
Aqui, não é necessário fornecer extensão .rb junto com um nome de arquivo.
Exemplo
$LOAD_PATH << '.'
require 'trig.rb'
require 'moral'
y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)
Aqui estamos usando $ LOAD_PATH << '.' para tornar Ruby ciente de que os arquivos
incluídos devem ser pesquisados no diretório atual. Se você não quiser usar $
LOAD_PATH, então você pode usar require_relative para incluir arquivos de um
diretório relativo.
IMPORTANTE - Aqui, os dois arquivos contêm o mesmo nome de função. Portanto,

isso resultará em ambigüidade de código, incluindo no programa de chamada, mas os
módulos evitam a ambigüidade do código e podemos chamar a função apropriada
usando o nome do módulo.
Ruby incluir declaração

Você pode incorporar um módulo em uma classe. Para incorporar um módulo em uma
classe, você usa a instrução include na classe -
Sintaxe
include modulename
Se um módulo é definido em um arquivo separado, é necessário incluir esse arquivo

usando require statement antes de embutir o módulo em uma classe.
Exemplo
Considere o seguinte módulo escrito no arquivo support.rb .
module Week
FIRST_DAY = "Sunday"
def Week.weeks_in_month
puts "You have four weeks in a month"
end
def Week.weeks_in_year
puts "You have 52 weeks in a year"
end
end
Agora, você pode incluir este módulo em uma classe da seguinte maneira -
#!/usr/bin/ruby
$LOAD_PATH << '.'
require "support"
class Decade
include Week
no_of_yrs = 10
def no_of_months
puts Week::FIRST_DAY
number = 10*12
puts number
end
end
d1 = Decade.new
puts Week::FIRST_DAY
Week.weeks_in_month
Week.weeks_in_year
d1.no_of_months
Sunday
You have four weeks in a month
You have 52 weeks in a year
Sunday
120
Mixins em Ruby
Antes de passar por esta seção, assumimos que você tem o conhecimento de Conceitos
Orientados a Objetos.
Quando uma classe pode herdar recursos de mais de uma classe pai, a classe deve
mostrar herança múltipla.
O Ruby não suporta múltiplas heranças diretamente, mas o Ruby Modules tem outro
uso maravilhoso. De uma só vez, eles praticamente eliminam a necessidade de herança
múltipla, fornecendo uma facilidade chamada mixin .
Os mixins oferecem uma maneira maravilhosamente controlada de adicionar

funcionalidade às classes. No entanto, seu verdadeiro poder é lançado quando o código
no mixin começa a interagir com o código na classe que o utiliza.
Vamos examinar o seguinte exemplo de código para entender o mixin -
module A
def a1
end
def a2
end
end
module B
def b1
end
def b2
end
end
class Sample
include A
include B
def s1
end
end
samp = Sample.new
samp.a1
samp.a2
samp.b1
samp.b2
samp.s1
O módulo A consiste nos métodos a1 e a2. O módulo B consiste nos métodos b1 e b2. A
classe Sample inclui os módulos A e B. A classe Sample pode acessar todos os quatro
métodos, a saber, a1, a2, b1 e b2. Portanto, você pode ver que a classe Sample herda
de ambos os módulos. Assim, você pode dizer que a classe Sample mostra herança
múltipla ou um mixin .
Ruby - Cordas
Um objeto String em Ruby mantém e manipula uma seqüência arbitrária de um ou mais
bytes, geralmente representando caracteres que representam a linguagem humana.
Os literais de string mais simples são colocados entre aspas simples (o caractere de
apóstrofo). O texto dentro das marcas de aspas é o valor da string -
'This is a simple Ruby string literal'
Se você precisar colocar um apóstrofo dentro de um literal de aspas simples, preceda-o

com uma barra invertida, para que o interpretador Ruby não pense que ele encerra a
cadeia -
'Won\'t you read O\'Reilly\'s book?'
A barra invertida também funciona para escapar de outra barra invertida, de modo que
a segunda barra invertida não é interpretada como um caractere de escape.
A seguir estão os recursos relacionados a cadeias de caracteres do Ruby.
Substituição de Expressão
A substituição de expressão é um meio de incorporar o valor de qualquer expressão
Ruby em uma string usando # {e} -
#!/usr/bin/ruby
x, y, z = 12, 36, 72
puts "The value of x is #{ x }."
puts "The sum of x and y is #{ x + y }."
puts "The average was #{ (x + y + z)/3 }."
The value of x is 12.

The sum of x and y is 48.
The average was 40.
Cordas Delimitadas Geral

Com strings delimitadas em geral, você pode criar strings dentro de um par de
caracteres delimitadores arbitrários, eg,!, (, {, <, Etc., precedidos por um caractere
percentual (%). Q, qex têm significados especiais Cadeias delimitadas por geral podem
ser -
%{Ruby is fun.} equivalent to "Ruby is fun."

%Q{ Ruby is fun. } equivalent to " Ruby is fun. "
%q[Ruby is fun.] equivalent to a single-quoted string
%x!ls! equivalent to back tick command output `ls`
Personagens de fuga
A tabela a seguir é uma lista de caracteres de escape ou não imprimíveis que
podem ser representados com a notação de barra invertida.
Codificação de caracteres
O conjunto de caracteres padrão para Ruby é ASCII, cujos caracteres podem ser
representados por bytes únicos. Se você usar o UTF-8 ou outro conjunto de caracteres
moderno, os caracteres poderão ser representados em um a quatro bytes.
Você pode alterar o seu conjunto de caracteres usando $ KCODE no início do seu
programa, como este -
$KCODE = 'u'
A seguir estão os valores possíveis para $ KCODE.
Métodos internos de string

Precisamos ter uma instância do objeto String para chamar um método String. A seguir
está a maneira de criar uma instância do objeto String -
new [String.new(str = "")]
Isso retornará um novo objeto de string contendo uma cópia de str . Agora, usando o
objeto str , todos nós podemos usar qualquer método de instância disponível. Por
exemplo -
#!/usr/bin/ruby
myStr = String.new("THIS IS TEST")

foo = myStr.downcase
puts "#{foo}"
this is test
A seguir estão os métodos public String (Supondo que str seja um objeto
String) -
String descompactar diretivas

A tabela a seguir lista as diretivas de descompactação do método String #
unpack.
Exemplo
Tente o exemplo a seguir para descompactar vários dados.
"abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "]

"abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*') #=> ["abc ", "abc "]
"aa".unpack('b8B8') #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c') #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS') #=> [-2, 65534]
"now = 20is".unpack('M*') #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a') #=> ["h", "e", "l", "l", "o"]
Ruby - Arrays
Matrizes Ruby são ordenadas, coleções indexadas por inteiro de qualquer objeto. Cada
elemento em uma matriz é associado e referenciado por um índice.
A indexação de matriz começa em 0, como em C ou Java. Um índice negativo é

assumido em relação ao final da matriz --- ou seja, um índice de -1 indica o último
elemento da matriz, -2 é o próximo ao último elemento na matriz e assim por diante.
Os arrays Ruby podem conter objetos como String, Integer, Fixnum, Hash, Symbol e
até mesmo outros objetos Array. Os arrays Ruby não são tão rígidos quanto os arrays
em outros idiomas. Os arrays Ruby crescem automaticamente ao adicionar elementos a
eles.
Criando Matrizes
Existem muitas maneiras de criar ou inicializar uma matriz. Uma maneira é com o novo
método de classe -
names = Array.new
Você pode definir o tamanho de uma matriz no momento da criação da matriz
names = Array.new(20)
Os nomes das matrizes agora têm um tamanho ou comprimento de 20 elementos. Você

pode retornar o tamanho de uma matriz com os métodos de tamanho ou tamanho -
#! / usr / bin / ruby
names = Array . new ( 20 )
coloca nomes . size # Isso retorna 20
nomes de puts . comprimento # Isso também retorna 20
20
20
Você pode atribuir um valor a cada elemento da matriz da seguinte maneira -

#!/usr/bin/ruby
names = Array.new(4, "mac")

puts "#{names}"
["mac", "mac", "mac", "mac"]
Você também pode usar um bloco com novo, preenchendo cada elemento com o que o
bloco avalia para -
#!/usr/bin/ruby
nums = Array.new(10) { |e| e = e * 2 }

puts "#{nums}"
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Existe outro método de Array, []. Funciona assim -
nums = Array.[](1, 2, 3, 4,5)
Mais uma forma de criação de matriz é a seguinte -
nums = Array[1, 2, 3, 4,5]
O módulo Kernel disponível no núcleo Ruby possui um método Array, que aceita apenas
um único argumento. Aqui, o método usa um intervalo como argumento para criar uma
matriz de dígitos -
#!/usr/bin/ruby
digits = Array(0..9)
puts "#{digits}"
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Métodos internos da matriz

Precisamos ter uma instância do objeto Array para chamar um método Array. Como
vimos, seguir é o caminho para criar uma instância do objeto Array -
Array.[](...) [or] Array[...] [or] [...]
Isso retornará uma nova matriz preenchida com os objetos fornecidos. Agora, usando o
objeto criado, podemos chamar qualquer método de instância disponível. Por exemplo -
#!/usr/bin/ruby
digits = Array(0..9)
num = digits.at(6)
puts "#{num}"
A seguir estão os métodos de matriz pública (supondo que matriz é um objeto

de matriz) -
Diretrizes do pacote de matrizes

A tabela a seguir lista as diretivas de pacote para uso com o Array # pack.
Exemplo
Tente o exemplo a seguir para compactar vários dados.
a = [ "a", "b", "c" ]
n = [ 65, 66, 67 ]
puts a.pack("A3A3A3") #=> "a b c "
puts a.pack("a3a3a3") #=> "a\000\000b\000\000c\000\000"
puts n.pack("ccc") #=> "ABC"
a b c
abc
ABC
Ruby - Hashes
Um hash é uma coleção de pares de valores-chave como este: "empregado" =>
"salário". É semelhante a um Array, exceto que a indexação é feita através de chaves
arbitrárias de qualquer tipo de objeto, não um índice inteiro.
A ordem na qual você percorre um hash por chave ou valor pode parecer arbitrária e
geralmente não estará na ordem de inserção. Se você tentar acessar um hash com uma
chave que não existe, o método retornará nulo .
Criando Hashes
Tal como acontece com as matrizes, existe uma variedade de maneiras de criar hashes.
Você pode criar um hash vazio com o novo método de classe -
months = Hash.new
Você também pode usar o novo para criar um hash com um valor padrão, que é de
outra forma apenas nulo -
months = Hash.new( "month" )
or
months = Hash.new "month"
Quando você acessa qualquer chave em um hash que tenha um valor padrão, se a
chave ou o valor não existir, o acesso ao hash retornará o valor padrão -
#!/usr/bin/ruby
puts "#{months[0]}"
puts "#{months[72]}"
month
month
#!/usr/bin/ruby
H = Hash["a" => 100, "b" => 200]
puts "#{H['a']}"
puts "#{H['b']}"
100
200
Você pode usar qualquer objeto Ruby como uma chave ou valor, até mesmo um array,
então o exemplo a seguir é válido -
[1,"jan"] => "January"
Métodos internos de hash

Precisamos ter uma instância do objeto Hash para chamar um método Hash. Como
vimos, seguir é o caminho para criar uma instância do objeto Hash -
Hash[[key =>|, value]* ] or

Hash.new [or] Hash.new(obj) [or]
Hash.new { |hash, key| block }
Isso retornará um novo hash preenchido com os objetos fornecidos. Agora, usando o
objeto criado, podemos chamar qualquer método de instância disponível. Por exemplo -
#!/usr/bin/ruby
$, = ", "
months = {"1" => "January", "2" => "February"}
keys = months.keys
puts "#{keys}"
["1", "2"]
A seguir estão os métodos de hash públicos (supondo que hash é um objeto de matriz)
-
Sr. Métodos e Descrição

Não.
hash == other_hash
Testa se dois hashes são iguais, com base em se eles têm o mesmo número
1
de pares de valores-chave e se os pares de valores-chave correspondem ao
par correspondente em cada hash.
chave de hash]
2 Usando uma chave, faz referência a um valor do hash. Se a chave não for
encontrada, retorna um valor padrão.
hash. [chave] = valor

3
Associa o valor dado por valor com a chave dada pela chave .
hash.clear
4
Remove todos os pares de valores-chave do hash.
hash.default (key = nil)
5 Retorna o valor padrão para hash , nil se não for definido por padrão =. ([]
retorna um valor padrão se a chave não existir no hash .)
hash.default = obj
6
Define um valor padrão para hash .
7 hash.default_proc
Retorna um bloco se o hash foi criado por um bloco.
hash.delete (chave) [ou]
array.delete (key) {| chave | quadra }

8 Exclui um par de valores-chave de hash por chave . Se o bloco é usado,
retorna o resultado de um bloco se o par não for encontrado. Compare
delete_if .
hash.delete_if {| chave, valor | quadra }
9 Exclui um par de valores-chave do hash para cada par que o bloco avalia como
verdadeiro .
hash.each {| chave, valor | quadra }
10 Itera sobre hash , chamando o bloco uma vez para cada chave, passando o
valor-chave como uma matriz de dois elementos.
hash.each_key {| chave | quadra }
11 Itera sobre hash , chamando o bloco uma vez para cada chave, passando a
chave como parâmetro.
hash.each_key {| key_value_array | quadra }
12 Itera sobre hash , chamando o bloco uma vez para cada chave , passando a
chave e valor como parâmetros.
hash.each_key {| value | quadra }
13 Itera sobre hash , chamando o bloco uma vez para cada chave , passando o
valor como parâmetro.
hash.empty
14 Testa se o hash está vazio (não contém pares de valores-chave), retornando

true ou false .
15 hash.fetch (key [, padrão]) [ou]
hash.fetch (key) {| chave | quadra }
Retorna um valor de hash para a chave dada . Se a chave não puder ser
encontrada e não houver outros argumentos, ela gerará uma exceção
IndexError ; se o padrão é dado, ele é retornado; se o bloco opcional for
especificado, seu resultado será retornado.
hash.has_key? (key) [ou] hash.include? (chave) [ou]
hash.key? (chave) [ou] hash.member? (chave)

16
Testa se uma determinada chave está presente no hash, retornando true ou
false .
hash.has_value? (valor)
17
Testa se o hash contém o valor fornecido .
hash.index (valor)
18 Retorna a chave para o valor fornecido em hash, nil se nenhum valor

correspondente for encontrado.
hash.indexes (chaves)
Retorna um novo array que consiste em valores para a (s) chave (s) dada (s).
19
Inserirá o valor padrão para chaves que não são encontradas. Este método
está obsoleto. Use select.
hash.indices (chaves)
Retorna um novo array que consiste em valores para a (s) chave (s) dada (s).
20
Inserirá o valor padrão para chaves que não são encontradas. Este método
está obsoleto. Use select.
hash.inspect
21
Retorna uma versão bonita de string de impressão de hash.
hash.invert
22 Cria um novo hash , invertendo chaves e valores do hash ; ou seja, no novo

hash, as chaves do hash se tornam valores e valores tornam-se chaves.
hash.keys
23
Cria um novo array com chaves do hash .
hash.length
24
Retorna o tamanho ou o comprimento do hash como um inteiro.
25 hash.merge (other_hash) [ou]

hash.merge (other_hash) {| chave, oldval, newval | quadra }
Retorna um novo hash contendo o conteúdo de hash e other_hash ,

sobrescrevendo pares em hash com chaves duplicadas com aqueles de
other_hash .
hash.merge! (other_hash) [ou]
26 hash.merge! (other_hash) {| chave, oldval, newval | quadra }
O mesmo que mesclar, mas as alterações são feitas no lugar.
hash.rehash
27 Reconstrói o hash com base nos valores atuais de cada chave . Se os valores
foram alterados desde que foram inseridos, esse método reindexará o hash .
hash.reject {| chave, valor | quadra }

28
Cria um novo hash para cada par que o bloco avalia como verdadeiro
hash.reject! {| chave, valor | quadra }

29
O mesmo que rejeitar , mas as mudanças são feitas no lugar.
hash.replace (other_hash)
30
Substitui o conteúdo do hash pelo conteúdo de other_hash .
hash.select {| chave, valor | quadra }
31 Retorna um novo array que consiste em pares key-value do hash para o qual o
bloco retorna true .
hash.shift
32 Remove um par de valores-chave do hash , retornando-o como uma matriz de

dois elementos.
hash.size
33
Retorna o tamanho ou o comprimento do hash como um inteiro.
hash.sort
34 Converte o hash em um array bidimensional contendo matrizes de pares de

valores-chave e classifica-os como um array.
35 hash.store (chave, valor)

Armazena um par de valores-chave em hash .
hash.to_a
Cria um array bidimensional a partir do hash. Cada par chave / valor é

36
convertido em um array, e todos esses arrays são armazenados em um array
contendo.
hash.to_hash
37
Retorna o hash (self).
hash.to_s
38 Converte o hash em uma matriz e, em seguida, converte essa matriz em uma

string.
hash.update (other_hash) [ou]
hash.update (other_hash) {| chave, oldval, newval | quadra}

39 Retorna um novo hash contendo o conteúdo de hash e other_hash ,
sobrescrevendo pares em hash com chaves duplicadas com aqueles de
other_hash .
hash.value? (valor)
40
Testa se o hash contém o valor fornecido .
valores de hash
41
Retorna uma nova matriz contendo todos os valores de hash .
hash.values_at (obj, ...)
42 Retorna uma nova matriz contendo os valores do hash associados à chave ou

chaves fornecidas.
Ruby - Data e Hora

A classe Time representa datas e horas em Ruby. É uma camada fina sobre a
funcionalidade de data e hora do sistema fornecida pelo sistema operacional. Esta
classe pode não ser capaz de representar datas antes de 1970 ou depois de 2038.
Este capítulo familiariza você com todos os conceitos de data e hora mais desejados.
Obtendo a data e hora atuais

A seguir, o exemplo simples para obter data e hora atuais -
#!/usr/bin/ruby -w
time1 = Time.new
puts "Current Time : " + time1.inspect
# Time.now is a synonym:
time2 = Time.now
puts "Current Time : " + time2.inspect
Current Time : Mon Jun 02 12:02:39 -0700 2008

Obtendo componentes de uma data e hora

Podemos usar o objeto Time para obter vários componentes de data e hora. A seguir
está o exemplo mostrando o mesmo -
#!/usr/bin/ruby -w
time = Time.new
# Components of a Time
puts "Current Time : " + time.inspect
puts time.year # => Year of the date
puts time.month # => Month of the date (1 to 12)
puts time.day # => Day of the date (1 to 31 )
puts time.wday # => 0: Day of week: 0 is Sunday
puts time.yday # => 365: Day of year
puts time.hour # => 23: 24-hour clock
puts time.min # => 59
puts time.sec # => 59
puts time.usec # => 999999: microseconds
puts time.zone # => "UTC": timezone name

2008
6
2
1
154
12
3
8
247476
UTC
Funções Time.utc, Time.gm e Time.local

Essas duas funções podem ser usadas para formatar a data em um formato padrão da
seguinte maneira:
# July 8, 2008
Time.local(2008, 7, 8)
# July 8, 2008, 09:10am, local time
Time.local(2008, 7, 8, 9, 10)
# July 8, 2008, 09:10 UTC
Time.utc(2008, 7, 8, 9, 10)
# July 8, 2008, 09:10:11 GMT (same as UTC)
Time.gm(2008, 7, 8, 9, 10, 11)
A seguir, o exemplo para obter todos os componentes em uma matriz no seguinte

formato -
[sec,min,hour,day,month,year,wday,yday,isdst,zone]
Tente o seguinte -
#!/usr/bin/ruby -w
time = Time.new
values = time.to_a
p values
Isso gerará o seguinte resultado -
[26, 10, 12, 2, 6, 2008, 1, 154, false, "MST"]
Essa matriz pode ser passada para as funções Time.utc ou Time.local para obter
diferentes formatos de datas da seguinte maneira -
#!/usr/bin/ruby -w
time = Time.new
values = time.to_a
puts Time.utc(*values)
Isso gerará o seguinte resultado -
Mon Jun 02 12:15:36 UTC 2008
A seguir, a maneira de obter o tempo representado internamente como segundos desde

a época (dependente da plataforma) -
# Returns number of seconds since epoch

time = Time.now.to_i
# Convert number of seconds into Time object.

Time.at(time)
# Returns second since epoch which includes microseconds

time = Time.now.to_f
Fusos Horários e Horário de Verão

Você pode usar um objeto Time para obter todas as informações relacionadas a fusos
horários e horário de verão da seguinte maneira:
time = Time.new
# Here is the interpretation

time.zone # => "UTC": return the timezone
time.utc_offset # => 0: UTC is 0 seconds offset from UTC
time.zone # => "PST" (or whatever your timezone is)
time.isdst # => false: If UTC does not have DST.
time.utc? # => true: if t is in UTC time zone
time.localtime # Convert to local timezone.
time.gmtime # Convert back to UTC.
time.getlocal # Return a new Time object in local zone
time.getutc # Return a new Time object in UTC
Tempos de Formatação e Datas

Existem várias maneiras de formatar a data e a hora. Aqui está um exemplo mostrando
alguns -
#!/usr/bin/ruby -w
time = Time.new
puts time.to_s
puts time.ctime
puts time.localtime
puts time.strftime("%Y-%m-%d %H:%M:%S")
Mon Jun 02 12:35:19 -0700 2008

Mon Jun 2 12:35:19 2008
Mon Jun 02 12:35:19 -0700 2008
2008-06-02 12:35:19
Diretivas de formatação de hora

Essas diretivas na tabela a seguir são usadas com o método Time.strftime .
Sr. Diretiva e Descrição

Não.
%uma
1
O nome abreviado do dia da semana (Sun).
%UMA
2
O nome completo do dia da semana (domingo).
3 %b
O nome abreviado do mês (Jan).

%B
4
O nome completo do mês (janeiro).
%c
5
A representação de data e hora local preferida.
%d
6
Dia do mês (01 a 31).
%H
7
Hora do dia, relógio de 24 horas (00 a 23).
%EU
8
Hora do dia, relógio de 12 horas (01 a 12).
%j
9
Dia do ano (001 a 366).
%m
10
Mês do ano (01 a 12).
%M
11
Minuto da hora (00 a 59).
%p
12
Indicador meridiano (AM ou PM).
%S
13
Segundo do minuto (00 a 60).
%VOCÊ
14 Número da semana do ano atual, começando com o primeiro domingo como o

primeiro dia da primeira semana (00 a 53).
15 %W
Número da semana do ano atual, começando com a primeira segunda-feira

como o primeiro dia da primeira semana (00 a 53).
%W
16
Dia da semana (domingo é 0, 0 a 6).
%x
17
Representação preferida apenas para a data, sem tempo.
%X
18
Representação preferida apenas pelo tempo, sem data.
%y
19
Ano sem um século (00 a 99).
%Y
20
Ano com o século.
%Z
21
Nome do fuso horário.
%%
22
Caractere Literal%.
Aritmética do Tempo
Você pode executar aritmética simples com o tempo da seguinte forma -
now = Time.now # Current time
puts now
past = now - 10 # 10 seconds ago. Time - number => Time

puts past
future = now + 10 # 10 seconds from now Time + number => Time

puts future
diff = future - now # => 10 Time - Time => number of seconds

puts diff
Thu Aug 01 20:57:05 -0700 2013

Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
10.0
Ruby - Ranges
Os intervalos ocorrem em todos os lugares: janeiro a dezembro, 0 a 9, linhas 50 a 67 e
assim por diante. Ruby suporta intervalos e nos permite usar intervalos de várias
maneiras -
Intervalos como seqüências
Intervalos como condições
Intervalos como intervalos
Intervalos como seqüências

O primeiro e talvez o uso mais natural de intervalos é expressar uma sequência. As
sequências têm um ponto inicial, um ponto final e uma maneira de produzir valores
sucessivos na sequência.
Ruby cria essas seqüências usando os operadores de faixa '' .. '' e '' ... '' . O formulário
de dois pontos cria um intervalo inclusivo, enquanto o formulário de três pontos cria um
intervalo que exclui o valor alto especificado.
(1..5) #==> 1, 2, 3, 4, 5
(1...5) #==> 1, 2, 3, 4
('a'..'d') #==> 'a', 'b', 'c', 'd'
A sequência 1..100 é mantida como um objeto Range contendo referências a dois

objetos Fixnum . Se você precisar, poderá converter um intervalo em uma lista usando
o método to_a . Experimente o seguinte exemplo -
#!/usr/bin/ruby
$, =", " # Array value separator

range1 = (1..10).to_a
range2 = ('bar'..'bat').to_a
puts "#{range1}"
puts "#{range2}"
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
["bar", "bas", "bat"]
Os intervalos implementam métodos que permitem iterar sobre eles e testar seu
conteúdo de várias maneiras -
#!/usr/bin/ruby
# Assume a range
digits = 0..9
puts digits.include?(5)
ret = digits.min
puts "Min value is #{ret}"
ret = digits.max
puts "Max value is #{ret}"
ret = digits.reject {|i| i < 5 }

puts "Rejected values are #{ret}"
digits.each do |digit|
puts "In Loop #{digit}"
end
true
Min value is 0
Max value is 9
Rejected values are 5, 6, 7, 8, 9
In Loop 0
In Loop 1
In Loop 2
In Loop 3
In Loop 4
In Loop 5
In Loop 6
In Loop 7
In Loop 8
In Loop 9
Intervalos como condições

Os intervalos também podem ser usados como expressões condicionais. Por exemplo, o
fragmento de código a seguir imprime conjuntos de linhas da entrada padrão, em que a
primeira linha de cada conjunto contém a palavra início e a última linha em que a
palavra termina -
while gets
print if /start/../end/
end
Os intervalos podem ser usados em declarações de caso -

#!/usr/bin/ruby
score = 70
result = case score

when 0..40 then "Fail"
when 41..60 then "Pass"
when 61..70 then "Pass with Merit"
when 71..100 then "Pass with Distinction"
else "Invalid Score"
end
puts result
Pass with Merit
Intervalos como intervalos

Um uso final do intervalo versátil é como um teste de intervalo: ver se algum valor está
dentro do intervalo representado pelo intervalo. Isso é feito usando ===, o operador de
igualdade de casos.
#!/usr/bin/ruby
if ((1..10) === 5)
puts "5 lies in (1..10)"
end
if (('a'..'j') === 'c')

puts "c lies in ('a'..'j')"
end
if (('a'..'j') === 'z')

puts "z lies in ('a'..'j')"
end
5 lies in (1..10)
c lies in ('a'..'j')
Ruby - Iteradores
Iteradores não são nada além de métodos suportados por coleções . Objetos que
armazenam um grupo de membros de dados são chamados de coleções. Em Ruby,
matrizes e hashes podem ser chamados de coleções.
Iteradores retornam todos os elementos de uma coleção, um após o outro. Estaremos

discutindo dois iteradores aqui, cada um e coletamos . Vamos ver isso em detalhes.
Ruby cada iterador

O iterador de cada retorna todos os elementos de uma matriz ou um hash.
Sintaxe
collection.each do |variable|
code
end
Executa o código para cada elemento na coleção . Aqui, a coleção pode ser uma matriz
ou um hash de rubi.
Exemplo
#!/usr/bin/ruby
ary = [1,2,3,4,5]
ary.each do |i|
puts i
end
1
2
3
4
5
Você sempre associa cada iterador a um bloco. Ele retorna cada valor da matriz, um por
um, ao bloco. O valor é armazenado na variável i e, em seguida, exibido na tela.
Rubi coletar Iterador

O iterador de coleta retorna todos os elementos de uma coleção.
Sintaxe
collection = collection.collect
O método de coleta nem sempre precisa estar associado a um bloco. O método collect
retorna toda a coleção, independentemente de ser uma matriz ou um hash.
Exemplo
#!/usr/bin/ruby
a = [1,2,3,4,5]
b = Array.new
b = a.collect
puts b
1
2
3
4
5
OBSERVAÇÃO : o método collect não é o caminho certo para fazer cópias entre arrays.
Existe outro método chamado clone , que deve ser usado para copiar um array em
outro array.
Você normalmente usa o método collect quando deseja fazer algo com cada um dos
valores para obter o novo array. Por exemplo, esse código produz um array b contendo
10 vezes cada valor em a .
#!/usr/bin/ruby
a = [1,2,3,4,5]
b = a.collect{|x| 10*x}
puts b
10
20
30
40
50
Ruby - File I / O
Ruby fornece um conjunto completo de métodos relacionados a E / S implementados no
módulo Kernel. Todos os métodos de E / S são derivados da classe IO.
A classe IO fornece todos os métodos básicos, como read, write, gets, puts, readline,
getc e printf .
Este capítulo cobrirá todas as funções básicas de E / S disponíveis no Ruby. Para mais
funções, por favor consulte Ruby Class IO .
A declaração puts
Nos capítulos anteriores, você atribuiu valores a variáveis e depois imprimiu a saída
usando a instrução puts .
A instrução puts instrui o programa a exibir o valor armazenado na variável. Isto irá
adicionar uma nova linha no final de cada linha que escreve.
Exemplo
#!/usr/bin/ruby
val1 = "This is variable one"

val2 = "This is variable two"
puts val1
puts val2
This is variable one

This is variable two
A instrução recebe
A instrução gets pode ser usada para obter qualquer entrada do usuário da tela padrão
chamada STDIN.
Exemplo
O código a seguir mostra como usar a instrução gets. Esse código solicitará ao usuário
que insira um valor, que será armazenado em um valor variável e, finalmente, será
impresso no STDOUT.
#!/usr/bin/ruby
puts "Enter a value :"

val = gets
puts val
Enter a value :
This is entered value
This is entered value
A declaração putc
Ao contrário da instrução puts , que gera a string inteira na tela, a instrução putc pode
ser usada para gerar um caractere por vez.
Exemplo
A saída do código a seguir é apenas o caractere H -
#!/usr/bin/ruby
str = "Hello Ruby!"

putc str
A declaração de impressão
A instrução print é semelhante à instrução puts . A única diferença é que a instrução
puts vai para a próxima linha depois de imprimir o conteúdo, enquanto que com a
instrução print o cursor está posicionado na mesma linha.
Exemplo
#!/usr/bin/ruby
print "Hello World"

print "Good Morning"
Hello WorldGood Morning
Abrindo e fechando arquivos

Até agora, você estava lendo e escrevendo para a entrada e saída padrão. Agora,
vamos ver como jogar com arquivos de dados reais.
O método File.new
Você pode criar um objeto File usando o método File.new para leitura, gravação ou
ambos, de acordo com a string de modo. Finalmente, você pode usar o método
File.close para fechar esse arquivo.
Sintaxe
aFile = File.new("filename", "mode")
# ... process the file
aFile.close
O método File.open
Você pode usar o método File.open para criar um novo objeto de arquivo e atribuir esse
objeto de arquivo a um arquivo. No entanto, há uma diferença entre File.Open e
File.New métodos. A diferença é que o método File.open pode ser associado a um
bloco, enquanto você não pode fazer o mesmo usando o método File.new .
File.open("filename", "mode") do |aFile|

# ... process the file
end
Aqui está uma lista dos diferentes modos de abrir um arquivo -
Lendo e escrevendo arquivos

Os mesmos métodos que utilizamos para E / S 'simples' estão disponíveis para todos os
objetos de arquivo. Portanto, o gets lê uma linha da entrada padrão e aFile.gets lê uma
linha do objeto de arquivo aFile.
No entanto, os objetos de E / S fornecem um conjunto adicional de métodos de acesso

para facilitar nossas vidas.
O método sysread
Você pode usar o método sysread para ler o conteúdo de um arquivo. Você pode abrir o
arquivo em qualquer um dos modos ao usar o método sysread. Por exemplo -
A seguir, o arquivo de texto de entrada -
This is a simple text file for testing purpose.
Agora vamos tentar ler este arquivo -
#!/usr/bin/ruby
aFile = File.new("input.txt", "r")
if aFile
content = aFile.sysread(20)
puts content
else
puts "Unable to open file!"
end
Esta declaração mostrará os primeiros 20 caracteres do arquivo. O ponteiro do arquivo

agora será colocado no 21º caractere no arquivo.
O método syswrite
Você pode usar o método syswrite para gravar o conteúdo em um arquivo. Você precisa
abrir o arquivo no modo de gravação ao usar o método syswrite. Por exemplo -
#!/usr/bin/ruby
aFile = File.new("input.txt", "r+")

if aFile
aFile.syswrite("ABCDEF")
else
end
Esta declaração irá escrever "ABCDEF" no arquivo.
O método each_byte
Este método pertence à classe File . O método each_byte está sempre associado a um
bloco. Considere o seguinte exemplo de código -
#!/usr/bin/ruby
aFile = File.new("input.txt", "r+")

if aFile
aFile.syswrite("ABCDEF")
aFile.each_byte {|ch| putc ch; putc ?. }
else
end
Os caracteres são passados um a um para a variável ch e, em seguida, exibidos na tela

da seguinte maneira -
s. .a. .s.i.m.p.l.e. .t.e.x.t. .f.i.l.e. .f.o.r. .t.e.s.t.i.n.g. .p.u.r.p.o.s.e...

.
.
O método IO.readlines
A classe File é uma subclasse da classe IO. A classe IO também possui alguns métodos,
que podem ser usados para manipular arquivos.
Um dos métodos da classe IO é IO.readlines . Este método retorna o conteúdo do
arquivo linha por linha. O código a seguir exibe o uso do método IO.readlines -
#!/usr/bin/ruby
arr = IO.readlines("input.txt")
puts arr[0]
puts arr[1]
Neste código, a variável arr é um array. Cada linha do arquivo input.txt será um
elemento no array arr. Portanto, arr [0] conterá a primeira linha, enquanto arr [1]
conterá a segunda linha do arquivo.
O método IO.foreach
Este método também retorna saída linha por linha. A diferença entre o método foreach
e o método readlines é que o método foreach está associado a um bloco. No entanto,
ao contrário das linhas de leitura do método , o método foreach não retorna uma
matriz. Por exemplo -
#!/usr/bin/ruby
IO.foreach("input.txt"){|block| puts block}
Este código passará o conteúdo do teste de arquivo linha a linha para o bloco de
variáveis e, em seguida, a saída será exibida na tela.
Renomeando e Excluindo Arquivos

Você pode renomear e excluir arquivos programaticamente com Ruby com os métodos
rename e delete .
A seguir está o exemplo para renomear um arquivo existente test1.txt -
#!/usr/bin/ruby
# Rename a file from test1.txt to test2.txt

File.rename( "test1.txt", "test2.txt" )
A seguir está o exemplo para excluir um arquivo existente test2.txt -
#!/usr/bin/ruby
# Delete file test2.txt

File.delete("test2.txt")
Modos de Arquivo e Propriedade

Use o método chmod com uma máscara para alterar o modo ou permissões / lista de
acesso de um arquivo -
A seguir, o exemplo para alterar o modo de um arquivo test.txt existente para um valor
de máscara -
#!/usr/bin/ruby
file = File.new( "test.txt", "w" )

file.chmod( 0755 )
A seguir está a tabela, que pode ajudá-lo a escolher uma máscara diferente
para o método chmod -
Inquéritos de arquivo
O comando a seguir testa se um arquivo existe antes de abri-lo -
#!/usr/bin/ruby
File.open("file.rb") if File::exists?( "file.rb" )
O seguinte comando pergunta se o arquivo é realmente um arquivo -
#!/usr/bin/ruby
# This returns either true or false

File.file?( "text.txt" )
O seguinte comando descobre se o nome do arquivo fornecido é um diretório -
#!/usr/bin/ruby
# a directory
File::directory?( "/usr/local/bin" ) # => true
# a file
File::directory?( "file.rb" ) # => false
O seguinte comando descobre se o arquivo é legível, gravável ou executável -
#!/usr/bin/ruby
File.readable?( "test.txt" ) # => true

File.writable?( "test.txt" ) # => true
File.executable?( "test.txt" ) # => false
O seguinte comando descobre se o arquivo tem tamanho zero ou não -
#!/usr/bin/ruby
File.zero?( "test.txt" ) # => true
O seguinte comando retorna o tamanho do arquivo -
#!/usr/bin/ruby
File.size?( "text.txt" ) # => 1002

O seguinte comando pode ser usado para descobrir um tipo de arquivo -
#!/usr/bin/ruby
File::ftype( "test.txt" ) # => file
O método ftype identifica o tipo do arquivo retornando um dos seguintes - arquivo,

diretório, caractereEspecial, blocoEspecial, fifo, link, soquete ou desconhecido.
O comando a seguir pode ser usado para localizar quando um arquivo foi criado,
modificado ou acessado pela última vez -
#!/usr/bin/ruby
File::ctime( "test.txt" ) # => Fri May 09 10:06:37 -0700 2008

File::mtime( "text.txt" ) # => Fri May 09 10:44:44 -0700 2008
File::atime( "text.txt" ) # => Fri May 09 10:45:01 -0700 2008
Diretórios em Ruby
Todos os arquivos estão contidos em vários diretórios, e o Ruby não tem nenhum
problema em lidar com isso também. Enquanto a classe File manipula arquivos, os
diretórios são tratados com a classe Dir .
Navegando pelos diretórios

Para alterar o diretório dentro de um programa Ruby, use Dir.chdir da seguinte
maneira. Este exemplo altera o diretório atual para / usr / bin .
Dir.chdir("/usr/bin")
Você pode descobrir qual é o diretório atual com Dir.pwd -
puts Dir.pwd # This will return something like /usr/bin
Você pode obter uma lista dos arquivos e diretórios dentro de um diretório específico
usando Dir.entries -
puts Dir.entries("/usr/bin").join(' ')
Dir.entries retorna uma matriz com todas as entradas no diretório especificado.

Dir.foreach fornece o mesmo recurso -
Dir.foreach("/usr/bin") do |entry|
puts entry
end
Uma forma ainda mais concisa de obter listagens de diretórios é usando o método array
da classe Dir -
Dir["/usr/bin/*"]
Criando um diretório
O Dir.mkdir pode ser usado para criar diretórios -
Dir.mkdir("mynewdir")
Você também pode definir permissões em um novo diretório (não um que já exista)
com mkdir -
NOTA - A máscara 755 define permissões owner, group, world [qualquer um] para
rwxr-xr-x onde r = read, w = write e x = execute.
Dir.mkdir( "mynewdir", 755 )
Excluindo um diretório
O Dir.delete pode ser usado para excluir um diretório. O Dir.unlink e o Dir.rmdir
executam exatamente a mesma função e são fornecidos por conveniência.
Dir.delete("testdir")
Criando arquivos e diretórios temporários

Arquivos temporários são aqueles que podem ser criados brevemente durante a
execução de um programa, mas não são um armazenamento permanente de
informações.
Dir.tmpdir fornece o caminho para o diretório temporário no sistema atual, embora o

método não esteja disponível por padrão. Para tornar o Dir.tmpdir disponível, é
necessário usar require 'tmpdir'.
Você pode usar Dir.tmpdir com File.join para criar um arquivo temporário independente
de plataforma -
require 'tmpdir'
tempfilename = File.join(Dir.tmpdir, "tingtong")
tempfile = File.new(tempfilename, "w")
tempfile.puts "This is a temporary file"
tempfile.close
File.delete(tempfilename)
Esse código cria um arquivo temporário, grava dados nele e o exclui. A biblioteca
padrão do Ruby também inclui uma biblioteca chamada Tempfile que pode criar
arquivos temporários para você -
require 'tempfile'
f = Tempfile.new('tingtong')
f.puts "Hello"
puts f.path
f.close
Funções incorporadas
Aqui estão as funções internas do ruby para processar arquivos e diretórios -
Classe de arquivo e métodos .
Classe Dir e Métodos .
Ruby - exceções
A execução e a exceção sempre andam juntas. Se você está abrindo um arquivo, o que
não existe, então se você não lidou com esta situação corretamente, então seu
programa é considerado de má qualidade.
O programa pára se ocorrer uma exceção. Portanto, as exceções são usadas para
manipular vários tipos de erros, que podem ocorrer durante a execução de um
programa e tomar a ação apropriada, em vez de interromper completamente o
programa.
Ruby fornece um bom mecanismo para lidar com exceções. Colocamos o código que
poderia levantar uma exceção em um bloco de início / fim e usar cláusulas de
salvamento para dizer ao Ruby os tipos de exceções que queremos manipular.
Sintaxe
begin
# -
rescue OneTypeOfException
# -
rescue AnotherTypeOfException
# -
else
# Other exceptions
ensure
# Always will be executed
end
Tudo desde o início até o resgate é protegido. Se ocorrer uma exceção durante a
execução deste bloco de código, o controle é passado para o bloco entre resgate e fim .
Para cada cláusula de resgate no bloco de início , Ruby compara a exceção levantada
com cada um dos parâmetros, por sua vez. A correspondência será bem-sucedida se a
exceção nomeada na cláusula rescue for a mesma do tipo da exceção lançada
atualmente ou se for uma superclasse dessa exceção.
Em um evento em que uma exceção não corresponde a nenhum dos tipos de erro
especificados, podemos usar uma cláusula else após todas as cláusulas de resgate .
Exemplo
#!/usr/bin/ruby  Demonstração ao vivo
begin
file = open("/unexistant_file")
if file
puts "File opened successfully"
end
rescue
file = STDIN
end
print file, "==", STDIN, "\n"
Isso produzirá o seguinte resultado. Você pode ver que STDIN é substituído por arquivo
porque a abertura falhou.
#<IO:0xb7d16f84>==#<IO:0xb7d16f84>
Usando a declaração de repetição

Você pode capturar uma exceção usando resgate do bloco e, em seguida, usar
repetição declaração para executar começar bloco desde o início.
Sintaxe
begin
# Exceptions raised by this code will
# be caught by the following rescue clause
rescue
# This block will capture all types of exceptions
retry # This will move control to the beginning of begin
end
Exemplo
#!/usr/bin/ruby
begin
file = open("/unexistant_file")
if file
puts "File opened successfully"
end
rescue
fname = "existant_file"
retry
end
O seguinte é o fluxo do processo -
Uma exceção ocorreu em aberto.
Fui resgatar. fname foi reatribuído.
Por tentativa foi para o começo do começo.
Este arquivo de tempo é aberto com sucesso.
Continuou o processo essencial.

OBSERVAÇÃO - Observe que, se o arquivo de nome substituído novamente não existir,
este código de exemplo será repetido infinitamente. Tenha cuidado se você usar
novamente para um processo de exceção.
Usando declaração de aumento

Você pode usar o aumento declaração para gerar uma exceção. O método a seguir gera
uma exceção sempre que é chamado. Sua segunda mensagem será impressa.
Sintaxe
raise
OR
raise "Error Message"
OR
raise ExceptionType, "Error Message"
OR
raise ExceptionType, "Error Message" condition
O primeiro formulário simplesmente ressalta a exceção atual (ou um RuntimeError, se

não houver uma exceção atual). Isso é usado em manipuladores de exceção que
precisam interceptar uma exceção antes de transmiti-la.
O segundo formulário cria uma nova exceção RuntimeError , configurando sua

mensagem para a cadeia especificada. Esta exceção é então levantada a pilha de
chamadas.
A terceira forma usa o primeiro argumento para criar uma exceção e, em seguida,
define a mensagem associada ao segundo argumento.
A quarta forma é semelhante à terceira forma, mas você pode adicionar qualquer
instrução condicional como , a menos, para gerar uma exceção.
Exemplo
#!/usr/bin/ruby
begin
puts 'I am before the raise.'
raise 'An error has occurred.'
puts 'I am after the raise.'
rescue
puts 'I am rescued.'
end
puts 'I am after the begin block.'

I am before the raise.
I am rescued.
I am after the begin block.
Mais um exemplo mostrando o uso de aumento -

#!/usr/bin/ruby
begin
raise 'A test exception.'
rescue Exception => e
puts e.message
puts e.backtrace.inspect
end
A test exception.
["main.rb:4"]
Usando Assegurar Declaração

Às vezes, você precisa garantir que algum processamento seja feito no final de um
bloco de código, independentemente de uma exceção ter sido gerada. Por exemplo,
você pode ter um arquivo aberto na entrada do bloco e você precisa ter certeza de que
ele será fechado quando o bloco sair.
A cláusula de garantia faz exatamente isso. Certifique-se de que vai após a última
cláusula rescue e contém um pedaço de código que sempre será executado quando o
bloco terminar. Não importa se o bloco sai normalmente, se ele gera e resgata uma
exceção, ou se ele é terminado por uma exceção não identificada, o bloco de garantia
será executado.
Sintaxe
begin
#.. process
#..raise exception
rescue
#.. handle error
ensure
#.. finally ensure execution
#.. This will always execute.
end
Exemplo
begin
raise 'A test exception.'
puts e.message
ensure
puts "Ensuring execution"
end
A test exception.
["main.rb:4"]
Ensuring execution
Usando outra declaração

Se a cláusula else está presente, ela vai após as cláusulas de resgate e antes de
qualquer garantia .
O corpo de uma cláusula else é executado apenas se nenhuma exceção for levantada
pelo corpo principal do código.
Sintaxe
begin
#.. process
#..raise exception
rescue
# .. handle error
else
#.. executes if there is no exception
ensure
#.. finally ensure execution
#.. This will always execute.
end
Exemplo
begin
# raise 'A test exception.'
puts "I'm not raising exception"
puts e.message
else
puts "Congratulations-- no errors!"
ensure
puts "Ensuring execution"
end
I'm not raising exception

Congratulations-- no errors!
Ensuring execution
Mensagem de erro levantada pode ser capturada usando $! variável.

Pegar e jogar
Enquanto o mecanismo de exceção de raise e resgate é ótimo para abandonar a
execução quando as coisas dão errado, às vezes é bom poder saltar de alguma
construção profundamente aninhada durante o processamento normal. É aqui que o
catch e o throw são úteis.
A captura define um bloco rotulado com o nome fornecido (que pode ser um símbolo ou
uma string). O bloco é executado normalmente até que um lance seja encontrado.
Sintaxe
throw :lablename
#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end
OR
throw :lablename condition

#.. this will not be executed
catch :lablename do
#.. matching catch will be executed after a throw is encountered.
end
Exemplo
O exemplo a seguir usa um lance para encerrar a interação com o usuário se '!' é
digitado em resposta a qualquer solicitação.
def promptAndGet(prompt)
print prompt
res = readline.chomp
throw :quitRequested if res == "!"
return res
end
catch :quitRequested do
name = promptAndGet("Name: ")
age = promptAndGet("Age: ")
sex = promptAndGet("Sex: ")
# ..
# process information
end
promptAndGet("Name:")
Você deve experimentar o programa acima na sua máquina porque ele precisa de
interação manual. Isso produzirá o seguinte resultado -
Name: Ruby on Rails

Age: 3
Sex: !
Name:Just Ruby
Exceção de Classe
As classes e módulos padrão do Ruby geram exceções. Todas as classes de exceção
formam uma hierarquia, com a exceção de classe no topo. O próximo nível contém sete
tipos diferentes -
Interromper
NoMemoryError
SignalException
Erro de script
Erro padrão
SystemExit
Existe uma outra exceção nesse nível, Fatal , mas o interpretador Ruby só usa isso
internamente.
Tanto ScriptError quanto StandardError possuem várias subclasses, mas não

precisamos entrar nos detalhes aqui. O importante é que, se criarmos nossas próprias
classes de exceção, elas precisam ser subclasses de qualquer exceção de classe ou um
de seus descendentes.
Vamos ver um exemplo
class FileSaveError < StandardError

attr_reader :reason
def initialize(reason)
@reason = reason
end
end
Agora, veja o exemplo a seguir, que usará essa exceção -
File.open(path, "w") do |file|

begin
# Write out the data ...
rescue
# Something went wrong!
raise FileSaveError.new($!)
end
end
A linha importante aqui é aumentar FileSaveError.new ($!) . Chamamos raise para

sinalizar que ocorreu uma exceção, passando uma nova instância de FileSaveError, com
o motivo de essa exceção específica ter causado falha na gravação dos dados.
Ruby - Orientado a Objetos

Ruby é uma linguagem pura orientada a objetos e tudo parece para Ruby como um
objeto. Todo valor em Ruby é um objeto, até mesmo os mais primitivos: strings,
números e até true e false. Até mesmo uma classe em si é um objeto que é uma
instância da classe Class . Este capítulo irá levá-lo através de todas as principais
funcionalidades relacionadas ao Ruby Orientado a Objetos.
Uma classe é usada para especificar a forma de um objeto e combina representação de

dados e métodos para manipular esses dados em um pacote puro. Os dados e métodos
dentro de uma classe são chamados de membros da classe.
Definição de Classe Ruby

Quando você define uma classe, você define um blueprint para um tipo de dados. Isso
não define realmente nenhum dado, mas define o que o nome da classe significa, isto
é, em que um objeto da classe consistirá e quais operações podem ser executadas em
tal objeto.
Uma definição de classe começa com a classe de palavra-chave seguida pelo nome da
classe e é delimitada por um final . Por exemplo, definimos a classe Box usando a
classe de palavra-chave da seguinte maneira:
class Box
code
end
O nome deve começar com uma letra maiúscula e os nomes das convenções que
contêm mais de uma palavra são executados juntamente com cada palavra em
maiúscula e nenhum caractere separador (CamelCase).
Definir objetos Ruby

Uma classe fornece os blueprints para objetos, portanto, basicamente, um objeto é
criado a partir de uma classe. Nós declaramos objetos de uma classe usando uma nova
palavra-chave. As seguintes declarações declaram dois objetos da classe Box -
box1 = Box.new
box2 = Box.new
O método inicializar
O método initialize é um método de classe Ruby padrão e funciona quase da mesma
maneira que o construtor funciona em outras linguagens de programação orientadas a
objeto. O método initialize é útil quando você deseja inicializar algumas variáveis de
classe no momento da criação do objeto. Este método pode ter uma lista de parâmetros
e, como qualquer outro método ruby, seria precedido por uma palavra-chave def como
mostrado abaixo -
class Box
def initialize(w,h)
@width, @height = w, h
end
end
As variáveis da instância
As variáveis de instância são tipos de atributos de classe e tornam-se propriedades
de objetos depois que os objetos são criados usando a classe. Os atributos de cada
objeto são atribuídos individualmente e não compartilham nenhum valor com outros
objetos. Eles são acessados usando o operador @ dentro da classe, mas para acessá-
los fora da classe, usamos métodos públicos , que são chamados de métodos de
acesso . Se tomarmos a classe acima definido Box então @largura e @height são
variáveis de instância para a caixa de classe.
class Box
def initialize(w,h)
# assign instance variables
end
end
O acessador e setter Métodos

Para tornar as variáveis disponíveis fora da classe, elas devem ser definidas dentro dos
métodos de acesso , esses métodos de acesso também são conhecidos como
métodos getter. O exemplo a seguir mostra o uso de métodos de acesso -
#!/usr/bin/ruby -w
# define a class
class Box
# constructor method
def initialize(w,h)
end
# accessor methods
def printWidth
@width
end
def printHeight
@height
end
end
# create an object
box = Box.new(10, 20)
# use accessor methods

x = box.printWidth()
y = box.printHeight()
puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"
Quando o código acima é executado, produz o seguinte resultado -
Width of the box is : 10

Height of the box is : 20
Semelhante aos métodos de acesso, que são usados para acessar o valor das variáveis,
Ruby fornece uma maneira de definir os valores dessas variáveis de fora da classe
usando métodos setter , que são definidos abaixo -
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# accessor methods
def getWidth
@width
end
def getHeight
@height
end
# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end
end
# create an object
# use setter methods

box.setWidth = 30
box.setHeight = 50

x = box.getWidth()
y = box.getHeight()

Width of the box is : 30

Height of the box is : 50
Os métodos da instância
Os métodos de instância também são definidos da mesma forma que definimos
qualquer outro método usando a palavra-chave def e eles podem ser usados usando
uma instância de classe apenas como mostrado abaixo. Sua funcionalidade não se
limita a acessar as variáveis de instância, mas também podem fazer muito mais
conforme sua necessidade.
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# instance method
def getArea
@width * @height
end
end
# create an object
# call instance methods

a = box.getArea()
puts "Area of the box is : #{a}"
Area of the box is : 200
A classe Métodos e Variáveis

As variáveis de classe são uma variável, que é compartilhada entre todas as
instâncias de uma classe. Em outras palavras, há uma instância da variável e ela é
acessada por instâncias de objetos. As variáveis de classe são prefixadas com dois
caracteres @ (@@). Uma variável de classe deve ser inicializada dentro da definição de
classe, conforme mostrado abaixo.
Um método de classe é definido usando def self.methodname () , que termina com o

delimitador final e seria chamado usando o nome da classe como
classname.methodname, conforme mostrado no exemplo a seguir -
#!/usr/bin/ruby -w
class Box
# Initialize our class variables
@@count = 0
def initialize(w,h)
# assign instance avriables
@@count += 1
end
def self.printCount()
puts "Box count is : #@@count"
end
end
# create two object

box1 = Box.new(10, 20)
box2 = Box.new(30, 100)
# call class method to print box count

Box.printCount()
Box count is : 2
O método to_s
Qualquer classe que você definir deve ter um método de instância to_s para retornar
uma representação de string do objeto. A seguir, um exemplo simples para representar
um objeto Box em termos de largura e altura -
#!/usr/bin/ruby -w
class Box
def initialize(w,h)
end
# define to_s method
def to_s
"(w:#@width,h:#@height)" # string formatting of the object.
end
end
# create an object
# to_s method will be called in reference of string automatically.

puts "String representation of box is : #{box}"
String representation of box is : (w:10,h:20)
Controle de acesso
O Ruby oferece três níveis de proteção no nível de métodos da instância, que podem
ser públicos, privados ou protegidos . Ruby não aplica nenhum controle de acesso
sobre variáveis de instância e classe.
Métodos públicos - métodos públicos podem ser chamados por qualquer

pessoa. Os métodos são públicos por padrão, exceto para initialize, que é
sempre privado.
Métodos privados - os métodos privados não podem ser acessados nem

exibidos de fora da turma. Apenas os métodos de classe podem acessar
membros privados.
Métodos Protegidos - Um método protegido pode ser chamado apenas por

objetos da classe de definição e suas subclasses. O acesso é mantido dentro da
família.
A seguir, um exemplo simples para mostrar a sintaxe de todos os três modificadores de

acesso -
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# instance method by default it is public

def getArea
getWidth() * getHeight
end
# define private accessor methods

def getWidth
@width
end
def getHeight
@height
end
# make them private
private :getWidth, :getHeight
# instance method to print area

def printArea
@area = getWidth() * getHeight
puts "Big box area is : #@area"
end
# make it protected
protected :printArea
end
# create an object

a = box.getArea()
# try to call protected or methods

box.printArea()
Quando o código acima é executado, produz o seguinte resultado. Aqui, o primeiro

método é chamado com sucesso, mas o segundo método deu um problema.

test.rb:42: protected method `printArea' called for #
<Box:0xb7f11280 @height = 20, @width = 10> (NoMethodError)
Herança de Classe
Um dos conceitos mais importantes na programação orientada a objetos é o da
herança. A herança nos permite definir uma classe em termos de outra classe, o que
facilita a criação e manutenção de um aplicativo.
A herança também oferece uma oportunidade de reutilizar a funcionalidade do código e

o tempo de implementação rápido, mas infelizmente o Ruby não suporta vários níveis
de heranças, mas o Ruby suporta mixins . Um mixin é como uma implementação
especializada de herança múltipla, na qual apenas a parte da interface é herdada.
Ao criar uma classe, em vez de escrever membros de dados e funções de membro

completamente novos, o programador pode designar que a nova classe deve herdar os
membros de uma classe existente. Essa classe existente é chamada de classe base ou
superclasse , e a nova classe é referida como classe derivada ou subclasse .
Ruby também suporta o conceito de subclassificação, isto é, herança e o exemplo a

seguir explica o conceito. A sintaxe para estender uma classe é simples. Basta adicionar
um caractere <e o nome da superclasse ao seu comando de classe. Por exemplo, seguir
define uma classe BigBox como uma subclasse de Box -
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# instance method
def getArea
@width * @height
end
end
# define a subclass
class BigBox < Box
# add a new instance method

def printArea
@area = @width * @height
end
end
# create an object
box = BigBox.new(10, 20)
# print the area

box.printArea()
Big box area is : 200

Métodos Substituindo
Embora você possa adicionar nova funcionalidade em uma classe derivada, mas às
vezes você gostaria de alterar o comportamento do método já definido em uma classe
pai. Você pode fazer isso simplesmente mantendo o mesmo nome do método e
substituindo a funcionalidade do método, conforme mostrado abaixo no exemplo -
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# instance method
def getArea
@width * @height
end
end
# define a subclass
class BigBox < Box
# change existing getArea method as follows

def getArea
@area = @width * @height
end
end
# create an object
box = BigBox.new(10, 20)
# print the area using overriden method.

box.getArea()
Sobrecarga do Operador
Gostaríamos que o operador + realizasse a adição vetorial de dois objetos Box usando
+, o operador * para multiplicar uma largura e altura de caixa por um escalar e o
operador unário para negar a largura e a altura da caixa. Aqui está uma versão da
classe Box com operadores matemáticos definidos -
class Box
def initialize(w,h) # Initialize the width and height
@width,@height = w, h
end
def +(other) # Define + to do vector addition

Box.new(@width + other.width, @height + other.height)
end
def -@ # Define unary minus to negate width and height

Box.new(-@width, -@height)
end
def *(scalar) # To perform scalar multiplication

Box.new(@width*scalar, @height*scalar)
end
end
Objetos Congelados
Às vezes, queremos impedir que um objeto seja alterado. O método freeze em Object
nos permite fazer isso, transformando efetivamente um objeto em uma constante.
Qualquer objeto pode ser congelado chamando Object.freeze . Um objeto congelado
não pode ser modificado: você não pode alterar suas variáveis de instância.
Você pode verificar se um determinado objeto já está congelado ou não usando

Object.frozen? método, que retorna true caso o objeto esteja congelado, caso
contrário, um valor false é retornado. O exemplo a seguir apaga o conceito -
#!/usr/bin/ruby -w
# define a class
class Box
def initialize(w,h)
end
# accessor methods
def getWidth
@width
end
def getHeight
@height
end
# setter methods
def setWidth=(value)
@width = value
end
def setHeight=(value)
@height = value
end
end
# create an object
# let us freez this object

box.freeze
if( box.frozen? )
puts "Box object is frozen object"
else
puts "Box object is normal object"
end
# now try using setter methods

box.setWidth = 30
box.setHeight = 50

x = box.getWidth()
y = box.getHeight()
Box object is frozen object

test.rb:20:in `setWidth=': can't modify frozen object (TypeError)
from test.rb:39
Constantes de Classe
Você pode definir uma constante dentro de uma classe atribuindo um valor numérico ou
de seqüência direta a uma variável, que é definida sem usar @ ou @@. Por convenção,
nós mantemos nomes constantes em maiúsculas.
Uma vez que uma constante é definida, você não pode alterar seu valor, mas você pode
acessar uma constante diretamente dentro de uma classe como uma variável, mas se
você quiser acessar uma constante fora da classe, você deve usar classname ::
constant como mostrado o exemplo abaixo.
#!/usr/bin/ruby -w
# define a class
class Box
BOX_COMPANY = "TATA Inc"
BOXWEIGHT = 10
def initialize(w,h)
end
# instance method
def getArea
@width * @height
end
end
# create an object

a = box.getArea()
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

TATA Inc
Box weight is: 10
Constantes de classe são herdadas e podem ser substituídas como métodos de

instância.
Criar objeto usando alocar

Pode haver uma situação em que você deseja criar um objeto sem chamar seu
construtor de inicializar, ou seja, usando o novo método, nesse caso, você pode
chamar allocate , que criará um objeto não inicializado para você, como no exemplo a
seguir -
#!/usr/bin/ruby -w
# define a class
class Box
attr_accessor :width, :height
def initialize(w,h)
end
# instance method
def getArea
@width * @height
end
end
# create an object using new

box1 = Box.new(10, 20)
# create another object using allocate

box2 = Box.allocate
# call instance method using box1

a = box1.getArea()
# call instance method using box2

a = box2.getArea()

test.rb:14: warning: instance variable @width not initialized
test.rb:14: warning: instance variable @height not initialized
test.rb:14:in `getArea': undefined method `*'
for nil:NilClass (NoMethodError) from test.rb:29
Informações de Classe
Se as definições de classe são código executável, isso implica que elas sejam
executadas no contexto de algum objeto: self deve referenciar alguma coisa. Vamos
descobrir o que é isso.
#!/usr/bin/ruby -w
class Box
# print class information
puts "Type of self = #{self.type}"
puts "Name of self = #{self.name}"
end
Type of self = Class

Name of self = Box
Isso significa que uma definição de classe é executada com essa classe como o objeto
atual. Isso significa que os métodos na metaclasse e suas superclasses estarão
disponíveis durante a execução da definição do método.
Ruby - Expressões Regulares

Uma expressão regular é uma seqüência especial de caracteres que ajuda você a
encontrar ou encontrar outras strings ou conjuntos de strings usando uma sintaxe
especializada mantida em um padrão.
Um literal de expressão regular é um padrão entre barras ou entre delimitadores

arbitrários seguido por% r como segue -
Sintaxe
/pattern/
/pattern/im # option can be specified
%r!/usr/local! # general delimited regular expression
Exemplo
#!/usr/bin/ruby
line1 = "Cats are smarter than dogs";

line2 = "Dogs also like meat";
if ( line1 =~ /Cats(.*)/ )
puts "Line1 contains Cats"
end
if ( line2 =~ /Cats(.*)/ )
puts "Line2 contains Dogs"
end
Line1 contains Cats
Modificadores de Expressão Regular

Os literais de expressões regulares podem incluir um modificador opcional para
controlar vários aspectos da correspondência. O modificador é especificado após o
segundo caractere de barra, conforme mostrado anteriormente e pode ser representado
por um desses caracteres -
Sr. Modificador e Descrição

Não.
1 Eu
Ignora o caso ao corresponder ao texto.
2 Executa interpolações # {} apenas uma vez, a primeira vez que o literal

regexp é avaliado.
x
3
Ignora o espaço em branco e permite comentários em expressões regulares.
4 Corresponde a várias linhas, reconhecendo novas linhas como caracteres

normais.
u, e, s, n
Interpreta o regexp como Unicode (UTF-8), EUC, SJIS ou ASCII. Se nenhum

5
desses modificadores for especificado, presume-se que a expressão regular
use a codificação de origem.
Como os literais de string delimitados com% Q, Ruby permite que você inicie suas
expressões regulares com% r seguido por um delimitador de sua escolha. Isso é útil
quando o padrão que você está descrevendo contém muitos caracteres de barra que
você não quer escapar -
# Following matches a single slash character, no escape required

%r|/|
# Flag characters are allowed with this syntax, too

%r[</(.*)>]i
Padrões de Expressão Regular

Exceto pelos caracteres de controle, (+?. * ^ $ () [] {} | \) , Todos os caracteres são
compatíveis. Você pode escapar de um caractere de controle precedendo-o com uma
barra invertida.
A tabela a seguir lista a sintaxe da expressão regular disponível em Ruby.
Exemplos de Expressões Regulares

Personagens Literal
Classes de Personagem
Classes Especiais de Personagem
Casos de Repetição
Repetição não gananciosa
Agrupando com Parênteses
Voltar Referências
Alternativas
Âncoras
Sintaxe Especial com Parênteses
Pesquisar e substituir
Alguns dos métodos String mais importantes que usam expressões regulares são sub e
gsub e suas variantes in-loco sub! e gsub! .
Todos esses métodos executam uma operação de pesquisa e substituição usando um

padrão Regexp. O sub e sub! substitui a primeira ocorrência do padrão e gsub &
gsub! substitui todas as ocorrências.
O sub e o gsub retornam uma nova string, deixando o original não modificado onde
como sub! e gsub! Modifique a string na qual eles são chamados.
A seguir está o exemplo -

#!/usr/bin/ruby
phone = "2004-959-559 #This is Phone Number"
# Delete Ruby-style comments

phone = phone.sub!(/#.*$/, "")
puts "Phone Num : #{phone}"
# Remove anything other than digits

phone = phone.gsub!(/\D/, "")
puts "Phone Num : #{phone}"

Phone Num : 2004-959-559
Phone Num : 2004959559
A seguir, outro exemplo -

#!/usr/bin/ruby
text = "rails are rails, really good Ruby on Rails"
# Change "rails" to "Rails" throughout

text.gsub!("rails", "Rails")
# Capitalize the word "Rails" throughout

text.gsub!(/\brails\b/, "Rails")
puts "#{text}"
Rails are Rails, really good Ruby on Rails
Tutorial Ruby / DBI

Este capítulo ensina como acessar um banco de dados usando Ruby. O módulo Ruby
DBI fornece uma interface independente de banco de dados para scripts Ruby
semelhantes aos do módulo Perl DBI.
DBI significa Database Independent Interface for Ruby, o que significa que o DBI
fornece uma camada de abstração entre o código Ruby e o banco de dados subjacente,
permitindo que você mude as implementações do banco de dados com muita facilidade.
Ele define um conjunto de métodos, variáveis e convenções que fornecem uma
interface de banco de dados consistente, independente do banco de dados real que está
sendo usado.
DBI pode interagir com o seguinte -
ADO (ActiveX Data Objects)
DB2
Base Frontal
mSQL
MySQL
ODBC
Oráculo
OCI8 (Oracle)
PostgreSQL
Servidor proxy
SQLite
SQLRelay
Arquitetura de um aplicativo DBI
O DBI é independente de qualquer banco de dados disponível no backend. Você pode
usar o DBI se estiver trabalhando com Oracle, MySQL ou Informix, etc. Isso fica claro
no diagrama de arquitetura a seguir.
A arquitetura geral do Ruby DBI usa duas camadas -
A camada da interface do banco de dados (DBI). Essa camada é independente

de banco de dados e fornece um conjunto de métodos de acesso comuns que
são usados da mesma maneira, independentemente do tipo de servidor de
banco de dados com o qual você está se comunicando.
A camada do driver do banco de dados (DBD). Esta camada é dependente do

banco de dados; drivers diferentes fornecem acesso a diferentes mecanismos
de banco de dados. Existe um driver para o MySQL, outro para o PostgreSQL,
outro para o InterBase, outro para o Oracle e assim por diante. Cada driver
interpreta solicitações da camada DBI e as mapeia em solicitações apropriadas
para um determinado tipo de servidor de banco de dados.
Pré-requisitos
Se você quiser escrever scripts Ruby para acessar bancos de dados MySQL, você
precisará ter o módulo Ruby MySQL instalado.
Este módulo funciona como um DBD, conforme explicado acima, e pode ser baixado em
https://www.tmtm.org/en/mysql/ruby/
Obtendo e instalando Ruby / DBI

Você pode baixar e instalar o módulo Ruby DBI no seguinte local -
https://imgur.com/NFEuWe4/embed
Antes de iniciar esta instalação, certifique-se de ter o privilégio de root. Agora, siga os
passos abaixo -
Passo 1
$ tar zxf dbi-0.2.0.tar.gz
Passo 2
Vá no diretório de distribuição dbi-0.2.0 nd configure-o usando o script setup.rb nesse
diretório. O comando de configuração mais geral se parece com isso, sem argumentos
após o argumento de configuração. Este comando configura a distribuição para instalar
todos os drivers por padrão.
$ ruby setup.rb config
Para ser mais específico, forneça uma opção --with que lista as partes específicas da
distribuição que você deseja usar. Por exemplo, para configurar apenas o módulo DBI
principal e o driver do nível DBD do MySQL, emita o seguinte comando -
$ ruby setup.rb config --with = dbi,dbd_mysql
etapa 3
O passo final é construir o driver e instalá-lo usando os seguintes comandos -
$ ruby setup.rb setup

$ ruby setup.rb install
Conexão de banco de dados

Supondo que vamos trabalhar com banco de dados MySQL, antes de conectar a um
banco de dados, certifique-se do seguinte -
Você criou um banco de dados TESTDB.
Você criou EMPLOYEE no TESTDB.
Esta tabela tem os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.
O ID do usuário "testuser" e a senha "test123" estão configurados para acessar

o TESTDB.
Ruby Module DBI está instalado corretamente em sua máquina.
Você passou pelo tutorial do MySQL para entender o MySQL Basics.
A seguir, o exemplo de conexão com o banco de dados MySQL "TESTDB"
#!/usr/bin/ruby -w
require "dbi"
begin
# connect to the MySQL server
dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
# get server version string and display it
row = dbh.select_one("SELECT VERSION()")
puts "Server version: " + row[0]
rescue DBI::DatabaseError => e
puts "An error occurred"
puts "Error code: #{e.err}"
puts "Error message: #{e.errstr}"
ensure
# disconnect from server
dbh.disconnect if dbh
end
Ao executar este script, ele produz o seguinte resultado em nossa máquina Linux.
Server version: 5.0.45
Se uma conexão for estabelecida com a fonte de dados, um Database Handle será
retornado e salvo em dbh para uso posterior. Caso contrário, o dbh será definido como
valor nulo e o código de erro de retorno e.err e e :: errstr e uma string de erro
respectivamente.
Finalmente, antes de sair, assegure-se de que a conexão com o banco de dados esteja
fechada e os recursos sejam liberados.
Operação INSERIR
A operação INSERT é necessária quando você deseja criar seus registros em uma tabela
de banco de dados.
Uma vez que uma conexão de dados é estabelecida, estamos prontos para criar tabelas
ou registros nas tabelas de banco de dados usando fazer método ou preparar e
executar método.
Usando do Statement
Instruções que não retornam linhas podem ser emitidas invocando o método do
identificador do banco de dados. Esse método usa um argumento de string de instrução
e retorna uma contagem do número de linhas afetadas pela instrução.
dbh.do("DROP TABLE IF EXISTS EMPLOYEE")

dbh.do("CREATE TABLE EMPLOYEE (
FIRST_NAME CHAR(20) NOT NULL,
LAST_NAME CHAR(20),
AGE INT,
SEX CHAR(1),
INCOME FLOAT )" );
Da mesma forma, você pode executar a instrução SQL INSERT para criar um registro
na tabela EMPLOYEE.
#!/usr/bin/ruby -w
require "dbi"
begin
dbh.do( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES ('Mac', 'Mohan', 20, 'M', 2000)" )
puts "Record has been created"
dbh.commit
dbh.rollback
ensure
end
Usando preparar e executar

Você pode usar preparar e executar métodos da classe DBI para executar a instrução
SQL através do código Ruby.
Criação de registro leva as seguintes etapas -
Preparando a instrução SQL com a instrução INSERT. Isso será feito usando o
método prepare .
Executando consulta SQL para selecionar todos os resultados do banco de

dados. Isso será feito usando o método de execução .
Liberando o comando da instrução. Isso será feito usando a API de

acabamento
Se tudo correr bem, confirme essa operação, caso contrário, você poderá
reverter a transação completa.
A seguir está a sintaxe para usar esses dois métodos -
sth = dbh.prepare(statement)
sth.execute
... zero or more SQL operations ...
sth.finish
Esses dois métodos podem ser usados para transmitir valores de ligação para
instruções SQL. Pode haver um caso em que os valores a serem inseridos não sejam
dados antecipadamente. Nesse caso, os valores de ligação são usados. Um ponto de
interrogação ( ? ) É usado no lugar dos valores reais e, em seguida, os valores reais
são passados pela API execute ().
A seguir, o exemplo para criar dois registros na tabela EMPLOYEE -
#!/usr/bin/ruby -w
require "dbi"
begin
sth = dbh.prepare( "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
VALUES (?, ?, ?, ?, ?)" )
sth.execute('John', 'Poul', 25, 'M', 2300)
sth.execute('Zara', 'Ali', 17, 'F', 1000)
sth.finish
dbh.commit
puts "Record has been created"
dbh.rollback
ensure
end
Se houver vários INSERTs por vez, preparar uma instrução primeiro e, em seguida,
executá-la várias vezes em um loop é mais eficiente do que invocar cada vez durante o
loop.
Operação de LEITURA
LEITURA Operação em qualquer banco de dados significa buscar algumas informações
úteis do banco de dados.
Uma vez estabelecida a nossa conexão com o banco de dados, estamos prontos para
fazer uma consulta neste banco de dados. Podemos usar tanto fazer método ou
preparar e executar métodos para buscar valores de uma tabela de banco de dados.
A obtenção de registros leva as seguintes etapas -
Preparando a consulta SQL com base nas condições necessárias. Isso será feito
usando o método prepare .

Buscando todos os resultados um por um e imprimindo esses resultados. Isso

será feito usando o método fetch .
Liberando o comando da instrução. Isso será feito usando o método de

acabamento .
A seguir, o procedimento para consultar todos os registros da tabela EMPLOYEE com

salário maior que 1000.
#!/usr/bin/ruby -w
require "dbi"
begin
sth = dbh.prepare("SELECT * FROM EMPLOYEE WHERE INCOME > ?")
sth.execute(1000)
sth.fetch do |row|
printf "First Name: %s, Last Name : %s\n", row[0], row[1]
printf "Age: %d, Sex : %s\n", row[2], row[3]
printf "Salary :%d \n\n", row[4]
end
sth.finish
ensure
end
First Name: Mac, Last Name : Mohan

Age: 20, Sex : M
Salary :2000
First Name: John, Last Name : Poul

Age: 25, Sex : M
Salary :2300
Existem mais métodos de atalho para buscar registros do banco de dados. Se você
estiver interessado, então vá até Buscar o Resultado. Caso contrário, vá para a
próxima seção.
Operação de atualização
ATUALIZAÇÃO Operação em qualquer banco de dados significa atualizar um ou mais
registros, que já estão disponíveis no banco de dados. A seguir, o procedimento para
atualizar todos os registros que possuem SEX como 'M'. Aqui, nós aumentaremos AGE
de todos os machos em um ano. Isso levará três etapas -


acabamento .
Se tudo correr bem, submeta essa operação, caso contrário, você poderá
#!/usr/bin/ruby -w
require "dbi"
begin
sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
sth.execute('M')
sth.finish
dbh.commit
dbh.rollback
ensure
end
Operação DELETE
A operação DELETE é necessária quando você deseja excluir alguns registros do banco
de dados. A seguir, o procedimento para excluir todos os registros do EMPLOYEE, nos
quais a idade é superior a 20. Essa operação seguirá as etapas a seguir.
Executando a consulta SQL para excluir registros necessários do banco de


acabamento .
Se tudo correr bem, submeta essa operação, caso contrário, você poderá
#!/usr/bin/ruby -w
require "dbi"
begin
sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
sth.execute(20)
sth.finish
dbh.commit
dbh.rollback
ensure
end
Executando Transações
As transações são um mecanismo que garante a consistência dos dados. As transações
devem ter as quatro propriedades a seguir -
Atomicidade - Uma transação é concluída ou nada acontece.
Consistência - Uma transação deve começar em um estado consistente e

deixar o sistema com um estado consistente.
Isolamento - Resultados intermediários de uma transação não são visíveis fora
da transação atual.
Durabilidade - Uma vez que uma transação foi confirmada, os efeitos são
persistentes, mesmo após uma falha no sistema.
O DBI fornece dois métodos para confirmar ou reverter uma transação. Há mais um
método chamado transação, que pode ser usado para implementar transações. Existem
duas abordagens simples para implementar transações -
Abordagem I
A primeira abordagem usa os métodos de confirmação e reversão do DBI para
confirmar ou cancelar explicitamente a transação -
dbh['AutoCommit'] = false # Set auto commit to false.

begin
dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
dbh.commit
rescue
puts "transaction failed"
dbh.rollback
end
dbh['AutoCommit'] = true
Abordagem II
A segunda abordagem usa o método de transação . Isso é mais simples, porque é
necessário um bloco de códigos contendo as instruções que compõem a transação. O
método de transação executa o bloco e invoca commit ou rollback automaticamente,
dependendo se o bloco é bem-sucedido ou falha -
dbh['AutoCommit'] = false # Set auto commit to false.

dbh.transaction do |dbh|
dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'John'")
dbh.do("UPDATE EMPLOYEE SET AGE = AGE+1 WHERE FIRST_NAME = 'Zara'")
end
dbh['AutoCommit'] = true
Operação COMMIT
Commit é a operação, que dá um sinal verde ao banco de dados para finalizar as
mudanças e, após essa operação, nenhuma alteração pode ser revertida.
Aqui está um exemplo simples para chamar o método commit .
dbh.commit
Operação ROLLBACK
Se você não estiver satisfeito com uma ou mais das alterações e quiser reverter essas
alterações completamente, use o método de reversão .
Aqui está um exemplo simples para chamar o método de reversão .
dbh.rollback
Desconectando banco de dados

Para desconectar a conexão com o banco de dados, use a API de desconexão.
dbh.disconnect
Se a conexão com um banco de dados for fechada pelo usuário com o método de
desconexão, todas as transações pendentes serão revertidas pelo DBI. No entanto, em
vez de depender de qualquer um dos detalhes de implementação do DBI, seria melhor
que seu aplicativo chamasse o commit ou o rollback explicitamente.
Manipulando Erros
Existem muitas fontes de erros. Alguns exemplos são um erro de sintaxe em uma
instrução SQL executada, uma falha de conexão ou a chamada do método de busca
para um identificador de instrução já cancelado ou concluído.
Se um método DBI falhar, o DBI levantará uma exceção. Os métodos DBI podem gerar
vários tipos de exceção, mas as duas classes de exceção mais importantes são DBI ::
InterfaceError e DBI :: DatabaseError .
Objetos de exceção dessas classes têm três atributos chamados err , errstr e state ,
que representam o número do erro, uma cadeia de erro descritiva e um código de erro
padrão. Os atributos são explicados abaixo -
err - Retorna uma representação de número inteiro do erro ocorrido ou nil se

isto não for suportado pelo DBD. O DBD do Oracle, por exemplo, retorna a parte
numérica de uma mensagem de erro ORA-XXXX .
errstr - Retorna uma representação de string do erro ocorrido.
state - Retorna o código SQLSTATE do erro ocorrido. O SQLSTATE é uma string

de cinco caracteres. A maioria dos DBDs não suporta isso e retorna nil.
Você viu o seguinte código acima na maioria dos exemplos -

dbh.rollback
ensure
end
Para obter informações de depuração sobre o que seu script está fazendo enquanto ele
é executado, você pode ativar o rastreamento. Para fazer isso, você deve primeiro
carregar o módulo dbi / trace e, em seguida, chamar o método de rastreio que controla
o modo de rastreio e o destino de saída -
require "dbi/trace"
..............
trace(mode, destination)
O valor do modo pode ser 0 (desligado), 1, 2 ou 3 e o destino deve ser um objeto IO.
Os valores padrão são 2 e STDERR, respectivamente.
Blocos de código com métodos

Existem alguns métodos que criam alças. Esses métodos podem ser chamados com um
bloco de códigos. A vantagem de usar o bloco de códigos junto com métodos é que eles
fornecem o identificador para o bloco de código como seu parâmetro e
automaticamente limpa o identificador quando o bloco termina. Existem alguns
exemplos para entender o conceito.
DBI.connect - Esse método gera um identificador de banco de dados e é

recomendável chamar a desconexão no final do bloco para desconectar o banco
de dados.
dbh.prepare - Esse método gera um identificador de instrução e é

recomendável concluir no final do bloco. Dentro do bloco, você deve invocar
executar método para executar a instrução.
dbh.execute - Este método é semelhante, exceto que não precisamos invocar

a execução dentro do bloco. O identificador de instrução é executado
automaticamente.
Exemplo 1
O DBI.connect pode pegar um bloco de código, passar o identificador do banco de
dados para ele e desconectar automaticamente o identificador no final do bloco da
seguinte maneira.
dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") do |dbh|
Exemplo 2
O dbh.prepare pode pegar um bloco de código, passar o identificador de instrução
para ele e as chamadas automaticamente terminam no final do bloco da seguinte
maneira.
dbh.prepare("SHOW DATABASES") do |sth|

sth.execute
puts "Databases: " + sth.fetch_all.join(", ")
end
Exemplo 3
O dbh.execute pode pegar um bloco de código, passar o identificador de instrução
para ele e as chamadas automaticamente terminam no final do bloco da seguinte
maneira -
dbh.execute("SHOW DATABASES") do |sth|

puts "Databases: " + sth.fetch_all.join(", ")
end
O método de transação DBI também aceita um bloco de código que foi descrito acima.
Funções e Atributos Específicos do Driver

O DBI permite que os drivers de banco de dados forneçam funções adicionais
específicas do banco de dados, que podem ser chamadas pelo usuário através do
método func de qualquer objeto Handle.
Atributos específicos do driver são suportados e podem ser configurados ou obtidos

usando os métodos [] = ou [] .
DBD :: Mysql implementa as seguintes funções específicas do driver -
Exemplo
#!/usr/bin/ruby
require "dbi"
begin
puts dbh.func(:client_info)
puts dbh.func(:client_version)
puts dbh.func(:host_info)
puts dbh.func(:proto_info)
puts dbh.func(:server_info)
puts dbh.func(:thread_id)
puts dbh.func(:stat)
ensure
end
5.0.45
50045
Localhost via UNIX socket
10
5.0.45
150621
Uptime: 384981 Threads: 1 Questions: 1101078 Slow queries: 4 \
Opens: 324 Flush tables: 1 Open tables: 64 \
Queries per second avg: 2.860
Ruby Web Applications - Programação CGI

Ruby é uma linguagem de propósito geral; ele não pode ser chamado de linguagem da
web . Mesmo assim, aplicações web e ferramentas web em geral estão entre os usos
mais comuns do Ruby.
Não só você pode escrever seu próprio servidor SMTP, daemon FTP ou servidor Web em
Ruby, mas você também pode usar Ruby para tarefas mais usuais, como programação
CGI ou como um substituto para PHP.
Por favor, passe alguns minutos com o Tutorial de Programação CGI para mais
detalhes sobre a programação CGI.
Escrevendo Scripts CGI

O script CGI mais básico se parece com isso -
#!/usr/bin/ruby
puts "HTTP/1.0 200 OK"

puts "Content-type: text/html\n\n"
puts "<html><body>This is a test</body></html>"
Se você chamar esse script de test.cgi e carregá -lo em um provedor de hospedagem

baseado em Unix com as permissões corretas, poderá usá-lo como um script CGI.
Por exemplo, se você tiver o site https://www.example.com/ hospedado em um

provedor de hospedagem Web Linux e carregar o arquivo test.cgi para o diretório
principal e conceder permissões de execução, visite https: // www.
example.com/test.cgi deve retornar uma página HTML dizendo Isto é um teste .
Aqui quando test.cgi é solicitado de um navegador da Web, o servidor Web procura por
test.cgi no site e, em seguida, o executa usando o interpretador Ruby. O script Ruby
retorna um cabeçalho HTTP básico e retorna um documento HTML básico.
Usando cgi.rb
O Ruby vem com uma biblioteca especial chamada cgi que permite interações mais
sofisticadas do que aquelas com o script CGI anterior.
Vamos criar um script CGI básico que usa cgi -

#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
puts cgi.header
puts "<html><body>This is a test</body></html>"
Aqui, você criou um objeto CGI e usou-o para imprimir a linha de cabeçalho para você.
Processamento de Formulários
Usando a classe CGI, você tem acesso aos parâmetros de consulta HTML de duas
maneiras. Suponha que recebamos uma URL de /cgi-bin/test.cgi?FirstName = Zara &
LastName = Ali.
Você pode acessar os parâmetros FirstName e LastName usando CGI # [] diretamente

como segue -
#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
cgi['FirstName'] # => ["Zara"]
cgi['LastName'] # => ["Ali"]
Existe outra maneira de acessar essas variáveis de formulário. Este código lhe dará um
hash de todas as chaves e valores -
#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
h = cgi.params # => {"FirstName"=>["Zara"],"LastName"=>["Ali"]}
h['FirstName'] # => ["Zara"]
h['LastName'] # => ["Ali"]
A seguir está o código para recuperar todas as chaves -
#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
cgi.keys # => ["FirstName", "LastName"]
Se um formulário contiver vários campos com o mesmo nome, os valores

correspondentes serão retornados ao script como uma matriz. O acessador [] retorna
apenas o primeiro destes.index o resultado do método params para obtê-los todos.
Neste exemplo, suponha que o formulário tenha três campos chamados "nome" e
inserimos três nomes "Zara", "Huma" e "Nuha" -
#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
cgi['name'] # => "Zara"
cgi.params['name'] # => ["Zara", "Huma", "Nuha"]
cgi.keys # => ["name"]
cgi.params # => {"name"=>["Zara", "Huma", "Nuha"]}
Nota - Ruby cuidará dos métodos GET e POST automaticamente. Não há tratamento
separado para esses dois métodos diferentes.
Um formulário associado, mas básico, que poderia enviar os dados corretos teria o
código HTML como assim -
<html>
<body>
<form method = "POST" action = "http://www.example.com/test.cgi">
First Name :<input type = "text" name = "FirstName" value = "" />
<br />
Last Name :<input type = "text" name = "LastName" value = "" />
<input type = "submit" value = "Submit Data" />
</form>
</body>
</html>
Criando Formulários e HTML

CGI contém um grande número de métodos usados para criar HTML. Você encontrará
um método por tag. Para habilitar esses métodos, você deve criar um objeto CGI
chamando CGI.new.
Para facilitar o aninhamento de tags, esses métodos usam seu conteúdo como blocos
de código. Os blocos de código devem retornar uma String , que será usada como
conteúdo da tag. Por exemplo -
#!/usr/bin/ruby
require "cgi"
cgi = CGI.new("html4")
cgi.out {
cgi.html {
cgi.head { "\n"+cgi.title{"This Is a Test"} } +
cgi.body { "\n"+
cgi.form {"\n"+
cgi.hr +
cgi.h1 { "A Form: " } + "\n"+
cgi.textarea("get_text") +"\n"+
cgi.br +
cgi.submit
}
}
}
}
OBSERVAÇÃO : o método de formulário da classe CGI pode aceitar um parâmetro de

método, que definirá o método HTTP (GET, POST, etc.) a ser usado no envio de
formulários. O padrão usado neste exemplo é o POST.
Content-Type: text/html
Content-Length: 302
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Final//EN">
<HTML>
<HEAD>
<TITLE>This Is a Test</TITLE>
</HEAD>
<BODY>
<FORM METHOD = "post" ENCTYPE = "application/x-www-form-urlencoded">
<HR>
<H1>A Form: </H1>
<TEXTAREA COLS = "70" NAME = "get_text" ROWS = "10"></TEXTAREA>
<BR>
<INPUT TYPE = "submit">
</FORM>
</BODY>
</HTML>
Citando cordas
Ao lidar com URLs e código HTML, você deve ter cuidado ao citar certos caracteres. Por
exemplo, um caractere de barra (/) tem um significado especial em um URL, portanto,
ele deve ser de escape se não fizer parte do nome do caminho.
Por exemplo, qualquer / na parte de consulta da URL será traduzida para a string% 2F e
deverá ser traduzida de volta para a / para você usá-la. Espaço e e comercial também
são caracteres especiais. Para lidar com isso, o CGI fornece as rotinas CGI.escape e
CGI.unescape .
#!/usr/bin/ruby
require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")
Zara+Ali%2FA Sweet+%26+Sour+Girl")
#!/usr/bin/ruby
require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')
<h1>Zara Ali/A Sweet & Sour Girl</h1>'
Métodos úteis na classe CGI

Aqui está a lista de métodos relacionados à classe CGI -
O CGI do Ruby - Métodos relacionados à biblioteca CGI padrão.
Cookies e Sessões
Nós explicamos esses dois conceitos em diferentes seções. Por favor, siga as seções -
Os cookies CGI do Ruby - Como lidar com cookies CGI.
The Ruby CGI Sessions - Como gerenciar sessões CGI.
Servidores Web Hosting

Você pode verificar o seguinte tópico na Internet para hospedar seu site em um
servidor baseado em Unix -
Hospedagem na Web baseada em Unix
Enviando e-mail usando Ruby - SMTP

O SMTP (Simple Mail Transfer Protocol) é um protocolo que manipula o envio de email e
o roteamento de email entre servidores de email.
Ruby fornece a classe Net :: SMTP para conexão do lado do cliente SMTP (Simple Mail
Transfer Protocol) e fornece dois métodos de classe new e start .
O novo leva dois parâmetros -
O nome do servidor padrão para localhost.
O número da porta padrão para a porta bem conhecida 25.
O método start pega esses parâmetros -
O servidor - nome do IP do servidor SMTP, padronizando para localhost.
A porta - Número da porta, com o padrão de 25.
O domínio - Domínio do remetente do email, padronizado como ENV

["HOSTNAME"].
A conta - nome de usuário, o padrão é nulo.
A senha - senha do usuário, cujo valor é nulo.
O authtype - Tipo de Autorização, padronizando a cram_md5 .
Um objeto SMTP tem um método de instância chamado sendmail, que normalmente

será usado para fazer o trabalho de enviar uma mensagem. Leva três parâmetros -
A fonte - Uma string ou array ou qualquer coisa com um iterador de cada um

retornando uma string de cada vez.
O remetente - Uma string que aparecerá no campo from do email.
Os destinatários - Uma string ou uma matriz de strings representando o (s)

destinatário (s) do destinatário.
Exemplo
Aqui está uma maneira simples de enviar um email usando o script Ruby. Tente uma
vez -
require 'net/smtp'
message = <<MESSAGE_END
From: Private Person <me@fromdomain.com>
To: A Test User <test@todomain.com>
Subject: SMTP e-mail test
This is a test e-mail message.

MESSAGE_END
Net::SMTP.start('localhost') do |smtp|
smtp.send_message message, 'me@fromdomain.com', 'test@todomain.com'
end
Aqui, você colocou um e-mail básico na mensagem, usando um documento, tomando o

cuidado de formatar os cabeçalhos corretamente. Os e-mails exigem um cabeçalho De ,
Para e Assunto , separados do corpo do e-mail com uma linha em branco.
Para enviar o e-mail, use Net :: SMTP para conectar-se ao servidor SMTP na máquina
local e use o método send_message junto com a mensagem, o endereço de e o
endereço de destino como parâmetros (embora os endereços de e para sejam dentro
do próprio e-mail, eles nem sempre são usados para rotear e-mail).
Se você não estiver executando um servidor SMTP em sua máquina, poderá usar o Net
:: SMTP para se comunicar com um servidor SMTP remoto. A menos que você esteja
usando um serviço de webmail (como o Hotmail ou o Yahoo! Mail), seu provedor de e-
mail fornecerá os detalhes do servidor de e-mail de saída que você pode fornecer para
o Net :: SMTP, da seguinte maneira -
Net::SMTP.start('mail.your-domain.com')
Essa linha de código se conecta ao servidor SMTP na porta 25 de mail.seudominio.com

sem usar nenhum nome de usuário ou senha. Se você precisar, no entanto, você pode
especificar o número da porta e outros detalhes. Por exemplo -
Net::SMTP.start('mail.your-domain.com',
25,
'localhost',
'username', 'password' :plain)
Este exemplo se conecta ao servidor SMTP em mail.seudominio.com usando um nome

de usuário e senha em formato de texto simples. Identifica o nome do host do cliente
como localhost.
Enviando um email em HTML usando o Ruby

Quando você envia uma mensagem de texto usando Ruby, todo o conteúdo será
tratado como texto simples. Mesmo se você incluir tags HTML em uma mensagem de
texto, ela será exibida como texto simples e as tags HTML não serão formatadas de
acordo com a sintaxe HTML. Mas Ruby Net :: SMTP fornece opção para enviar uma
mensagem HTML como mensagem HTML real.
Ao enviar uma mensagem de e-mail, você pode especificar uma versão Mime, um tipo
de conteúdo e um conjunto de caracteres para enviar um e-mail em HTML.
Exemplo
A seguir, o exemplo para enviar conteúdo HTML como um email. Tente uma vez -
require 'net/smtp'
message = <<MESSAGE_END
From: Private Person <me@fromdomain.com>
To: A Test User <test@todomain.com>
MIME-Version: 1.0
Content-type: text/html
Subject: SMTP e-mail test
This is an e-mail message to be sent in HTML format
<b>This is HTML message.</b>

<h1>This is headline.</h1>
MESSAGE_END
smtp.send_message message, 'me@fromdomain.com', 'test@todomain.com'
end
Enviando anexos como um email

Para enviar um e-mail com conteúdo misto, é necessário definir o cabeçalho do tipo de
conteúdo como multipartido / misto . Em seguida, as seções de texto e anexo
podem ser especificadas dentro dos limites .
Um limite é iniciado com dois hífens seguidos por um número exclusivo, que não pode
aparecer na parte da mensagem do email. Um limite final indicando a seção final do e-
mail também deve terminar com dois hífens.
Arquivos anexados devem ser codificados com a função pack ("m") para ter a
codificação base64 antes da transmissão.
Exemplo
A seguir está o exemplo, que enviará um arquivo /tmp/test.txt como anexo.
require 'net/smtp'
filename = "/tmp/test.txt"
# Read a file and encode it into base64 format
filecontent = File.read(filename)
encodedcontent = [filecontent].pack("m") # base64
marker = "AUNIQUEMARKER"
body = <<EOF
This is a test email to send an attachement.
EOF
# Define the main headers.
part1 = <<EOF
From: Private Person <me@fromdomain.net>
To: A Test User <test@todmain.com>
Subject: Sending Attachement
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary = #{marker}
--#{marker}
EOF
# Define the message action

part2 = <<EOF
Content-Type: text/plain
Content-Transfer-Encoding:8bit
#{body}
--#{marker}
EOF
# Define the attachment section

part3 = <<EOF
Content-Type: multipart/mixed; name = \"#{filename}\"
Content-Transfer-Encoding:base64
Content-Disposition: attachment; filename = "#{filename}"
#{encodedcontent}
--#{marker}--
EOF
mailtext = part1 + part2 + part3
# Let's put our code in safe area

begin
smtp.sendmail(mailtext, 'me@fromdomain.net', ['test@todmain.com'])
end
print "Exception occured: " + e
end
NOTA - Você pode especificar vários destinos dentro da matriz, mas eles devem ser
separados por vírgula.
Ruby - programação de soquete

O Ruby fornece dois níveis de acesso aos serviços de rede. Em um nível baixo, você
pode acessar o suporte a soquete básico no sistema operacional subjacente, o que
permite implementar clientes e servidores para protocolos orientados a conexão e sem
conexão.
O Ruby também possui bibliotecas que fornecem acesso de nível superior a protocolos
de rede específicos no nível do aplicativo, como FTP, HTTP e assim por diante.
Este capítulo dá-lhe uma compreensão sobre o conceito mais famoso em Networking -
Socket Programming.
O que são soquetes?

Soquetes são os pontos finais de um canal de comunicação bidirecional. Soquetes
podem se comunicar dentro de um processo, entre processos na mesma máquina ou
entre processos em diferentes continentes.
Os soquetes podem ser implementados em vários tipos de canais diferentes: soquetes

de domínio Unix, TCP, UDP e assim por diante. O soquete fornece classes específicas
para manipular os transportes comuns, bem como uma interface genérica para lidar
com o restante.
Soquetes tem seu próprio vocabulário -
Sr. Termo e Descrição

Não.
domínio
1 A família de protocolos que será usada como mecanismo de transporte. Esses

valores são constantes, como PF_INET, PF_UNIX, PF_X25 e assim por diante.
tipo
O tipo de comunicação entre os dois pontos de extremidade, geralmente

2
SOCK_STREAM para protocolos orientados a conexão e SOCK_DGRAM para
protocolos sem conexão.
protocolo
3 Normalmente zero, isso pode ser usado para identificar uma variante de um
protocolo dentro de um domínio e tipo.
nome de anfitrião
O identificador de uma interface de rede -
Uma string, que pode ser um nome de host, um endereço com quatro pontos
ou um endereço IPV6 na notação de dois-pontos (e possivelmente ponto)
4
Uma string "<broadcast>", que especifica um endereço INADDR_BROADCAST.
Uma cadeia de comprimento zero, que especifica INADDR_ANY ou
Um Integer, interpretado como um endereço binário na ordem de bytes do

host.
porta
Cada servidor escuta os clientes que ligam em uma ou mais portas. Uma porta
5
pode ser um número de porta Fixnum, uma cadeia contendo um número de
porta ou o nome de um serviço.
Um cliente simples
Aqui vamos escrever um programa cliente muito simples, que abrirá uma conexão com
uma determinada porta e um determinado host. A classe Ruby TCPSocket fornece uma
função aberta para abrir um desses soquetes.
O TCPSocket.open (hosname, port) abre uma conexão TCP para o hostname na

porta .
Depois de ter um soquete aberto, você pode ler como qualquer outro objeto de IO.
Quando terminar, lembre-se de fechá-lo, pois você fecharia um arquivo.
O código a seguir é um cliente muito simples que se conecta a um determinado host e

porta, lê qualquer dado disponível do soquete e sai -
require 'socket' # Sockets are in standard library
hostname = 'localhost'
port = 2000
s = TCPSocket.open(hostname, port)
while line = s.gets # Read lines from the socket

puts line.chop # And print with platform line terminator
end
s.close # Close the socket when done
Um servidor simples
Para gravar servidores da Internet, usamos a classe TCPServer . Um objeto TCPServer
é uma fábrica para objetos TCPSocket.
Agora, chame TCPServer.open (hostname, port function para especificar uma porta
para seu serviço e criar um objeto TCPServer .
Em seguida, chamar a aceitar método do objeto TCPServer retornado. Esse método

aguarda até que um cliente se conecte à porta especificada e, em seguida, retorna um
objeto TCPSocket que representa a conexão com esse cliente.
require 'socket' # Get sockets from stdlib
server = TCPServer.open(2000) # Socket to listen on port 2000

loop { # Servers run forever
client = server.accept # Wait for a client to connect
client.puts(Time.now.ctime) # Send the time to the client
client.puts "Closing the connection. Bye!"
client.close # Disconnect from the client
}
Agora, execute este servidor em segundo plano e, em seguida, execute o cliente acima
para ver o resultado.
Servidores TCP Multi-Client

A maioria dos servidores na Internet é projetada para lidar com um grande número de
clientes a qualquer momento.
A classe Thread de Ruby facilita a criação de um servidor multithread.one que aceita

solicitações e cria imediatamente um novo thread de execução para processar a
conexão enquanto permite que o programa principal aguarde mais conexões -
require 'socket' # Get sockets from stdlib
server = TCPServer.open(2000) # Socket to listen on port 2000

loop { # Servers run forever
Thread.start(server.accept) do |client|
client.puts(Time.now.ctime) # Send the time to the client
client.puts "Closing the connection. Bye!"
client.close # Disconnect from the client
end
}
Neste exemplo, você tem um loop permanente e, quando server.accept responde, um

novo thread é criado e iniciado imediatamente para manipular a conexão que acaba de
ser aceita, usando o objeto de conexão passado para o thread. No entanto, o programa
principal retorna imediatamente e aguarda novas conexões.
Usar Ruby Thread dessa maneira significa que o código é portátil e será executado da
mesma maneira no Linux, OS X e Windows.
Um pequeno navegador da web

Podemos usar a biblioteca de soquetes para implementar qualquer protocolo da
Internet. Aqui, por exemplo, é um código para buscar o conteúdo de uma página da
web -
require 'socket'
host = 'www.tutorialspoint.com' # The web server

port = 80 # Default HTTP port
path = "/index.htm" # The file we want
# This is the HTTP request we send to fetch a file

request = "GET #{path} HTTP/1.0\r\n\r\n"
socket = TCPSocket.open(host,port) # Connect to server

socket.print(request) # Send request
response = socket.read # Read complete response
# Split response at first blank line into headers and body
headers,body = response.split("\r\n\r\n", 2)
print body # And display it
Para implementar o Web client similar, você pode usar uma biblioteca pré-construída
como o Net :: HTTP para trabalhar com HTTP. Aqui está o código que faz o equivalente
do código anterior -
require 'net/http' # The library we need

host = 'www.tutorialspoint.com' # The web server
path = '/index.htm' # The file we want
http = Net::HTTP.new(host) # Create a connection
headers, body = http.get(path) # Request the file
if headers.code == "200" # Check the status code
print body
else
puts "#{headers.code} #{headers.message}"
end
Por favor, verifique bibliotecas semelhantes para trabalhar com protocolos FTP, SMTP,
POP e IMAP.
Leituras Adicionais
Nós lhe demos um começo rápido em Programação de Soquete. É um assunto grande,
por isso é recomendado que você vá através da Ruby Socket Library e Class Methods
para encontrar mais detalhes.
Ruby - Tutorial XML, XSLT e XPath

O que é XML?
A XML (Extensible Markup Language) é uma linguagem de marcação muito semelhante
a HTML ou SGML. Isso é recomendado pelo World Wide Web Consortium e disponível
como padrão aberto.
XML é uma linguagem de código aberto e portátil que permite aos programadores
desenvolver aplicativos que podem ser lidos por outros aplicativos, independentemente
do sistema operacional e / ou da linguagem de desenvolvimento.
O XML é extremamente útil para rastrear quantidades pequenas a médias de dados

sem exigir um backbone baseado em SQL.
Arquiteturas do XML Parser e APIs

Existem dois sabores diferentes disponíveis para analisadores XML -
SAX-like (interfaces de fluxo) - Aqui você registra callbacks para eventos de

interesse e então deixa o analisador prosseguir através do documento. Isso é
útil quando seus documentos são grandes ou você tem limitações de memória,
analisa o arquivo como ele lê do disco e o arquivo inteiro nunca é armazenado
na memória.
DOM-like (Object tree interfaces) - Esta é uma recomendação do World

Wide Web Consortium, na qual o arquivo inteiro é lido na memória e
armazenado em um formulário hierárquico (baseado em árvore) para
representar todos os recursos de um documento XML.
O SAX obviamente não pode processar informações tão rápido quanto o DOM ao
trabalhar com arquivos grandes. Por outro lado, usar o DOM exclusivamente pode
realmente matar seus recursos, especialmente se usado em muitos arquivos pequenos.
SAX é somente leitura, enquanto o DOM permite alterações no arquivo XML. Como
essas duas APIs diferentes literalmente se complementam, não há motivos para não
usá-las em projetos grandes.
Analisando e criando XML usando Ruby

A maneira mais comum de manipular XML é com a biblioteca REXML por Sean Russell.
Desde 2002, o REXML faz parte da distribuição padrão do Ruby.
O REXML é um processador XML pure-Ruby em conformidade com o padrão XML 1.0. É

um processador sem validação , passando por todos os testes de conformidade de não
validação OASIS.
O analisador de REXML tem as seguintes vantagens sobre outros analisadores

disponíveis -
Está escrito 100 por cento em Ruby.
Pode ser usado para análise SAX e DOM.
É leve, menos de 2000 linhas de código.
Métodos e classes são realmente fáceis de entender.
API baseada em SAX2 e suporte total ao XPath.
Fornecido com instalação Ruby e nenhuma instalação separada é necessária.
Para todos os nossos exemplos de código XML, vamos usar um arquivo XML simples
como uma entrada -
<collection shelf = "New Arrivals">

<movie title = "Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title = "Transformers">
<type>Anime, Science Fiction</type>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title = "Trigun">
<type>Anime, Action</type>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title = "Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>
Análise parecida com DOM

Vamos primeiro analisar nossos dados XML em forma de árvore . Começamos exigindo
a biblioteca rexml / document ; muitas vezes fazemos um include REXML para
importar para o namespace de nível superior por conveniência.
#!/usr/bin/ruby -w
require 'rexml/document'
include REXML
xmlfile = File.new("movies.xml")
xmldoc = Document.new(xmlfile)
# Now get the root element

root = xmldoc.root
puts "Root element : " + root.attributes["shelf"]
# This will output all the movie titles.

xmldoc.elements.each("collection/movie"){
|e| puts "Movie Title : " + e.attributes["title"]
}
# This will output all the movie types.

xmldoc.elements.each("collection/movie/type") {
|e| puts "Movie Type : " + e.text
}
# This will output all the movie description.

xmldoc.elements.each("collection/movie/description") {
|e| puts "Movie Description : " + e.text
}
Root element : New Arrivals

Movie Title : Enemy Behind
Movie Title : Transformers
Movie Title : Trigun
Movie Title : Ishtar
Movie Type : War, Thriller
Movie Type : Anime, Science Fiction
Movie Type : Anime, Action
Movie Type : Comedy
Movie Description : Talk about a US-Japan war
Movie Description : A schientific fiction
Movie Description : Vash the Stampede!
Movie Description : Viewable boredom
Análise parecida com SAX
Para processar os mesmos dados, filmes.xml , arquivo de uma maneira orientada por
fluxo , definiremos uma classe de ouvinte cujos métodos serão o alvo de retornos de
chamada do analisador.
OBSERVAÇÃO - Não é recomendável usar a análise parecida com o SAX para um

arquivo pequeno, isso é apenas para um exemplo de demonstração.
#!/usr/bin/ruby -w
require 'rexml/streamlistener'
include REXML
class MyListener
include REXML::StreamListener
def tag_start(*args)
puts "tag_start: #{args.map {|x| x.inspect}.join(', ')}"
end
def text(data)
return if data =~ /^\w*$/ # whitespace only
abbrev = data[0..40] + (data.length > 40 ? "..." : "")
puts " text : #{abbrev.inspect}"
end
end
list = MyListener.new
Document.parse_stream(xmlfile, list)
tag_start: "collection", {"shelf"=>"New Arrivals"}

tag_start: "movie", {"title"=>"Enemy Behind"}
tag_start: "type", {}
text : "War, Thriller"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
text : "Talk about a US-Japan war"
tag_start: "movie", {"title"=>"Transformers"}
text : "Anime, Science Fiction"
tag_start: "year", {}
text : "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
text : "Anime, Action"
tag_start: "episodes", {}
text : "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
text : "Viewable boredom"
XPath e Ruby
Uma maneira alternativa de visualizar o XML é o XPath. Esse é um tipo de pseudo-
linguagem que descreve como localizar elementos e atributos específicos em um
documento XML, tratando esse documento como uma árvore ordenada lógica.
O REXML tem suporte para XPath através da classe XPath . Assume a análise baseada
em árvore (modelo de objeto de documento) como vimos acima.
#!/usr/bin/ruby -w
include REXML
xmldoc = Document.new(xmlfile)
# Info for the first movie found

movie = XPath.first(xmldoc, "//movie")
p movie
# Print out all the movie types

XPath.each(xmldoc, "//type") { |e| puts e.text }
# Get an array of all of the movie formats.

names = XPath.match(xmldoc, "//format").map {|x| x.text }
p names
<movie title = 'Enemy Behind'> ... </>

War, Thriller
Anime, Science Fiction
Anime, Action
Comedy
["DVD", "DVD", "DVD", "VHS"]
XSLT e Ruby
Existem dois analisadores XSLT disponíveis que o Ruby pode usar. Uma breve descrição
de cada um é dada aqui.
Rubi-Sablotron
Este analisador é escrito e mantido por Masayoshi Takahashi. Isso é escrito
principalmente para o Linux OS e requer as seguintes bibliotecas -
Sablot
Iconv
Expatriados
Você pode encontrar este módulo em Ruby-Sablotron .
XSLT4R
O XSLT4R é escrito por Michael Neumann e pode ser encontrado no RAA na seção
Library em XML. O XSLT4R usa uma interface de linha de comando simples, embora
possa ser usado alternativamente em um aplicativo de terceiros para transformar um
documento XML.
O XSLT4R precisa que o XMLScan opere, que está incluído no arquivo XSLT4R e que
também é um módulo 100 por cento Ruby. Esses módulos podem ser instalados usando
o método de instalação padrão do Ruby (por exemplo, ruby install.rb).
XSLT4R possui a seguinte sintaxe -
ruby xslt.rb stylesheet.xsl document.xml [arguments]
Se você quiser usar o XSLT4R dentro de um aplicativo, você pode incluir o XSLT e
inserir os parâmetros necessários. Aqui está o exemplo -
require "xslt"
stylesheet = File.readlines("stylesheet.xsl").to_s
xml_doc = File.readlines("document.xml").to_s
arguments = { 'image_dir' => '/....' }
sheet = XSLT::Stylesheet.new( stylesheet, arguments )
# output to StdOut
sheet.apply( xml_doc )
# output to 'str'
str = ""
sheet.output = [ str ]
sheet.apply( xml_doc )
Leitura Adicional
Para obter detalhes completos sobre o REXML Parser, consulte a documentação
padrão da documentação do REXML Parser .
Você pode baixar o XSLT4R do Repositório RAA .
Web Services com Ruby - SOAP4R

O que é SOAP?
O protocolo SOAP (Simple Object Access Protocol) é um protocolo RPC de plataforma
cruzada e independente de linguagem, baseado em XML e, geralmente (mas não
necessariamente) HTTP.
Ele usa XML para codificar as informações que fazem a chamada de procedimento
remoto e HTTP para transportar essas informações através de uma rede de clientes
para servidores e vice-versa.
O SOAP tem várias vantagens sobre outras tecnologias como COM, CORBA, etc: por
exemplo, seus custos relativamente baixos de implantação e depuração, sua
extensibilidade e facilidade de uso, e a existência de várias implementações para
diferentes linguagens e plataformas.
Por favor, consulte o nosso simples tutorial SOAP para entendê-lo em detalhes.
Este capítulo o familiariza com a implementação do SOAP para Ruby (SOAP4R). Este é
um tutorial básico, portanto, se você precisar de um detalhamento profundo, precisará
consultar outros recursos.
Instalando o SOAP4R
SOAP4R é a implementação SOAP para Ruby desenvolvida por Hiroshi Nakamura e pode
ser baixada de -
NOTA - Pode haver uma grande chance de você já ter instalado este componente.
Download SOAP
Se você está ciente do utilitário gem , então você pode usar o seguinte comando para
instalar o SOAP4R e os pacotes relacionados.
$ gem install soap4r --include-dependencies
Se você estiver trabalhando no Windows, precisará baixar um arquivo compactado do

local acima e instalá-lo usando o método de instalação padrão executando ruby
install.rb .
Escrevendo Servidores SOAP4R

O SOAP4R suporta dois tipos diferentes de servidores -
Baseado em CGI / FastCGI (SOAP :: RPC :: CGIStub)
Standalone (SOAP :: RPC: StandaloneServer)

Este capítulo fornece detalhes sobre como escrever um servidor autônomo. As etapas a
seguir estão envolvidas na gravação de um servidor SOAP.
Etapa 1 - Herdar SOAP :: RPC :: StandaloneServer Classe

Para implementar seu próprio servidor autônomo, você precisa escrever uma nova
classe, que será filha de SOAP :: StandaloneServer da seguinte maneira -
class MyServer < SOAP::RPC::StandaloneServer

...............
end
OBSERVAÇÃO - Se você quiser gravar um servidor baseado em FastCGI, será

necessário tomar SOAP :: RPC :: CGIStub como classe pai; o restante do procedimento
permanecerá o mesmo.
Etapa 2 - Definir métodos do manipulador

O segundo passo é escrever seus métodos de Serviços da Web, que você gostaria de
expor ao mundo exterior.
Eles podem ser escritos como métodos simples de Ruby. Por exemplo, vamos escrever
dois métodos para adicionar dois números e dividir dois números -

...............
# Handler methods
def add(a, b)
return a + b
end
def div(a, b)
return a / b
end
end
Etapa 3 - Expor métodos do manipulador

O próximo passo é adicionar nossos métodos definidos ao nosso servidor. O método
initialize é usado para expor métodos de serviço com um dos dois métodos a seguir -

def initialize(*args)
add_method(receiver, methodName, *paramArg)
end
end
Aqui está a descrição dos parâmetros -
Sr. Parâmetro e Descrição

Não.
1 receptor
O objeto que contém o método methodName. Você define os métodos de

serviço na mesma classe que o método methodDef, esse parâmetro é self .
methodName
2
O nome do método que é chamado devido a uma solicitação de RPC.
paramArg
3 Especifica, quando fornecido, os nomes dos parâmetros e os modos de

parâmetros.
Para entender o uso de parâmetros inout ou out , considere o seguinte método de

serviço que usa dois parâmetros (inParam e inoutParam), retorna um valor de retorno
normal (retVal) e dois outros parâmetros: inoutParam e outParam -
def aMeth(inParam, inoutParam)

retVal = inParam + inoutParam
outParam = inParam . inoutParam
inoutParam = inParam * inoutParam
return retVal, inoutParam, outParam
end
Agora, podemos expor este método da seguinte forma -
add_method(self, 'aMeth', [
%w(in inParam),
%w(inout inoutParam),
%w(out outParam),
%w(retval return)
])
Etapa 4 - Inicie o servidor

A etapa final é iniciar seu servidor instanciando uma instância da classe derivada e
chamando o método start .
myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)
myServer.start
Aqui está a descrição dos parâmetros necessários -

Não.
Nome do servidor
1
Um nome de servidor, você pode dar o que você mais gosta.
urn: ruby: ServiceName
2 Aqui urn: ruby é constante, mas você pode dar um nome exclusivo de
ServiceName para este servidor.
3 nome de anfitrião
Especifica o nome do host no qual este servidor irá escutar.
porta
4
Um número de porta disponível a ser usado para o serviço da web.
Exemplo
Agora, usando as etapas acima, vamos escrever um servidor autônomo -
require "soap/rpc/standaloneserver"
begin
# Expose our services

def initialize(*args)
add_method(self, 'add', 'a', 'b')
add_method(self, 'div', 'a', 'b')
end
# Handler methods
def add(a, b)
return a + b
end
def div(a, b)
return a / b
end
end
server = MyServer.new("MyServer",
'urn:ruby:calculation', 'localhost', 8080)
trap('INT){
server.shutdown
}
server.start
rescue => err
puts err.message
end
Quando executado, este aplicativo de servidor inicia um servidor SOAP independente no

host local e atende a solicitações na porta 8080. Ele expõe um método de serviço, add
e div , que recebe dois parâmetros e retorna o resultado.
Agora, você pode executar este servidor em segundo plano da seguinte maneira -
$ ruby MyServer.rb&
Escrevendo Clientes SOAP4R

A classe SOAP :: RPC :: Driver fornece suporte para gravar aplicativos cliente SOAP.
Este capítulo descreve essa classe e demonstra seu uso com base em um aplicativo.
A seguir está a informação mínima que você precisaria para chamar um serviço SOAP -
A URL do serviço SOAP (URL do terminal SOAP).

O namespace dos métodos de serviço (URI do Namespace do Método).
Os nomes dos métodos de serviço e seus parâmetros.
Agora, vamos escrever um cliente SOAP que chamaria métodos de serviço definidos no
exemplo acima, chamados add e div .
Aqui estão as principais etapas para criar um cliente SOAP.
Etapa 1 - Criar uma Instância do Driver SOAP

Criamos uma instância de SOAP :: RPC :: Driver chamando seu novo método da
seguinte maneira -
SOAP::RPC::Driver.new(endPoint, nameSpace, soapAction)
Aqui está a descrição dos parâmetros necessários -

Não.
endPoint
1
URL do servidor SOAP para se conectar.
nameSpace
2 O namespace a ser usado para todos os RPCs feitos com esse objeto SOAP ::
RPC :: Driver.
sabãoAção
3 Um valor para o campo SOAPAction do cabeçalho HTTP. Se nil, o padrão é a

string vazia "".
Etapa 2 - Adicionar métodos de serviço

Para adicionar um método de serviço SOAP a um SOAP :: RPC :: Driver , podemos
chamar o seguinte método usando a instância SOAP :: RPC :: Driver -
driver.add_method(name, *paramArg)
Aqui está a descrição dos parâmetros -

Não.
nome
1
O nome do método de serviço da web remoto.
2 paramArg
Especifica os nomes dos parâmetros dos procedimentos remotos.
Etapa 3 - Invocar o serviço SOAP

A etapa final é faturar o serviço SOAP usando a instância SOAP :: RPC :: Driver da
seguinte maneira -
result = driver.serviceMethod(paramArg...)
Aqui serviceMethod é o método de serviço web real e paramArg ... são os parâmetros
de lista necessários para passar no método de serviço.
Exemplo
Com base nos passos acima, vamos escrever um cliente SOAP da seguinte forma -
#!/usr/bin/ruby -w
require 'soap/rpc/driver'
NAMESPACE = 'urn:ruby:calculation'
URL = 'http://localhost:8080/'
begin
driver = SOAP::RPC::Driver.new(URL, NAMESPACE)
# Add remote sevice methods

driver.add_method('add', 'a', 'b')
# Call remote service methods

puts driver.add(20, 30)
rescue => err
puts err.message
end
Leituras Adicionais
Eu expliquei apenas conceitos muito básicos de Web Services com Ruby. Se você quiser
aprofundá-lo ainda mais, há um link a seguir para encontrar mais detalhes sobre os
Serviços da Web com o Ruby .
Ruby - Guia de Tk
Introdução
A interface gráfica padrão do usuário (GUI) para Ruby é Tk. Tk começou como a GUI
para a linguagem de script Tcl desenvolvida por John Ousterhout.
Tk tem a distinção única de ser a única GUI multiplataforma. O Tk é executado no

Windows, Mac e Linux e fornece uma aparência nativa em cada sistema operacional.
O componente básico de um aplicativo baseado em Tk é chamado de widget. Um

componente também é algumas vezes chamado de janela, uma vez que, em Tk,
"janela" e "widget" são freqüentemente usados de forma intercambiável.
Os aplicativos tk seguem uma hierarquia de widgets em que qualquer número de

widgets pode ser colocado dentro de outro widget e aqueles widgets dentro de outro
widget, ad infinitum. O widget principal em um programa Tk é referido como o widget
raiz e pode ser criado fazendo uma nova instância da classe TkRoot.
A maioria dos aplicativos baseados em Tk segue o mesmo ciclo: crie os widgets,

coloque-os na interface e, finalmente, ligue os eventos associados a cada
widget a um método.
Existem três gerenciadores de geometria; lugar, grade e pacote que são

responsáveis por controlar o tamanho e a localização de cada um dos widgets
na interface.
Instalação
As ligações do Ruby Tk são distribuídas com o Ruby, mas o Tk é uma instalação
separada. Os usuários do Windows podem baixar uma instalação Tk de um único clique
do ActiveTcl da ActiveState .
Os usuários de Mac e Linux podem não precisar instalá-lo porque existe uma grande
chance de que ele já esteja instalado junto com o SO, mas se não, você pode baixar
pacotes pré-construídos ou obter o código-fonte do Tcl Developer Xchange .
Aplicação Tk Simples
Uma estrutura típica para programas Ruby / Tk é criar a janela principal ou raiz (uma
instância do TkRoot), adicionar widgets a ela para construir a interface do usuário e, em
seguida, iniciar o loop de eventos principal chamando Tk.mainloop .
O tradicional Olá, mundo! exemplo para Ruby / Tk é algo como isto -
require 'tk'
root = TkRoot.new { title "Hello, World!" }

TkLabel.new(root) do
text 'Hello, World!'
pack { padx 15 ; pady 15; side 'left' }
end
Tk.mainloop
Aqui, depois de carregar o módulo de extensão tk, criamos um quadro de nível raiz
usando TkRoot.new . Em seguida, criamos um widget TkLabel como filho do quadro
raiz, definindo várias opções para o rótulo. Finalmente, nós empacotamos o root frame
e entramos no loop principal do evento GUI.
Se você executasse este script, produziria o seguinte resultado -

Ruby / Tk Widget Classes
Existe uma lista de várias classes Ruby / Tk, que podem ser usadas para criar uma GUI
desejada usando Ruby / Tk.
TkFrame Cria e manipula widgets de quadros.
TkButton Cria e manipula widgets de botões.
TkLabel Cria e manipula widgets de rótulo.
TkEntry Cria e manipula widgets de entrada.
TkCheckButton Cria e manipula widgets de check-button.
TkRadioButton Cria e manipula widgets de radiobutton.
TkListbox Cria e manipula widgets de caixas de listagem.
TkComboBox Cria e manipula widgets de caixas de listagem.
TkMenu Cria e manipula widgets de menu.
TkMenubutton Cria e manipula widgets de submenu.
Tk.messageBox Cria e manipula um diálogo de mensagem.
TkScrollbar Cria e manipula widgets de barra de rolagem.
TkCanvas Cria e manipula widgets de tela.
TkScale Cria e manipula widgets de escala.
TkText Cria e manipula widgets de texto.
TkToplevel Cria e manipula widgets de nível superior.
TkSpinbox Cria e manipula widgets do Spinbox.
TkProgressBar Cria e manipula widgets da barra de progresso.
Caixa de diálogo Cria e manipula os widgets da caixa de diálogo.
Tk :: Tile :: Notebook Exibe várias janelas em espaço limitado com a

metáfora do notebook.
Tk :: Tile :: Paned Exibe um número de subjanelas, empilhadas na vertical

ou na horizontal.
Tk :: Tile :: Separator Exibe uma barra separadora horizontal ou vertical.

Fonte Ruby / Tk, Cores e Imagens Entendendo Fontes Ruby / Tk, Cores e
Imagens
Opções de configuração padrão

Todos os widgets possuem várias opções de configuração diferentes, que geralmente
controlam como elas são exibidas ou como elas se comportam. As opções disponíveis
dependem da classe do widget, é claro.
Aqui está uma lista de todas as opções de configuração padrão, que podem ser
aplicáveis a qualquer widget Ruby / Tk.
Existem outras opções específicas do widget, que seriam explicadas junto com
os widgets.
Gerenciamento de Geometria Ruby / Tk

O Geometry Management lida com o posicionamento de diferentes widgets conforme o
requisito. O gerenciamento de geometria no Tk depende do conceito de widgets master
e slave.
Um mestre é um widget, geralmente uma janela de nível superior ou um quadro, que

conterá outros widgets, chamados de escravos. Você pode imaginar um gerenciador de
geometria assumindo o controle do widget principal e decidindo o que será exibido nele.
O gerenciador de geometria perguntará a cada tamanho de widget de cada escravo, ou

quão grande seria ideal para ser exibido. Em seguida, ele pega essa informação e a
combina com quaisquer parâmetros fornecidos pelo programa quando ele solicita ao
gerenciador de geometria para gerenciar esse widget escravo em particular.
Existem três geometry managers place, grid e pack que são responsáveis por controlar
o tamanho e a localização de cada um dos widgets na interface.
grid Gerenciador de geometria que organiza widgets em uma grade.
embalar gerente geometria que as embalagens em torno das bordas da

cavidade.
Coloque o gerenciador de geometria para posicionamento fixo ou em folha de

borracha.
Manipulação de Eventos Ruby / Tk

Ruby / Tk suporta o loop de eventos , que recebe eventos do sistema operacional.
Essas são coisas como pressionamentos de botões, pressionamentos de tecla,
movimento do mouse, redimensionamento de janela e assim por diante.
Ruby / Tk cuida da gestão deste evento para você. Ele irá descobrir em qual widget o
evento se aplica (o usuário clicou neste botão? Se uma tecla foi pressionada, qual caixa
de texto tinha o foco?), E despacha-a de acordo. Widgets individuais sabem como
responder a eventos, portanto, por exemplo, um botão pode mudar de cor quando o
mouse se move sobre ele e reverter quando o mouse sai.
Em um nível mais alto, Ruby / Tk invoca callbacks em seu programa para indicar que
algo significativo aconteceu com um widget. Para ambos os casos, você pode fornecer
um bloco de código ou um objeto Ruby Proc que especifica como o aplicativo responde
ao evento ou callback.
Vamos dar uma olhada em como usar o método bind para associar eventos básicos do
sistema de janelas com os procedimentos Ruby que os manipulam. A forma mais
simples de ligação recebe como entrada uma string indicando o nome do evento e um
bloco de código que o Tk usa para manipular o evento.
Por exemplo, para capturar o evento ButtonRelease para o primeiro botão do mouse em
algum widget, você escreveria -
someWidget.bind('ButtonRelease-1') {
....code block to handle this event...
}
Um nome de evento pode incluir modificadores e detalhes adicionais. Um modificador é

uma string como Shift , Control ou Alt , indicando que uma das teclas modificadoras foi
pressionada.
Assim, por exemplo, para capturar o evento que é gerado quando o usuário mantém
pressionada a tecla Ctrl e clica no botão direito do mouse.
someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })
Muitos widgets Ruby / Tk podem acionar retornos de chamada quando o usuário os

ativa, e você pode usar o retorno de chamada do comando para especificar que um
determinado bloco de código ou procedimento é invocado quando isso acontece. Como
visto anteriormente, você pode especificar o procedimento de retorno de chamada do
comando ao criar o widget -
helpButton = TkButton.new(buttonFrame) {
text "Help"
command proc { showHelp }
}
Ou você pode atribuí-lo mais tarde, usando o método de comando do widget -
helpButton.command proc { showHelp }
Como o método de comando aceita procedimentos ou blocos de código, você também

pode escrever o exemplo de código anterior como -
helpButton = TkButton.new(buttonFrame) {
text "Help"
command { showHelp }
}
Você pode usar os seguintes tipos básicos de eventos em seu aplicativo Ruby /
Tk -
O método de configuração
O método configure pode ser usado para definir e recuperar quaisquer valores de
configuração do widget. Por exemplo, para alterar a largura de um botão, você pode
chamar o método configure a qualquer momento da seguinte forma:
require "tk"
button = TkButton.new {
text 'Hello World!'
pack
}
button.configure('activebackground', 'blue')
Tk.mainloop
Para obter o valor de um widget atual, basta fornecê-lo sem um valor da seguinte
forma:
color = button.configure('activebackground')
Você também pode chamar o configure sem nenhuma opção, o que lhe dará uma
listagem de todas as opções e seus valores.
O método cget
Para simplesmente recuperar o valor de uma opção, configure retorna mais informações
do que você geralmente deseja. O método cget retorna apenas o valor atual.
color = button.cget('activebackground')
Ruby - Tutorial LDAP

Ruby / LDAP é uma biblioteca de extensões para Ruby. Ele fornece a interface para
algumas bibliotecas LDAP, como OpenLDAP, UMich LDAP, Netscape SDK e
ActiveDirectory.
A API comum para desenvolvimento de aplicativos é descrita no RFC1823 e é suportada

pelo Ruby / LDAP.
Instalação Ruby / LDAP

Você pode baixar e instalar um pacote Ruby / LDAP completo em
SOURCEFORGE.NET .
Antes de instalar o Ruby / LDAP, certifique-se de ter os seguintes componentes -
Ruby 1.8.x (pelo menos 1.8.2 se você quiser usar o ldap / control).
OpenLDAP, Netscape SDK, Windows 2003 ou Windows XP.
Agora, você pode usar o método de instalação padrão do Ruby. Antes de começar, se
você quiser ver as opções disponíveis para o extconf.rb, execute-o com a opção '--help'.
$ ruby extconf.rb [--with-openldap1|--with-openldap2| \

--with-netscape|--with-wldap32]
$ make
$ make install
OBSERVAÇÃO : se você estiver criando o software no Windows, talvez seja necessário

usar o nmake em vez do make .
Estabelecer conexão LDAP

Este é um processo de duas etapas -
Etapa 1 - Criar Objeto de Conexão

A seguir está a sintaxe para criar uma conexão com um diretório LDAP.
LDAP::Conn.new(host = 'localhost', port = LDAP_PORT)
host - Esse é o ID do host que está executando o diretório LDAP. Nós vamos
tomá-lo como localhost .
porta - esta é a porta que está sendo usada para o serviço LDAP. As portas
LDAP padrão são 636 e 389. Verifique se a porta está sendo usada em seu
servidor, caso contrário, você poderá usar LDAP :: LDAP_PORT.
Esta chamada retorna uma nova conexão LDAP :: Conn para o servidor, host , na porta
port .
Etapa 2 - Encadernação
É aqui que geralmente especificamos o nome de usuário e a senha que usaremos para
o restante da sessão.
A seguir está a sintaxe para vincular uma conexão LDAP, usando o método DN, dn ,
credential, pwd e bind, método -
conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)do

....
end
Você pode usar o mesmo método sem um bloco de código. Nesse caso, você precisaria
desvincular a conexão explicitamente da seguinte maneira -
conn.bind(dn = nil, password = nil, method = LDAP::LDAP_AUTH_SIMPLE)

....
conn.unbind
Se um bloco de código é dado, o self é cedido ao bloco.

Agora podemos realizar buscas, adicionar, modificar ou excluir operações dentro do
bloco do método bind (entre bind e unbind), desde que tenhamos as permissões
apropriadas.
Exemplo
Assumindo que estamos trabalhando em um servidor local, vamos colocar as coisas em

conjunto com o host, domínio, ID de usuário e senha apropriados, etc.
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'
$PORT = LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT
conn = LDAP::Conn.new($HOST, $PORT)

conn.bind('cn = root, dc = localhost, dc = localdomain','secret')
....
conn.unbind
Adicionando uma entrada LDAP

Adicionar uma entrada LDPA é um processo de duas etapas -
Etapa 1 - Criando o objeto LDAP :: Mod

Precisamos passar o objeto LDAP :: Mod para o método conn.add para criar uma
entrada. Aqui está uma sintaxe simples para criar o objeto LDAP :: Mod -
Mod.new(mod_type, attr, vals)
mod_type - Uma ou mais opções LDAP_MOD_ADD, LDAP_MOD_REPLACE ou

LDAP_MOD_DELETE.
attr - deve ser o nome do atributo no qual operar.
vals - é uma matriz de valores pertencentes ao attr . Se vals contiver dados

binários, mod_type deve ser logicamente OR'ed (|) com LDAP_MOD_BVALUES.
Essa chamada retorna o objeto LDAP :: Mod , que pode ser passado para os métodos
da classe LDAP :: Conn, como Conn # add, Conn # add_ext, Conn # modify e Conn #
modify_ext.
Etapa 2 - Chamando o método conn.add

Quando estivermos prontos com o objeto LDAP :: Mod , podemos chamar o método
conn.add para criar uma entrada. Aqui está uma sintaxe para chamar esse método -
conn.add(dn, attrs)
Este método adiciona uma entrada com o DN, dn e os atributos attrs . Aqui, attrs deve
ser uma matriz de objetos LDAP :: Mod ou um hash de pares de matriz de atributo /
valor.
Exemplo
Aqui está um exemplo completo, que criará duas entradas de diretório -
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'

conn.perror("bind")
entry1 = [
LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','domain']),
LDAP.mod(LDAP::LDAP_MOD_ADD,'o',['TTSKY.NET']),
LDAP.mod(LDAP::LDAP_MOD_ADD,'dc',['localhost']),
]
entry2 = [
LDAP.mod(LDAP::LDAP_MOD_ADD,'objectclass',['top','person']),
LDAP.mod(LDAP::LDAP_MOD_ADD, 'cn', ['Zara Ali']),
LDAP.mod(LDAP::LDAP_MOD_ADD | LDAP::LDAP_MOD_BVALUES, 'sn',
['ttate','ALI', "zero\000zero"]),
]
begin
conn.add("dc = localhost, dc = localdomain", entry1)
conn.add("cn = Zara Ali, dc = localhost, dc = localdomain", entry2)
rescue LDAP::ResultError
conn.perror("add")
exit
end
conn.perror("add")
conn.unbind
Modificando uma entrada LDAP

Modificar uma entrada é semelhante a adicionar uma. Apenas chame o método modify
em vez de adicionar com os atributos para modificar. Aqui está uma sintaxe simples do
método de modificação .
conn.modify(dn, mods)
Este método modifica uma entrada com o DN, dn e os atributos, mods . Aqui, os mods
devem ser uma matriz de objetos LDAP :: Mod ou um hash de pares de matriz de
atributo / valor.
Exemplo
Para modificar o sobrenome da entrada, que adicionamos na seção anterior,
escreveríamos -
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'

conn.perror("bind")
entry1 = [
LDAP.mod(LDAP::LDAP_MOD_REPLACE, 'sn', ['Mohtashim']),
]
begin
conn.modify("cn = Zara Ali, dc = localhost, dc = localdomain", entry1)
conn.perror("modify")
exit
end
conn.perror("modify")
conn.unbind
Excluindo uma entrada LDAP

Para excluir uma entrada, chame o método delete com o nome distinto como
parâmetro. Aqui está uma sintaxe simples do método delete .
conn.delete(dn)
Este método exclui uma entrada com o DN, dn .
Exemplo
Para excluir a entrada Zara Mohtashim , que adicionamos na seção anterior,
escreveríamos:
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'

conn.perror("bind")
begin
conn.delete("cn = Zara-Mohtashim, dc = localhost, dc = localdomain")
conn.perror("delete")
exit
end
conn.perror("delete")
conn.unbind
Modificando o nome distinto

Não é possível modificar o nome distinto de uma entrada com o método de modificação
. Em vez disso, use o método modrdn . Aqui está a sintaxe simples do método modrdn
-
conn.modrdn(dn, new_rdn, delete_old_rdn)
Este método modifica o RDN da entrada com DN, dn , dando a ele o novo RDN,
new_rdn . Se delete_old_rdn for true , o valor do RDN antigo será excluído da entrada.
Exemplo
Suponha que tenhamos a seguinte entrada -
dn: cn = Zara Ali,dc = localhost,dc = localdomain

cn: Zara Ali
sn: Ali
objectclass: person
Então, podemos modificar seu nome distinto com o seguinte código -
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'

conn.perror("bind")
begin
conn.modrdn("cn = Zara Ali, dc = localhost, dc = localdomain", "cn = Zara Mohtashim", true)
conn.perror("modrdn")
exit
end
conn.perror("modrdn")
conn.unbind
Realizando uma pesquisa

Para realizar uma pesquisa em um diretório LDAP, use o método de pesquisa com um
dos três modos de pesquisa diferentes -
LDAP_SCOPE_BASEM - Pesquisar apenas o nó base.
LDAP_SCOPE_ONELEVEL - Pesquisar todos os filhos do nó base.
LDAP_SCOPE_SUBTREE - Pesquisar a subárvore inteira, incluindo o nó base.
Exemplo
Aqui, vamos pesquisar toda a subárvore de entrada dc = localhost, dc = localdomain
para objetos de pessoa -
#/usr/bin/ruby -w
require 'ldap'
$HOST = 'localhost'
base = 'dc = localhost,dc = localdomain'

scope = LDAP::LDAP_SCOPE_SUBTREE
filter = '(objectclass = person)'
attrs = ['sn', 'cn']

conn.perror("bind")
begin
conn.search(base, scope, filter, attrs) { |entry|
# print distinguished name
p entry.dn
# print all attribute names
p entry.attrs
# print values of attribute 'sn'
p entry.vals('sn')
# print entry as Hash
p entry.to_hash
}
conn.perror("search")
exit
end
conn.perror("search")
conn.unbind
Isso invoca o bloco de código fornecido para cada entrada correspondente em que a
entrada LDAP é representada por uma instância da classe LDAP :: Entry. Com o último
parâmetro de pesquisa, você pode especificar os atributos nos quais está interessado,
omitindo todos os outros. Se você passar nulo aqui, todos os atributos serão retornados
da mesma forma que "SELECT *" nos bancos de dados relacionais.
O método dn (alias para get_dn) da classe LDAP :: Entry retorna o nome distinto da
entrada, e com o método to_hash, você pode obter uma representação hash de seus
atributos (incluindo o nome distinto). Para obter uma lista dos atributos de uma
entrada, use o método attrs (alias para get_attributes). Além disso, para obter a lista
de valores de um atributo específico, use o método vals (alias para get_values).
Manipulando Erros
Ruby / LDAP define duas classes de exceção diferentes -
Em caso de erro, os métodos new, bind ou unbind levantam uma exceção LDAP
:: Error.
Em caso de adicionar, modificar, excluir ou pesquisar um diretório LDAP, crie um

LDAP :: ResultError.
Leitura Adicional
Para obter detalhes completos sobre os métodos LDAP, consulte a documentação
padrão da documentação do LDAP .
Ruby - Multithreading
Os programas tradicionais têm um único encadeamento de execução, as instruções ou
instruções que compõem o programa são executadas seqüencialmente até o término do
programa.
Um programa multithread tem mais de um thread de execução. Dentro de cada thread,

as instruções são executadas seqüencialmente, mas os threads em si podem ser
executados em paralelo em uma CPU multicore, por exemplo. Frequentemente, em
uma única máquina de CPU, vários encadeamentos não são realmente executados em
paralelo, mas o paralelismo é simulado pela intercalação da execução dos
encadeamentos.
O Ruby facilita a gravação de programas multi-thread com a classe Thread . Os

encadeamentos Ruby são uma maneira leve e eficiente de obter simultaneidade em seu
código.
Criando Threads Ruby

Para iniciar um novo thread, associe um bloco a uma chamada para Thread.new . Um
novo thread será criado para executar o código no bloco, e o thread original retornará
de Thread.new imediatamente e retomará a execução com o próximo comando -
# Thread #1 is running here

Thread.new {
# Thread #2 runs this code
}
# Thread #1 runs this code
Exemplo
Aqui está um exemplo, que mostra como podemos usar o programa Ruby multi-
threaded.
#!/usr/bin/ruby
def func1
i = 0
while i<=2
puts "func1 at: #{Time.now}"
sleep(2)
i = i+1
end
end
def func2
j = 0
while j<=2
puts "func2 at: #{Time.now}"
sleep(1)
j = j+1
end
end
puts "Started At #{Time.now}"

t1 = Thread.new{func1()}
t2 = Thread.new{func2()}
t1.join
t2.join
puts "End at #{Time.now}"
Isto irá produzir resultado seguinte -
Started At Wed May 14 08:21:54 -0700 2008

func1 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:54 -0700 2008
func2 at: Wed May 14 08:21:55 -0700 2008
func1 at: Wed May 14 08:21:56 -0700 2008
func2 at: Wed May 14 08:21:56 -0700 2008
func1 at: Wed May 14 08:21:58 -0700 2008
End at Wed May 14 08:22:00 -0700 2008
Ciclo de vida da rosca

Um novos segmentos são criados com Thread.new . Você também pode usar os
sinônimos Thread.start e Thread.fork .
Não há necessidade de iniciar um thread após criá-lo, ele começa a ser executado
automaticamente quando os recursos da CPU se tornam disponíveis.
A classe Thread define vários métodos para consultar e manipular o encadeamento

enquanto ele está em execução. Um thread executa o código no bloco associado à
chamada para Thread.new e, em seguida, ele para de executar.
O valor da última expressão nesse bloco é o valor do encadeamento e pode ser obtido
chamando o método de valor do objeto Thread. Se o encadeamento tiver sido
executado até a conclusão, o valor retornará o valor do encadeamento imediatamente.
Caso contrário, o método value é bloqueado e não retorna até que o encadeamento
seja concluído.
O método de classe Thread.current retorna o objeto Thread que representa o segmento

atual. Isso permite que os threads se manipulem. O método de classe Thread.main
retorna o objeto Thread que representa o thread principal. Este é o primeiro thread de
execução que começou quando o programa Ruby foi iniciado.
Você pode esperar que um segmento específico termine chamando o método

Thread.join desse segmento . O segmento de chamada irá bloquear até que o
segmento determinado seja concluído.
Threads e Exceções
Se uma exceção é levantada no thread principal e não é tratada em lugar algum, o
interpretador Ruby imprime uma mensagem e sai. Em encadeamentos, além do thread
principal, as exceções não tratadas fazem com que o encadeamento pare de ser
executado.
Se um encadeamento t sair por causa de uma exceção não tratada e outro

encadeamento s chamar t.join ou t.value, a exceção que ocorreu em t será levantada
no encadeamento s .
Se Thread.abort_on_exception for false , a condição padrão, uma exceção não tratada

simplesmente mata o thread atual e todo o resto continua a ser executado.
Se você quiser que qualquer exceção não tratada em qualquer thread faça com que o
intérprete saia, defina o método de classe Thread.abort_on_exception como true .
t = Thread.new { ... }
t.abort_on_exception = true
Variáveis de Thread
Um thread pode acessar normalmente as variáveis que estão no escopo quando o
thread é criado. Variáveis locais para o bloco de um segmento são locais para o
segmento e não são compartilhadas.
A classe de encadeamento apresenta um recurso especial que permite que variáveis

locais de encadeamento sejam criadas e acessadas pelo nome. Você simplesmente trata
o objeto thread como se fosse um hash, escrevendo para elementos usando [] = e
lendo-os de volta usando [].
Neste exemplo, cada thread registra o valor atual da contagem de variáveis em uma
variável threadlocal com a chave mycount .
#!/usr/bin/ruby
count = 0
arr = []
10.times do |i|
arr[i] = Thread.new {
sleep(rand(0)/10.0)
Thread.current["mycount"] = count
count += 1
}
end
arr.each {|t| t.join; print t["mycount"], ", " }

puts "count = #{count}"
Isso produz o seguinte resultado -
8, 0, 3, 7, 2, 1, 6, 5, 4, 9, count = 10
O thread principal aguarda que as sub-threads terminem e, em seguida, imprime o
valor da contagem capturada por cada uma.
Prioridades de Thread
O primeiro fator que afeta o agendamento de encadeamentos é a prioridade do
encadeamento: encadeamentos de alta prioridade são agendados antes de
encadeamentos de baixa prioridade. Mais precisamente, um encadeamento só obterá
tempo de CPU se não houver encadeamentos de prioridade mais alta esperando para
serem executados.
Você pode definir e consultar a prioridade de um objeto Ruby Thread com prioridade =
e prioridade . Um encadeamento recém-criado inicia na mesma prioridade que o
encadeamento que o criou. O thread principal começa na prioridade 0.
Não há como definir a prioridade de um thread antes de começar a execução. Um

thread pode, no entanto, aumentar ou diminuir sua própria prioridade como primeira
ação.
Exclusão de Thread
Se dois encadeamentos compartilharem acesso aos mesmos dados e pelo menos um
dos encadeamentos modificar esses dados, você deverá tomar cuidado especial para
garantir que nenhum encadeamento possa ver os dados em um estado inconsistente.
Isso é chamado de exclusão de thread .
Mutex é uma classe que implementa um bloqueio de semáforo simples para acesso
mutuamente exclusivo a algum recurso compartilhado. Ou seja, apenas um thread pode
conter o bloqueio em um determinado momento. Outros tópicos podem optar por
esperar na fila para que o bloqueio fique disponível ou simplesmente optar por obter
um erro imediato, indicando que o bloqueio não está disponível.
Colocando todos os acessos aos dados compartilhados sob o controle de um mutex ,

garantimos consistência e operação atômica. Vamos tentar exemplos, primeiro sem
mutax e segundo com mutax -
Exemplo sem Mutax

#!/usr/bin/ruby
require 'thread'
count1 = count2 = 0
difference = 0
counter = Thread.new do
loop do
count1 += 1
count2 += 1
end
end
spy = Thread.new do
loop do
difference += (count1 - count2).abs
end
end
sleep 1
puts "count1 : #{count1}"
puts "difference : #{difference}"
count1 : 1583766
count2 : 1583766
difference : 0
#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new
count1 = count2 = 0
difference = 0
counter = Thread.new do
loop do
mutex.synchronize do
count1 += 1
count2 += 1
end
end
end
spy = Thread.new do
loop do
mutex.synchronize do
difference += (count1 - count2).abs
end
end
end
sleep 1
mutex.lock
puts "difference : #{difference}"
count1 : 696591
count2 : 696591
difference : 0
Manipulando Deadlock
Quando começamos a usar objetos Mutex para exclusão de encadeamentos, devemos
ter cuidado para evitar o impasse . Deadlock é a condição que ocorre quando todos os
threads estão aguardando para adquirir um recurso mantido por outro thread. Como
todos os segmentos estão bloqueados, eles não podem liberar os bloqueios que eles
mantêm. E porque eles não podem liberar os bloqueios, nenhum outro segmento pode
adquirir esses bloqueios.
É aqui que as variáveis de condição entram em cena. Uma variável de condição é

simplesmente um semáforo que está associado a um recurso e é usado dentro da
proteção de um mutex específico . Quando você precisa de um recurso que não está
disponível, você espera em uma variável de condição. Essa ação libera o bloqueio no
mutex correspondente . Quando algum outro segmento sinaliza que o recurso está
disponível, o thread original sai da espera e simultaneamente recupera o bloqueio na
região crítica.
Exemplo
#!/usr/bin/ruby
require 'thread'
mutex = Mutex.new
cv = ConditionVariable.new
a = Thread.new {
mutex.synchronize {
puts "A: I have critical section, but will wait for cv"
cv.wait(mutex)
puts "A: I have critical section again! I rule!"
}
}
puts "(Later, back at the ranch...)"
b = Thread.new {
mutex.synchronize {
puts "B: Now I am critical, but am done with cv"
cv.signal
puts "B: I am still critical, finishing up"
}
}
a.join
b.join
A: I have critical section, but will wait for cv

(Later, back at the ranch...)
B: Now I am critical, but am done with cv
B: I am still critical, finishing up
A: I have critical section again! I rule!
Estados da linha
Existem cinco possíveis valores de retorno correspondentes aos cinco estados possíveis,
conforme mostrado na tabela a seguir. O status status retorna o estado do
encadeamento.
Estado da linha Valor de retorno
Runnable corre
adormecido adormecido
Abortando abortando
Terminado normalmente falso
Terminado com exceção nada
Métodos de classe de thread

Os métodos a seguir são fornecidos pela classe Thread e são aplicáveis a todos os
encadeamentos disponíveis no programa. Esses métodos serão chamados usando o
nome da classe Thread da seguinte maneira -
Thread.abort_on_exception = true
Aqui está a lista completa de todos os métodos de classe disponíveis -
Métodos de instância de thread

Esses métodos são aplicáveis a uma instância de um segmento. Esses métodos serão
chamados como usando uma instância de um thread da seguinte maneira -
#!/usr/bin/ruby
thr = Thread.new do # Calling a class method new

puts "In second thread"
raise "Raise exception"
end
thr.join # Calling an instance method join
Aqui está a lista completa de todos os métodos de instância disponíveis -
Ruby - Funções Internas

Como o módulo do Kernel está incluído na classe Object , seus métodos estão
disponíveis em todos os lugares no programa Ruby. Eles podem ser chamados sem um
receptor (forma funcional). Portanto, eles são freqüentemente chamados de funções.
Uma lista completa de funções internas é dada aqui para sua referência -
Funções para números

Aqui está uma lista de funções internas relacionadas ao número. Eles devem ser usados
da seguinte maneira -
#!/usr/bin/ruby
num = 12.40
puts num.floor # 12
puts num + 10 # 22.40
puts num.integer? # false as num is a float.
12
22.4
false
Assumindo, n é um número -
Funções para Float

Aqui está uma lista de funções internas do Ruby especialmente para números
flutuantes. Supondo que temos um número flutuador f -
Funções para Matemática

Aqui está uma lista de funções matemáticas internas do Ruby -
Especificador de campo de conversão

A função sprintf (fmt [, arg ...]) e format (fmt [, arg ...]) retorna uma string na qual arg
é formatada de acordo com fmt. As especificações de formatação são essencialmente as
mesmas que as do sprintf na linguagem de programação C. Os especificadores de
conversão (% seguido pelo especificador de campo de conversão) em fmt são
substituídos pela string formatada do argumento correspondente.
Os seguintes especificadores de conversão são suportados pelo formato do

Ruby -
A seguir está o exemplo de uso -

#!/usr/bin/ruby
str = sprintf("%s\n", "abc") # => "abc\n" (simplest form)

puts str
str = sprintf("d=%d", 42) # => "d=42" (decimal output)

puts str
str = sprintf("%04x", 255) # => "00ff" (width 4, zero padded)

puts str
str = sprintf("%8s", "hello") # => " hello" (space padded)

puts str
str = sprintf("%.2s", "hello") # => "he" (trimmed by precision)

puts str

abc
d = 42
00ff
hello
he
Argumentos da Função de Teste

O teste de função (teste, f1 [, f2]) executa um dos seguintes testes de arquivo
especificados pelo teste de caractere . Para melhorar a legibilidade, você deve usar
métodos de classe de arquivo (por exemplo, File :: readable?) Em vez dessa função.
Aqui estão os testes de arquivo com um argumento -
Testes de arquivo com dois argumentos são os seguintes -
A seguir, o exemplo de uso. Assumindo que main.rb existe com permissões de leitura,
gravação e não execução -
#!/usr/bin/ruby
puts test(?r, "main.rb" ) # => true

puts test(?w, "main.rb" ) # => true
puts test(?x, "main.rb" ) # => false
true
false
false
Ruby - Variáveis Predefinidas

As variáveis predefinidas de Ruby afetam o comportamento de todo o programa,
portanto, seu uso em bibliotecas não é recomendado.
Os valores na maioria das variáveis predefinidas podem ser acessados por meios
alternativos.
A tabela a seguir lista todas as variáveis predefinidas do Ruby.
Sr. Nome e descrição da variável

Não.
$!
1 O último objeto de exceção gerado. O objeto de exceção também pode ser

acessado usando => na cláusula rescue .
2 $@
O backtrace de pilha para a última exceção levantada. As informações de
rastreamento de pilha podem ser recuperadas pelo método Exception #
backtrace da última exceção.
$/
3 O separador de registro de entrada (nova linha por padrão). Obtém, readline,

etc, tome seu separador de registro de entrada como argumento opcional.
$\
4
O separador de registro de saída (nulo por padrão).
$,
O separador de saída entre os argumentos para imprimir e Array # join (nil

5
por padrão). Você pode especificar o separador explicitamente como Array #
join.
$;
6 O separador padrão para divisão (nulo por padrão). Você pode especificar o
separador explicitamente para String # split.
$.
7 O número da última linha lida do arquivo de entrada atual. Equivalente a

ARGF.lineno.
$<
8
Sinônimo para ARGF.
$>
9
Sinônimo para $ defout.
$0
10
O nome do atual programa Ruby sendo executado.
$$
11
O processo pid do atual programa Ruby sendo executado.
$?
12
O status de saída do último processo foi finalizado.
13 $:
Sinônimo para $ LOAD_PATH.
$ DEBUG
14
Verdadeiro se a opção de linha de comando -d ou --debug for especificada.
$ defout
15
A saída de destino para print e printf ( $ stdout por padrão).
$F
A variável que recebe a saída da divisão quando -a é especificado. Essa

16
variável é definida se a opção da linha de comandos -a for especificada junto
com a opção -p ou -n.
$ FILENAME
17 O nome do arquivo atualmente sendo lido do ARGF. Equivalente a

ARGF.filename.
$ LOAD_PATH
18 Uma matriz que mantém os diretórios a serem pesquisados ao carregar

arquivos com a carga e exigir métodos.
$ SAFE
O nível de segurança
0 → Nenhuma verificação é executada em dados fornecidos externamente

(contaminados). (padrão)
1 → Operações potencialmente perigosas usando dados contaminados são

19 proibidas.
2 → Operações potencialmente perigosas em processos e arquivos são

proibidas.
3 → Todos os objetos recém-criados são considerados contaminados.
4 → A modificação de dados globais é proibida.
$ stdin
20
Entrada padrão (STDIN por padrão).
21 $ stdout
Saída padrão (STDOUT por padrão).
$ stderr
22
Erro padrão (STDERR por padrão).
$ VERBOSE
23 Verdadeiro se a opção da linha de comandos -v, -w ou --verbose for

especificada.
$-x
24 O valor da opção do interpretador -x (x = 0, a, d, F, i, K, l, p, v). Estas opções

estão listadas abaixo
$ -0
25
O valor da opção do interpretador -x e alias de $ /.
$ -a
26 O valor da opção do interpretador -x e true se a opção -a estiver definida.

Somente leitura.
$ -d
27
O valor da opção do interpretador -x e alias de $ DEBUG
$ -F
28
O valor da opção do interpretador -x e o alias de $ ;.
$ -i
O valor da opção do interpretador -x e no modo de edição no local, mantém a

29
extensão, caso contrário, nada. Pode ativar ou desativar o modo de edição no
local.
$ -I
30
O valor da opção do interpretador -x e alias de $:.
$ -l
31 O valor da opção do interpretador -x e true se a opção -l estiver definida.

Somente leitura.
32 $ -p
O valor da opção do interpretador -x e true se a opção -pis estiver definida.

Somente leitura.
$_
33
A variável local, última string lida por gets ou readline no escopo atual.
$~
34 A variável local, MatchData , relativa à última correspondência. Regex #

match method retorna as informações da última correspondência.
$ n ($ 1, $ 2, $ 3 ...)
35 A string correspondida no enésimo grupo da última correspondência de

padrões. Equivalente a m [n], onde m é um objeto MatchData .
$E
36 A string correspondida na última correspondência de padrões. Equivalente a m

[0], em que m é um objeto MatchData .
$`
37 A string que precede a correspondência na última correspondência de padrão.

Equivalente a m.pre_match, em que m é um objeto MatchData .
$'
38 A string que segue a correspondência na última correspondência de padrão.

Equivalente a m.post_match, em que m é um objeto MatchData.
$+
39 A string correspondente ao último grupo correspondido com sucesso na última

correspondência de padrão.
Ruby - constantes predefinidas

A tabela a seguir lista todas as constantes predefinidas do Ruby -
NOTA - VERDADEIRO, FALSO e NIL são compatíveis com versões anteriores. É

preferível usar true, false e nil.
Sr. Nome Constante e Descrição

Não.
1 VERDADE
Sinônimo de verdadeiro.
FALSO
2
Sinônimo de falso.
NADA
3
Sinônimo para nil.
ARGF
Um objeto que fornece acesso à concatenação virtual de arquivos passados

4
como argumentos de linha de comando ou entrada padrão, se não houver
argumentos de linha de comando. Um sinônimo para $ <.
ARGV
5 Uma matriz contendo os argumentos da linha de comando passados para o

programa. Um sinônimo para $ *.
DADOS
6 Um fluxo de entrada para ler as linhas de código seguindo a diretiva __END__.

Não definido se __END__ não estiver presente no código.
ENV
7 Um objeto semelhante a um hash contendo as variáveis de ambiente do

programa. ENV pode ser tratado como um hash.
RUBY_PLATFORM
8
Uma string indicando a plataforma do interpretador Ruby.
RUBY_RELEASE_DATE
9
Uma string indicando a data de lançamento do interpretador Ruby
RUBY_VERSION
10
Uma string indicando a versão do interpretador Ruby.
STDERR
11
Fluxo de saída de erro padrão. Valor padrão de $ stderr .
12 STDIN
Fluxo de entrada padrão. Valor padrão de $ stdin.
STDOUT
13
Fluxo de saída padrão. Valor padrão de $ stdout.
TOPLEVEL_BINDING
14
Um objeto de ligação no nível superior do Ruby.
Ruby - Ferramentas Associadas

Ferramentas Ruby Padrão
A distribuição padrão do Ruby contém ferramentas úteis junto com o interpretador e
bibliotecas padrão -
Essas ferramentas ajudam você a depurar e melhorar seus programas Ruby sem gastar
muito esforço. Este tutorial lhe dará um bom começo com essas ferramentas.
RubyGems -
O RubyGems é um utilitário de pacote para o Ruby, que instala pacotes de

software Ruby e os mantém atualizados.
Depurador Ruby -
Para ajudar a lidar com erros, a distribuição padrão do Ruby inclui um

depurador. Isso é muito semelhante ao utilitário gdb , que pode ser usado para
depurar programas complexos.
Ruby Interativo (irb) -
O irb (Interactive Ruby) foi desenvolvido por Keiju Ishitsuka. Ele permite que
você insira comandos no prompt e faça o interpretador responder como se você
estivesse executando um programa. O irb é útil para experimentar ou explorar o
Ruby.
Ruby Profiler -
O profiler Ruby ajuda você a melhorar o desempenho de um programa lento

encontrando o gargalo.
Ferramentas adicionais de Ruby

Existem outras ferramentas úteis que não vêm incluídas na distribuição padrão do
Ruby. No entanto, você precisa instalá-los você mesmo.
eRuby: Ruby Embeded -
eRuby significa Ruby incorporado. É uma ferramenta que incorpora fragmentos

de código Ruby em outros arquivos, como arquivos HTML similares a ASP, JSP e
PHP.
ri: Ruby Interactive Reference -
Quando você tem uma pergunta sobre o comportamento de um determinado

método, você pode invocar o ri para ler a breve explicação do método.
Para mais informações sobre ferramentas e recursos Ruby, dê uma olhada nos
Recursos Úteis do Ruby .
 Página anterior Próxima página 
FAQ's Política de Cookies Contato

© Copyright 2018. Todos os direitos reservados.
Enter email for newsletter vai

Guia Rápido de Ruby

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Guia Rápido de Ruby

Enviado por

Direitos autorais:

Formatos disponíveis



Ruby - Guia rápido

 Página anterior Próxima página 

Ruby - Visão Geral

Você pode encontrar o nome Yukihiro Matsumoto na lista de discussão Ruby em

Ruby é "o melhor amigo de um programador".

Ruby é uma linguagem de programação interpretada de propósito geral.

Ruby é uma verdadeira linguagem de programação orientada a objetos.

Ruby é uma linguagem de script do lado do servidor semelhante a Python e

Ruby pode ser incorporado no HTML (Hypertext Markup Language).

Ruby tem uma sintaxe semelhante à de muitas linguagens de programação

Ruby é muito escalável e grandes programas escritos em Ruby são facilmente

O Ruby pode ser instalado em ambientes Windows e POSIX.

O Ruby pode ser facilmente conectado ao DB2, MySQL, Oracle e Sybase.

Ferramentas que você precisará

Sistema operacional Linux ou Windows 95/98/2000 / NT ou Windows 7.

Servidor Web Apache 1.3.19-5.

Navegador da Web do Internet Explorer 5.0 ou superior.

Ruby - Configuração do Ambiente

Instalação Ruby no Linux / Unix - Se você planeja ter seu ambiente de

Instalação Ruby no Windows - Se você planeja ter seu ambiente de

Editores de rubis populares

Se você estiver trabalhando na máquina Windows, poderá usar qualquer editor

RubyWin é um Ambiente de Desenvolvimento Integrado (IDE) para Windows.

O Ambiente de Desenvolvimento Ruby (RDE) também é um IDE muito bom

Ruby Interativo (IRb)

puts "Hello, Ruby!";

Isso produzirá o seguinte resultado -

Espaço em branco no programa Ruby

Endings de linha no programa Ruby

Os nomes dos identificadores Ruby podem consistir em caracteres alfanuméricos e o

INÍCIO Faz Próximo então

FIM outro nada verdade

alias elsif não undef

e fim ou a não ser que

início garantir refazer até

pausa falso resgatar quando

caso para tente novamente enquanto

classe E se Retorna enquanto

def em auto __ARQUIVO__

definiram? módulo super __LINHA__

Aqui documento em Ruby

Se o terminador for citado, o tipo de aspas determina o tipo do literal da cadeia

Aqui estão exemplos diferentes -

print <<"EOF"; # same as above

print <<`EOC` # execute commands

print <<"foo", <<"bar" # you can stack them

Isso produzirá o seguinte resultado -

This is the first way of creating

Ruby BEGIN Statement

Declara o código a ser chamado antes que o programa seja executado.

puts "This is main Ruby Program"

Isso produzirá o seguinte resultado -

Initializing Ruby Program

Declaração Ruby END

Declara o código a ser chamado no final do programa.

puts "This is main Ruby Program"

Isso produzirá o seguinte resultado -

Initializing Ruby Program

# I am a comment. Just ignore me.

name = "Madisetti" # This is again comment

Você pode comentar várias linhas da seguinte maneira -

Ruby - Classes e Objetos

def em auto ARQUIVO

definiram? módulo super LINHA

FILE - O nome do arquivo de origem atual.

LINE - O número da linha atual no arquivo de origem.

puts "Multiplication Value : #{246060}";