Ruby - Guia Rápido

Ruby é uma linguagem de programação puramente 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 is "A Programmer's Best Friend".

Ruby tem recursos semelhantes aos de Smalltalk, Perl e Python. Perl, Python e Smalltalk são linguagens de script. Smalltalk é uma verdadeira linguagem orientada a objetos. Ruby, como Smalltalk, é uma linguagem orientada a objetos perfeita. Usar a sintaxe Ruby é muito mais fácil do que usar a sintaxe Smalltalk.

Características 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 de interface comum de gateway (CGI).

  • Ruby pode ser embutido em Hypertext Markup Language (HTML).

  • Ruby tem uma sintaxe limpa e fácil que permite que um novo desenvolvedor aprenda de forma 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 de fácil manutenção.

  • Ruby pode ser usado para desenvolver aplicativos de Internet e intranet.

  • Ruby pode ser instalado em ambientes Windows e POSIX.

  • Ruby oferece suporte a muitas ferramentas de GUI, como Tcl / Tk, GTK e OpenGL.

  • Ruby pode ser facilmente conectado a DB2, MySQL, Oracle e Sybase.

  • Ruby tem um rico conjunto de funções integradas, que podem ser usadas diretamente em scripts Ruby.

Ferramentas que você vai precisar

Para executar os exemplos discutidos neste tutorial, você precisará de um computador mais recente como Intel Core i3 ou i5 com um mínimo de 2 GB de RAM (4 GB de RAM recomendado). Você também precisará do seguinte software -

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

  • Servidor da Web Apache 1.3.19-5.

  • Navegador da Web 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 Ruby. Ele também falará sobre como estender e incorporar aplicativos Ruby.

O que vem a seguir?

O próximo capítulo o orienta onde você pode obter Ruby e sua documentação. Finalmente, ele instrui você sobre como instalar Ruby e preparar um ambiente para desenvolver aplicativos Ruby.

Configuração de ambiente local

Se você ainda deseja configurar seu ambiente para a linguagem de programação Ruby, então vamos prosseguir. Este tutorial vai te ensinar todos os tópicos importantes relacionados à configuração do ambiente. Recomendamos que você leia os seguintes tópicos primeiro e, em seguida, prossiga -

  • Instalação Ruby em Linux / Unix - Se você está planejando ter seu ambiente de desenvolvimento em uma máquina Linux / Unix, então vá até este capítulo.

  • Instalação Ruby no Windows - Se você está planejando ter seu ambiente de desenvolvimento em uma máquina Windows, siga este capítulo.

  • Opções de linha de comando Ruby - Este capítulo lista todas as opções de linha de comando, que você pode usar junto com o interpretador Ruby.

  • Variáveis ​​de ambiente Ruby - Este capítulo tem uma lista de todas as variáveis ​​de ambiente importantes a serem definidas para fazer o Ruby Interpreter funcionar.

Editores de Ruby populares

Para escrever seus programas Ruby, você precisará de um editor -

  • Se você estiver trabalhando em uma máquina Windows, poderá usar qualquer editor de texto simples, como o Bloco de notas 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 Ruby (IDE) para Windows.

  • Ruby Development Environment (RDE) também é um IDE muito bom para usuários do Windows.

Ruby interativo (IRb)

O Interactive Ruby (IRb) fornece um shell para experimentação. No shell do 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 precisa fazer nada extra para ter o IRb funcionando.

Basta digitar irb no seu prompt de comando e uma Sessão Ruby Interativa será iniciada conforme mostrado 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 subsequentes.

O que vem a seguir?

Assumimos agora que você tem um ambiente Ruby funcionando e está pronto para escrever o primeiro programa Ruby. O próximo capítulo irá ensiná-lo a escrever programas Ruby.

Vamos escrever um programa simples em ruby. Todos os arquivos ruby ​​terão extensão.rb. Portanto, coloque o seguinte código-fonte em um arquivo test.rb.

#!/usr/bin/ruby -w

puts "Hello, Ruby!";

Aqui, presumimos que você tenha um 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 Ruby.

Espaço em branco no programa Ruby

Caracteres de espaço em branco, como espaços e tabulações, geralmente são ignorados no código Ruby, exceto quando aparecem em strings. Às vezes, no entanto, eles são usados ​​para interpretar declarações ambíguas. Interpretações desse tipo produzem avisos quando a opção -w é 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)

Fim de linha no programa Ruby

Ruby interpreta ponto-e-vírgulas e caracteres de nova linha como o final de uma instrução. No entanto, se Ruby encontrar operadores, como +, - ou barra invertida 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. Os identificadores Ruby são sensíveis a maiúsculas e 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 sublinhado (_).

Palavras reservadas

A lista a seguir mostra as palavras reservadas em Ruby. Essas palavras reservadas não podem ser usadas como nomes de constantes ou variáveis. Eles podem, entretanto, ser usados ​​como nomes de métodos.

INÍCIO Faz Próximo então
FIM outro nada verdadeiro
apelido elsif não undef
e fim ou a menos que
início garantir refazer até
pausa falso resgate quando
caso para tentar novamente enquanto
classe E se Retorna enquanto
def dentro auto __ARQUIVO__
definiram? módulo super __LINHA__

Aqui Documento em Ruby

"Here Document" refere-se à construção de strings de várias linhas. Seguindo um <<, você pode especificar uma string ou um identificador para terminar a string literal, e todas as linhas seguindo a linha atual até o terminador são o valor da string.

Se o terminador estiver entre aspas, o tipo de aspas determina o tipo do literal de string orientado por linha. Observe que não deve haver espaço entre << e o terminador.

Aqui estão diferentes exemplos -

#!/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

Isso produzirá o seguinte resultado -

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.

Instrução Ruby BEGIN

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"
}

Isso produzirá o seguinte resultado -

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"
}

Isso produzirá o seguinte resultado -

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 após uma declaração ou expressão -

name = "Madisetti" # This is again comment

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

# This is a comment.
# This is a comment, too.
# This is a comment, too.
# I said that already.

Aqui está outro formulário. Este comentário de bloco oculta várias linhas do interpretador com = começo / = fim -

=begin
This is a comment.
This is a comment, too.
This is a comment, too.
I said that already.
=end

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
  • Polymorphism
  • Inheritance

Esses recursos foram discutidos no capítulo Ruby Orientado a Objetos .

Um programa orientado a objetos envolve classes e objetos. Uma classe é o projeto a partir do qual os objetos individuais são criados. Em termos orientados a objetos, dizemos que sua bicicleta é uma instância da classe de objetos conhecida como bicicletas.

Veja o exemplo de qualquer veículo. Inclui rodas, cavalos de força e capacidade do tanque de combustível ou gás. Essas características formam os membros de dados da classe Veículo. 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. Mesmo essas funções formam os membros de dados da classe Veículo. Você pode, portanto, definir uma classe como uma combinação de características e funções.

Um veículo de classe pode ser definido 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 Veículo. Por exemplo, um avião tem três rodas, potência de 1.000 cavalos, combustível como o tipo de tanque e capacidade de 100 litros. Da mesma forma, um carro tem quatro rodas, potência de 200 cavalos, gasolina como tipo de tanque e capacidade para 25 litros.

Definindo uma classe em Ruby

Para implementar a programação orientada a objetos usando Ruby, você precisa primeiro aprender como criar objetos e classes em Ruby.

Uma classe em Ruby sempre começa com a palavra-chave class 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ê termina uma classe usando a palavra-chave end . Todos os membros de dados da classe estão entre a definição da classe e a palavra-chave final .

Variáveis ​​em uma classe Ruby

Ruby fornece quatro tipos de variáveis ​​-

  • Local Variables- Variáveis ​​locais são as variáveis ​​que são 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 subsequente. Variáveis ​​locais começam com uma letra minúscula ou _.

  • Instance Variables- Variáveis ​​de instância estão disponíveis em métodos para qualquer instância ou objeto particular. 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.

  • Class Variables- As 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.

  • Global Variables- Variáveis ​​de classe não estão disponíveis entre classes. Se você deseja ter uma única variável, que está disponível em todas as classes, você precisa definir uma variável global. As variáveis ​​globais são sempre precedidas do 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 em Ruby usando o método new da classe.

O método new é um tipo único de método, que é predefinido na biblioteca Ruby. O novo método pertence aos métodos da classe .

Aqui está o exemplo para criar dois objetos cust1 e cust2 da classe Cliente -

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 (=) após o qual o nome da classe virá. Em seguida, o operador ponto e a palavra-chave new virão em seguida.

Método personalizado 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, você precisa declarar a inicialização do método no momento da criação da classe.

O método de inicialização é 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 de inicialização -

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @cust_id = id
      @cust_name = name
      @cust_addr = addr
   end
end

Neste exemplo, você declara o método de inicialização comid, namee addrcomo variáveis ​​locais. Aqui, def e end são usados ​​para definir uma inicialização de método Ruby . Você aprenderá mais sobre os métodos nos capítulos subsequentes.

No método de inicialização , 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 contêm os valores que são transmitidos 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 pelo nome do método.

O nome do método sempre preferido em lowercase letters. Você termina um método em Ruby usando a palavra-chave end .

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 instruções podem ser qualquer instrução Ruby válida. Por exemplo, podemos colocar um método puts para imprimir Hello Ruby da seguinte maneira -

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 para ver 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

Isso produzirá o seguinte resultado -

Hello Ruby!

Estudo de caso simples

Aqui está um estudo de caso se você quiser praticar mais com a classe e os objetos.

Estudo de caso da turma de Ruby

As 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 por Ruby. Você também já fez uma pequena descrição dessas variáveis ​​no capítulo anterior. Esses cinco tipos de variáveis ​​são explicados neste capítulo.

Variáveis ​​Globais Ruby

Variáveis ​​globais começam com $. Variáveis ​​globais não inicializadas têm o valor nil 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 tornam os programas enigmáticos.

Aqui está um exemplo que mostra 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 -

