Introdução aos comandos Ruby
1. O que é Ruby?
Ruby é uma linguagem de programação de código aberto. É interpretado, assim como orientado a objetos. Ruby foi criado por Yukihiro Matsumoto. Ruby é nomeado após uma pedra preciosa e, portanto, o criador a relacionou como a jóia das linguagens de programação. aqui discutiremos os diferentes tipos de comandos Ruby.
O design do Ruby leva em consideração os seguintes fatores - Simplicidade, Extensividade, Completude e Portabilidade. Ruby funciona na maioria das plataformas baseadas em UNIX. Uma grande parte do Ruby é construída no Linux. Ruby também funciona em plataformas comuns, como Windows, DOS, Mac, etc.
Comandos básicos do Ruby
1. Comando simples para imprimir uma string em Ruby
#!/usr/bin/ruby –w
puts “Hello, Ruby!”
2. Comando simples para imprimir várias linhas usando EOF
#!/usr/bin/ruby –w
print < Multiple line string.
First wayEOF
print <<"EOF"; # same as above
Multiple line string.
Second way
EOF#!/usr/bin/ruby –w
print < Multiple line string.
First wayEOF
print <<"EOF"; # same as above
Multiple line string.
Second way
EOF
3. Comando simples para imprimir várias cadeias de linhas usando execute um comando
#!/usr/bin/ruby –w
print <<`EOC` # execute commands
echo First Statement
echo Second Statement
EOC
4. Comando simples para imprimir várias seqüências de linhas empilhando.
#!/usr/bin/ruby –w
print <<"a", <<"b" # you can stack them
I said foo.
a
I said bar.
b
5. Declaração Ruby BEGIN
#!/usr/bin/ruby
puts "This statement comes later"
BEGIN (
puts "This statement will be printed in the beginning"
)
6. Declaração END Ruby
#!/usr/bin/ruby
puts "This is main body"
END (
puts "This block executes in the end"
)
BEGIN (
puts "This block executes in the beginning"
)
7. Comentário em uma única linha do Ruby
#!/usr/bin/ruby
# This is a single line comment.
uts "This is not a comment" # This is again a single line
comment.
8. Comentário de múltiplas linhas em Ruby
#!/usr/bin/ruby=begin
This is a multiple line comment.=end
puts "This is not a comment" # This is a single line comment.
9. Função de membro na classe Ruby. Criando um objeto e chamando um método.
#!/usr/bin/ruby
class Demo
def testmethod
puts "Hello World!"
end
end
# Now using above class to create objects
object = Demo.new
object.testmethod
10. Variáveis Globais em Ruby
#!/usr/bin/ruby
$globalvariable=123
class FirstClass
def printglobal
puts "Global variable in FirstClass is #$globalvariable"
end
end
class SecondClass
def printglobal
puts "Global variable in SecondClass is #$globalvariable
end
end
class1obj = FirstClass.new
class1obj.printglobal
class2obj = SecondClass.new
class2obj.printglobal
Comandos intermediários
1. SE… ELSE em Ruby
#!/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
2. Caso em Ruby
<#!/usr/bin/ruby
$age = 17
case $age
when 0 .. 17
puts "Not eligible to vote"
when > 17
puts "Eligible to vote"
else
puts "incorrect age"
end
3. Loops em Ruby
- 3.1 Enquanto loop
#!/usr/bin/ruby
$i = 0
$num = 10
while $i <
$num do
puts("Inside the loop i = #$i" )
$i = $i + 1
end
- 3.2 Até o loop
#!/usr/bin/ruby
$i = 0
$num = 4
until $i > $num do
puts("Inside the loop i = #$i" )
$i = $i + 1;
end
- 3.3 For Loop
#!/usr/bin/ruby
for i in 0..9
puts "Local variable value is #(i)"
end
- 3.4 Declaração de quebra
#!/usr/bin/ruby
for i in 0..5
if i > 3 then
break
end puts "Local variable is #(i)"
end
- 3.5 Próxima declaração
#!/usr/bin/ruby
for i in 0..10
if i < 6 then
next
end
puts "Local variable is #(i)"
end
4. Sintaxe do método no Ruby
#!/usr/bin/ruby
def test(a1 = "Noodles", a2 = "Pasta")
puts "The food is #(a1)"
puts "The food is #(a2)"
end
test "Burger", "Pizza"
test
5. Declaração de retorno em Ruby
#!/usr/bin/ruby
def testreturn
a = 10
b = 20
c = 30
return a, b, c
endvar1 = testreturn
puts var1
6. Método parametrizado em Ruby
#!/usr/bin/ruby
def sample (*testparam)
puts "The number of parameters are #( testparam.length)"
for i in 0… testparam.length
puts "The parameters are #(testparam(i))"
end
end
sample "Hello", "123", "ABC", "Programming"
sample "World", "456", "Ruby"
7. Bloco de implementação usando declaração de rendimento
#!/usr/bin/ruby
def test
yield
end
test( puts "Hello world")
8. Blocos BEGIN e END no Ruby
#!/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"
9. Substituição de expressão de string em Ruby
#!/usr/bin/ruby
a, b, c = 1, 2, 3
puts "The value of a is #( a )."
puts "The sum of b and c is #( b + c )."
puts "The average is #( (a + b + c)/3 )."
10. Criação de matrizes em Ruby
#!/usr/bin/ruby
names = Array.new(10)
puts names.size # returns 10
puts names.length # returns 10
Comandos avançados de Ruby
1. Métodos Getter e Setter em Ruby
#!/usr/bin/ruby -w
# defining a class
class Box
# constructor method
def initialize(l, b, h)
@length, @width, @height = l, b, h
end
# accessor methods
def printLength
@length
end
def printBreadth
@breadth
end
def printHeight
@height
end
end
# create
an object
box = Box.new(10, 30, 40)
# use accessor methods
l = box.printLength()
b = box.printBreadth()
h = box.printHeight()
puts "Box Length : #(l)"
puts "Box Breadth : #(b)"
puts “Box Height : #(h)”
2. Escrevendo scripts comuns de interface de gateway usando Ruby
#!/usr/bin/ruby "
require 'cgi'
cgi = CGI.new
puts cgi.header
puts "This is a test
3. Programação de soquetes usando Ruby
- 3.1 Um exemplo simples de servidor usando Ruby
require 'socket' # Get sockets from stdlib
server = TCPServer.open(8090) # listen on port 8090
loop ( # Running the server infinitely
client = server.accept # Connecting client wait time
client.puts(Time.now.ctime) # send time to client
client.puts "Closing the connection!"
client.close # Client disconnect
)
- 3.2 Um exemplo simples de um cliente usando Ruby
require 'socket' # Get socket from stdlib
hostname = 'localhost' # Set hostname
port = 8090 # Set portsock = TCPSocket.open(hostname, port)
while line = sock.gets # Read lines from the socket
puts line.chop # print with platform line terminator
end
sock.close # Socket closing
4. Exemplo de multithreading em Ruby
#!/usr/bin/ruby
def function1
i = 0
while i<=2
puts "function1 at: #(Time.now)"
sleep(2) i = i+1
end
end
def function2
j = 0
while j<=2
puts "function2 at: #(Time.now)"
sleep(1)
j = j+1
end
end
puts "Started At #(Time.now)"
t1 = Thread.new(function1())
t2 = Thread.new(function2())
t1.join
t2.join
puts "End at #(Time.now)"
Dicas e truques para usar comandos Ruby
Como trabalhar em qualquer linguagem de programação requer conhecimento e vontade de atualizar, este caso não é uma exceção. Usar os comandos básicos e praticar e dominar os comandos é a chave para dominar essa bela linguagem.
Conclusão - Comandos Ruby
O comando Ruby é uma linguagem de programação livre e de código aberto; é flexível e possui muitos recursos. Como o nome sugere, o ruby é de fato uma linguagem de joia que tem um custo de entrada muito baixo. Sua capacidade plug and play e também sintaxe de fácil leitura o tornam muito fácil de usar. Seu recurso de script avançado também resume sua popularidade.
Artigos recomendados
Este foi um guia para os comandos Ruby. Aqui discutimos os comandos básicos do Ruby e alguns comandos avançados do Ruby. Você também pode consultar o seguinte artigo para saber mais.
- Como usar comandos Selenium?
- Comandos Spark mais avançados
- Comandos do HBase
- Como usar os comandos do Tableau?
- Programação de soquete em Python