NOTE - Em Ruby, você PODE acessar o valor de qualquer variável ou constante colocando um caractere hash (#) antes dessa variável ou constante.

Global variable in Class1 is 10
Global variable in Class2 is 10

Variáveis ​​de instância 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 que mostra o uso de Variáveis ​​de instância.

#!/usr/bin/ruby

class Customer
   def initialize(id, name, addr)
      @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
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# 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

Variáveis ​​de classe começam com @@ e devem ser inicializadas antes que possam ser usadas nas definições de método.

Fazer referência a uma variável de classe não inicializada produz um erro. Variáveis ​​de classe são compartilhadas entre 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 que mostra o uso da variável de classe -

#!/usr/bin/ruby

class Customer
   @@no_of_customers = 0
   def initialize(id, name, addr)
      @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
cust1 = Customer.new("1", "John", "Wisdom Apartments, Ludhiya")
cust2 = Customer.new("2", "Poul", "New Empire road, Khandala")

# 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 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 até o final correspondente ou da chave de abertura de um bloco até sua chave de fechamento {}.

Quando uma variável local não inicializada é referenciada, ela é interpretada como uma chamada a um método sem argumentos.

A atribuição a variáveis ​​locais não inicializadas também serve como declaração de variável. As variáveis ​​passam a existir até que o final do escopo atual seja alcançado. O tempo de vida das variáveis ​​locais é determinado quando Ruby analisa o programa.

No exemplo acima, as variáveis ​​locais são id, name e addr.

Ruby Constants

As constantes começam com uma letra maiúscula. As constantes definidas em 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.

As constantes não podem ser definidas nos métodos. Fazer referência a uma constante não inicializada produz um erro. Fazer uma atribuição a uma constante que já foi 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

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 que representa verdadeiro.

  • false - Valor que representa falso.

  • nil - Valor que representa indefinido.

  • __FILE__ - O nome do arquivo de origem atual.

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

Literais básicos de Ruby

As regras que Ruby usa para literais são simples e intuitivas. Esta seção explica todos os literais básicos do Ruby.

Números inteiros

Ruby suporta números inteiros. Um número inteiro pode variar de -2 30 a 2 30-1 ou -2 62 a 2 62-1 . Os inteiros dentro deste intervalo são objetos da classe Fixnum e os inteiros fora deste intervalo são armazenados em objetos da classe Bignum .

Você escreve inteiros usando um sinal opcional, um indicador de base opcional (0 para octal, 0x para hex ou 0b para binário), seguido por uma sequência de dígitos na base apropriada. Os caracteres sublinhados são ignorados na sequência de dígitos.

Você também pode obter o valor inteiro, correspondendo 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

NOTE - 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 string

As strings Ruby são simplesmente sequências de bytes de 8 bits e são objetos da classe String. Strings com aspas duplas permitem substituição e notação de barra invertida, mas strings entre aspas simples não permitem substituição e permitem notação de barra invertida apenas para \\ e \ '

Exemplo

#!/usr/bin/ruby -w

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

Isso produzirá o seguinte resultado -

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 pode ser qualquer expressão rubi.

#!/usr/bin/ruby -w

puts "Multiplication Value : #{24*60*60}";

Isso produzirá o seguinte resultado -

Multiplication Value : 86400

Notações de barra invertida

A seguir está a lista de notações de barra invertida suportadas por Ruby -

Notação Personagem representado
\ n Nova linha (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 Control-x
\ Mx Meta-x (c | 0x80)
\ M- \ Cx Meta-Control-x
\ x Personagem x

Para obter mais detalhes sobre Ruby Strings, leia Ruby Strings .

Ruby Arrays

Literais de Ruby Array são criados colocando uma série separada por vírgulas de referências de objetos 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

Isso produzirá o seguinte resultado -

fred
10
3.14
This is a string
last element

Para obter mais detalhes sobre Ruby Arrays, consulte Ruby Arrays .

Ruby Hashes

Um Ruby Hash literal é criado colocando uma lista de pares de chave / valor entre colchetes, 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

Isso produzirá o seguinte resultado -

red is 3840
green is 240
blue is 15

Para obter mais detalhes sobre Ruby Hashes, vá até Ruby Hashes .

Ruby Ranges

Um intervalo representa um intervalo que é um conjunto de valores com um início e um fim. Os intervalos podem ser construídos usando os literais s..e e s ... e, ou com Range.new.

Faixas construídas usando .. vão do início ao 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 inclui 1, 2, 3, 4, 5 valores e um intervalo (1 ... 5) significa que inclui 1, 2, 3, 4 valores.

Exemplo

#!/usr/bin/ruby

(10..15).each do |n| 
   print n, ' ' 
end

Isso produzirá o seguinte resultado -

10 11 12 13 14 15

Para obter mais detalhes sobre Ruby Ranges, vá até Ruby Ranges .

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 é interpretado 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 Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador Descrição Exemplo
+ Adição - adiciona valores em ambos os lados do operador. a + b dará 30
- Subtração - subtrai o operando direito do operando esquerdo. a - b dará -10
* Multiplicação - Multiplica os valores em ambos os lados do operador. a * b dará 200
/ Divisão - Divide operando esquerdo pelo operando direito. b / a dará 2
% Módulo - Divide o operando esquerdo pelo operando direito e retorna o resto. b% a dará 0
** Expoente - Executa cálculo exponencial (potência) nos operadores. a ** b dará 10 à potência 20

Operadores de comparação Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador Descrição Exemplo
== Verifica se os valores de dois operandos são iguais ou não, se sim a condição torna-se verdadeira. (a == b) não é verdade.
! = Verifica se o valor de dois operandos é igual ou não; se os valores não são iguais, a condição se torna verdadeira. (a! = b) é verdade.
> Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se sim, a condição torna-se verdadeira. (a> b) não é verdade.
< Verifica se o valor do operando esquerdo é menor que o valor do operando direito; se sim, a condição torna-se verdadeira. (a <b) é verdade.
> = Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se sim a condição torna-se verdadeira. (a> = b) não é verdade.
<= Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se sim a condição torna-se verdadeira. (a <= b) é verdadeiro.
<=> Operador de comparação combinada. Retorna 0 se o primeiro operando for igual ao segundo, 1 se o primeiro operando for maior que o segundo e -1 se o primeiro operando for menor que o segundo. (a <=> b) retorna -1.
=== Usado para testar a igualdade dentro de uma cláusula when de uma instrução case . (1 ... 10) === 5 retorna verdadeiro.
.eql? Verdadeiro se o receptor e o argumento tiverem o mesmo tipo e valores iguais. 1 == 1.0 retorna verdadeiro, mas 1.eql? (1.0) é falso.
igual? Verdadeiro se o receptor e o argumento tiverem o mesmo id de objeto. se aObj é duplicado de bObj então aObj == bObj é verdadeiro, a.equal? ​​bObj é falso, mas a.equal? ​​aObj é verdadeiro.

Operadores de atribuição Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador Descrição Exemplo
= Operador de atribuição simples, atribui valores de operandos do lado direito ao operando do lado esquerdo. c = a + b atribuirá o valor de a + b em c
+ = Adicionar operador de atribuição AND, adiciona operando direito ao operando esquerdo e atribui o resultado ao operando esquerdo. c + = a é equivalente a c = c + a
- = Subtrai o operador de atribuição AND, subtrai o operando direito do operando esquerdo e atribui o resultado ao operando esquerdo. c - = a é equivalente a c = c - a
* = Operador de atribuição Multiply AND, multiplica o operando direito pelo operando esquerdo e atribui o resultado ao operando esquerdo. c * = a é equivalente a c = c * a
/ = Operador de atribuição Dividir AND, divide o operando esquerdo com o operando direito e atribui o resultado ao operando esquerdo. c / = a é equivalente a c = c / a
% = O operador de atribuição de módulo AND pega o módulo usando dois operandos e atribui o resultado ao operando esquerdo. c% = a é equivalente a c = c% a
** = O operador de atribuição de expoente AND executa cálculo exponencial (potência) nos operadores e atribui valor ao operando esquerdo. c ** = a é equivalente a c = c ** a

Atribuição Paralela 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 declarado mais rapidamente usando 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 Ruby Bitwise

O operador bit a bit funciona em bits e executa operação bit a bit.

Suponha que a = 60; e b = 13; agora em formato binário 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.

Operador Descrição Exemplo
E O operador Binário AND copia um bit para o resultado se ele existir em ambos os operandos. (a & b) dará 12, que é 0000 1100
| O operador binário OR copia um bit se ele existir em qualquer operando. (a | b) dará 61, que é 0011 1101
^ O operador binário XOR copia o bit se for definido em um operando, mas não em ambos. (a ^ b) dará 49, que é 0011 0001
~ O operador de complemento binários é unário e tem o efeito de 'inverter' bits. (~ a) resultará em -61, que é 1100 0011 na forma de complemento de 2 devido a um número binário com sinal.
<< Operador binário de deslocamento à esquerda. O valor dos operandos à esquerda é movido para a esquerda pelo número de bits especificado pelo operando à direita. um << 2 dará 240, que é 1111 0000
>> Operador binário de deslocamento à direita. O valor dos operandos à esquerda é movido para a direita pelo número de bits especificado pelo operando à direita. a >> 2 dará 15, que é 0000 1111

Operadores lógicos Ruby

Os seguintes operadores lógicos são suportados pela linguagem Ruby

Suponha que a variável a tenha 10 e a variável b tenha 20, então -

Operador Descrição Exemplo
e Operador lógico chamado AND. Se ambos os operandos forem verdadeiros, a condição se torna verdadeira. (aeb) é verdade.
ou Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira. (a ou b) é verdadeiro.
&& Operador lógico chamado AND. Se ambos os operandos forem diferentes de zero, a condição se torna verdadeira. (a && b) é verdadeiro.
|| Operador lógico ou chamado. Se qualquer um dos dois operandos for diferente de zero, a condição se torna verdadeira. (a || b) é verdade.
! Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador lógico NOT tornará falso. ! (a && b) é falso.
não Operador lógico chamado NOT. Use para reverter o estado lógico de seu operando. Se uma condição for verdadeira, o operador lógico NOT tornará falso. not (a && b) é falso.

Operador Ternário Ruby

Existe mais um operador chamado Operador Ternário. Ele primeiro avalia uma expressão para um valor verdadeiro ou falso e, em seguida, executa uma das duas instruções fornecidas, dependendo do resultado da avaliação. O operador condicional tem esta sintaxe -

Operador Descrição Exemplo
? : Expressão Condicional Se a condição for verdadeira? Então valor X: Caso 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 em um valor inicial, um valor final e um intervalo de valores intermediários.

Em Ruby, essas sequências são criadas usando os operadores de intervalo ".." e "...". O formato de dois pontos cria um intervalo inclusivo, enquanto o formato de três pontos cria um intervalo que exclui o valor alto especificado.

Operador Descrição Exemplo
.. Cria um intervalo do ponto inicial ao ponto final, inclusive. 1..10 Cria um intervalo de 1 a 10 inclusive.
... Cria um intervalo do ponto inicial ao ponto final exclusivo. 1 ... 10 Cria um intervalo de 1 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 definido? Operador

Uso 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

Uso 2

defined? method_call # True if a method is defined

For Example

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

For Example

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

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Ruby Dot "." e dois-pontos duplos "::" 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 em uma classe ou módulo, para serem acessados ​​de qualquer lugar fora da classe ou módulo.

Remember em Ruby, classes e métodos também podem ser considerados constantes.

Você precisa apenas prefixar o :: Const_name com uma expressão que retorna a classe ou objeto de módulo apropriado.

Se nenhuma expressão de prefixo for usada, a classe Object principal será 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

Second Example

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 mais alta precedência à mais baixa.

Método Operador Descrição
sim :: Operador de resolução constante
sim [] [] = Referência de elemento, conjunto de elementos
sim ** Exponenciação (elevar à potência)
sim ! ~ + - Não, complemento, mais e menos unários (os 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 para direita e esquerda
sim E 'E' bit a bit
sim ^ | "OR" exclusivo bit a bit e "OR" regular
sim <= <>> = Operadores de comparação
sim <=> == ===! = = ~! ~ Operadores de igualdade e correspondência de padrão (! = E! ~ Não podem ser definidos como métodos)
  && 'E' lógico
  || 'OU' lógico
  .. ... Alcance (inclusivo e exclusivo)
  ? : Ternário if-then-else
  =% = {/ = - = + = | = & = >> = << = * = && = || = ** = Tarefa
  definiram? Verifique se o símbolo especificado está definido
  não Negação lógica
  ou e Composição lógica

NOTE- Os operadores com um Sim na coluna do método são na verdade métodos e, como tal, podem ser substituídos.

Comentários são linhas de anotação no código Ruby que são ignoradas no tempo de execução. Um comentário de uma única linha começa com o caractere # e 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!

Comentários Ruby Multiline

Você pode comentar várias linhas usando =begin e =end sintaxe 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

Quando executado, o programa acima produz o seguinte resultado -

Hello, Ruby!

Certifique-se de que os comentários finais estejam distantes o suficiente do código e que sejam facilmente distinguidos. Se houver mais de um comentário final 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 oferece estruturas condicionais que são bastante comuns às linguagens modernas. Aqui, explicaremos todas as instruções condicionais e modificadores disponíveis em Ruby.

Declaração Ruby if ... else

Sintaxe

if conditional [then]
   code...
[elsif conditional [then]
   code...]...
[else
   code...]
end

se as expressões são usadas para execução condicional. Os valores false e nil são false e tudo o mais é true. Observe que o Ruby usa elsif, não else if nem elif.

Executa o código se a condicional for verdadeira. Se a condição não for verdadeira, o código especificado na cláusula else é executado.

Uma condicional de expressão if é separada do código pela palavra reservada then , 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

Isso produzirá o seguinte resultado -

debug

Ruby a menos que declaração

Sintaxe

unless conditional [then]
   code
[else
   code ]
end

Executa o código se condicional for falsa. Se a condição for verdadeira, o código especificado na cláusula else é executado.

Exemplo

#!/usr/bin/ruby

x = 1 
unless x>=2
   puts "x is less than 2"
 else
   puts "x is greater than 2"
end

Isso produzirá o seguinte resultado -

x is less than 2

Ruby a menos que modificador

Sintaxe

code unless conditional

Executa o código se condicional for falsa.

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

Isso produzirá o seguinte resultado -

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 caso e aquela especificada por ao usar o operador === e executa o código da cláusula when correspondente.

A expressão especificada pela cláusula when é avaliada como o operando esquerdo. Se nenhuma cláusula when coincidir, case executa o código da cláusula else .

A expressão de uma instrução when é separada do código pela palavra reservada then, 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

Isso produzirá o seguinte resultado -

little child

Loops em Ruby são usados ​​para executar o mesmo bloco de código um determinado número de vezes. Este capítulo detalha todas as instruções de loop suportadas por Ruby.

Ruby while Declaração

Sintaxe

while conditional [do]
   code
end

Executa o código enquanto a condição for 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

Isso produzirá o seguinte resultado -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Ruby enquanto modificador

Sintaxe

code while condition

OR

begin 
  code 
end while conditional

Executa o código enquanto a condição for verdadeira.

Se um modificador while segue uma instrução begin sem cláusulas de resgate ou de garantia, o código é executado uma vez antes de o condicional ser avaliado.

Exemplo

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1
end while $i < $num

Isso produzirá o seguinte resultado -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4

Ruby até declaração

until conditional [do]
   code
end

Executa código enquanto condicional é falsa. A condicional de uma instrução até é 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
   puts("Inside the loop i = #$i" )
   $i +=1;
end

Isso produzirá o seguinte resultado -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Ruby até modificador

Sintaxe

code until conditional

OR

begin
   code
end until conditional

Executa código enquanto condicional é falsa.

Se um modificador until segue uma instrução begin sem cláusulas de salvamento ou de garantia, o código é executado uma vez antes de o condicional ser avaliado.

Exemplo

#!/usr/bin/ruby

$i = 0
$num = 5
begin
   puts("Inside the loop i = #$i" )
   $i +=1;
end until $i > $num

Isso produzirá o seguinte resultado -

Inside the loop i = 0
Inside the loop i = 1
Inside the loop i = 2
Inside the loop i = 3
Inside the loop i = 4
Inside the loop i = 5

Ruby para declaração

Sintaxe

for variable [, variable ...] in expression [do]
   code
end

Executa o código uma vez para cada elemento da 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 instrução para i em 0..5 permitirá que i assuma valores no intervalo de 0 a 5 (incluindo 5). Isso produzirá o seguinte resultado -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

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

(expression).each do |variable[, variable...]| code end

exceto que um de loop não criar um novo escopo para 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|
   puts "Value of local variable is #{i}"
end

Isso produzirá o seguinte resultado -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Declaração de quebra de Ruby

Sintaxe

break

Termina o loop mais interno. Termina 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
   puts "Value of local variable is #{i}"
end

Isso produzirá o seguinte resultado -

Value of local variable is 0
Value of local variable is 1
Value of local variable is 2

Próxima declaração Ruby

Sintaxe

next

Pula para a próxima iteração do loop mais interno. Termina a execução de um bloco se chamada dentro de um bloco (com rendimento ou chamada retornando nulo).

Exemplo

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      next
   end
   puts "Value of local variable is #{i}"
end

Isso produzirá o seguinte resultado -

Value of local variable is 2
Value of local variable is 3
Value of local variable is 4
Value of local variable is 5

Declaração de refazer Ruby

Sintaxe

redo

Reinicia esta iteração do loop mais interno, sem verificar a condição do loop. Reinicia o rendimento ou chamada se chamado dentro de um bloco.

Exemplo

#!/usr/bin/ruby

for i in 0..5
   if i < 2 then
      puts "Value of local variable is #{i}"
      redo
   end
end

Isso produzirá o seguinte resultado e entrará em um loop infinito -

Value of local variable is 0
Value of local variable is 0
............................

Instrução Ruby Retry

Sintaxe

retry

Se a nova tentativa aparecer na cláusula de resgate da expressão inicial, reinicie do início do corpo inicial.

begin
   do_something # exception raised
rescue
   # handles error
   retry  # restart from beginning
end

Se a nova tentativa aparecer no iterador, o bloco ou o corpo da expressão for reinicia a chamada da chamada do iterador. Os 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
puts "Value of local variable is #{i}"
end

Isso produzirá o seguinte resultado e entrará em um loop infinito -

Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
Value of local variable is 1
Value of local variable is 2
............................

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 repetíveis 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 chamada de método indefinido.

Sintaxe

def method_name [( [arg [= default]]...[, * arg [, &expr ]])]
   expr..
end

Portanto, você pode definir um método simples da seguinte maneira -

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 os parâmetros necessários -

def method_name (var1 = value1, var2 = value2)
   expr..
end

Sempre que você chama o método simples, você escreve apenas o nome do método da seguinte forma -

method_name

No entanto, ao chamar um método com parâmetros, você 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 se lembrar do 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, 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

Isso produzirá o seguinte resultado -

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

Cada método em Ruby retorna um valor por padrão. Este valor retornado será o valor da última instruçã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 Ruby

A instrução return 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 fornecida, 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

Isso produzirá o seguinte resultado -

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, você precisará passar dois parâmetros junto com ele.

No entanto, Ruby permite que você declare 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"

Neste código, você declarou um exemplo de método que aceita um teste de parâmetro. No entanto, este parâmetro é um parâmetro variável. Isso significa que este parâmetro pode receber qualquer número de variáveis. Portanto, o código acima 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 da 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ê deseja acessar um método de uma classe, primeiro você precisa instanciar a classe. Então, usando o objeto, você pode acessar qualquer membro da classe.

Ruby oferece 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 ponto, 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, não é necessário criar objetos da classe Contas.

Declaração de alias Ruby

Isso fornece alias para 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.

É proibido criar apelidos para as variáveis ​​globais numeradas ($ 1, $ 2, ...). Substituir as variáveis ​​globais integradas pode causar problemas sérios.

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 alias para $ &

Declaração Ruby undef

Isso cancela a definição do método. Um undef não pode aparecer no corpo do método.

Usando undef e alias , a interface da classe pode ser modificada independentemente da superclasse, mas observe que pode haver programas interrompidos pela chamada do método interno para self.

Sintaxe

undef method-name

Exemplo

Para cancelar a definição de um método chamado bar, faça o seguinte -

undef bar

Você viu como Ruby define métodos onde você pode colocar um número de instruções e então chamar esse método. Da mesma forma, Ruby tem um conceito de Bloco.

  • Um bloco consiste em pedaços de código.

  • Você atribui um nome a um bloco.

  • O código no bloco está sempre entre colchetes ({}).

  • Um bloco é sempre invocado a partir de uma função com o mesmo nome do bloco. Isso significa que, se você tiver um bloco com o nome teste , use o teste de função para invocar esse bloco.

  • Você invoca um bloco usando a instrução de rendimento .

Sintaxe

block_name {
   statement1
   statement2
   ..........
}

Aqui, você aprenderá a invocar um bloco usando uma instrução de rendimento simples . Você também aprenderá a usar uma instrução de rendimento com parâmetros para invocar um bloco. Você verificará o código de amostra com os dois tipos de declarações de rendimento .

A declaração de rendimento

Vejamos 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"}

Isso produzirá o seguinte resultado -

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}"}

Isso produzirá o seguinte resultado -

You are in the block 5
You are in the method test
You are in the block 100

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 para 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 instrução puts -

puts "You are in the block #{i}"

A saída desta instrução puts é -

You are in the block 5

Se você deseja 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 um ao outro. Normalmente, você invoca um bloco usando a instrução yield de um método que tem 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 for 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 * e & estarem presentes na lista de argumentos, & deve vir depois.

#!/usr/bin/ruby

def test(&block)
   block.call
end
test { puts "Hello World!"}

Isso produzirá o seguinte resultado -

Hello World!

Blocos BEGIN e END

Cada arquivo fonte Ruby pode declarar blocos de código a serem executados enquanto o arquivo está sendo carregado (os blocos BEGIN) e após o programa terminar de ser executado (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. Quando executado, o programa acima produz o seguinte resultado -

BEGIN code block
MAIN code block
END code block

Módulos são uma forma de agrupar métodos, classes e constantes. Os módulos oferecem dois benefícios principais.

  • Os módulos fornecem um namespace e evitam conflitos de nomes.

  • Módulos implementam a facilidade mixin .

Os módulos definem um namespace, uma caixa de areia 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 exatamente como as constantes de classe, com uma letra inicial maiúscula. As definições de método também são semelhantes: os métodos de módulo são definidos como os métodos de classe.

Como acontece com os 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 com 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 o nome do método.

Declaração de requerer Ruby

A instrução require é semelhante à instrução include do C e C ++ e à instrução import do Java. Se um terceiro programa deseja 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 dar .rb extensão 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, você pode usarrequire_relative para incluir arquivos de um diretório relativo.

IMPORTANT- Aqui, ambos os arquivos contêm o mesmo nome de função. Portanto, isso resultará em ambigüidade de código ao incluir na chamada do programa, mas os módulos evitam essa ambiguidade de 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 for definido em um arquivo separado, será necessário incluir esse arquivo usando a instrução require antes de incorporar 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

Isso produzirá o seguinte resultado -

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, presumimos que você tenha conhecimento dos 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 herança múltipla diretamente, mas os Módulos Ruby têm outro uso maravilhoso. De uma só vez, eles praticamente eliminam a necessidade de herança múltipla, fornecendo um recurso chamado mixin .

Mixins oferecem uma maneira maravilhosamente controlada de adicionar funcionalidade às classes. No entanto, seu verdadeiro poder surge quando o código no mixin começa a interagir com o código da classe que o usa.

Vamos examinar o seguinte código de amostra 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. 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 é herdada de ambos os módulos. Assim, você pode dizer que a classe Sample mostra herança múltipla ou um mixin .

Um objeto String em Ruby mantém e manipula uma sequê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 apóstrofo). O texto entre aspas é o valor da string -

'This is a simple Ruby string literal'

Se você precisar colocar um apóstrofo dentro de um literal de string entre aspas simples, coloque uma barra invertida antes dele, para que o interpretador Ruby não pense que ele termina a string -

'Won\'t you read O\'Reilly\'s book?'

A barra invertida também funciona para escapar de outra barra invertida, de forma que a segunda barra invertida não seja interpretada como um caractere de escape.

A seguir estão os recursos relacionados a strings de Ruby.

Substituição de Expressão

A substituição de expressão é um meio de embutir 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 }."

Isso produzirá o seguinte resultado -

The value of x is 12.
The sum of x and y is 48.
The average was 40.

Cordas Delimitadas Gerais

Com strings delimitadas gerais, você pode criar strings dentro de um par de caracteres delimitadores arbitrários, por exemplo,!, (, {, <, Etc., precedidos por um caractere de porcentagem (%). Q, q e x têm significados especiais . Strings delimitadas gerais 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

NOTE- Em uma string entre aspas duplas, um caractere de escape é interpretado; em uma string entre aspas simples, um caractere de escape é preservado.

Notação de barra invertida Caráter hexadecimal Descrição
\uma 0x07 Sino ou alerta
\ b 0x08 Backspace
\ cx   Control-x
\ Cx   Control-x
\ e 0x1b Escapar
\ f 0x0c Formfeed
\ M- \ Cx   Meta-Control-x
\ n 0x0a Nova linha
\ nnn   Notação octal, onde n está no intervalo de 0,7
\ r 0x0d Retorno de carruagem
\ s 0x20 Espaço
\ t 0x09 Aba
\ v 0x0b Guia vertical
\ x   Personagem x
\ xnn   Notação hexadecimal, em que n está no intervalo 0,9, af ou AF

Codificação de Caracteres

O conjunto de caracteres padrão para Ruby é ASCII, cujos caracteres podem ser representados por bytes únicos. Se você usar UTF-8 ou outro conjunto de caracteres moderno, os caracteres podem ser representados em um a quatro bytes.

Você pode alterar seu conjunto de caracteres usando $ KCODE no início de seu programa, assim -

$KCODE = 'u'
Sr. Não. Código e Descrição
1

a

ASCII (igual a nenhum). Este é o padrão.

2

e

EUC.

3

n

Nenhum (igual ao ASCII).

4

u

UTF-8.

Métodos integrados 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 string contendo uma cópia de str . Agora, usando o objeto str , todos nós podemos usar quaisquer métodos de instância disponíveis. Por exemplo -

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

Isso produzirá o seguinte resultado -

this is test
Sr. Não. Métodos e Descrição
1

str % arg

Formata uma string usando uma especificação de formato. arg deve ser uma matriz se contiver mais de uma substituição. Para obter informações sobre a especificação do formato, consulte sprintf em "Módulo de kernel".

2

str * integer

Retorna uma nova string contendo número inteiro vezes str. Em outras palavras, str são imes inteiros repetidos.

3

str + other_str

Concatena other_str para str.

4

str << obj

Concatena um objeto a str. Se o objeto for um Fixnum no intervalo de 0,255, ele será convertido em um caractere. Compare-o com concat.

5

str <=> other_str

Compara str com other_str, retornando -1 (menor que), 0 (igual) ou 1 (maior que). A comparação diferencia maiúsculas de minúsculas.

6

str == obj

Testa str e obj para igualdade. Se obj não for uma String, retorna falso; retorna verdadeiro se str <=> obj retornar 0.

7

str =~ obj

Corresponde str a um padrão de expressão regular obj. Retorna a posição onde a partida começa; caso contrário, false.

8

str.capitalize

Capitaliza uma string.

9

str.capitalize!

O mesmo que capitalizar, mas as alterações são feitas no local.

10

str.casecmp

Faz uma comparação de strings que não diferencia maiúsculas de minúsculas.

11

str.center

Centraliza uma corda.

12

str.chomp

Remove o separador de registro ($ /), geralmente \ n, do final de uma string. Se não houver separador de registro, não faz nada.

13

str.chomp!

O mesmo que chomp, mas as alterações são feitas no local.

14

str.chop

Remove o último caractere em str.

15

str.chop!

O mesmo que cortar, mas as alterações são feitas no local.

16

str.concat(other_str)

Concatena other_str para str.

17

str.count(str, ...)

Conta um ou mais conjuntos de caracteres. Se houver mais de um conjunto de caracteres, conta a interseção desses conjuntos

18

str.crypt(other_str)

Aplica um hash criptográfico unilateral a str. O argumento é a string salt, que deve ter dois caracteres, cada caractere no intervalo az, AZ, 0,9,. ou /.

19

str.delete(other_str, ...)

Retorna uma cópia de str com todos os caracteres na interseção de seus argumentos excluídos.

20

str.delete!(other_str, ...)

O mesmo que excluir, mas as alterações são feitas no local.

21

str.downcase

Retorna uma cópia de str com todas as letras maiúsculas substituídas por minúsculas.

22

str.downcase!

Igual ao downcase, mas as alterações são feitas no local.

23

str.dump

Retorna uma versão de str com todos os caracteres não imprimíveis substituídos pela notação \ nnn e todos os caracteres especiais com escape.

24

str.each(separator = $/) { |substr| block }

Divide str usando o argumento como separador de registro ($ / por padrão), passando cada substring para o bloco fornecido.

25

str.each_byte { |fixnum| block }

Passa cada byte de str para o bloco, retornando cada byte como uma representação decimal do byte.

26

str.each_line(separator=$/) { |substr| block }

Divide str usando o argumento como separador de registro ($ / por padrão), passando cada substring para o bloco fornecido.

27

str.empty?

Retorna verdadeiro se str estiver vazio (tem comprimento zero).

28

str.eql?(other)

Duas strings são iguais se tiverem o mesmo comprimento e conteúdo.

29

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

Retorna uma cópia de str com todas as ocorrências de padrão substituídas por substituição ou o valor do bloco. O padrão normalmente será um Regexp; se for uma string, nenhum metacaractere de expressão regular será interpretado (ou seja, / \ d / corresponderá a um dígito, mas '\ d' corresponderá a uma barra invertida seguida por um 'd')

30

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

Referências str, usando os seguintes argumentos: um Fixnum, retorna um código de caractere em fixnum; dois Fixnums, retorna uma substring começando em um deslocamento (primeiro fixnum) até o comprimento (segundo fixnum); intervalo, retorna uma substring no intervalo; regexp retorna parte da string combinada; regexp com fixnum, retorna os dados correspondentes em fixnum; other_str retorna substring que corresponde a other_str. Um Fixnum negativo começa no final da string com -1.

31

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ]

Substitua (atribua) toda ou parte de uma string. Sinônimo de fatia !.

32

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block }

Executa as substituições de String # gsub no lugar, retornando str ou nil se nenhuma substituição foi realizada.

33

str.hash

Retorna um hash com base no comprimento e no conteúdo da string.

34

str.hex

Trata os caracteres iniciais de str como uma sequência de dígitos hexadecimais (com um sinal opcional e um 0x opcional) e retorna o número correspondente. Zero é retornado em caso de erro.

35

str.include? other_str [or] str.include? fixnum

Retorna verdadeiro se str contiver a string ou caractere fornecido.

36

str.index(substring [, offset]) [or]

str.index(fixnum [, offset]) [or]

str.index(regexp [, offset])

Retorna o índice da primeira ocorrência da substring, caractere (fixnum) ou padrão (regexp) fornecida em str. Retorna nulo se não for encontrado. Se o segundo parâmetro estiver presente, ele especifica a posição na string para iniciar a pesquisa.

37

str.insert(index, other_str)

Insere other_str antes do caractere no índice fornecido, modificando str. Índices negativos contam a partir do final da string e são inseridos após o caractere fornecido. A intenção é inserir uma string de forma que comece no índice fornecido.

38

str.inspect

Retorna uma versão imprimível de str, com caracteres especiais escapados.

39

str.intern [or] str.to_sym

Retorna o símbolo correspondente a str, criando o símbolo se ele não existisse anteriormente.

40

str.length

Retorna o comprimento de str. Compare o tamanho.

41

str.ljust(integer, padstr = ' ')

Se inteiro for maior que o comprimento de str, retorna uma nova String de comprimento inteiro com str justificado à esquerda e preenchido com padstr; caso contrário, retorna str.

42

str.lstrip

Retorna uma cópia de str com os espaços em branco à esquerda removidos.

43

str.lstrip!

Remove o espaço em branco inicial de str, retornando nulo se nenhuma alteração foi feita.

44

str.match(pattern)

Converte o padrão em um Regexp (se ainda não for um) e, a seguir, invoca seu método de correspondência em str.

45

str.oct

Trata os caracteres iniciais de str como uma sequência de dígitos octais (com um sinal opcional) e retorna o número correspondente. Retorna 0 se a conversão falhar.

46

str.replace(other_str)

Substitui o conteúdo e contaminação de str pelos valores correspondentes em other_str.

47

str.reverse

Retorna uma nova string com os caracteres de str na ordem inversa.

48

str.reverse!

Inverte str no lugar.

49

str.rindex(substring [, fixnum]) [or]

str.rindex(fixnum [, fixnum]) [or]

str.rindex(regexp [, fixnum])

Retorna o índice da última ocorrência da substring, caractere (fixnum) ou padrão (regexp) fornecida em str. Retorna nulo se não for encontrado. Se o segundo parâmetro estiver presente, ele especifica a posição na string para finalizar a pesquisa. Caracteres além deste ponto não serão considerados.

50

str.rjust(integer, padstr = ' ')

Se inteiro for maior que o comprimento de str, retorna uma nova String de comprimento inteiro com str justificado à direita e preenchido com padstr; caso contrário, retorna str.

51

str.rstrip

Retorna uma cópia de str com o espaço em branco final removido.

52

str.rstrip!

Remove o espaço em branco à direita de str, retornando nulo se nenhuma alteração foi feita.

53

str.scan(pattern) [or]

str.scan(pattern) { |match, ...| block }

Ambas as formas iteram por meio de str, correspondendo ao padrão (que pode ser um Regexp ou uma String). Para cada correspondência, um resultado é gerado e adicionado ao array de resultados ou passado para o bloco. Se o padrão não contém grupos, cada resultado individual consiste na string correspondente, $ &. Se o padrão contém grupos, cada resultado individual é em si uma matriz contendo uma entrada por grupo.

54

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]

str.slice(range) [or] str.slice(regexp) [or]

str.slice(regexp, fixnum) [or] str.slice(other_str)

See str[fixnum], etc.

str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or]

str.slice!(range) [or] str.slice!(regexp) [or]

str.slice!(other_str)

Exclui a parte especificada de str e retorna a parte excluída. As formas que assumem Fixnum geram um IndexError se o valor estiver fora do intervalo; o formulário Range levantará um RangeError, e os formulários Regexp e String irão ignorar silenciosamente a atribuição.

55

str.split(pattern = $, [limit])

Divide str em substrings com base em um delimitador, retornando uma matriz dessas substrings.

Se pattern for uma String, então seu conteúdo será usado como delimitador ao dividir str. Se o padrão for um único espaço, str é dividido em espaços em branco, com espaços em branco iniciais e execuções de caracteres de espaço em branco contíguos ignorados.

Se o padrão for um Regexp, str será dividido onde o padrão corresponder. Sempre que o padrão corresponde a uma string de comprimento zero, str é dividido em caracteres individuais.

Se o padrão for omitido, o valor de$; is used. If $; é nil (que é o padrão), str é dividido em espaços em branco como se `` fosse especificado.

Se o parâmetro limit for omitido, os campos nulos à direita serão suprimidos. Se limite for um número positivo, no máximo esse número de campos será retornado (se limite for 1, toda a string é retornada como a única entrada em uma matriz). Se negativo, não há limite para o número de campos retornados e os campos nulos à direita não são suprimidos.

56

str.squeeze([other_str]*)

Cria um conjunto de caracteres a partir do (s) parâmetro (s) other_str usando o procedimento descrito para String # count. Retorna uma nova string em que as execuções do mesmo caractere que ocorrem neste conjunto são substituídas por um único caractere. Se nenhum argumento for fornecido, todas as execuções de caracteres idênticos serão substituídas por um único caractere.

57

str.squeeze!([other_str]*)

Aperta str no lugar, retornando str ou nil se nenhuma alteração foi feita.

58

str.strip

Retorna uma cópia de str com os espaços em branco à esquerda e à direita removidos.

59

str.strip!

Remove os espaços em branco à esquerda e à direita de str. Retorna nil se str não foi alterado.

60

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

Retorna uma cópia de str com a primeira ocorrência do padrão substituída por substituição ou pelo valor do bloco. O padrão normalmente será um Regexp; se for uma string, nenhum metacaractere de expressão regular será interpretado.

61

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

Executa as substituições de String # sub no lugar, retornando str ou nil se nenhuma substituição foi realizada.

62

str.succ [or] str.next

Retorna o sucessor de str.

63

str.succ! [or] str.next!

Equivalente a String # succ, mas modifica o receptor no lugar.

64

str.sum(n = 16)

Retorna uma soma de verificação básica de n bits dos caracteres em str, onde n é o parâmetro Fixnum opcional, padronizado como 16. O resultado é simplesmente a soma do valor binário de cada caractere em str módulo 2n - 1. Este não é um particularmente boa soma de verificação.

65

str.swapcase

Retorna uma cópia de str com caracteres alfabéticos maiúsculos convertidos em minúsculas e caracteres minúsculos convertidos em maiúsculas.

66

str.swapcase!

Equivalente a String # swapcase, mas modifica o receptor no lugar, retornando str ou nil se nenhuma alteração foi feita.

67

str.to_f

> Retorna o resultado da interpretação dos caracteres iniciais em str como um número de ponto flutuante. Caracteres estranhos após o final de um número válido são ignorados. Se não houver um número válido no início de str, 0.0 é retornado. Este método nunca levanta uma exceção.

68

str.to_i(base = 10)

Retorna o resultado da interpretação dos caracteres iniciais em str como uma base inteira (base 2, 8, 10 ou 16). Caracteres estranhos após o final de um número válido são ignorados. Se não houver um número válido no início de str, 0 é retornado. Este método nunca levanta uma exceção.

69

str.to_s [or] str.to_str

Retorna o receptor.

70

str.tr(from_str, to_str)

Retorna uma cópia de str com os caracteres em from_str substituídos pelos caracteres correspondentes em to_str. Se to_str for mais curto que from_str, ele será preenchido com seu último caractere. Ambas as strings podem usar a notação c1.c2 para denotar intervalos de caracteres, e from_str pode começar com um ^, que denota todos os caracteres, exceto aqueles listados.

71

str.tr!(from_str, to_str)

Traduz str no lugar, usando as mesmas regras da String # tr. Retorna str ou nil se nenhuma alteração foi feita.

72

str.tr_s(from_str, to_str)

Processa uma cópia de str conforme descrito em String # tr e, em seguida, remove caracteres duplicados em regiões que foram afetadas pela tradução.

73

str.tr_s!(from_str, to_str)

Executa o processamento da String # tr_s em str no lugar, retornando str ou nil se nenhuma alteração foi feita.

74

str.unpack(format)

> Decodifica str (que pode conter dados binários) de acordo com a string de formato, retornando um array de cada valor extraído. A string de formato consiste em uma sequência de diretivas de caractere único, resumidas na Tabela 18. Cada diretiva pode ser seguida por um número, indicando o número de vezes para repetir com esta diretiva. Um asterisco (*) usará todos os elementos restantes. Cada uma das diretivas sSiIlL pode ser seguida por um sublinhado (_) para usar o tamanho nativo da plataforma subjacente para o tipo especificado; caso contrário, ele usa um tamanho consistente independente da plataforma. Os espaços são ignorados na string de formato.

75

str.upcase

Retorna uma cópia de str com todas as letras minúsculas substituídas por suas contrapartes maiúsculas. A operação é insensível ao local. Apenas os caracteres de a a z são afetados.

76

str.upcase!

Altera o conteúdo de str para maiúsculas, retornando nil se nenhuma alteração for feita.

77

str.upto(other_str) { |s| block }

Itera por meio de valores sucessivos, começando em str e terminando em other_str inclusive, passando cada valor por vez para o bloco. O método String # succ é usado para gerar cada valor.

String desempacotar diretivas

Diretriz Devoluções Descrição
UMA Corda Com nulos e espaços à direita removidos.
uma Corda Corda.
B Corda Extrai bits de cada caractere (o bit mais significativo primeiro).
b Corda Extrai bits de cada caractere (o bit menos significativo primeiro).
C Fixnum Extrai um caractere como um inteiro sem sinal.
c Fixnum Extrai um caractere como um inteiro.
D, d Flutuador Trata caracteres sizeof (duplos) como um duplo nativo.
E Flutuador Trata os caracteres sizeof (duplos) como duplos na ordem de bytes littleendian.
e Flutuador Trata os caracteres sizeof (float) como um float na ordem de bytes littleendian.
F, f Flutuador Trata os caracteres sizeof (float) como um float nativo.
G Flutuador Trata caracteres sizeof (duplos) como duplos na ordem de bytes da rede.
g Corda Trata caracteres sizeof (flutuantes) como flutuantes na ordem de bytes da rede.
H Corda Extrai nibbles hexadecimais de cada caractere (o bit mais significativo primeiro)
h Corda Extrai nibbles hexadecimais de cada caractere (o bit menos significativo primeiro).
Eu Inteiro Trata sizeof (int) (modificado por _) caracteres sucessivos como um inteiro nativo sem sinal.
Eu Inteiro Trata sizeof (int) (modificado por _) caracteres sucessivos como um inteiro nativo assinado.
eu Inteiro Trata quatro (modificados por _) caracteres sucessivos como um inteiro longo nativo sem sinal.
eu Inteiro Trata quatro (modificados por _) caracteres sucessivos como um inteiro longo nativo com sinal.
M Corda Para impressão entre aspas.
m Corda Codificado em Base64.
N Inteiro Trata quatro caracteres como um longo sem sinal na ordem de bytes da rede.
n Fixnum Trata dois caracteres como um curto sem sinal na ordem de bytes da rede.
P Corda Trata os caracteres sizeof (char *) como um ponteiro e retorna os caracteres \ emph {len} do local referenciado.
p Corda Trata os caracteres sizeof (char *) como um ponteiro para uma string terminada em nulo.
Q Inteiro Trata oito caracteres como uma palavra quádrupla sem sinal (64 bits).
q Inteiro Trata oito caracteres como uma palavra quádrupla com sinal (64 bits).
S Fixnum Trata dois (diferentes se _ usados) caracteres sucessivos como um short sem sinal na ordem de bytes nativa.
s Fixnum Trata dois (diferentes se _ usados) caracteres sucessivos como um short assinado na ordem de bytes nativos.
você Inteiro Caracteres UTF-8 como inteiros sem sinal.
você Corda Codificado em UU.
V Fixnum Trata quatro caracteres como um longo sem sinal na ordem de bytes little-endian.
v Fixnum Trata dois caracteres como um curto sem sinal na ordem de bytes little-endian.
W Inteiro Número inteiro comprimido de BER.
X   Pula um caractere para trás.
x   Avança um caractere.
Z Corda Com os nulos finais removidos até o primeiro nulo com *.
@   Pula para o deslocamento fornecido pelo argumento de comprimento.

Exemplo

Experimente o seguinte exemplo 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"]

Arrays Ruby são coleções ordenadas e indexadas por inteiros de qualquer objeto. Cada elemento em uma matriz é associado e referido por um índice.

A indexação da 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 penúltimo elemento da matriz e assim por diante.

Arrays Ruby podem conter objetos como String, Integer, Fixnum, Hash, Symbol e até mesmo outros objetos Array. Arrays Ruby não são tão rígidos quanto arrays em outras linguagens. Arrays Ruby crescem automaticamente ao adicionar elementos a eles.

Criação de matrizes

Existem muitas maneiras de criar ou inicializar um array. 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 da matriz 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 comprimento -

#!/usr/bin/ruby

names = Array.new(20)
puts names.size  # This returns 20
puts names.length # This also returns 20

Isso produzirá o seguinte resultado -

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}"

Isso produzirá o seguinte resultado -

["mac", "mac", "mac", "mac"]

Você também pode usar um bloco com new, populando cada elemento com o que o bloco avalia -

#!/usr/bin/ruby

nums = Array.new(10) { |e| e = e * 2 }
puts "#{nums}"

Isso produzirá o seguinte resultado -

[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 array é a seguinte -

nums = Array[1, 2, 3, 4,5]

O módulo Kernel disponível no núcleo do Ruby tem 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}"

Isso produzirá o seguinte resultado -

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Métodos integrados de matriz

Precisamos ter uma instância do objeto Array para chamar um método Array. Como vimos, a seguir está a maneira de 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 quaisquer métodos de instância disponíveis. Por exemplo -

#!/usr/bin/ruby

digits = Array(0..9)
num = digits.at(6)
puts "#{num}"

Isso produzirá o seguinte resultado -

6
Sr. Não. Métodos e Descrição
1

array & other_array

Retorna um novo array contendo elementos comuns aos dois arrays, sem duplicatas.

2

array * int [or] array * str

Retorna uma nova matriz construída pela concatenação das cópias internas de self. Com um argumento String, equivalente a self.join (str).

3

array + other_array

Retorna uma nova matriz construída pela concatenação das duas matrizes para produzir uma terceira matriz.

4

array - other_array

Retorna uma nova matriz que é uma cópia da matriz original, removendo todos os itens que também aparecem em other_array.

5

array <=> other_array

Compara str com other_str, retornando -1 (menor que), 0 (igual) ou 1 (maior que). A comparação diferencia maiúsculas de minúsculas.

6

array | other_array

Retorna um novo array juntando array com other_array, removendo duplicatas.

7

array << obj

Empurra o objeto fornecido para o final da matriz. Esta expressão retorna a própria matriz, portanto, vários anexos podem ser encadeados.

8

array <=> other_array

Retorna um inteiro (-1, 0 ou +1) se esta matriz for menor, igual ou maior que other_array.

9

array == other_array

Duas matrizes são iguais se contiverem o mesmo número de elementos e se cada elemento for igual (de acordo com Object. ==) ao elemento correspondente na outra matriz.

10

array[index] [or] array[start, length] [or]

array[range] [or] array.slice(index) [or]

array.slice(start, length) [or] array.slice(range)

Retorna o elemento no índice ou retorna um subarray começando no início e continuando para os elementos de comprimento , ou retorna um subarray especificado por intervalo . Índices negativos contam para trás a partir do final da matriz (-1 é o último elemento). Retorna nil se o índice (ou índice inicial) estiver fora do intervalo.

11

array[index] = obj [or]

array[start, length] = obj or an_array or nil [or]

array[range] = obj or an_array or nil

Define o elemento no índice ou substitui um subarray começando no início e continuando para elementos de comprimento , ou substitui um subarray especificado por intervalo . Se os índices forem maiores do que a capacidade atual do array, o array cresce automaticamente. Os índices negativos contarão para trás a partir do final da matriz. Insere elementos se o comprimento for zero. Se nil for usado na segunda e na terceira forma, exclui os elementos de si mesmo .

12

array.abbrev(pattern = nil)

Calcula o conjunto de abreviações inequívocas para as strings em si . Se for passado um padrão ou string, apenas as strings correspondentes ao padrão ou começando com a string serão consideradas.

13

array.assoc(obj)

Pesquisa um array cujos elementos também são arrays comparando obj com o primeiro elemento de cada array contido usando obj. ==. Retorna a primeira matriz contida que corresponde ou nulo se nenhuma correspondência for encontrada.

14

array.at(index)

Retorna o elemento no índice. Um índice negativo conta a partir do final do self. Retorna nulo se o índice estiver fora do intervalo.

15

array.clear

Remove todos os elementos da matriz.

16

array.collect { |item| block } [or]

array.map { |item| block }

Invoca o bloco uma vez para cada elemento do self . Cria uma nova matriz contendo os valores retornados pelo bloco.

17

array.collect! { |item| block } [or]

array.map! { |item| block }

Invoca block uma vez para cada elemento de self , substituindo o elemento pelo valor retornado por block .

18

array.compact

Retorna uma cópia de si mesmo com todos os elementos nulos removidos.

19

array.compact!

Remove nenhum elemento da matriz. Retorna nulo se nenhuma alteração foi feita.

20

array.concat(other_array)

Acrescenta os elementos em other_array a self .

21

array.delete(obj) [or]

array.delete(obj) { block }

Exclui itens de si mesmo que são iguais a obj . Se o item não for encontrado, retorna nulo . Se o bloco de código opcional for fornecido, retorna o resultado do bloco se o item não for encontrado.

22

array.delete_at(index)

Exclui o elemento no índice especificado , retornando esse elemento, ou nulo se o índice estiver fora do intervalo.

23

array.delete_if { |item| block }

Exclui todos os elementos de self para os quais o bloco é avaliado como verdadeiro.

24

array.each { |item| block }

Chama o bloco uma vez para cada elemento em si , passando esse elemento como parâmetro.

25

array.each_index { |index| block }

Igual ao Array # each, mas passa o índice do elemento em vez do próprio elemento.

26

array.empty?

Retorna verdadeiro se a matriz self não contiver elementos.

27

array.eql?(other)

Retorna verdadeiro se array e other forem o mesmo objeto, ou se forem arrays com o mesmo conteúdo.

28

array.fetch(index) [or]

array.fetch(index, default) [or]

array.fetch(index) { |index| block }

Tenta retornar o elemento no índice de posição . Se o índice está fora da matriz, a primeira forma lança uma exceção IndexError , a segunda forma retorna o padrão e a terceira forma retorna o valor de invocar o bloco , passando o índice . Os valores negativos do índice contam a partir do final da matriz.

29

array.fill(obj) [or]

array.fill(obj, start [, length]) [or]

array.fill(obj, range) [or]

array.fill { |index| block } [or]

array.fill(start [, length] ) { |index| block } [or]

array.fill(range) { |index| block }

As três primeiras formas definem os elementos selecionados de self para obj . Um início de nil é equivalente a zero. Um comprimento de nil é equivalente a self.length . Os três últimos formulários preenchem o array com o valor do bloco. O bloco é passado com o índice absoluto de cada elemento a ser preenchido.

30

array.first [or]

array.first(n)

Retorna o primeiro elemento, ou os primeiros n elementos, da matriz. Se a matriz estiver vazia, a primeira forma retorna nil e a segunda forma retorna uma matriz vazia.

31

array.flatten

Retorna uma nova matriz que é um achatamento unidimensional desta matriz (recursivamente).

32

array.flatten!

Nivela a matriz no lugar. Retorna nulo se nenhuma modificação foi feita. (a matriz não contém submatrizes.)

33

array.frozen?

Retorna verdadeiro se a matriz estiver congelada (ou temporariamente congelada enquanto está sendo classificada).

34

array.hash

Calcula um código hash para array. Duas matrizes com o mesmo conteúdo terão o mesmo código hash.

35

array.include?(obj)

Retorna verdadeiro se obj estiver presente em self , falso caso contrário.

36

array.index(obj)

Retorna o índice do primeiro objeto em self que é == para obj. Retorna nil se nenhuma correspondência for encontrada.

37

array.indexes(i1, i2, ... iN) [or]

array.indices(i1, i2, ... iN)

Este método está obsoleto na última versão do Ruby, portanto, use Array # values_at.

38

array.indices(i1, i2, ... iN) [or]

array.indexes(i1, i2, ... iN)

Este método está obsoleto na última versão do Ruby, portanto, use Array # values_at.

39

array.insert(index, obj...)

Insere os valores fornecidos antes do elemento com o índice fornecido (que pode ser negativo).

40

array.inspect

Cria uma versão imprimível da matriz.

41

array.join(sep = $,)

Retorna uma string criada pela conversão de cada elemento da matriz em uma string, separada por sep .

42

array.last [or] array.last(n)

Retorna o (s) último (s) elemento (s) de si mesmo . Se a matriz estiver vazia , a primeira forma retorna nulo .

43

array.length

Retorna o número de elementos em si mesmo . Pode ser zero.

44

array.map { |item| block } [or]

array.collect { |item| block }

Invoca o bloco uma vez para cada elemento do self . Cria uma nova matriz contendo os valores retornados pelo bloco.

45

array.map! { |item| block } [or]

array.collect! { |item| block }

Invoca block uma vez para cada elemento do array , substituindo o elemento pelo valor retornado por block.

46

array.nitems

Retorna o número de elementos não nulos em si mesmo . Pode ser zero.

47

array.pack(aTemplateString)

Empacota o conteúdo da matriz em uma sequência binária de acordo com as diretivas em um TemplateString. As diretivas A, a e Z podem ser seguidas por uma contagem, que fornece a largura do campo resultante. As diretivas restantes também podem fazer uma contagem, indicando o número de elementos da matriz a serem convertidos. Se a contagem for um asterisco (*), todos os elementos restantes da matriz serão convertidos. Qualquer uma das diretivas ainda pode ser seguida por um sublinhado (_) para usar o tamanho nativo da plataforma subjacente para o tipo especificado; caso contrário, eles usam um tamanho independente de plataforma. Os espaços são ignorados na string do modelo.

48

array.pop

Remove o último elemento da matriz e o retorna, ou nulo se a matriz estiver vazia.

49

array.push(obj, ...)

Empurra (anexa) o objeto fornecido no final desta matriz. Esta expressão retorna a própria matriz, portanto, vários anexos podem ser encadeados.

50

array.rassoc(key)

Pesquisa a matriz cujos elementos também são matrizes. Compara a chave com o segundo elemento de cada array contido usando ==. Retorna a primeira matriz contida que corresponde.

51

array.reject { |item| block }

Retorna uma nova matriz contendo a matriz de itens para a qual o bloco não é verdadeiro .

52

array.reject! { |item| block }

Exclui elementos da matriz para a qual o bloco é avaliado como verdadeiro , mas retorna nulo se nenhuma alteração foi feita. Equivalente a Array # delete_if.

53

array.replace(other_array)

Substitui o conteúdo de array pelo conteúdo de other_array , truncando ou expandindo se necessário.

54

array.reverse

Retorna um novo array contendo os elementos do array em ordem reversa.

55

array.reverse!

Inverte a matriz no lugar.

56

array.reverse_each {|item| block }

Igual a Array # each, mas percorre a matriz na ordem inversa.

57

array.rindex(obj)

Retorna o índice do último objeto na matriz == para obj. Retorna nil se nenhuma correspondência for encontrada.

58

array.select {|item| block }

Invoca o bloco que passa em elementos sucessivos do array, retornando um array contendo os elementos para os quais o bloco retorna um valor verdadeiro .

59

array.shift

Retorna o primeiro elemento de self e o remove (deslocando todos os outros elementos em um). Retorna nil se a matriz estiver vazia.

60

array.size

Retorna o comprimento da matriz (número de elementos). Alias ​​para comprimento.

61

array.slice(index) [or] array.slice(start, length) [or]

array.slice(range) [or] array[index] [or]

array[start, length] [or] array[range]

Retorna o elemento no índice ou retorna um subarray começando no início e continuando para os elementos de comprimento , ou retorna um subarray especificado por range . Índices negativos contam para trás a partir do final da matriz (-1 é o último elemento). Retorna nil se o índice (ou índice inicial) estiver fora do intervalo.

62

array.slice!(index) [or] array.slice!(start, length) [or]

array.slice!(range)

Exclui o (s) elemento (s) fornecido (s) por um índice (opcionalmente com um comprimento) ou por um intervalo . Retorna o objeto excluído, subarray ou nil se o índice estiver fora do intervalo.

63

array.sort [or] array.sort { | a,b | block }

Retorna um novo array criado classificando self.

64

array.sort! [or] array.sort! { | a,b | block }

Classifica-se sozinho.

65

array.to_a

Retorna a si mesmo . Se chamado em uma subclasse de Array , converte o receptor em um objeto Array.

66

array.to_ary

Retorna a si mesmo.

67

array.to_s

Retorna self.join.

68

array.transpose

Assume que self é um array de arrays e transpõe as linhas e colunas.

69

array.uniq

Retorna uma nova matriz removendo valores duplicados na matriz .

70

array.uniq!

Remove elementos duplicados de si mesmo . Retorna nil se nenhuma alteração for feita (ou seja, nenhuma duplicata for encontrada).

71

array.unshift(obj, ...)

Anexa objetos à frente da matriz, outros elementos acima de um.

72

array.values_at(selector,...)

Retorna uma matriz contendo os elementos próprios correspondentes ao seletor fornecido (um ou mais). Os seletores podem ser índices inteiros ou intervalos.

73

array.zip(arg, ...) [or]

array.zip(arg, ...){ | arr | block }

Converte quaisquer argumentos em matrizes e, em seguida, mescla os elementos da matriz com os elementos correspondentes de cada argumento.

Diretivas de pacote de matriz

Sr. Não. Diretriz e descrição
1

@

Move para a posição absoluta.

2

A

String ASCII (espaço preenchido, contagem é largura).

3

a

String ASCII (preenchido com nulos, a contagem é a largura).

4

B

string (ordem decrescente de bits).

5

b

Cadeia de bits (ordem crescente de bits).

6

C

Caracter não identifcado.

7

c

Caracteres.

8

D, d

Flutuação de precisão dupla, formato nativo.

9

E

Flutuação de precisão dupla, ordem de byte little endian.

10

e

Flutuação de precisão única, ordem de bytes little endian.

11

F, f

Flutuação de precisão única, formato nativo.

12

G

Flutuação de precisão dupla, ordem de byte de rede (big-endian).

13

g

Flutuação de precisão única, ordem de byte de rede (big-endian).

14

H

String hexagonal (primeiro nibble alto).

15

h

String hexagonal (mordidela baixa primeiro).

16

I

Inteiro sem sinal.

17

i

Inteiro.

18

L

Longo sem sinal.

19

l

Grandes.

20

M

Codificação MIME para impressão entre aspas (consulte RFC 2045).

21

m

String codificada em Base64.

22

N

Ordem de bytes longa da rede (big-endian).

23

n

Ordem de bytes curta, rede (big-endian).

24

P

Ponteiro para uma estrutura (string de comprimento fixo).

25

p

Ponteiro para uma string terminada em nulo.

26

Q, q

Número de 64 bits.

27

S

Curto sem sinal.

28

s

Baixo.

29

U

UTF-8.

30

u

String codificada em UU.

31

V

Ordem de bytes little endian longa.

32

v

Ordem de bytes little endian curta.

33

w

Número inteiro compactado com BER \ fnm.

34

X

Faça backup de um byte.

35

x

Byte nulo.

36

Z

O mesmo que a, exceto que null é adicionado com *.

Exemplo

Tente o exemplo a seguir para empacotar 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"

Isso produzirá o seguinte resultado -

a  b  c
abc
ABC

Um Hash é uma coleção de pares de valores-chave como este: "funcionário" => "salário". É semelhante a um Array, exceto que a indexação é feita por meio de chaves arbitrárias de qualquer tipo de objeto, não um índice inteiro.

A ordem em que você atravessa um hash por chave ou valor pode parecer arbitrária e geralmente não estará no pedido de inserção. Se você tentar acessar um hash com uma chave que não existe, o método retornará nil .

Criando Hashes

Assim como acontece com os arrays, há 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 new para criar um hash com um valor padrão, que de outra forma é apenas nil -

months = Hash.new( "month" )

or

months = Hash.new "month"

Quando você acessa qualquer chave em um hash que tem um valor padrão, se a chave ou valor não existir, acessar o hash retornará o valor padrão -

#!/usr/bin/ruby

months = Hash.new( "month" )

puts "#{months[0]}"
puts "#{months[72]}"

Isso produzirá o seguinte resultado -

month
month

#!/usr/bin/ruby

H = Hash["a" => 100, "b" => 200]

puts "#{H['a']}"
puts "#{H['b']}"

Isso produzirá o seguinte resultado -

100
200

Você pode usar qualquer objeto Ruby como uma chave ou valor, até mesmo uma matriz, então o exemplo a seguir é válido -

[1,"jan"] => "January"

Métodos Hash embutidos

Precisamos ter uma instância do objeto Hash para chamar um método Hash. Como vimos, a seguir está a maneira de 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 quaisquer métodos de instância disponíveis. Por exemplo -

#!/usr/bin/ruby

$, = ", "
months = Hash.new( "month" )
months = {"1" => "January", "2" => "February"}

keys = months.keys
puts "#{keys}"

Isso produzirá o seguinte resultado -

["1", "2"]

A seguir estão os métodos de hash públicos (assumindo que o hash é um objeto de matriz) -

Sr. Não. Métodos e Descrição
1

hash == other_hash

Testa se dois hashes são iguais, com base em se eles têm o mesmo número de pares de valor-chave e se os pares de valor-chave correspondem ao par correspondente em cada hash.

2

hash.[key]

Usando uma chave, faz referência a um valor de hash. Se a chave não for encontrada, retorna um valor padrão.

3

hash.[key] = value

Associa o valor fornecido por valor à chave fornecida por chave .

4

hash.clear

Remove todos os pares de valores-chave do hash.

5

hash.default(key = nil)

Retorna o valor padrão para hash , nil se não definido por default =. ([] retorna um valor padrão se a chave não existe no hash .)

6

hash.default = obj

Define um valor padrão para hash .

7

hash.default_proc

Retorna um bloco se o hash foi criado por um bloco.

8

hash.delete(key) [or]

array.delete(key) { |key| block }

Exclui um par de valores-chave de hash por chave . Se o bloco for usado, retorna o resultado de um bloco se o par não for encontrado. Compare delete_if .

9

hash.delete_if { |key,value| block }

Exclui um par de valores-chave do hash para cada par que o bloco avalia como verdadeiro .

10

hash.each { |key,value| block }

Itera por hash , chamando o bloco uma vez para cada chave, passando o valor-chave como uma matriz de dois elementos.

11

hash.each_key { |key| block }

Repete o hash , chamando o bloco uma vez para cada chave, passando a chave como parâmetro.

12

hash.each_key { |key_value_array| block }

Itera por hash , chamando o bloco uma vez para cada chave , passando a chave e o valor como parâmetros.

13

hash.each_key { |value| block }

Repete o hash , chamando o bloco uma vez para cada chave , passando o valor como parâmetro.

14

hash.empty?

Testa se o hash está vazio (não contém pares de valor-chave), retornando verdadeiro ou falso .

15

hash.fetch(key [, default] ) [or]

hash.fetch(key) { | key | block }

Retorna um valor de hash para a chave fornecida . Se a chave não puder ser encontrada e não houver outros argumentos, ela gerará uma exceção IndexError ; se o padrão for fornecido, ele será retornado; se o bloco opcional for especificado, seu resultado será retornado.

16

hash.has_key?(key) [or] hash.include?(key) [or]

hash.key?(key) [or] hash.member?(key)

Testa se uma determinada chave está presente no hash, retornando verdadeiro ou falso .

17

hash.has_value?(value)

Testa se o hash contém o valor fornecido .

18

hash.index(value)

Retorna a chave para o valor fornecido em hash, nulo se nenhum valor correspondente for encontrado.

19

hash.indexes(keys)

Retorna uma nova matriz que consiste em valores para a (s) chave (s) fornecida (s). Irá inserir o valor padrão para as chaves que não foram encontradas. Este método está obsoleto. Use select.

20

hash.indices(keys)

Retorna uma nova matriz que consiste em valores para a (s) chave (s) fornecida (s). Irá inserir o valor padrão para as chaves que não foram encontradas. Este método está obsoleto. Use select.

21

hash.inspect

Retorna uma versão de sequência de caracteres bonita do hash.

22

hash.invert

Cria um novo hash , invertendo chaves e valores do hash ; ou seja, no novo hash, as chaves do hash tornam-se valores e os valores tornam-se chaves.

23

hash.keys

Cria uma nova matriz com chaves de hash .

24

hash.length

Retorna o tamanho ou comprimento do hash como um inteiro.

25

hash.merge(other_hash) [or]

hash.merge(other_hash) { |key, oldval, newval| block }

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 .

26

hash.merge!(other_hash) [or]

hash.merge!(other_hash) { |key, oldval, newval| block }

O mesmo que mesclar, mas as alterações são feitas no local.

27

hash.rehash

Reconstrói o hash com base nos valores atuais de cada chave . Se os valores foram alterados desde que foram inseridos, este método reindexa o hash .

28

hash.reject { |key, value| block }

Cria um novo hash para cada par que o bloco avalia como verdadeiro

29

hash.reject! { |key, value| block }

O mesmo que rejeitar , mas as alterações são feitas no local.

30

hash.replace(other_hash)

Substitui o conteúdo de hash pelo conteúdo de other_hash .

31

hash.select { |key, value| block }

Retorna uma nova matriz que consiste em pares de valores-chave do hash para o qual o bloco retorna verdadeiro .

32

hash.shift

Remove um par de valores-chave do hash , retornando-o como uma matriz de dois elementos.

33

hash.size

Retorna o tamanho ou comprimento do hash como um inteiro.

34

hash.sort

Converte o hash em uma matriz bidimensional contendo matrizes de pares de valores-chave e, em seguida, classifica-a como uma matriz.

35

hash.store(key, value)

Armazena um par de valor-chave em hash .

36

hash.to_a

Cria uma matriz bidimensional a partir do hash. Cada par chave / valor é convertido em uma matriz e todas essas matrizes são armazenadas em uma matriz contida.

37

hash.to_hash

Retorna hash (self).

38

hash.to_s

Converte o hash em uma matriz e, em seguida, converte essa matriz em uma string.

39

hash.update(other_hash) [or]

hash.update(other_hash) {|key, oldval, newval| block}

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 .

40

hash.value?(value)

Testa se o hash contém o valor fornecido .

41

hash.values

Retorna uma nova matriz contendo todos os valores de hash .

42

hash.values_at(obj, ...)

Retorna uma nova matriz contendo os valores do hash que estão associados à chave ou chaves fornecidas.

o Timeclasse 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 em seu sistema de representar datas antes de 1970 ou depois de 2038.

Este capítulo o familiariza com todos os conceitos mais desejados de data e hora.

Obtendo data e hora atuais

A seguir está o exemplo simples para obter a 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

Isso produzirá o seguinte resultado -

Current Time : Mon Jun 02 12:02:39 -0700 2008
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 que mostra 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

Isso produzirá o seguinte resultado -

Current Time : Mon Jun 02 12:03:08 -0700 2008
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 forma -

# 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 está o exemplo para obter todos os componentes em uma matriz no seguinte formato -

[sec,min,hour,day,month,year,wday,yday,isdst,zone]

Experimente o seguinte -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
p values

Isso irá 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 formatos diferentes de datas da seguinte forma -

#!/usr/bin/ruby -w

time = Time.new
values = time.to_a
puts Time.utc(*values)

Isso irá gerar o seguinte resultado -

Mon Jun 02 12:15:36 UTC 2008

A seguir está 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 aos fusos horários e horário de verão da seguinte forma -

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

Formatação de horas 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")

Isso produzirá o seguinte resultado -

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. Não. Diretriz e descrição
1

%a

O nome abreviado do dia da semana (Dom).

2

%A

O nome completo do dia da semana (domingo).

3

%b

O nome abreviado do mês (janeiro).

4

%B

O nome completo do mês (janeiro).

5

%c

A representação local preferida de data e hora.

6

%d

Dia do mês (01 a 31).

7

%H

Hora do dia, relógio de 24 horas (00 a 23).

8

%I

Hora do dia, relógio de 12 horas (01 a 12).

9

%j

Dia do ano (001 a 366).

10

%m

Mês do ano (01 a 12).

11

%M

Minuto da hora (00 a 59).

12

%p

Indicador de meridiano (AM ou PM).

13

%S

Segundo do minuto (00 a 60).

14

%U

Número da semana do ano atual, começando com o primeiro domingo como 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).

16

%w

Dia da semana (domingo é 0, 0 a 6).

17

%x

Representação preferida apenas para data, sem hora.

18

%X

Representação preferida para o tempo sozinho, sem data.

19

%y

Ano sem século (00 a 99).

20

%Y

Ano com século.

21

%Z

Nome do fuso horário.

22

%%

Caractere% literal.

Tempo Aritmético

Você pode realizar aritmética simples com o tempo da seguinte maneira -

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 - past     # => 10  Time - Time => number of seconds
puts diff

Isso produzirá o seguinte resultado -

Thu Aug 01 20:57:05 -0700 2013
Thu Aug 01 20:56:55 -0700 2013
Thu Aug 01 20:57:15 -0700 2013
20.0

Os intervalos ocorrem em todos os lugares: janeiro a dezembro, 0 a 9, linhas 50 a 67 e assim por diante. Ruby oferece suporte a intervalos e nos permite usar intervalos de várias maneiras -

  • Intervalos como sequências
  • Varia conforme as condições
  • Varia como intervalos

Intervalos como sequências

O primeiro e talvez o mais natural uso 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 sequências usando o ''..'' e ''...''operadores de alcance. O formato de dois pontos cria um intervalo inclusivo, enquanto o formato 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 necessário, você pode 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}"

Isso produzirá o seguinte resultado -

[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 seus conteúdos 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

Isso produzirá o seguinte resultado -

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

Varia conforme as 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, onde a primeira linha de cada conjunto contém o início da palavra e a última linha termina a palavra -

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

Isso produzirá o seguinte resultado -

Pass with Merit

Varia como intervalos

Um uso final do intervalo versátil é como um teste de intervalo: ver se algum valor cai dentro do intervalo representado pelo intervalo. Isso é feito usando ===, o operador de igualdade de maiúsculas e minúsculas.

#!/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

Isso produzirá o seguinte resultado -

5 lies in (1..10)
c lies in ('a'..'j')

Os iteradores nada mais são do que métodos suportados por coleções . Os objetos que armazenam um grupo de membros de dados são chamados de coleções. Em Ruby, arrays e hashes podem ser chamados de coleções.

Os iteradores retornam todos os elementos de uma coleção, um após o outro. Estaremos discutindo dois iteradores aqui, each e collect . Vamos examinar isso em detalhes.

Ruby cada Iterator

Cada iterador retorna todos os elementos de uma matriz ou hash.

Sintaxe

collection.each do |variable|
   code
end

Executa código para cada elemento da coleção . Aqui, a coleção pode ser um array ou um hash ruby.

Exemplo

#!/usr/bin/ruby

ary = [1,2,3,4,5]
ary.each do |i|
   puts i
end

Isso produzirá o seguinte resultado -

1
2
3
4
5

Você sempre associa cada iterador a um bloco. Ele retorna cada valor da matriz, um por um, para o bloco. O valor é armazenado na variáveli e então exibido na tela.

Ruby collect Iterator

O iterador collect 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 a coleção inteira, 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

Isso produzirá o seguinte resultado -

1
2
3
4
5

NOTE- O método de coleta não é a maneira correta de copiar entre matrizes. Existe outro método chamado clone , que deve ser usado para copiar um array em outro array.

Normalmente, você usa o método collect quando deseja fazer algo com cada um dos valores para obter a nova matriz. Por exemplo, este código produz uma matriz 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

Isso produzirá o seguinte resultado -

10
20
30
40
50

Ruby fornece um conjunto completo de métodos relacionados a E / S implementados no módulo Kernel. Todos os métodos de I / O 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 I / O disponíveis em Ruby. Para obter mais funções, 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. Isso adicionará uma nova linha ao final de cada linha escrita.

Exemplo

#!/usr/bin/ruby

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

Isso produzirá o seguinte resultado -

This is variable one
This is variable two

A declaração de get

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. Este código solicitará que o usuário insira um valor, que será armazenado em uma variável val e, finalmente, será impresso em STDOUT.

#!/usr/bin/ruby

puts "Enter a value :"
val = gets
puts val

Isso produzirá o seguinte resultado -

Enter a value :
This is entered value
This is entered value

A declaração putc

Ao contrário da instrução puts , que exibe toda a string na tela, a instrução putc pode ser usada para exibir 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

Isso produzirá o seguinte resultado -

H

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 com a instrução print o cursor é posicionado na mesma linha.

Exemplo

#!/usr/bin/ruby

print "Hello World"
print "Good Morning"

Isso produzirá o seguinte resultado -

Hello WorldGood Morning

Abrindo e fechando arquivos

Até agora, você leu e gravou na entrada e na saída padrão. Agora, veremos como brincar 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
Sr. Não. Modos e descrição
1

r

Modo somente leitura. O ponteiro do arquivo é colocado no início do arquivo. Este é o modo padrão.

2

r+

Modo de leitura e gravação. O ponteiro do arquivo estará no início do arquivo.

3

w

Modo somente gravação. Substitui o arquivo se ele existir. Se o arquivo não existir, cria um novo arquivo para gravação.

4

w+

Modo de leitura e gravação. Substitui o arquivo existente, se o arquivo existir. Se o arquivo não existir, cria um novo arquivo para leitura e gravação.

5

a

Modo somente gravação. O ponteiro do arquivo está no final do arquivo se o arquivo existir. Ou seja, o arquivo está no modo de acréscimo. Se o arquivo não existir, ele cria um novo arquivo para gravação.

6

a+

Modo de leitura e gravação. O ponteiro do arquivo está no final do arquivo se o arquivo existir. O arquivo é aberto no modo anexar. Se o arquivo não existir, ele cria um novo arquivo para leitura e gravação.

Ler e gravar arquivos

Os mesmos métodos que temos usado para E / S 'simples' estão disponíveis para todos os objetos de arquivo. Portanto, get 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 tornar nossas vidas mais fáceis.

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 está 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 irá gerar 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
   puts "Unable to open file!"
end

Esta declaração gravará "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
   puts "Unable to open file!"
end

Os caracteres são passados ​​um a um para a variável ch e, em seguida, exibidos na tela da seguinte forma -

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]

Nesse código, a variável arr é um array. Cada linha do arquivo input.txt será um elemento do 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 a 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 do método readlines , o método foreach não retorna uma matriz. Por exemplo -

#!/usr/bin/ruby

IO.foreach("input.txt"){|block| puts block}

Este código irá passar o conteúdo do teste de arquivo linha por linha para o bloco variável e então a saída será exibida na tela.

Renomeando e Excluindo Arquivos

Você pode renomear e excluir arquivos programaticamente com Ruby com os métodos renomear e excluir .

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 as permissões / lista de acesso de um arquivo -

A seguir está o exemplo para alterar o modo de um arquivo existente test.txt para um valor de máscara -

#!/usr/bin/ruby

file = File.new( "test.txt", "w" )
file.chmod( 0755 )
Sr. Não. Máscara e descrição
1

0700

máscara rwx para o proprietário

2

0400

r para dono

3

0200

w para dono

4

0100

x para dono

5

0070

máscara rwx para grupo

6

0040

r para grupo

7

0020

w para o grupo

8

0010

x para grupo

9

0007

máscara rwx para outro

10

0004

r para outro

11

0002

w para outro

12

0001

x para outro

13

4000

Definir o ID do usuário na execução

14

2000

Definir o ID do grupo na execução

15

1000

Salve o texto trocado, mesmo após o uso

Consultas de arquivos

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 comando a seguir 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 comando a seguir 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, characterSpecial, blockSpecial, fifo, link, socket ou desconhecido.

O seguinte comando pode ser usado para descobrir 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 Ruby não tem problemas em lidar com eles também. Enquanto a classe File lida com arquivos, os diretórios são tratados com a classe Dir .

Navegando pelos diretórios

Para mudar de diretório dentro de um programa Ruby, use Dir.chdir como segue. 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 maneira ainda mais concisa de obter listagens de diretório é usando o método de matriz de classe de Dir -

Dir["/usr/bin/*"]

Criação de 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 -

NOTE - A máscara 755 define as permissões proprietário, grupo, mundo [qualquer pessoa] para rwxr-xr-x onde r = ler, w = escrever e x = executar.

Dir.mkdir( "mynewdir", 755 )

Excluindo um Diretório

O Dir.delete pode ser usado para excluir um diretório. O Dir.unlink e Dir.rmdir desempenham exatamente a mesma função e são fornecidos para sua conveniência.

Dir.delete("testdir")

Criação de 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 disponibilizar Dir.tmpdir é 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)

Este 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 integradas

Aqui estão as funções embutidas do ruby ​​para processar arquivos e diretórios -

  • Classe e métodos de arquivo .

  • Classe e métodos de dir .

A execução e a exceção sempre andam juntas. Se você estiver abrindo um arquivo que não existe, se você não lidou com esta situação adequadamente, seu programa é considerado de má qualidade.

O programa pára se ocorrer uma exceção. Portanto, as exceções são usadas para lidar com 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. Incluímos o código que poderia gerar uma exceção em um bloco inicial / final e usamos cláusulas de resgate para informar a Ruby os tipos de exceções que desejamos tratar.

Sintaxe

begin  
# -  
rescue OneTypeOfException  
# -  
rescue AnotherTypeOfException  
# -  
else  
# Other exceptions
ensure
# Always will be executed
end

Tudo, do início ao resgate, está protegido. Se ocorrer uma exceção durante a execução deste bloco de código, o controle é passado para o bloco entre o resgate e o fim .

Para cada resgate cláusula no início do bloco, Ruby compara a exceção levantada contra cada um dos parâmetros, por sua vez. A correspondência será bem-sucedida se a exceção nomeada na cláusula de resgate for o mesmo que o tipo da exceção lançada atualmente ou se for uma superclasse dessa exceção.

No caso de uma exceção não corresponder a nenhum dos tipos de erro especificados, temos permissão para usar uma cláusula else após todas as cláusulas de resgate .

Exemplo

#!/usr/bin/ruby

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 pelo arquivo porque a abertura falhou.

#<IO:0xb7d16f84>==#<IO:0xb7d16f84>

Usando instrução de nova tentativa

Você pode capturar uma exceção usando resgate do bloco e, em seguida, uso 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

A seguir está o fluxo do processo -

  • Ocorreu uma exceção na abertura.
  • Foi resgatar. fname foi reatribuído.
  • Por nova tentativa foi para o início do início.
  • Este arquivo é aberto com sucesso.
  • Continuou o processo essencial.

NOTE- Observe que se o arquivo de nome substituído não existir, este código de exemplo será repetido infinitamente. Tenha cuidado ao usar a repetição para um processo de exceção.

Usando a declaração de aumento

Você pode usar o aumento declaração para gerar uma exceção. O método a seguir levanta 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

A primeira forma simplesmente levanta novamente a exceção atual (ou um RuntimeError se não houver exceção atual). Isso é usado em tratadores de exceção que precisam interceptar uma exceção antes de passá-la adiante.

A segunda forma cria uma nova exceção RuntimeError , definindo sua mensagem para a string fornecida. Essa exceção é então gerada na pilha de chamadas.

A terceira forma usa o primeiro argumento para criar uma exceção e então define a mensagem associada para o segundo argumento.

A quarta forma é semelhante à terceira, mas você pode adicionar qualquer instrução condicional como a menos que 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.'

Isso produzirá o seguinte resultado -

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

Isso produzirá o seguinte resultado -

A test exception.
["main.rb:4"]

Usando a declaração de segurança

À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 levantada. Por exemplo, você pode ter um arquivo aberto na entrada do bloco e precisa ter certeza de que ele seja fechado quando o bloco sair.

A cláusula garanta faz exatamente isso. Garantir vai após a última cláusula de resgate 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 levanta e resgata uma exceção ou se é encerrado por uma exceção não capturada, o bloco garantir 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.'
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
ensure
   puts "Ensuring execution"
end

Isso produzirá o seguinte resultado -

A test exception.
["main.rb:4"]
Ensuring execution

Usando outra instrução

Se a cláusula else estiver presente, ela seguirá 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"
rescue Exception => e
   puts e.message
   puts e.backtrace.inspect
else
   puts "Congratulations-- no errors!"
ensure
   puts "Ensuring execution"
end

Isso produzirá o seguinte resultado -

I'm not raising exception
Congratulations-- no errors!
Ensuring execution

A mensagem de erro levantada pode ser capturada usando $! variável.

Pegar e jogar

Embora o mecanismo de exceção de aumento e recuperação seja ótimo para abandonar a execução quando as coisas dão errado, às vezes é bom poder pular de alguma construção profundamente aninhada durante o processamento normal. É aqui que pegar e jogar são úteis.

A captura define um bloco que é rotulado com o nome fornecido (que pode ser um símbolo ou uma string). O bloqueio é executado normalmente até que um lançamento 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 lançamento para encerrar a interação com o usuário se '!' é digitado em resposta a qualquer prompt.

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 tentar o programa acima em 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 levantam exceções. Todas as classes de exceção formam uma hierarquia, com a classe Exception no topo. O próximo nível contém sete tipos diferentes -

  • Interrupt
  • NoMemoryError
  • SignalException
  • ScriptError
  • StandardError
  • SystemExit

Há uma outra exceção neste nível, Fatal, mas o interpretador Ruby só usa isso internamente.

Tanto ScriptError quanto StandardError têm várias subclasses, mas não precisamos entrar em detalhes aqui. O importante é que, se criarmos nossas próprias classes de exceção, elas precisam ser subclasses da classe Exception ou de uma de suas descendentes.

Vejamos um exemplo -

class FileSaveError < StandardError
   attr_reader :reason
   def initialize(reason)
      @reason = reason
   end
end

Agora, olhe para o exemplo a seguir, que usará esta 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 a ela uma nova instância de FileSaveError, com a razão de que a exceção específica causou falha na gravação dos dados.

Ruby é uma linguagem puramente orientada a objetos e tudo aparece para Ruby como um objeto. Cada valor em Ruby é um objeto, mesmo as coisas mais primitivas: strings, números e até mesmo verdadeiro e falso. Mesmo uma classe em si é um objeto que é uma instância da classe Class . Este capítulo o levará por 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 organizado. Os dados e métodos dentro de uma classe são chamados de membros da classe.

Definição de classe Ruby

Ao definir uma classe, você define um blueprint para um tipo de dados. Na verdade, isso não define nenhum dado, mas define o que o nome da classe significa, ou seja, em que consistirá um objeto da classe e quais operações podem ser executadas nesse objeto.

Uma definição de classe começa com a palavra-chave class seguido pelo class name e é delimitado por um end. Por exemplo, definimos a classe Box usando a classe de palavra-chave da seguinte forma -

class Box
   code
end

O nome deve começar com uma letra maiúscula e, por convenção, os nomes que contêm mais de uma palavra são executados junto com cada palavra maiúscula e sem caracteres de separação (CamelCase).

Definir objetos Ruby

Uma classe fornece os blueprints para objetos, portanto, basicamente, um objeto é criado a partir de uma classe. Declaramos objetos de uma classe usandonewpalavra-chave. As seguintes declarações declaram dois objetos da classe Box -

box1 = Box.new
box2 = Box.new

O método de inicialização

o initialize method é um método de classe Ruby padrão e funciona quase da mesma maneira que constructorfunciona em outras linguagens de programação orientadas a objetos. 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 receber uma lista de parâmetros e, como qualquer outro método ruby, seria precedido pordef palavra-chave conforme mostrado abaixo -

class Box
   def initialize(w,h)
      @width, @height = w, h
   end
end

As variáveis ​​de instância

o instance variablessão uma espécie de atributos de classe e se tornam propriedades de objetos, uma vez 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 que usamospublic métodos, que são chamados accessor methods. Se tomarmos a classe definida acimaBox então @width e @height são variáveis ​​de instância para a classe Box.

class Box
   def initialize(w,h)
      # assign instance variables
      @width, @height = w, h
   end
end

Métodos de acessador e setter

Para disponibilizar as variáveis ​​de fora da classe, elas devem ser definidas dentro accessor methods, esses métodos acessadores 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)
      @width, @height = 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, ele 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 setter methods, que são definidos como abaixo -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = 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
box = Box.new(10, 20)

# use setter methods
box.setWidth = 30
box.setHeight = 50

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Quando o código acima é executado, ele produz o seguinte resultado -

Width of the box is : 30
Height of the box is : 50

Os métodos da instância

o instance methods também são definidos da mesma forma que definimos qualquer outro método usando defpalavra-chave 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 de acordo com sua necessidade.

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

Quando o código acima é executado, ele produz o seguinte resultado -

Area of the box is : 200

A classe Métodos e Variáveis

o class variablesé uma variável, que é compartilhada entre todas as instâncias de uma classe. Em outras palavras, existe uma instância da variável e ela é acessada por instâncias do objeto. 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 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
      @width, @height = w, h

      @@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()

Quando o código acima é executado, ele produz o seguinte resultado -

Box count is : 2

O método to_s

Qualquer classe que você definir deve ter um to_smétodo de instância para retornar uma representação de string do objeto. A seguir está um exemplo simples para representar um objeto Box em termos de largura e altura -

#!/usr/bin/ruby -w

class Box
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # define to_s method
   def to_s
      "(w:#@width,h:#@height)"  # string formatting of the object.
   end
end

# create an object
box = Box.new(10, 20)

# to_s method will be called in reference of string automatically.
puts "String representation of box is : #{box}"

Quando o código acima é executado, ele produz o seguinte resultado -

String representation of box is : (w:10,h:20)

Controle de acesso

Ruby oferece três níveis de proteção no nível dos métodos de instância, que podem ser public, private, or protected. Ruby não aplica nenhum controle de acesso sobre variáveis ​​de instância e classe.

  • Public Methods- Os métodos públicos podem ser chamados por qualquer pessoa. Os métodos são públicos por padrão, exceto para inicializar, que é sempre privado.

  • Private Methods- Os métodos privados não podem ser acessados ​​ou mesmo visualizados de fora da classe. Apenas os métodos de classe podem acessar membros privados.

  • Protected Methods- 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 está um exemplo simples para mostrar a sintaxe de todos os três modificadores de acesso -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = 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
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"

# try to call protected or methods
box.printArea()

Quando o código acima é executado, ele produz o seguinte resultado. Aqui, o primeiro método é chamado com sucesso, mas o segundo método deu um problema.

Area of the box is : 200
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 de herança. A herança nos permite definir uma classe em termos de outra classe, o que torna mais fácil criar e manter um aplicativo.

A herança também oferece uma oportunidade de reutilizar a funcionalidade do código e tempo de implementação rápido, mas infelizmente Ruby não suporta vários níveis de heranças, mas 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. Esta classe existente é chamada debase class or superclass, e a nova classe é chamada de derived class or sub-class.

Ruby também suporta o conceito de subclasse, ou seja, 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 à sua instrução de classe. Por exemplo, a seguir, defina uma classe BigBox como uma subclasse de Box -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = 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
      puts "Big box area is : #@area"
   end
end

# create an object
box = BigBox.new(10, 20)

# print the area
box.printArea()

Quando o código acima é executado, ele produz o seguinte resultado -

Big box area is : 200

Substituição de métodos

Embora você possa adicionar novas funcionalidades em uma classe derivada, à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 como mostrado abaixo no exemplo -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = 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
      puts "Big box area is : #@area"
   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 a largura e a altura de uma Box por um escalar e o operador unário - para negar a largura e a altura da Box. 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

Congelando objetos

Às vezes, queremos evitar 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 invocandoObject.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 verdadeiro caso o objeto esteja congelado, caso contrário, um valor falso é retornado. O exemplo a seguir esclarece o conceito -

#!/usr/bin/ruby -w

# define a class
class Box
   # constructor method
   def initialize(w,h)
      @width, @height = 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
box = Box.new(10, 20)

# 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

# use accessor methods
x = box.getWidth()
y = box.getHeight()

puts "Width of the box is : #{x}"
puts "Height of the box is : #{y}"

Quando o código acima é executado, ele produz o seguinte resultado -

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 direto ou string a uma variável, que é definida sem usar @ ou @@. Por convenção, 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 muito parecido com uma variável, mas se você quiser acessar uma constante fora da classe, então você terá que usar classname::constant conforme mostrado no exemplo abaixo.

#!/usr/bin/ruby -w

# define a class
class Box
   BOX_COMPANY = "TATA Inc"
   BOXWEIGHT = 10
   # constructor method
   def initialize(w,h)
      @width, @height = w, h
   end
   # instance method
   def getArea
      @width * @height
   end
end

# create an object
box = Box.new(10, 20)

# call instance methods
a = box.getArea()
puts "Area of the box is : #{a}"
puts Box::BOX_COMPANY
puts "Box weight is: #{Box::BOXWEIGHT}"

Quando o código acima é executado, ele produz o seguinte resultado -

Area of the box is : 200
TATA Inc
Box weight is: 10

As 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 initializeou seja, usando um novo método, nesse caso, você pode chamar alocar , 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

   # constructor method
   def initialize(w,h)
      @width, @height = 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()
puts "Area of the box is : #{a}"

# call instance method using box2
a = box2.getArea()
puts "Area of the box is : #{a}"

Quando o código acima é executado, ele produz o seguinte resultado -

Area of the box is : 200
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ção da Classe

Se as definições de classe são códigos executáveis, isso implica que são executadas no contexto de algum objeto: self deve fazer referência a algo. Vamos descobrir o que é.

#!/usr/bin/ruby -w

class Box
   # print class information
   puts "Type of self = #{self.type}"
   puts "Name of self = #{self.name}"
end

Quando o código acima é executado, ele produz o seguinte resultado -

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 da metaclasse e de suas superclasses estarão disponíveis durante a execução da definição do método.

Uma expressão regular é uma sequência especial de caracteres que ajuda 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 seguidos 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

Isso produzirá o seguinte resultado -

Line1 contains Cats

Modificadores de expressão regular

Literais de expressão regular podem incluir um modificador opcional para controlar vários aspectos de correspondência. O modificador é especificado após o segundo caractere de barra, conforme mostrado anteriormente e pode ser representado por um desses caracteres -

Sr. Não. Modificador e descrição
1

i

Ignora maiúsculas e minúsculas ao corresponder o texto.

2

o

Executa # {} interpolações apenas uma vez, na primeira vez que o literal regexp é avaliado.

3

x

Ignora espaços em branco e permite comentários em expressões regulares.

4

m

Corresponde a várias linhas, reconhecendo novas linhas como caracteres normais.

5

u,e,s,n

Interpreta o regexp como Unicode (UTF-8), EUC, SJIS ou ASCII. Se nenhum 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ê comece 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 deseja 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 para personagens de controle, (+ ? . * ^ $ ( ) [ ] { } | \), todos os personagens se combinam. Você pode escapar de um caractere de controle precedendo-o com uma barra invertida.

Sr. Não. Padrão e Descrição
1

^

Corresponde ao início da linha.

2

$

Corresponde ao fim da linha.

3

.

Corresponde a qualquer caractere único, exceto nova linha. Usar a opção m permite que ele corresponda a nova linha também.

4

[...]

Corresponde a qualquer caractere único entre colchetes.

5

[^...]

Corresponde a qualquer caractere único que não esteja entre colchetes

6

re*

Corresponde a 0 ou mais ocorrências da expressão anterior.

7

re+

Corresponde a 1 ou mais ocorrências da expressão anterior.

8

re?

Corresponde a 0 ou 1 ocorrência da expressão anterior.

9

re{ n}

Corresponde exatamente ao número n de ocorrências da expressão anterior.

10

re{ n,}

Corresponde a n ou mais ocorrências da expressão anterior.

11

re{ n, m}

Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.

12

a| b

Corresponde a a ou b.

13

(re)

Agrupa expressões regulares e lembra o texto correspondente.

14

(?imx)

Alterna temporariamente as opções i, m ou x em uma expressão regular. Se estiver entre parênteses, apenas essa área é afetada.

15

(?-imx)

Desativa temporariamente as opções i, m ou x em uma expressão regular. Se estiver entre parênteses, apenas essa área é afetada.

16

(?: re)

Agrupa expressões regulares sem lembrar o texto correspondente.

17

(?imx: re)

Alterna temporariamente as opções i, m ou x entre parênteses.

18

(?-imx: re)

Desativa temporariamente as opções i, m ou x entre parênteses.

19

(?#...)

Comente.

20

(?= re)

Especifica a posição usando um padrão. Não tem alcance.

21

(?! re)

Especifica a posição usando negação de padrão. Não tem alcance.

22

(?> re)

Corresponde ao padrão independente sem retrocesso.

23

\w

Corresponde a caracteres de palavras.

24

\W

Corresponde a caracteres que não sejam palavras.

25

\s

Corresponde ao espaço em branco. Equivalente a [\ t \ n \ r \ f].

26

\S

Corresponde a espaços não brancos.

27

\d

Corresponde aos dígitos. Equivalente a [0-9].

28

\D

Corresponde a nondigits.

29

\A

Corresponde ao início da string.

30

\Z

Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.

31

\z

Corresponde ao final da string.

32

\G

As partidas apontam onde a última partida terminou.

33

\b

Corresponde aos limites da palavra quando fora dos colchetes. Corresponde ao backspace (0x08) quando entre colchetes.

34

\B

Corresponde a limites não-palavra.

35

\n, \t, etc.

Corresponde a novas linhas, retornos de carro, guias, etc.

36

\1...\9

Corresponde à enésima subexpressão agrupada.

37

\10

Corresponde à enésima subexpressão agrupada, se já houver correspondência. Caso contrário, refere-se à representação octal de um código de caractere.

Exemplos de expressões regulares

Sr. Não. Exemplo e descrição
1

/ruby/

Corresponde a "ruby".

2

¥

Corresponde ao sinal de ienes. Os caracteres multibyte são suportados no Ruby 1.9 e Ruby 1.8.

Sr. Não. Exemplo e descrição
1

/[Rr]uby/

Corresponde a "Ruby" ou "ruby".

2

/rub[ye]/

Corresponde a "ruby" ou "rube".

3

/[aeiou]/

Corresponde a qualquer vogal minúscula.

4

/[0-9]/

Corresponde a qualquer dígito; igual a / [0123456789] /.

5

/[a-z]/

Corresponde a qualquer letra ASCII minúscula.

6

/[A-Z]/

Corresponde a qualquer letra ASCII maiúscula.

7

/[a-zA-Z0-9]/

Corresponde a qualquer uma das opções acima.

8

/[^aeiou]/

Corresponde a qualquer coisa que não seja uma vogal minúscula.

9

/[^0-9]/

Corresponde a qualquer coisa diferente de um dígito.

Sr. Não. Exemplo e descrição
1

/./

Corresponde a qualquer caractere, exceto nova linha.

2

/./m

No modo multilinha, também corresponde a nova linha.

3

/\d/

Corresponde a um dígito: / [0-9] /.

4

/\D/

Corresponde a um não dígito: / [^ 0-9] /.

5

/\s/

Corresponde a um caractere de espaço em branco: / [\ t \ r \ n \ f] /.

6

/\S/

Corresponde a espaços não em branco: / [^ \ t \ r \ n \ f] /.

7

/\w/

Corresponde a um único caractere de palavra: / [A-Za-z0-9 _] /.

8

/\W/

Corresponde a um caractere diferente de palavra: / [^ A-Za-z0-9 _] /.

Sr. Não. Exemplo e descrição
1

/ruby?/

Corresponde a "rub" ou "ruby": o y é opcional.

2

/ruby*/

Corresponde a "rub" mais 0 ou mais ys.

3

/ruby+/

Corresponde a "esfregar" mais 1 ou mais ys.

4

/\d{3}/

Corresponde exatamente a 3 dígitos.

5

/\d{3,}/

Corresponde a 3 ou mais dígitos.

6

/\d{3,5}/

Corresponde a 3, 4 ou 5 dígitos.

Isso corresponde ao menor número de repetições -

Sr. Não. Exemplo e descrição
1

/<.*>/

Repetição gananciosa: corresponde a "<ruby> perl>".

2

/<.*?>/

Não ganancioso: corresponde a "<ruby>" em "<ruby> perl>".

Sr. Não. Exemplo e descrição
1

/\D\d+/

Nenhum grupo: + repete-se \ d

2

/(\D\d)+/

Agrupado: + repete \ D \ d par

3

/([Rr]uby(, )?)+/

Corresponde a "Ruby", "Ruby, ruby, ruby" etc.

Isso corresponde a um grupo anteriormente correspondido novamente -

Sr. Não. Exemplo e descrição
1

/([Rr])uby&\1ails/

Combina ruby ​​& rails ou Ruby & Rails.

2

/(['"])(?:(?!\1).)*\1/

String entre aspas simples ou duplas. \ 1 corresponde a tudo o que o primeiro grupo correspondeu. \ 2 corresponde ao que o 2º grupo correspondeu, etc.

Sr. Não. Exemplo e descrição
1

/ruby|rube/

Corresponde a "ruby" ou "rube".

2

/rub(y|le))/

Corresponde a "rubi" ou "rublo".

3

/ruby(!+|\?)/

"ruby" seguido por um ou mais! ou um?

Ele precisa especificar a posição de correspondência.

Sr. Não. Exemplo e descrição
1

/^Ruby/

Corresponde a "Ruby" no início de uma string ou linha interna.

2

/Ruby$/

Corresponde a "Ruby" no final de uma string ou linha.

3

/\ARuby/

Corresponde a "Ruby" no início de uma string.

4

/Ruby\Z/

Corresponde a "Ruby" no final de uma string.

5

/\bRuby\b/

Corresponde a "Ruby" no limite de uma palavra.

6

/\brub\B/

\ B é um limite sem palavra: corresponde a "esfregar" em "rube" e "ruby", mas não sozinho.

7

/Ruby(?=!)/

Corresponde a "Ruby", se seguido por um ponto de exclamação.

8

/Ruby(?!!)/

Corresponde a "Ruby", se não for seguido por um ponto de exclamação.

Sr. Não. Exemplo e descrição
1

/R(?#comment)/

Corresponde a "R". Todo o resto é um comentário.

2

/R(?i)uby/

Não diferencia maiúsculas de minúsculas enquanto corresponde a "uby".

3

/R(?i:uby)/

O mesmo que acima.

4

/rub(?:y|le))/

Grupo apenas sem criar \ 1 referência anterior.

Pesquisar e substituir

Alguns dos métodos String mais importantes que usam expressões regulares são sub e gsub, e suas variantes no local sub! e gsub!.

Todos esses métodos executam uma operação de pesquisa e substituição usando um padrão Regexp. osub E sub! substitui a primeira ocorrência do padrão e gsub E gsub! substitui todas as ocorrências.

o sub e gsub retorna uma nova string, deixando o original inalterado, onde como sub! e gsub! modifique a string na qual 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}"

Isso produzirá o seguinte resultado -

Phone Num : 2004-959-559
Phone Num : 2004959559

A seguir está 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}"

Isso produzirá o seguinte resultado -

Rails are Rails, really good Ruby on Rails

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 semelhante àquela do módulo Perl DBI.

DBI significa Database Independent Interface for Ruby, o que significa que DBI fornece uma camada de abstração entre o código Ruby e o banco de dados subjacente, permitindo que você alterne as implementações do banco de dados com 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
  • Frontbase
  • mSQL
  • MySQL
  • ODBC
  • Oracle
  • OCI8 (Oracle)
  • PostgreSQL
  • Proxy/Server
  • SQLite
  • SQLRelay

Arquitetura de um aplicativo DBI

O DBI é independente de qualquer banco de dados disponível no backend. Você pode usar DBI se estiver trabalhando com Oracle, MySQL ou Informix, etc. Isso fica claro no diagrama de arquitetura a seguir.

A arquitetura geral para Ruby DBI usa duas camadas -

  • A camada de interface de banco de dados (DBI). Essa camada é independente do 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 de banco de dados (DBD). Esta camada depende do banco de dados; diferentes drivers fornecem acesso a diferentes mecanismos de banco de dados. Existe um driver para MySQL, outro para PostgreSQL, outro para InterBase, outro para Oracle e assim por diante. Cada driver interpreta as solicitações da camada DBI e as mapeia nas solicitações apropriadas para um determinado tipo de servidor de banco de dados.

Pré-requisitos

Se você deseja escrever scripts Ruby para acessar bancos de dados MySQL, você precisará ter o módulo Ruby MySQL instalado.

Este módulo atua como um DBD conforme explicado acima e pode ser baixado de https://www.tmtm.org/en/mysql/ruby/

Obtendo e Instalando Ruby / DBI

Você pode baixar e instalar o módulo Ruby DBI a partir do seguinte local -

https://imgur.com/NFEuWe4/embed

Antes de iniciar esta instalação, certifique-se de ter privilégios de root. Agora, siga as etapas abaixo -

Passo 1

$ tar zxf dbi-0.2.0.tar.gz

Passo 2

Acesse o diretório de distribuição dbi-0.2.0 e configure-o usando o script setup.rb nesse diretório. O comando de configuração mais geral se parece com este, 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 MySQL DBD, emita o seguinte comando -

$ ruby setup.rb config --with = dbi,dbd_mysql

etapa 3

A etapa 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 iremos trabalhar com o 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 em TESTDB.

  • Esta tabela contém os campos FIRST_NAME, LAST_NAME, AGE, SEX e INCOME.

  • O ID do usuário "testuser" e a senha "test123" são definidos para acessar o TESTDB.

  • O Módulo Ruby DBI está instalado corretamente em sua máquina.

  • Você passou pelo tutorial do MySQL para entender os fundamentos do MySQL.

A seguir está 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 identificador de banco de dados é retornado e salvo em dbh para uso posterior de outra forma dbhé definido como valor nulo e e.err e e :: errstr retornam o código de erro e uma string de erro, respectivamente.

Por fim, antes de lançá-lo, certifique-se de que a conexão com o banco de dados seja fechada e os recursos liberados.

Operação INSERT

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 banco de dados é estabelecida, estamos prontos para criar tabelas ou registros nas tabelas de banco de dados usando do método ou prepare e execute método.

Usando fazer declaração

As instruções que não retornam linhas podem ser emitidas invocando o dométodo de manipulação de banco de dados. Este 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
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   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
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Usando preparar e executar

Você pode usar métodos de preparação e execução da classe DBI para executar a instrução SQL por meio do código Ruby.

A criação do registro segue as seguintes etapas -

  • Preparando a instrução SQL com a instrução INSERT. Isso será feito usando oprepare método.

  • Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usando oexecute método.

  • Identificador de declaração de liberação. Isso será feito usandofinish API

  • Se tudo correr bem, então commit esta operação, caso contrário, você pode rollback 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 passar bindvalores para instruções SQL. Pode haver um caso em que os valores a serem inseridos não sejam fornecidos com antecedência. Nesse caso, os valores de ligação são usados. Uma interrogação (?) é usado no lugar dos valores reais e, em seguida, os valores reais são passados ​​por meio da API execute ().

A seguir está o exemplo para criar dois registros na tabela EMPLOYEE -

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   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"
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Se houver vários INSERTs ao mesmo tempo, preparar uma instrução primeiro e, em seguida, executá-la várias vezes dentro de um loop é mais eficiente do que chamar do a cada vez através do loop.

Operação READ

A operação READ em qualquer banco de dados significa buscar algumas informações úteis do banco de dados.

Assim que nossa conexão com o banco de dados for estabelecida, estamos prontos para fazer uma consulta neste banco de dados. Podemos usar qualquer umdo método ou prepare e execute métodos para buscar valores de uma tabela de banco de dados.

A busca de registros segue as seguintes etapas -

  • Preparando a consulta SQL com base nas condições exigidas. Isso será feito usando oprepare método.

  • Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usando oexecute método.

  • Buscando todos os resultados um por um e imprimindo esses resultados. Isso será feito usando ofetch método.

  • Identificador de declaração de liberação. Isso será feito usando ofinish método.

A seguir está o procedimento para consultar todos os registros da tabela EMPLOYEE com salário acima de 1000.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   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
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

Isso produzirá o seguinte resultado -

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 estiver interessado, vá até Buscando o resultado, caso contrário, vá para a próxima seção.

Operação de atualização

ATUALIZAR 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 está o procedimento para atualizar todos os registros que têm SEXO como 'M'. Aqui, aumentaremos a AGE de todos os homens em um ano. Isso levará três etapas -

  • Preparando a consulta SQL com base nas condições exigidas. Isso será feito usando oprepare método.

  • Execução de consulta SQL para selecionar todos os resultados do banco de dados. Isso será feito usando oexecute método.

  • Identificador de declaração de liberação. Isso será feito usando ofinish método.

  • Se tudo correr bem então commit esta operação, caso contrário, você pode rollback a transação completa.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = ?")
   sth.execute('M')
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Operação DELETE

A operação DELETE é necessária quando você deseja excluir alguns registros de seu banco de dados. A seguir está o procedimento para excluir todos os registros de EMPLOYEE onde AGE é maior que 20. Esta operação executará as seguintes etapas.

  • Preparando a consulta SQL com base nas condições exigidas. Isso será feito usando oprepare método.

  • Execução de consulta SQL para excluir registros necessários do banco de dados. Isso será feito usando oexecute método.

  • Identificador de declaração de liberação. Isso será feito usando ofinish método.

  • Se tudo correr bem então commit esta operação, caso contrário, você pode rollback a transação completa.

#!/usr/bin/ruby -w

require "dbi"

begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123")
   sth = dbh.prepare("DELETE FROM EMPLOYEE WHERE AGE > ?")
   sth.execute(20)
   sth.finish
   dbh.commit
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Realizando transações

As transações são um mecanismo que garante a consistência dos dados. As transações devem ter as seguintes quatro propriedades -

  • Atomicity - Ou uma transação é concluída ou nada acontece.

  • Consistency - Uma transação deve começar em um estado consistente e deixar o sistema em um estado consistente.

  • Isolation - Os resultados intermediários de uma transação não são visíveis fora da transação atual.

  • Durability - Depois que uma transação foi confirmada, os efeitos são persistentes, mesmo após uma falha do sistema.

O DBI fornece dois métodos para confirmar ou reverter uma transação. Existe 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 leva um bloco de código contendo as instruções que constituem a transação. O método de transação executa o bloco e, em seguida, invoca o commit ou rollback automaticamente, dependendo se o bloco foi bem-sucedido ou falhou -

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 alterações e, após esta operação, nenhuma alteração pode ser revertida.

Aqui está um exemplo simples para chamar o commit método.

dbh.commit

Operação ROLLBACK

Se você não estiver satisfeito com uma ou mais das mudanças e quiser reverter essas mudanças completamente, use o rollback método.

Aqui está um exemplo simples para chamar o rollback método.

dbh.rollback

Desconectando banco de dados

Para desconectar a conexão do 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, seu aplicativo seria melhor chamar o commit ou rollback explicitamente.

Tratamento de 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 fetch 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 qualquer um dos vários tipos de exceção, mas as duas classes de exceção mais importantes são DBI :: InterfaceError e DBI :: DatabaseError .

Os objetos de exceção dessas classes têm três atributos denominados err , errstr e estado , que representam o número do erro, uma string de erro descritiva e um código de erro padrão. Os atributos são explicados abaixo -

  • err- Retorna uma representação inteira do erro ocorrido ou nulo se isso não for suportado pelo DBD. O DBD 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 oferece suporte para isso e, em vez disso, retorna nil.

Você viu o seguinte código acima na maioria dos exemplos -

rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
   dbh.rollback
ensure
   # disconnect from server
   dbh.disconnect if dbh
end

Para obter informações de depuração sobre o que seu script está fazendo enquanto é executado, você pode ativar o rastreio. Para fazer isso, você deve primeiro carregar o módulo dbi / trace e, em seguida, chamar o método de rastreamento que controla o modo de rastreamento 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ódigo. A vantagem de usar bloco de código junto com métodos é que eles fornecem o identificador para o bloco de código como seu parâmetro e limpam automaticamente o identificador quando o bloco termina. Existem alguns exemplos para entender o conceito.

  • DBI.connect- Este método gera um identificador de banco de dados e é recomendado chamar a desconexão no final do bloco para desconectar o banco de dados.

  • dbh.prepare- Este método gera um identificador de instrução e é recomendado terminar 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 execute dentro do bloco. O identificador de instrução é executado automaticamente.

Exemplo 1

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

dbh.prepare pode pegar um bloco de código, passar o identificador de instrução para ele e chamar automaticamente terminar no final do bloco, como segue.

dbh.prepare("SHOW DATABASES") do |sth|
   sth.execute
   puts "Databases: " + sth.fetch_all.join(", ")
end

Exemplo 3

dbh.execute pode pegar um bloco de código, passar o identificador de instrução para ele e chamar automaticamente terminar 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 leva 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 por meio do método func de qualquer objeto Handle.

Atributos específicos do driver são suportados e podem ser definidos ou obtidos usando o []= ou [] métodos.

Sr. Não. Funções e descrição
1

dbh.func(:createdb, db_name)

Cria um novo banco de dados.

2

dbh.func(:dropdb, db_name)

Descarta um banco de dados.

3

dbh.func(:reload)

Executa uma operação de recarregamento.

4

dbh.func(:shutdown)

Encerra o servidor.

5

dbh.func(:insert_id) => Fixnum

Retorna o valor AUTO_INCREMENT mais recente para uma conexão.

6

dbh.func(:client_info) => String

Retorna informações do cliente MySQL em termos de versão.

7

dbh.func(:client_version) => Fixnum

Retorna informações do cliente em termos de versão. É semelhante a: client_info, mas retorna um fixnum em vez de sting.

8

dbh.func(:host_info) => String

Retorna informações do host.

9

dbh.func(:proto_info) => Fixnum

Retorna o protocolo que está sendo usado para a comunicação.

10

dbh.func(:server_info) => String

Retorna informações do servidor MySQL em termos de versão.

11

dbh.func(:stat) => String

Retorna o estado atual do banco de dados.

12

dbh.func(:thread_id) => Fixnum

Retorna o ID do segmento atual.

Exemplo

#!/usr/bin/ruby

require "dbi"
begin
   # connect to the MySQL server
   dbh = DBI.connect("DBI:Mysql:TESTDB:localhost", "testuser", "test123") 
   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)
rescue DBI::DatabaseError => e
   puts "An error occurred"
   puts "Error code:    #{e.err}"
   puts "Error message: #{e.errstr}"
ensure
   dbh.disconnect if dbh
end

Isso produzirá o seguinte resultado -

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 é uma linguagem de propósito geral; ela não pode ser chamada propriamente de linguagem da web . Mesmo assim, aplicações web e ferramentas web em geral estão entre os usos mais comuns de Ruby.

Não apenas você pode escrever seu próprio servidor SMTP, daemon FTP ou servidor Web em Ruby, mas também pode usar Ruby para tarefas mais usuais, como programação CGI ou como um substituto para PHP.

Por favor, gaste alguns minutos com o Tutorial de programação CGI para obter mais detalhes sobre a programação CGI.

Escrevendo Scripts CGI

O script CGI Ruby mais básico se parece com isto -

#!/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 na Web 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 com um provedor de hospedagem da Web Linux e você carrega test.cgi para o diretório principal e dá a ele permissões de execução, em seguida, visitandohttps://www.example.com/test.cgi deve retornar uma página HTML dizendo This is a test.

Aqui, quando test.cgi é solicitado de um navegador da Web, o servidor da Web procura test.cgi no site e o executa usando o interpretador Ruby. O script Ruby retorna um cabeçalho HTTP básico e, em seguida, retorna um documento HTML básico.

Usando cgi.rb

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 o usou para imprimir a linha do cabeçalho para você.

Processamento de Formulário

O uso da classe CGI fornece acesso aos parâmetros de consulta HTML de duas maneiras. Suponha que recebemos um URL de /cgi-bin/test.cgi?FirstName = Zara & LastName = Ali.

Você pode acessar os parâmetros FirstName e LastName usando CGI # [] diretamente da seguinte forma -

#!/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 fornecerá 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 deles.index o resultado do método params para obter todos eles.

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"]}

Note- Ruby cuidará dos métodos GET e POST automaticamente. Não existe um 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 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>

Criação de 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 consideram seu conteúdo como blocos de código. Os blocos de código devem retornar uma String , que será usada como o 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
         }
      }
   }
}

NOTE- 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 e assim por diante ...) a ser usado no envio do formulário. O padrão, usado neste exemplo, é POST.

Isso produzirá o seguinte resultado -

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 Strings

Ao lidar com URLs e código HTML, você deve ter o cuidado de citar alguns caracteres. Por exemplo, um caractere de barra (/) tem um significado especial em um URL, então deve serescaped se não fizer parte do nome do caminho.

Por exemplo, qualquer / na parte da consulta do URL será traduzido para a string% 2F e deve ser traduzido de volta para / para que você possa usá-lo. Espaço e e comercial também são caracteres especiais. Para lidar com isso, CGI fornece as rotinasCGI.escape e CGI.unescape.

#!/usr/bin/ruby

require 'cgi'
puts CGI.escape(Zara Ali/A Sweet & Sour Girl")

Isso produzirá o seguinte resultado -

Zara+Ali%2FA Sweet+%26+Sour+Girl")

#!/usr/bin/ruby

require 'cgi'
puts CGI.escapeHTML('<h1>Zara Ali/A Sweet & Sour Girl</h1>')

Isso produzirá o seguinte resultado -

&lt;h1&gt;Zara Ali/A Sweet & Sour Girl&lt;/h1&gt;'

Métodos úteis na classe CGI

Aqui está a lista de métodos relacionados à classe CGI -

  • O CGI Ruby - Métodos relacionados à biblioteca CGI padrão.

Cookies e Sessões

Explicamos esses dois conceitos em seções diferentes. Siga as seções -

  • Os Cookies CGI Ruby - Como lidar com Cookies CGI.

  • The Ruby CGI Sessions - Como gerenciar sessões CGI.

Servidores de hospedagem na web

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

O protocolo SMTP (Simple Mail Transfer Protocol) é um protocolo que lida com o envio e o roteamento de e-mail entre servidores de e-mail.

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 new leva dois parâmetros -

    • O nome do servidor padronizado para localhost.

    • O número da porta padronizado para a porta 25 conhecida.

  • o start método usa esses parâmetros -

    • O servidor - nome 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 e-mail, padronizado para ENV ["HOSTNAME"].

    • A conta - nome de usuário, o padrão é nulo.

    • A senha - senha do usuário, com o padrão nulo.

    • O authtype - tipo de autorização, padronizado para cram_md5 .

Um objeto SMTP tem um método de instância chamado sendmail, que normalmente será usado para fazer o trabalho de envio de uma mensagem. Leva três parâmetros -

  • A fonte - uma string ou array ou qualquer coisa com cada iterador retornando uma string por vez.

  • O remetente - Uma string que aparecerá no do campo de e-mail.

  • Os destinatários - uma string ou uma matriz de strings que representa o (s) destinatário (s) dos destinatários.

Exemplo

Aqui está uma maneira simples de enviar um e-mail usando o script Ruby. Experimente uma vez -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
Subject: SMTP e-mail test

This is a test e-mail message.
MESSAGE_END

Net::SMTP.start('localhost') do |smtp|
  smtp.send_message message, '[email protected]', '[email protected]'
end

Aqui, você colocou um e-mail básico na mensagem, usando um documento, cuidando para formatar os cabeçalhos corretamente. Os e-mails requerem umFrom, Toe Subject cabeçalho, separado do corpo do e-mail por uma linha em branco.

Para enviar o e-mail, você usa Net :: SMTP para se conectar ao servidor SMTP na máquina local e, em seguida, usa o método send_message junto com a mensagem, o endereço de origem e o endereço de destino como parâmetros (mesmo que os endereços de e para no próprio e-mail, nem sempre são usados ​​para encaminhar e-mails).

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 Hotmail ou Yahoo! Mail), seu provedor de e-mail fornecerá a você os detalhes do servidor de e-mail de saída que você pode fornecer ao Net :: SMTP, como segue -

Net::SMTP.start('mail.your-domain.com')

Esta linha de código se conecta ao servidor SMTP na porta 25 de mail.seu-domínio.com sem usar nenhum nome de usuário ou senha. Se for necessário, 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.seu-domínio.com usando um nome de usuário e uma senha em formato de texto simples. Ele identifica o nome do host do cliente como localhost.

Enviando um e-mail HTML usando Ruby

Ao enviar uma mensagem de texto usando Ruby, todo o conteúdo será tratado como texto simples. Mesmo que você inclua 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 a opção de enviar uma mensagem HTML como uma mensagem HTML real.

Ao enviar uma mensagem de e-mail, você pode especificar uma versão Mime, tipo de conteúdo e conjunto de caracteres para enviar um e-mail em HTML.

Exemplo

A seguir está o exemplo para enviar conteúdo HTML como um e-mail. Experimente uma vez -

require 'net/smtp'

message = <<MESSAGE_END
From: Private Person <[email protected]>
To: A Test User <[email protected]>
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

Net::SMTP.start('localhost') do |smtp|
   smtp.send_message message, '[email protected]', '[email protected]'
end

Envio de anexos por e-mail

Para enviar um e-mail com conteúdo misto, é necessário definir Content-type cabeçalho para multipart/mixed. Então, as seções de texto e anexo podem ser especificadas dentroboundaries.

Um limite é iniciado com dois hifens seguidos por um número exclusivo, que não pode aparecer na parte da mensagem do e-mail. Um limite final denotando a seção final do e-mail também deve terminar com dois hifens.

Os arquivos anexados devem ser codificados com o pack("m") função para ter codificação base64 antes da transmissão.

Exemplo

A seguir está o exemplo, que irá enviar um arquivo /tmp/test.txt como um 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 <[email protected]>
To: A Test User <[email protected]>
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 
   Net::SMTP.start('localhost') do |smtp|
      smtp.sendmail(mailtext, '[email protected]', ['[email protected]'])
   end
rescue Exception => e  
   print "Exception occured: " + e  
end

NOTE - Você pode especificar vários destinos dentro da matriz, mas eles devem ser separados por vírgula.

Ruby fornece dois níveis de acesso a serviços de rede. Em um nível inferior, você pode acessar o suporte de soquete básico no sistema operacional subjacente, que permite implementar clientes e servidores para protocolos orientados a conexão e sem conexão.

Ruby também tem bibliotecas que fornecem acesso de nível superior a protocolos de rede de nível de aplicativo específicos, como FTP, HTTP e assim por diante.

Este capítulo fornece uma compreensão do conceito mais famoso em Rede - Programação de Soquete.

O que são soquetes?

Os soquetes são os terminais de um canal de comunicação bidirecional. Os sockets podem se comunicar dentro de um processo, entre processos na mesma máquina ou entre processos em continentes diferentes.

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 lidar com os transportes comuns, bem como uma interface genérica para lidar com o resto.

Os soquetes têm seu próprio vocabulário -

Sr. Não. Termo e descrição
1

domain

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.

2

type

O tipo de comunicação entre os dois pontos de extremidade, normalmente SOCK_STREAM para protocolos orientados à conexão e SOCK_DGRAM para protocolos sem conexão.

3

protocol

Normalmente zero, isso pode ser usado para identificar uma variante de um protocolo dentro de um domínio e tipo.

4

hostname

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 em notação de dois pontos (e possivelmente de ponto)

Uma string "<broadcast>", que especifica um endereço INADDR_BROADCAST.

Uma string de comprimento zero, que especifica INADDR_ANY, ou

Um número inteiro, interpretado como um endereço binário na ordem de bytes do host.

5

port

Cada servidor escuta os clientes chamando em uma ou mais portas. Uma porta pode ser um número de porta Fixnum, uma string contendo um número de porta ou o nome de um serviço.

Um cliente simples

Aqui, escreveremos um programa cliente muito simples, que abrirá uma conexão para uma determinada porta e um determinado host. Aula de RubyTCPSocketfornece a função aberta para abrir tal soquete.

o TCPSocket.open(hosname, port )abre uma conexão TCP para o nome do host na porta .

Depois de ter um soquete aberto, você pode ler dele como qualquer objeto IO. Quando terminar, lembre-se de fechá-lo, como você fecharia um arquivo.

O código a seguir é um cliente muito simples que se conecta a um determinado host e porta, lê todos os dados disponíveis 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 escrever servidores de Internet, usamos o TCPServerclasse. Um objeto TCPServer é uma fábrica de objetos TCPSocket.

Agora ligue TCPServer.open(hostname, portfunção para especificar uma porta para o seu serviço e criar umTCPServer objeto.

Em seguida, chamar a aceitar método do objeto TCPServer retornado. Este método espera 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 execute o cliente acima para ver o resultado.

Servidores TCP de múltiplos clientes

A maioria dos servidores na Internet é projetada para lidar com um grande número de clientes a qualquer momento.

A classe Thread do Ruby facilita a criação de um servidor multithread. Um 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 acabou de ser aceita, usando o objeto de conexão passado para o thread. No entanto, o programa principal volta imediatamente e aguarda novas conexões.

Usar encadeamentos Ruby dessa forma significa que o código é portátil e será executado da mesma maneira no Linux, OS X e Windows.

Um Tiny Web Browser

Podemos usar a biblioteca de soquetes para implementar qualquer protocolo da Internet. Aqui, por exemplo, está 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 cliente da web semelhante, você pode usar uma biblioteca pré-construída como Net::HTTPpara trabalhar com HTTP. Aqui está o código que faz o equivalente ao 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

Verifique se bibliotecas semelhantes funcionam com protocolos FTP, SMTP, POP e IMAP.

Leituras adicionais

Fornecemos um guia rápido para programação de soquetes. É um assunto extenso, portanto, é recomendável que você consulte a Biblioteca de soquetes Ruby e Métodos de classe para encontrar mais detalhes.

O que é XML?

A Extensible Markup Language (XML) é uma linguagem de marcação muito parecida com HTML ou SGML. Isso é recomendado pelo World Wide Web Consortium e está disponível como um padrão aberto.

XML é uma linguagem portátil e de código aberto que permite aos programadores desenvolver aplicativos que podem ser lidos por outros aplicativos, independentemente do sistema operacional e / ou linguagem de desenvolvimento.

XML é extremamente útil para rastrear pequenas e médias quantidades de dados sem exigir um backbone baseado em SQL.

Arquiteturas XML Parser e APIs

Existem dois sabores diferentes disponíveis para analisadores XML -

  • SAX-like (Stream interfaces)- 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, ele analisa o arquivo enquanto o lê do disco e o arquivo inteiro nunca é armazenado na memória.

  • DOM-like (Object tree interfaces) - Esta é a recomendação do World Wide Web Consortium em que todo o arquivo é lido na memória e armazenado em uma forma hierárquica (baseada em árvore) para representar todos os recursos de um documento XML.

Obviamente, o SAX 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 DOM permite alterações no arquivo XML. Uma vez que essas duas APIs diferentes se complementam literalmente, não há razão para que você não possa usá-las para grandes projetos.

Análise e criação de XML usando Ruby

A maneira mais comum de manipular XML é com a biblioteca REXML de Sean Russell. Desde 2002, REXML faz parte da distribuição padrão do Ruby.

REXML é um processador XML Ruby puro em conformidade com o padrão XML 1.0. É um processador de não validação , passando em todos os testes de conformidade de não validação OASIS.

O analisador REXML tem as seguintes vantagens sobre outros analisadores disponíveis -

  • Está escrito 100 por cento em Ruby.
  • Ele pode ser usado para análise SAX e DOM.
  • É leve, com menos de 2.000 linhas de código.
  • Métodos e classes são realmente fáceis de entender.
  • API baseada em SAX2 e suporte completo a XPath.
  • Enviado com a instalação do Ruby e nenhuma instalação separada é necessária.

Para todos os nossos exemplos de código XML, vamos usar um arquivo XML simples como 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>
      <format>DVD</format>
      <year>1989</year>
      <rating>R</rating>
      <stars>8</stars>
      <description>A schientific fiction</description>
   </movie>
   <movie title = "Trigun">
      <type>Anime, Action</type>
      <format>DVD</format>
      <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 semelhante a DOM

Vamos primeiro analisar nossos dados XML em forma de árvore . Começamos exigindo orexml/documentbiblioteca; frequentemente, incluímos 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 
}

Isso produzirá o seguinte resultado -

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 semelhante a SAX

Para processar os mesmos dados, movies.xml , arquivo de uma forma orientada a fluxo , definiremos uma classe de ouvinte cujos métodos serão o alvo de retornos de chamada do analisador.

NOTE - Não é sugerido usar análise semelhante a SAX para um arquivo pequeno, isso é apenas para um exemplo de demonstração.

#!/usr/bin/ruby -w

require 'rexml/document'
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
xmlfile = File.new("movies.xml")
Document.parse_stream(xmlfile, list)

Isso produzirá o seguinte resultado -

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"}
tag_start: "type", {}
   text   :   "Anime, Science Fiction"
tag_start: "format", {}
tag_start: "year", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "A schientific fiction"
tag_start: "movie", {"title"=>"Trigun"}
tag_start: "type", {}
   text   :   "Anime, Action"
tag_start: "format", {}
tag_start: "episodes", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Vash the Stampede!"
tag_start: "movie", {"title"=>"Ishtar"}
tag_start: "type", {}
tag_start: "format", {}
tag_start: "rating", {}
tag_start: "stars", {}
tag_start: "description", {}
   text   :   "Viewable boredom"

XPath e Ruby

Uma forma alternativa de visualizar XML é XPath. Este é 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.

REXML tem suporte XPath por meio da classe XPath . Ele assume a análise baseada em árvore (modelo de objeto de documento) como vimos acima.

#!/usr/bin/ruby -w

require 'rexml/document'
include REXML

xmlfile = File.new("movies.xml")
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

Isso produzirá o seguinte resultado -

<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 Ruby pode usar. Uma breve descrição de cada um é fornecida aqui.

Ruby-Sablotron

Este analisador foi escrito e mantido por Masayoshi Takahashi. Isso foi escrito principalmente para o sistema operacional Linux e requer as seguintes bibliotecas -

  • Sablot
  • Iconv
  • Expat

Você pode encontrar este módulo em Ruby-Sablotron.

XSLT4R

XSLT4R foi escrito por Michael Neumann e pode ser encontrado no RAA na seção Biblioteca 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 do XMLScan para operar, que está incluído no arquivo XSLT4R e que também é um módulo Ruby 100 por cento. Esses módulos podem ser instalados usando o método de instalação padrão do Ruby (ou seja, ruby ​​install.rb).

XSLT4R tem a seguinte sintaxe -

ruby xslt.rb stylesheet.xsl document.xml [arguments]

Se quiser usar o XSLT4R de 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 para REXML Parser Documentation .

  • Você pode fazer download do XSLT4R no repositório RAA .

O que é SOAP?

O Simple Object Access Protocol (SOAP) é 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.

SOAP tem várias vantagens sobre outras tecnologias como COM, CORBA etc: por exemplo, sua implantação relativamente barata e custos de depuração, sua extensibilidade e facilidade de uso, e a existência de várias implementações para diferentes linguagens e plataformas.

Consulte nosso tutorial SOAP simples para entendê-lo em detalhes.

Este capítulo o familiariza com a implementação SOAP para Ruby (SOAP4R). Este é um tutorial básico, portanto, se você precisar de detalhes profundos, deverá consultar outros recursos.

Instalando SOAP4R

SOAP4R é a implementação SOAP para Ruby desenvolvida por Hiroshi Nakamura e pode ser baixado de -

NOTE - Pode haver uma grande chance de você já ter instalado este componente.

Download SOAP

Se você está ciente de gem utilitário então você pode usar o seguinte comando para instalar SOAP4R e 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

SOAP4R suporta dois tipos diferentes de servidores -

  • Baseado em CGI / FastCGI (SOAP :: RPC :: CGIStub)
  • Independente (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 a classe SOAP :: RPC :: StandaloneServer

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

class MyServer < SOAP::RPC::StandaloneServer
  ...............
end

NOTE- Se você deseja escrever um servidor baseado em FastCGI, você precisa tomar SOAP :: RPC :: CGIStub como classe pai, o resto do procedimento permanecerá o mesmo.

Etapa 2 - Definir Métodos de Manipulação

A segunda etapa é escrever seus métodos de Web Services, 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 -

class MyServer < SOAP::RPC::StandaloneServer
   ...............

   # Handler methods
   def add(a, b)
      return a + b
   end
   def div(a, b) 
      return a / b 
   end
end

Etapa 3 - Expor métodos de manipulador

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

class MyServer < SOAP::RPC::StandaloneServer
   def initialize(*args)
      add_method(receiver, methodName, *paramArg)
   end
end

Aqui está a descrição dos parâmetros -

Sr. Não. Parâmetro e Descrição
1

receiver

O objeto que contém o método methodName. Você define os métodos de serviço na mesma classe do método methodDef, este parâmetro é self .

2

methodName

O nome do método que é chamado devido a uma solicitação RPC.

3

paramArg

Especifica, quando fornecidos, os nomes e modos dos parâmetros.

Para entender o uso dos 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 parâmetros adicionais: inoutParam e outParam -

def aMeth(inParam, inoutParam)
   retVal = inParam + inoutParam
   outParam = inParam . inoutParam
   inoutParam = inParam * inoutParam
   return retVal, inoutParam, outParam
end

Agora, podemos expor esse método da seguinte maneira -

add_method(self, 'aMeth', [
   %w(in inParam),
   %w(inout inoutParam),
   %w(out outParam),
   %w(retval return)
])

Etapa 4 - iniciar o servidor

A etapa final é iniciar seu servidor instanciando uma instância da classe derivada e chamando start método.

myServer = MyServer.new('ServerName', 'urn:ruby:ServiceName', hostname, port)

myServer.start

Aqui está a descrição dos parâmetros necessários -

Sr. Não. Parâmetro e Descrição
1

ServerName

Um nome de servidor, você pode dar o que você mais gosta.

2

urn:ruby:ServiceName

Aqui urn: ruby é constante, mas você pode fornecer um nome ServiceName exclusivo para este servidor.

3

hostname

Especifica o nome do host no qual este servidor ouvirá.

4

port

Um número de porta disponível para 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
   class MyServer < SOAP::RPC::StandaloneServer

      # 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 localhost e escuta as solicitações na porta 8080. Ele expõe um método de serviço, add e div , que leva 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 escrever aplicativos cliente SOAP. Este capítulo descreve essa classe e demonstra seu uso com base em um aplicativo.

A seguir estão as informações mínimas de que você precisa 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, escreveremos 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 -

Sr. Não. Parâmetro e Descrição
1

endPoint

URL do servidor SOAP ao qual se conectar.

2

nameSpace

O namespace a ser usado para todos os RPCs feitos com este objeto SOAP :: RPC :: Driver.

3

soapAction

Um valor para o campo SOAPAction do cabeçalho HTTP. Se nulo, 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 -

Sr. Não. Parâmetro e Descrição
1

name

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 da web real e paramArg ... são os parâmetros de lista necessários para passar o método de serviço.

Example

Com base nas etapas acima, escreveremos um cliente SOAP da seguinte maneira -

#!/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 a você apenas conceitos básicos de Web Services com Ruby. Se você quiser se aprofundar ainda mais, há o seguinte link para encontrar mais detalhes sobre Web Services com Ruby .

Introdução

A interface gráfica do usuário (GUI) padrão 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 interface gráfica de plataforma cruzada. Tk é executado em 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 é às vezes chamado de janela, uma vez que, em Tk, "janela" e "widget" costumam ser usados ​​alternadamente.

Os aplicativos Tk seguem uma hierarquia de widgets em que qualquer número de widgets pode ser colocado em outro widget e esses widgets em outro widget, ad infinitum. O widget principal em um programa Tk é conhecido como widget raiz e pode ser criado criando 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, vincule 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 Ruby Tk são distribuídas com Ruby, mas Tk é uma instalação separada. Os usuários do Windows podem baixar a instalação do Tk com um único clique do ActiveTcl do ActiveState .

Os usuários de Mac e Linux podem não precisar instalá-lo porque há uma grande chance de que ele já esteja instalado junto com o sistema operacional, mas se não, você pode baixar pacotes pré-construídos ou obter o código-fonte no Tcl Developer Xchange .

Aplicativo Tk Simples

Uma estrutura típica para programas Ruby / Tk é criar o principal ou root janela (uma instância de TkRoot), adicione widgets a ela para construir a interface do usuário e, em seguida, inicie o loop de evento principal chamando Tk.mainloop.

O tradicional Hello, World! exemplo para Ruby / Tk parece algo assim -

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 frame raiz, definindo várias opções para o rótulo. Por fim, empacotamos o quadro raiz e entramos no loop de eventos da GUI principal.

Se você executasse este script, ele produziria o seguinte resultado -

Ruby / Tk Widget Classes

Há 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 quadro.

  • TkButton Cria e manipula widgets de botão.

  • TkLabel Cria e manipula widgets de rótulo.

  • TkEntry Cria e manipula widgets de entrada.

  • TkCheckButton Cria e manipula widgets checkbutton.

  • TkRadioButton Cria e manipula widgets de botão de rádio .

  • TkListbox Cria e manipula widgets de caixa de listagem.

  • TkComboBox Cria e manipula widgets de caixa de listagem.

  • TkMenu Cria e manipula widgets de menu.

  • TkMenubutton Cria e manipula widgets de menu.

  • Tk.messageBox Cria e manipula um diálogo de mensagem.

  • TkScrollbar Cria e manipula widgets da 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 Spinbox.

  • TkProgressBar Cria e manipula widgets da barra de progresso.

  • Caixa de diálogo Cria e manipula widgets de 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 verticalmente ou horizontalmente.

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

  • Fonte, cores e imagens Ruby / Tk Noções básicas sobre fontes, cores e imagens Ruby / Tk

Opções de configuração padrão

Todos os widgets têm várias opções de configuração diferentes, que geralmente controlam como eles são exibidos ou como 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.

Sr. Não. Opções e descrição
1

activebackground => String

Especifica a cor de fundo a ser usada ao desenhar elementos ativos. Um elemento está ativo se o cursor do mouse estiver posicionado sobre o elemento e pressionar um botão do mouse fará com que alguma ação ocorra. Você pode usar nomes de cores como "vermelho", "azul", "rosa", "amarelo" etc.

2

activeborderwidth => Inteiro

Especifica um valor não negativo indicando a largura da borda 3-D desenhada ao redor dos elementos ativos.

3

activeforeground => String

Especifica a cor de primeiro plano a ser usada ao desenhar elementos ativos.

4

anchor => String

Especifica como as informações em um widget (por exemplo, texto ou bitmap) devem ser exibidas no widget. Deve ser um dos valoresn, ne, e, se, s, sw, w, nw, ou center. Por exemplo,nw significa exibir as informações de forma que seu canto superior esquerdo esteja no canto superior esquerdo do widget.

5

background or bg => String

Especifica a cor de fundo normal a ser usada ao exibir o widget.

6

bitmap => Bitmap

Especifica um bitmap a ser exibido no widget. A maneira exata como o bitmap é exibido pode ser afetada por outras opções, como ancorar ou justificar.

7

borderwidth or bd => Inteiro

Especifica um valor não negativo indicando a largura da borda 3-D a ser desenhada ao redor do widget.

8

compound => String

Especifica se o widget deve exibir texto e bitmaps / imagens ao mesmo tempo e, em caso afirmativo, onde o bitmap / imagem deve ser colocado em relação ao texto. Deve ser um dos valoresnone, bottom, top, left, right, ou center.

9

cursor => String

Especifica o cursor do mouse a ser usado para o widget. Os valores possíveis podem ser "watch", "arrow" etc.

10

disabledforeground => String

Especifica a cor de primeiro plano a ser usada ao desenhar um elemento desativado.

11

exportselection => Booleano

Especifica se uma seleção no widget também deve ser a seleção X. O valor pode ter qualquer um dostrue, false, 0, 1, yes, ou no. Se a seleção for exportada, então selecionar no widget desmarca a seleção X atual, selecionar fora do widget desmarca qualquer seleção de widget e o widget responderá às solicitações de recuperação de seleção quando tiver uma seleção.

12

font => String

Especifica a fonte a ser usada ao desenhar texto dentro do widget.

13

foreground or fg => String

Especifica a cor de primeiro plano normal a ser usada ao exibir o widget.

14

highlightbackground => String

Especifica a cor a ser exibida na região de destaque transversal quando o widget não tem o foco de entrada.

15

highlightcolor => String

Especifica a cor a ser usada para o retângulo de destaque transversal que é desenhado ao redor do widget quando ele tem o foco de entrada.

16

highlightthickness => Inteiro

Especifica um valor não negativo que indica a largura do retângulo de destaque a ser desenhado ao redor do widget quando ele tem o foco de entrada.

17

image => Imagem

Especifica uma imagem a ser exibida no widget, que deve ter sido criada com uma criação de imagem. Normalmente, se a opção de imagem for especificada, ela substitui outras opções que especificam um bitmap ou valor textual a ser exibido no widget; a opção de imagem pode ser redefinida para uma string vazia para reativar um bitmap ou exibição de texto.

18

jump => String

Para widgets com um controle deslizante que pode ser arrastado para ajustar um valor, como barras de rolagem e escalas, esta opção determina quando as notificações são feitas sobre alterações no valor. O valor da opção deve ser booleano. Se o valor for falso, as atualizações são feitas continuamente conforme o controle deslizante é arrastado. Se o valor for verdadeiro, as atualizações serão atrasadas até que o botão do mouse seja liberado para encerrar o arrasto; nesse ponto, uma única notificação é feita.

19

justify => String

Quando há várias linhas de texto exibidas em um widget, esta opção determina como as linhas se alinham. Deve ser um dosleft, center, ou right. Left significa que todas as bordas esquerdas das linhas se alinham, center significa que os centros das linhas estão alinhados, e right significa que as bordas direitas das linhas estão alinhadas.

20

offset => String

Especifica o deslocamento dos ladrilhos (ver também tileopção). Pode ter dois formatos diferentesoffset x,y ou offset side, onde o lado pode estar n, ne, e, se, s, sw, w, nw, ou center.

21

orient => String

Para widgets que podem ser dispostos com orientação horizontal ou vertical, como barras de rolagem, esta opção especifica qual orientação deve ser usada. Deve ser qualquer umhorizontal ou vertical ou uma abreviatura de um destes.

22

padx => Inteiro

Especifica um valor não negativo indicando quanto espaço extra solicitar para o widget na direção X.

23

pady => Inteiro

Especifica um valor não negativo indicando quanto espaço extra solicitar para o widget na direção Y.

24

relief => Inteiro

Especifica o efeito 3-D desejado para o widget. Os valores aceitáveis ​​sãoraised, sunken, flat, ridgee groove.

25

repeatdelay => Inteiro

Especifica o número de milissegundos que um botão ou tecla deve ser pressionado antes de começar a se repetir automaticamente. Usado, por exemplo, nas setas para cima e para baixo nas barras de rolagem.

26

repeatinterval => Inteiro

Usado em conjunto com repeatdelay: uma vez que a repetição automática começa, esta opção determina o número de milissegundos entre as repetições automáticas

27

selectbackground => String

Especifica a cor de fundo a ser usada ao exibir os itens selecionados.

28

selectborderwidth => Inteiro

Especifica um valor não negativo indicando a largura da borda 3-D para desenhar ao redor dos itens selecionados.

29

selectforeground => String

Especifica a cor de primeiro plano a ser usada ao exibir os itens selecionados.

30

setgrid => Booleano

Especifica um valor booleano que determina se este widget controla a grade de redimensionamento para sua janela de nível superior. Esta opção é normalmente usada em widgets de texto, onde as informações no widget têm um tamanho natural (o tamanho de um caractere) e faz sentido que as dimensões da janela sejam números inteiros dessas unidades.

31

takefocus => Inteiro

Fornece informações usadas ao mover o foco de janela para janela por meio do teclado (por exemplo, Tab e Shift-Tab). Antes de definir o foco para uma janela, os scripts de passagem primeiro verificam se a janela é visível (ela e todos os seus ancestrais estão mapeados); caso contrário, a janela é ignorada. Um valor 0 significa que esta janela deve ser totalmente ignorada durante a passagem do teclado. 1 significa que esta janela deve sempre receber o foco de entrada.

32

text => String

Especifica uma string a ser exibida dentro do widget. A maneira como a string é exibida depende do widget específico e pode ser determinada por outras opções, comoanchor ou justify.

33

textvariable => Variável

Especifica o nome de uma variável. O valor da variável é uma string de texto a ser exibida dentro do widget; se o valor da variável mudar, o widget se atualizará automaticamente para refletir o novo valor. A maneira como a string é exibida no widget depende do widget específico e pode ser determinada por outras opções, comoanchor ou justify.

34

tile => Imagem

Especifica a imagem usada para exibir o widget. Se a imagem for uma string vazia, a cor de fundo normal será exibida.

35

troughcolor => String

Especifica a cor a ser usada para as áreas retangulares da calha em widgets, como barras de rolagem e escalas.

36

troughtile => Imagem

Especifica a imagem usada para exibição nas áreas retangulares da calha em widgets, como barras de rolagem e escalas.

37

underline => Inteiro

Especifica o índice inteiro de um caractere a sublinhar no widget. Esta opção é usada pelas ligações padrão para implementar a travessia do teclado para botões de menu e entradas de menu. 0 corresponde ao primeiro caractere do texto exibido no widget, 1 ao próximo caractere e assim por diante.

38

wraplength => Inteiro

Para widgets que podem realizar quebra de linha, esta opção especifica o comprimento máximo da linha.

39

xscrollcommand => função

Especifica um retorno de chamada usado para se comunicar com barras de rolagem horizontais.

40

yscrollcommand => função

Especifica um retorno de chamada usado para se comunicar com barras de rolagem verticais.

Gerenciamento de geometria Ruby / Tk

Gerenciamento de geometria lida com o posicionamento de widgets diferentes de acordo com a necessidade. O gerenciamento de geometria no Tk se baseia no conceito de widgets mestre e escravo.

Um mestre é um widget, normalmente uma janela de nível superior ou um quadro, que conterá outros widgets, que são chamados de escravos. Você pode pensar em um gerenciador de geometria como assumindo o controle do widget mestre e decidindo o que será exibido nele.

O gerenciador de geometria pedirá a cada widget escravo seu tamanho natural ou quão grande ele gostaria de ser exibido. Ele então pega essas informações e as combina com quaisquer parâmetros fornecidos pelo programa quando pede ao gerenciador de geometria para gerenciar aquele widget escravo específico.

Existem três gerenciadores de geometria local, grade e pacote que são responsáveis ​​por controlar o tamanho e a localização de cada um dos widgets na interface.

  • grade Gerenciador de geometria que organiza widgets em uma grade.

  • pack Gerenciador de geometria que se compacta ao redor das bordas da cavidade.

  • coloque o gerenciador de geometria para colocação fixa ou de folha de borracha.

Tratamento de eventos Ruby / Tk

Ruby / Tk suporta loop de evento , que recebe eventos do sistema operacional. São coisas como pressionamentos de botão, pressionamentos de tecla, movimento do mouse, redimensionamento de janela e assim por diante.

Ruby / Tk se encarrega de gerenciar esse loop de eventos para você. Ele descobrirá a qual widget o evento se aplica (o usuário clicou neste botão? Se uma tecla foi pressionada, qual caixa de texto estava em foco?) E o despacha de acordo. Widgets individuais sabem como responder a eventos, então, 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 superior, Ruby / Tk invoca retornos de chamada em seu programa para indicar que algo significativo aconteceu a um widget. Para qualquer um dos casos, você pode fornecer um bloco de código ou um objeto Ruby Proc que especifica como o aplicativo responde ao evento ou retorno de chamada.

Vamos dar uma olhada em como usar o método bind para associar eventos básicos do sistema de janela aos procedimentos Ruby que os tratam. A forma mais simples de ligação leva como entrada uma string indicando o nome do evento e um bloco de código que Tk usa para tratar 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 com o botão direito do mouse.

someWidget.bind('Control-ButtonPress-3', proc { puts "Ouch!" })

Muitos widgets Ruby / Tk podem disparar callbacks quando o usuário os ativa, e você pode usar o callback 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 }

Visto que 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 }
}
Sr. Não. Tag e descrição do evento
1

"1" (one)

Botão esquerdo do mouse clicado.

2

"ButtonPress-1"

Botão esquerdo do mouse clicado.

3

"Enter"

Movido o mouse para dentro.

4

"Leave"

Movido o mouse para fora.

5

"Double-1"

Clique duas vezes.

6

"B3-Motion"

Arraste o botão direito de uma posição para outra.

7

Control-ButtonPress-3

O botão direito é pressionado junto com a tecla Ctrl .

8

Alt-ButtonPress-1

O botão Let é pressionado junto com a tecla Alt .

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 de configuração 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 configure sem nenhuma opção, o que lhe dará uma lista 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 / LDAP é uma biblioteca de extensão para Ruby. Ele fornece a interface para algumas bibliotecas LDAP como OpenLDAP, UMich LDAP, Netscape SDK, ActiveDirectory.

A API comum para desenvolvimento de aplicativos é descrita em RFC1823 e é suportada por Ruby / LDAP.

Instalação Ruby / LDAP

Você pode baixar e instalar um pacote Ruby / LDAP completo em SOURCEFORGE.NET .

Antes de instalar Ruby / LDAP, certifique-se de ter os seguintes componentes -

  • Ruby 1.8.x (pelo menos 1.8.2 se você quiser usar 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 quiser ver as opções disponíveis para extconf.rb, execute-o com a opção '--help'.

$ ruby extconf.rb [--with-openldap1|--with-openldap2| \
                   --with-netscape|--with-wldap32]
$ make $ make install

NOTE- Se você estiver construindo o software no Windows, pode ser necessário usar nmake em vez de 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- Este é o ID do host executando o diretório LDAP. Iremos considerá-lo como localhost .

  • port- Esta é a porta que está sendo usada para o serviço LDAP. As portas LDAP padrão são 636 e 389. Certifique-se de qual porta está sendo usada em seu servidor, caso contrário, você pode usar LDAP :: LDAP_PORT.

Esta chamada retorna uma nova conexão LDAP :: Conn ao servidor, host , na porta da porta .

Etapa 2 - Ligação

É aqui que geralmente especificamos o nome de usuário e a senha que usaremos no restante da sessão.

A seguir está a sintaxe para vincular uma conexão LDAP, usando o DN, dn, a credencial, pwd, e o método de ligação, method -

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 é fornecido, self é cedido ao bloco.

Agora podemos realizar operações de pesquisa, adição, modificação ou exclusão dentro do bloco do método de vinculação (entre vincular e desvincular), desde que tenhamos as permissões adequadas.

Example

Supondo que estejamos trabalhando em um servidor local, vamos juntar as coisas 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

Adicionar uma entrada LDAP

Adicionar uma entrada LDPA é um processo de duas etapas -

Etapa 1 - Criação do objeto LDAP :: Mod

Precisamos da passagem do 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 a attr . Se vals contém dados binários, mod_type deve ser logicamente OR'ed (|) com LDAP_MOD_BVALUES.

Esta chamada retorna o objeto LDAP :: Mod , que pode ser passado para métodos na 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 este método -

conn.add(dn, attrs)

Este método adiciona uma entrada com o DN, dn , e os atributos, attrs . Aqui, attrs deve ser um array de objetos LDAP :: Mod ou um hash de pares de array de atributo / valor.

Example

Aqui está um exemplo completo, que criará duas entradas de diretório -

#/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.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. Basta chamar o método de modificação em vez de adicionar os atributos a serem modificados. 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' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
entry1 = [
   LDAP.mod(LDAP::LDAP_MOD_REPLACE, 'sn', ['Mohtashim']),
]

begin
   conn.modify("cn = Zara Ali, dc = localhost, dc = localdomain", entry1)
rescue LDAP::ResultError
   conn.perror("modify")
   exit
end
conn.perror("modify")
conn.unbind

Exclusão de 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 deletar a entrada Zara Mohtashim , que adicionamos na seção anterior, escreveríamos -

#/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.perror("bind")
begin
   conn.delete("cn = Zara-Mohtashim, dc = localhost, dc = localdomain")
rescue LDAP::ResultError
   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 RDN antigo será excluído da entrada.

Exemplo

Suponha que temos 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' $PORT =    LDAP::LDAP_PORT
$SSLPORT = LDAP::LDAPS_PORT conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

conn.perror("bind")
begin
   conn.modrdn("cn = Zara Ali, dc = localhost, dc = localdomain", "cn = Zara Mohtashim", true)
rescue LDAP::ResultError
   conn.perror("modrdn")
   exit
end
conn.perror("modrdn")
conn.unbind

Executando uma Pesquisa

Para realizar uma pesquisa em um diretório LDAP, use o método de pesquisa com um dos três diferentes modos de pesquisa -

  • LDAP_SCOPE_BASEM - Pesquise apenas o nó base.

  • LDAP_SCOPE_ONELEVEL - Pesquisar todos os filhos do nó base.

  • LDAP_SCOPE_SUBTREE - Pesquise toda a subárvore, incluindo o nó base.

Exemplo

Aqui, nós estamos indo para pesquisar toda a subárvore de entrada dc = localhost, DC = localdomain para pessoa objetos -

#/usr/bin/ruby -w

require 'ldap'

$HOST =    'localhost'
$PORT = LDAP::LDAP_PORT $SSLPORT = LDAP::LDAPS_PORT

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

conn = LDAP::Conn.new($HOST, $PORT)
conn.bind('cn = root, dc = localhost, dc = localdomain','secret')

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
   }
rescue LDAP::ResultError
   conn.perror("search")
   exit
end
conn.perror("search")
conn.unbind

Isso invoca o bloco de código fornecido para cada entrada correspondente, onde 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 nil 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 (apelido para get_values).

Tratamento de erros

Ruby / LDAP define duas classes de exceção diferentes -

  • Em caso de erro, os métodos new, bind ou unbind geram uma exceção LDAP :: Error.

  • No caso de adicionar, modificar, excluir ou pesquisar um diretório LDAP, acione um LDAP :: ResultError.

Leitura Adicional

Para obter detalhes completos sobre os métodos LDAP, consulte a documentação padrão da Documentação LDAP .

Os programas tradicionais têm um único thread de execução - as instruções ou instruções que compõem o programa são executadas sequencialmente até que o programa termine.

Um programa multithread tem mais de um thread de execução. Dentro de cada thread, as instruções são executadas sequencialmente, mas as próprias threads podem ser executadas em paralelo em uma CPU multicore, por exemplo. Freqüentemente, em uma única máquina de CPU, vários threads não são realmente executados em paralelo, mas o paralelismo é simulado intercalando a execução dos threads.

Ruby torna mais fácil escrever programas multithread com a classe Thread . Threads Ruby são uma forma leve e eficiente de obter simultaneidade em seu código.

Criação de Ruby Threads

Para iniciar um novo thread, basta associar um bloco com 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 continuará a execução com a próxima instrução -

# 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}"

Isso produzirá o seguinte resultado -

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 do Tópico

Um novo encadeamento é criado 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 ficam disponíveis.

A classe Thread define vários métodos para consultar e manipular o thread enquanto ele está em execução. Um thread executa o código no bloco associado à chamada para Thread.new e então para de ser executado.

O valor da última expressão nesse bloco é o valor da thread e pode ser obtido chamando o método de valor do objeto Thread. Se o encadeamento foi executado até a conclusão, o valor retorna o valor do encadeamento imediatamente. Caso contrário, o método de valor bloqueia e não retorna até que o thread seja concluído.

O método de classe Thread.current retorna o objeto Thread que representa o thread 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 thread inicial de execução que começou quando o programa Ruby foi iniciado.

Você pode esperar que um determinado segmento termine chamando o método Thread.join desse segmento . O thread de chamada será bloqueado até que o thread fornecido seja concluído.

Tópicos e exceções

Se uma exceção for levantada no thread principal e não for tratada em nenhum lugar, o interpretador Ruby imprime uma mensagem e sai. Em threads, diferentes do thread principal, exceções não tratadas fazem com que a execução do thread seja interrompida.

Se um tópico t sai por causa de uma exceção não tratada e outro thread schama t.join ou t.value, então a exceção que ocorreu emt é levantado na discussão s.

Se Thread.abort_on_exception for false , a condição padrão, uma exceção não tratada simplesmente elimina o thread atual e todo o resto continua a ser executado.

Se você deseja que qualquer exceção não tratada em qualquer thread faça com que o interpretador saia, defina o método de classe Thread.abort_on_exception como true .

t = Thread.new { ... }
t.abort_on_exception = true

Variáveis ​​de discussão

Um thread normalmente pode acessar qualquer variável que esteja no escopo quando o thread é criado. Variáveis ​​locais para o bloco de um thread são locais para o thread e não são compartilhadas.

A classe thread apresenta um recurso especial que permite que variáveis ​​locais do thread sejam criadas e acessadas por nome. Você simplesmente trata o objeto thread como se fosse um Hash, escrevendo nos elementos usando [] = e lendo-os de volta usando [].

Neste exemplo, cada thread registra o valor atual da contagem de variável 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 espera que os subthreads terminem e depois imprime o valor da contagem capturada por cada um.

Prioridades de discussão

O primeiro fator que afeta o agendamento do thread é a prioridade do thread: threads de alta prioridade são agendados antes dos threads 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 começa com a mesma prioridade do encadeamento que o criou. O thread principal começa na prioridade 0.

Não há como definir a prioridade de um thread antes de sua execução. Um thread pode, no entanto, aumentar ou diminuir sua própria prioridade como a primeira ação que executa.

Exclusão de discussão

Se dois encadeamentos compartilham acesso aos mesmos dados, e pelo menos um dos encadeamentos modifica esses dados, você deve tomar cuidado especial para garantir que nenhum encadeamento possa ver os dados em um estado inconsistente. Isso é chamado de exclusão de discussão .

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 segurar o bloqueio em um determinado momento. Outros threads podem escolher esperar na fila para que o bloqueio fique disponível ou podem simplesmente escolher obter um erro imediato indicando que o bloqueio não está disponível.

Ao colocar todos os acessos aos dados compartilhados sob o controle de um mutex , garantimos a consistência e a operação atômica. Vamos tentar exemplos, primeiro um sem mutax e o 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 "count2 :  #{count2}"
puts "difference : #{difference}"

Isso produzirá o seguinte resultado -

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 "count1 :  #{count1}"
puts "count2 :  #{count2}"
puts "difference : #{difference}"

Isso produzirá o seguinte resultado -

count1 :  696591
count2 :  696591
difference : 0

Manipulação de impasse

Quando começamos a usar objetos Mutex para exclusão de thread, devemos ter cuidado para evitar deadlock . Deadlock é a condição que ocorre quando todos os threads estão esperando para adquirir um recurso mantido por outro thread. Como todos os threads estão bloqueados, eles não podem liberar os bloqueios que mantêm. E porque eles não podem liberar os bloqueios, nenhum outro thread 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 na proteção de um mutex específico . Quando você precisa de um recurso que não está disponível, você espera uma variável de condição. Essa ação libera o bloqueio no mutex correspondente . Quando alguma outra thread sinaliza que o recurso está disponível, a 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

Isso produzirá o seguinte resultado -

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 do Tópico

Existem cinco valores de retorno possíveis correspondentes aos cinco estados possíveis, conforme mostrado na tabela a seguir. O método de status retorna o estado do thread.

Estado da linha Valor de retorno
Executável corre
adormecido adormecido
Abortando abortando
Terminado normalmente falso
Terminado com exceção nada

Métodos de classe de thread

Os seguintes métodos são fornecidos pela classe Thread e são aplicáveis ​​a todos os threads disponíveis no programa. Esses métodos serão chamados usando o nome da classe Thread da seguinte forma -

Thread.abort_on_exception = true
Sr. Não. Métodos e Descrição
1

Thread.abort_on_exception

Retorna o status do aborto global na condição de exceção . O padrão é falso . Quando definido como verdadeiro , fará com que todos os threads sejam abortados (o processo será encerrado (0)) se uma exceção for levantada em qualquer thread

2

Thread.abort_on_exception=

Quando definido como verdadeiro , todos os threads serão abortados se uma exceção for levantada. Retorna o novo estado.

3

Thread.critical

Retorna o status da condição crítica do thread global .

4

Thread.critical=

Define o status da condição crítica do encadeamento global e o retorna. Quando definido como verdadeiro , proíbe o agendamento de qualquer thread existente. Não impede que novos threads sejam criados e executados. Certas operações de thread (como interromper ou eliminar um thread, suspender no thread atual e gerar uma exceção) podem fazer com que um thread seja agendado mesmo quando estiver em uma seção crítica.

5

Thread.current

Retorna o thread atualmente em execução.

6

Thread.exit

Encerra o encadeamento atualmente em execução e agenda outro encadeamento para ser executado. Se este segmento já estiver marcado para ser eliminado, exit retorna o segmento. Se este for o thread principal ou o último, saia do processo.

7

Thread.fork { block }

Sinônimo de Thread.new.

8

Thread.kill( aThread )

Faz com que um determinado Tópico saia

9

Thread.list

Retorna uma matriz de objetos Thread para todos os threads executáveis ​​ou parados. Fio.

10

Thread.main

Retorna o thread principal do processo.

11

Thread.new( [ arg ]* ) {| args | block }

Cria um novo thread para executar as instruções fornecidas no bloco e começa a executá-lo. Quaisquer argumentos passados ​​para Thread.new são passados ​​para o bloco.

12

Thread.pass

Invoca o agendador de thread para passar a execução para outro thread.

13

Thread.start( [ args ]* ) {| args | block }

Basicamente o mesmo que Thread.new . No entanto, se a classe Thread for uma subclasse, chamar start nessa subclasse não invocará o método de inicialização da subclasse .

14

Thread.stop

Para a execução do encadeamento atual, colocando-o em um estado de hibernação , e agenda a execução de outro encadeamento. Redefine a condição crítica para falsa.

Métodos de instância de thread

Esses métodos são aplicáveis ​​a uma instância de um thread. Esses métodos serão chamados usando uma instância de um Thread da seguinte forma -

#!/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
Sr. Não. Métodos e Descrição
1

thr[ aSymbol ]

Atributo Referência - Retorna o valor de uma variável de segmento local, usando um símbolo ou um asymbol nome. Se a variável especificada não existir, retorna nil .

2

thr[ aSymbol ] =

Atribuição de atributo - define ou cria o valor de uma variável local do segmento, usando um símbolo ou uma string.

3

thr.abort_on_exception

Retorna o status do aborto na condição de exceção para thr . O padrão é falso .

4

thr.abort_on_exception=

Quando definido como verdadeiro , faz com que todos os threads (incluindo o programa principal) abortem se uma exceção for levantada em thr . O processo será encerrado efetivamente (0) .

5

thr.alive?

Retorna verdadeiro se thr estiver executando ou dormindo.

6

thr.exit

Encerra thr e agenda outro thread para ser executado. Se este segmento já estiver marcado para ser eliminado, exit retorna o segmento . Se este for o thread principal ou o último, sai do processo.

7

thr.join

O thread de chamada suspenderá a execução e executará thr . Não retorna até thr sai. Quaisquer threads não unidos serão eliminados quando o programa principal for encerrado.

8

thr.key?

Retorna verdadeiro se a string (ou símbolo) fornecida existe como uma variável local do segmento.

9

thr.kill

Sinônimo de Thread.exit .

10

thr.priority

Retorna a prioridade de thr . O padrão é zero; threads de prioridade mais alta serão executados antes de threads de prioridade mais baixa.

11

thr.priority=

Define a prioridade de thr para um inteiro. Os threads de prioridade mais alta serão executados antes dos threads de prioridade mais baixa.

12

thr.raise( anException )

Gera uma exceção de thr . O chamador não precisa ser thr .

13

thr.run

Acorda thr , tornando-se elegíveis para agendamento. Se não estiver em uma seção crítica, invoca o planejador.

14

thr.safe_level

Retorna o nível seguro em vigor para thr .

15

thr.status

Retorna o status de thr : sleep se thr está dormindo ou esperando por E / S, executa se thr está executando, false se thr termina normalmente e nil se thr termina com uma exceção.

16

thr.stop?

Retorna verdadeiro se thr estiver morto ou dormindo.

17

thr.value

Espera que thr seja concluído por meio de Thread.join e retorne seu valor.

18

thr.wakeup

Marcas thr como elegível para agendamento, pode ainda permanecem bloqueadas em I / O, no entanto.

Como o módulo Kernel é incluído pela classe Object , seus métodos estão disponíveis em qualquer lugar no programa Ruby. Eles podem ser chamados sem um receptor (forma funcional). Portanto, são freqüentemente chamados de funções.

Sr. Não. Métodos e Descrição
1

abort

Encerra o programa. Se uma exceção for levantada (ou seja, $! Não é nulo), sua mensagem de erro é exibida.

2

Array( obj)

Retorna obj após convertê-lo em um array usando to_ary ou to_a.

3

at_exit {...}

Registra um bloco para execução quando o programa termina. Semelhante à instrução END, mas a instrução END registra o bloco apenas uma vez.

4

autoload( classname, file)

Registra um nome de classe de classe a ser carregado do arquivo na primeira vez que é usado. classname pode ser uma string ou um símbolo.

5

binding

Retorna a variável atual e as ligações de método. O objeto Binding que é retornado pode ser passado para o método eval como seu segundo argumento.

6

block_given?

Retorna verdadeiro se o método foi chamado com um bloco .

7

callcc {| c|...}

Passa um objeto de continuação c para o bloco e executa o bloco. callcc pode ser usado para saída global ou construção de loop.

8

caller([ n])

Retorna a pilha de execução atual em uma matriz de strings no formato file: line . Se n for especificado, retorna as entradas da pilha do enésimo nível para baixo.

9

catch( tag) {...}

Pega uma saída não local por um lance chamado durante a execução de seu bloco.

10

chomp([ rs = $/])

Retorna o valor da variável $_ with the ending newline removed, assigning the result back to $_. O valor da string de nova linha pode ser especificado com rs.

11

chomp!([ rs = $/])

Remove a nova linha de $ _, modificando a string no lugar.

12

chop

Retorna o valor de $_ with its last character (one byte) removed, assigning the result back to $_.

13

chop!

Remove o último caractere de $ _, modificando a string no lugar.

14

eval( str[, scope[, file, line]])

Executa str como código Ruby. A ligação na qual realizar a avaliação pode ser especificada com escopo . O nome do arquivo e o número da linha do código a ser compilado podem ser especificados usando arquivo e linha.

15

exec( cmd[, arg...])

Substitui o processo atual executando o comando cmd . Se vários argumentos forem especificados, o comando será executado sem expansão de shell.

16

exit([ result = 0])

Sai do programa, resultando em código de status retornado.

17

exit!([ result = 0])

Mata o programa, ignorando o tratamento de saída, como garantir , etc.

18

fail(...)

Veja aumento (...)

19

Float( obj)

Retorna obj após convertê-lo em um flutuador. Objetos numéricos são convertidos diretamente; nil é convertido em 0,0; as strings são convertidas considerando o prefixo de raiz 0x, 0b. O resto é convertido usando obj.to_f.

20

fork

fork {...}

Cria um processo filho. nil é retornado no processo filho e o ID do processo filho (inteiro) é retornado no processo pai. Se um bloco for especificado, ele será executado no processo filho.

21

format( fmt[, arg...])

Veja sprintf.

22

gets([ rs = $/])

Lê o nome do arquivo especificado na linha de comando ou uma linha da entrada padrão. A string do separador de registro pode ser especificada explicitamente com rs.

23

global_variables

Retorna uma matriz de nomes de variáveis ​​globais.

24

gsub( x, y)

gsub( x) {...}

Substitui todas as strings correspondentes a x em $_ with y. If a block is specified, matched strings are replaced with the result of the block. The modified result is assigned to $_.

25

gsub!( x, y)

gsub!( x) {...}

Executa a mesma substituição que gsub, exceto que a string é alterada no lugar.

26

Integer( obj)

Retorna obj após convertê-lo em um inteiro. Objetos numéricos são convertidos diretamente; nil é convertido em 0; as strings são convertidas considerando o prefixo de raiz 0x, 0b. O resto é convertido usando obj.to_i.

27

lambda {| x|...}

proc {| x|...}

lambda

proc

Converte um bloco em um objeto Proc . Se nenhum bloco for especificado, o bloco associado ao método de chamada é convertido.

28

load( file[, private = false])

Carrega um programa Ruby do arquivo . Ao contrário de require , ele não carrega bibliotecas de extensão. Se private for true , o programa é carregado em um módulo anônimo, protegendo assim o namespace do programa de chamada.

29

local_variables

Retorna uma matriz de nomes de variáveis ​​locais.

30

loop {...}

Repete um bloco de código.

31

open( path[, mode = "r"])

open( path[, mode = "r"]) {| f|...}

Abre um arquivo . Se um bloco for especificado, o bloco será executado com o fluxo aberto passado como argumento. O arquivo é fechado automaticamente quando o bloco termina. Se o caminho começar com um tubo |, a sequência a seguir será executada como um comando e o fluxo associado a esse processo será retornado.

32

p( obj)

Exibe obj usando seu método inspect (frequentemente usado para depuração).

33

print([ arg...])

Imprime arg em $ defout . Se nenhum argumento for especificado, o valor de $ _ é impresso.

34

printf( fmt[, arg...])

Formata arg de acordo com fmt usando sprintf e imprime o resultado em $ defout . Para especificações de formatação, consulte sprintf para detalhes.

35

proc {| x|...}

proc

Veja lamda.

36

putc( c)

Imprime um caractere na saída padrão ( $ defout ).

37

puts([ str])

Imprime string na saída padrão ( $ defout ). Se a string não terminar com uma nova linha, uma nova linha será anexada à string.

38

raise(...)

fail(...)

Gera uma exceção. Assume RuntimeError se nenhuma classe de exceção for especificada. Chamar raise sem argumentos em uma cláusula de resgate levanta novamente a exceção. Fazer isso fora de uma cláusula de resgate gera um RuntimeError sem mensagem .fail é um nome obsoleto para aumento.

39

rand([ max = 0])

Gera um número pseudoaleatório maior ou igual a 0 e menor que max. Se max não for especificado ou for definido como 0, um número aleatório será retornado como um número de ponto flutuante maior ou igual a 0 e menor que 1. srand pode ser usado para inicializar o fluxo pseudo-aleatório.

40

readline([ rs = $/])

Equivalente a gets, exceto que gera uma exceção EOFError ao ler EOF.

41

readlines([ rs = $/])

Retorna uma matriz de strings contendo os nomes de arquivos especificados como argumentos de linha de comando ou o conteúdo da entrada padrão.

42

require( lib)

Carrega a biblioteca (incluindo bibliotecas de extensão) lib quando é chamada pela primeira vez. require não carregará a mesma biblioteca mais de uma vez. Se nenhuma extensão for especificada em lib , require tenta adicionar .rb, .so, etc., a ele.

43

scan( re)

scan( re) {|x|...}

Equivalente a $ _. Scan.

44

select( reads[, writes = nil[, excepts = nil[, timeout = nil]]])

Verifica se há mudanças no status de três tipos de entrada, saída e exceções de objetos IO que são passados ​​como matrizes de objetos IO. nil é passado para argumentos que não precisam de verificação. É retornada uma matriz de três elementos contendo matrizes dos objetos IO para os quais houve mudanças de status. nil é retornado no tempo limite.

45

set_trace_func( proc)

Define um manipulador para rastreamento. proc pode ser uma string ou um objeto proc . set_trace_func é usado pelo depurador e profiler.

46

sleep([ sec])

Suspende a execução do programa por segundos. Se sec não for especificado, o programa será suspenso para sempre.

47

split([ sep[, max]])

Equivalente a $ _. Split.

48

sprintf( fmt[, arg...])

format( fmt[, arg...])

Retorna uma string em que arg é formatado de acordo com fmt. As especificações de formatação são essencialmente as mesmas do sprintf na linguagem de programação C. Especificadores de conversão (% seguido pelo especificador de campo de conversão) em fmt são substituídos pela string formatada do argumento correspondente. Uma lista de conversões arquivadas é fornecida abaixo na próxima seção.

49

srand([ seed])

Inicializa uma matriz de números aleatórios. Se a semente não for especificada, a inicialização será executada usando a hora e outras informações do sistema para a semente.

50

String( obj)

Retorna obj após convertê-lo em uma string usando obj.to_s.

51

syscall( sys[, arg...])

Chama uma função de chamada do sistema operacional especificada por number sys . Os números e o significado de sys dependem do sistema.

52

system( cmd[, arg...])

Executa cmd como uma chamada para a linha de comando. Se vários argumentos forem especificados, o comando será executado diretamente sem expansão de shell. Retorna verdadeiro se o status de retorno for 0 (sucesso).

53

sub( x, y)

sub( x) {...}

Substitui a primeira string correspondente a x em $ _ por y. Se um bloco for especificado, as strings correspondentes serão substituídas pelo resultado do bloco. O resultado modificado é atribuído a $ _.

54

sub!( x, y)

sub!( x) {...}

Executa a mesma substituição que sub, exceto que a string é alterada no lugar.

55

test( test, f1[, f2])

Executa vários testes de arquivo especificados pelo teste de caracteres . Para melhorar a legibilidade, você deve usar os métodos da classe File (por exemplo, File :: readable?) Em vez desta função. Uma lista de argumentos é fornecida abaixo na próxima seção.

56

throw( tag[, value = nil])

Salta para a função catch esperando com o símbolo ou tag string . value é o valor de retorno a ser usado pelo catch .

57

trace_var( var, cmd)

trace_var( var) {...}

Define o rastreamento de uma variável global. O nome da variável é especificado como um símbolo. cmd pode ser uma string ou um objeto Proc.

58

trap( sig, cmd)

trap( sig) {...}

Define um manipulador de sinal. sig pode ser uma string (como SIGUSR1) ou um inteiro. SIG pode ser omitido do nome do sinal. O manipulador de sinais para o sinal EXIT ou o sinal número 0 é invocado antes do término do processo.

59

untrace_var( var[, cmd])

Remove o rastreamento de uma variável global. Se cmd for especificado, apenas esse comando será removido.

Funções para números

Aqui está uma lista de funções integradas relacionadas ao número. Eles devem ser usados ​​da seguinte forma -

#!/usr/bin/ruby

num = 12.40
puts num.floor      # 12
puts num + 10       # 22.40
puts num.integer?   # false  as num is a float.

Isso produzirá o seguinte resultado -

12
22.4
false
Sr. Não. Métodos e Descrição
1

n + num

n - num

n * num

n / num

Executa operações aritméticas: adição, subtração, multiplicação e divisão.

2

n % num

Retorna o módulo de n.

3

n ** num

Exponenciação.

4

n.abs

Retorna o valor absoluto de n.

5

n.ceil

Retorna o menor inteiro maior ou igual a n.

6

n.coerce( num)

Retorna uma matriz contendo num e n possivelmente convertidos em um tipo que permite que sejam operados mutuamente. Usado na conversão automática de tipo em operadores numéricos.

7

n.divmod( num)

Retorna uma matriz contendo o quociente e o módulo da divisão de n por num.

8

n.floor

Retorna o maior inteiro menor ou igual a n.

9

n.integer?

Retorna verdadeiro se n for um inteiro.

10

n.modulo( num)

Retorna o módulo obtido dividindo n por num e arredondando o quociente com chão

11

n.nonzero?

Retorna n se não for zero, caso contrário, nil.

12

n.remainder( num)

Retorna o restante obtido pela divisão n de nume removendo decimais do quociente. oresult e n sempre tem o mesmo sinal.

13

n.round

Retorna n arredondado para o número inteiro mais próximo.

14

n.truncate

Retorna n como um número inteiro com decimais removidos.

15

n.zero?

Retorna zero se n for 0.

16

n & num

n | num

n ^ num

Operações bit a bit: AND, OR, XOR e inversão.

17

n << num

n >> num

Deslocamento à esquerda e à direita bit a bit.

18

n[num]

Retorna o valor de numo bit do bit menos significativo, que é n [0].

19

n.chr

Retorna uma string contendo o caractere para o código do caractere n.

20

n.next

n.succ

Retorna o próximo inteiro após n. Equivalente a n + 1.

21

n.size

Retorna o número de bytes na representação da máquina de n.

22

n.step( upto, step) {|n| ...}

Repete o bloco de n para upto, incrementando por step cada vez.

23

n.times {|n| ...}

Repete o bloco n vezes.

24

n.to_f

Converte nem um número de ponto flutuante. A conversão de flutuação pode perder informações de precisão.

25

n.to_int

Devoluções n após a conversão em número interger.

Funções para Float

Sr. Não. Métodos e Descrição
1

Float::induced_from(num)

Retorna o resultado da conversão de num em um número de ponto flutuante.

2

f.finite?

Retorna verdadeiro se f não for infinito e f.nan for falso.

3

f.infinite?

Retorna 1 se f for infinito positivo, -1 se infinito negativo ou nulo se qualquer outra coisa.

4

f.nan?

Retorna verdadeiro se f não for um número de ponto flutuante IEEE válido.

Funções para matemática

Sr. Não. Métodos e Descrição
1

atan2( x, y)

Calcula a tangente do arco.

2

cos( x)

Calcula o cosseno de x.

3

exp( x)

Calcula uma função exponencial (e elevado à potência de x).

4

frexp( x)

Retorna uma matriz de dois elementos contendo a fração nominalizada e o expoente de x.

5

ldexp( x, exp)

Retorna o valor de x vezes 2 à potência de exp.

6

log( x)

Calcula o logaritmo natural de x.

7

log10( x)

Calcula o logaritmo de base 10 de x.

8

sin( x)

Calcula o seno de x.

9

sqrt( x)

Retorna a raiz quadrada de x. x deve ser positivo.

10

tan( x)

Calcula a tangente de x.

Especificador de campo de conversão

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

Sr. Não. Especificador e descrição
1

b

Inteiro binário

2

c

Personagem único

3

d,i

Número inteiro decimal

4

e

Notação exponencial (por exemplo, 2.44e6)

5

E

Notação exponencial (por exemplo, 2.44E6)

6

f

Número de ponto flutuante (por exemplo, 2,44)

7

g

use% e se o expoente for menor que -4,% f caso contrário

8

G

use% E se o expoente for menor que -4,% f caso contrário

9

o

Octal inteiro

10

s

String ou qualquer objeto convertido usando to_s

11

u

Inteiro decimal sem sinal

12

x

Número inteiro hexadecimal (por exemplo, 39ff)

13

X

Número inteiro hexadecimal (por exemplo, 39FF)

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

Isso produzirá o seguinte resultado -

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 caracteres . Para melhorar a legibilidade, você deve usar os métodos da classe File (por exemplo, File :: readable?) Em vez desta função.

Sr. Não. Argumento e Descrição
1

?r

F1 é legível pelo uid efetivo do chamador?

2

?w

O f1 é gravável pelo uid efetivo do chamador?

3

?x

F1 é executável pelo uid efetivo do chamador?

4

?o

F1 pertence ao uid efetivo do chamador?

5

?R

F1 é legível pelo uid real do chamador?

6

?W

O f1 é gravável pelo uid real do chamador?

7

?X

É f1 executável pelo uid real do chamador?

8

?O

F1 pertence ao uid real do chamador?

9

?e

F1 existe?

10

?z

F1 tem comprimento zero?

11

?s

Tamanho do arquivo de f1 (nulo se 0)

12

?f

F1 é um arquivo normal?

13

?d

F1 é um diretório?

14

?l

F1 é um link simbólico?

15

?p

F1 é um pipe nomeado (FIFO)?

16

?S

F1 é um soquete?

17

?b

F1 é um dispositivo de bloco?

18

?c

F1 é um dispositivo de caractere?

19

?u

F1 tem o bit setuid definido?

20

?g

F1 tem o bit setgid definido?

21

?k

F1 tem o bit sticky definido?

22

?M

Hora da última modificação para f1.

23

?A

Última hora de acesso para f1.

24

?C

Tempo de mudança do último inode para f1.

Sr. Não. Argumento e Descrição
1

?=

Os tempos de modificação de f1 e f2 são iguais?

2

?>

O tempo de modificação de f1 é mais recente do que f2?

3

?<

O tempo de modificação de f1 é mais antigo que f2?

4

?-

F1 é um link físico para f2?

A seguir está 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

Isso produzirá o seguinte resultado -

true
false
false

Ruby - Variáveis ​​Predefinidas

As variáveis ​​predefinidas do 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. Não. Nome e descrição da variável
1

$!

O último objeto de exceção gerado. O objeto de exceção também pode ser acessado usando => na cláusula de resgate .

2

$@

O backtrace da pilha para a última exceção gerada. As informações de backtrace da 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). get, readline, etc., tomam seu separador de registro de entrada como argumento opcional.

4

$\

O separador de registro de saída (nulo por padrão).

5

$,

O separador de saída entre os argumentos a serem impressos e Array # join (nil por padrão). Você pode especificar o separador explicitamente para Array # join.

6

$;

O separador padrão para divisão (nulo por padrão). Você pode especificar o separador explicitamente para a divisão String #.

7

$.

O número da última linha lida do arquivo de entrada atual. Equivalente a ARGF.lineno.

8

$<

Sinônimo de ARGF.

9

$>

Sinônimo de $ defout.

10

$0

O nome do programa Ruby atual sendo executado.

11

$$

O processo pid do programa Ruby atual sendo executado.

12

$?

O status de saída do último processo encerrado.

13

$:

Sinônimo de $ LOAD_PATH.

14

$DEBUG

Verdadeiro se a opção de linha de comando -d ou --debug for especificada.

15

$defout

A saída de destino para print e printf ( $ stdout por padrão).

16

$F

A variável que recebe a saída da divisão quando -a é especificado. Esta variável é definida se a opção de linha de comando -a for especificada junto com a opção -p ou -n.

17

$FILENAME

O nome do arquivo que está sendo lido atualmente do ARGF. Equivalente a ARGF.filename.

18

$LOAD_PATH

Um array contendo os diretórios a serem pesquisados ​​ao carregar arquivos com os métodos load e require.

19

$SAFE

O nível de segurança

0 → Nenhuma verificação é realizada nos dados fornecidos externamente (contaminados). (padrão)

1 → Operações potencialmente perigosas usando dados contaminados são proibidas.

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

3 → Todos os objetos recém-criados são considerados corrompidos.

4 → A modificação dos dados globais é proibida.

20

$stdin

Entrada padrão (STDIN por padrão).

21

$stdout

Saída padrão (STDOUT por padrão).

22

$stderr

Erro padrão (STDERR por padrão).

23

$VERBOSE

Verdadeiro se a opção de linha de comando -v, -w ou --verbose for especificada.

24

$- x

O valor da opção do interpretador -x (x = 0, a, d, F, i, K, l, p, v). Essas opções estão listadas abaixo

25

$-0

O valor da opção do interpretador -x e alias de $ /.

26

$-a

O valor da opção -x do interpretador e true se a opção -a for definida. Somente leitura.

27

$-d

O valor da opção do interpretador -x e alias de $ DEBUG

28

$-F

O valor da opção do interpretador -x e alias de $ ;.

29

$-i

O valor da opção do interpretador -x e no modo de edição no local mantém a extensão, caso contrário, nil. Pode ativar ou desativar o modo de edição local.

30

$-I

O valor da opção do interpretador -x e alias de $ :.

31

$-l

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

32

$-p

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

33

$_

A variável local, última string lida por get ou readline no escopo atual.

34

$~

A variável local, MatchData , relacionada à última correspondência. O método de correspondência Regex # retorna as informações da última correspondência.

35

$ n ($1, $2, $3...)

A string correspondeu ao enésimo grupo da última correspondência de padrão. Equivalente a m [n], onde m é um objeto MatchData .

36

$&

A string correspondeu na última correspondência de padrão. Equivalente a m [0], onde m é um objeto MatchData .

37

$`

A string que precede a correspondência na última correspondência de padrão. Equivalente a m.pre_match, onde m é um objeto MatchData .

38

$'

A string após a correspondência na última correspondência de padrão. Equivalente a m.post_match, onde 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 -

NOTE- TRUE, FALSE e NIL são compatíveis com versões anteriores. É preferível usar true, false e nil.

Sr. Não. Nome e descrição da constante
1

TRUE

Sinônimo de verdade.

2

FALSE

Sinônimo de falso.

3

NIL

Sinônimo de nulo.

4

ARGF

Um objeto que fornece acesso à concatenação virtual de arquivos passados ​​como argumentos de linha de comando ou entrada padrão se não houver argumentos de linha de comando. Um sinônimo para $ <.

5

ARGV

Uma matriz contendo os argumentos da linha de comando transmitidos ao programa. Um sinônimo para $ *.

6

DATA

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.

7

ENV

Um objeto semelhante a um hash contendo as variáveis ​​de ambiente do programa. ENV pode ser tratado como um hash.

8

RUBY_PLATFORM

Uma string que indica a plataforma do interpretador Ruby.

9

RUBY_RELEASE_DATE

Uma string indicando a data de lançamento do interpretador Ruby

10

RUBY_VERSION

Uma string que indica a versão do interpretador Ruby.

11

STDERR

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.

13

STDOUT

Fluxo de saída padrão. Valor padrão de $ stdout.

14

TOPLEVEL_BINDING

Um objeto de ligação no nível superior de Ruby.

Ruby - Ferramentas Associadas

Ferramentas Ruby Padrão

A distribuição padrão do Ruby contém ferramentas úteis, juntamente com o interpretador e bibliotecas padrão -

Essas ferramentas ajudam a depurar e melhorar seus programas Ruby sem gastar muito esforço. Este tutorial lhe dará um bom começo com essas ferramentas.

  • RubyGems -

    RubyGems é um utilitário de pacote para Ruby, que instala pacotes de software Ruby e os mantém atualizados.

  • Ruby Debugger -

    Para ajudar a lidar com os bugs, a distribuição padrão do Ruby inclui um depurador. É muito semelhante ao utilitário gdb , que pode ser usado para depurar programas complexos.

  • Interactive Ruby (irb) -

    irb (Interactive Ruby) foi desenvolvido por Keiju Ishitsuka. Ele permite que você insira comandos no prompt e faça com que o intérprete responda como se você estivesse executando um programa. irb é útil para experimentar ou explorar Ruby.

  • Ruby Profiler -

    O criador de perfil Ruby ajuda a melhorar o desempenho de um programa lento, encontrando o gargalo.

Ferramentas Ruby Adicionais

Existem outras ferramentas úteis que não vêm com a distribuição padrão do Ruby. No entanto, você mesmo precisa instalá-los.

  • eRuby: Embeded Ruby -

    eRuby significa Ruby incorporado. É uma ferramenta que incorpora fragmentos de código Ruby em outros arquivos, como arquivos HTML semelhantes a ASP, JSP e PHP.

  • ri: Ruby Interactive Reference -

    Quando você tiver uma dúvida sobre o comportamento de um determinado método, pode invocar ri para ler a breve explicação do método.

Para obter mais informações sobre a ferramenta e recursos Ruby, dê uma olhada em Ruby Useful Resources.