Introducción de comandos Ruby
1. ¿Qué es Ruby?
Ruby es un lenguaje de programación de código abierto. Es interpretado y orientado a objetos. Ruby fue creado por Yukihiro Matsumoto. Ruby lleva el nombre de una piedra preciosa y, por lo tanto, el creador lo relacionó como la joya de los lenguajes de programación. Aquí discutiremos los diferentes tipos de comandos de Ruby.
El diseño de Ruby tiene en cuenta los siguientes factores: simplicidad, amplitud, integridad y portabilidad. Ruby funciona en la mayoría de las plataformas basadas en UNIX. Una parte importante de Ruby está construida en Linux. Ruby también funciona en plataformas comunes como Windows, DOS, Mac, etc.
Comandos básicos de rubí
1. Comando simple para imprimir una cadena en Ruby
#!/usr/bin/ruby –w
puts “Hello, Ruby!”
2. Comando simple para imprimir cadenas de líneas múltiples 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 simple para imprimir cadenas de varias líneas mediante el uso de ejecutar un comando
#!/usr/bin/ruby –w
print <<`EOC` # execute commands
echo First Statement
echo Second Statement
EOC
4. Comando simple para imprimir cadenas de líneas múltiples apilando.
#!/usr/bin/ruby –w
print <<"a", <<"b" # you can stack them
I said foo.
a
I said bar.
b
5. Declaración de Ruby BEGIN
#!/usr/bin/ruby
puts "This statement comes later"
BEGIN (
puts "This statement will be printed in the beginning"
)
6. Declaración de Ruby END
#!/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. Comentario de línea única de Ruby
#!/usr/bin/ruby
# This is a single line comment.
uts "This is not a comment" # This is again a single line
comment.
8. Comentario de varias líneas de 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. Función miembro en Ruby Class. Crear un objeto y llamar a un 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. Variables globales en 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 intermedios
1. SI … ELSE en 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 en rubí
<#!/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. Bucles en Ruby
- 3.1. Mientras bucle
#!/usr/bin/ruby
$i = 0
$num = 10
while $i <
$num do
puts("Inside the loop i = #$i" )
$i = $i + 1
end
- 3.2. Hasta el bucle
#!/usr/bin/ruby
$i = 0
$num = 4
until $i > $num do
puts("Inside the loop i = #$i" )
$i = $i + 1;
end
- 3.3. En bucle
#!/usr/bin/ruby
for i in 0..9
puts "Local variable value is #(i)"
end
- 3.4. Declaración de ruptura
#!/usr/bin/ruby
for i in 0..5
if i > 3 then
break
end puts "Local variable is #(i)"
end
- 3.5. Siguiente declaración
#!/usr/bin/ruby
for i in 0..10
if i < 6 then
next
end
puts "Local variable is #(i)"
end
4. Sintaxis del método en 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. Declaración de devolución en Ruby
#!/usr/bin/ruby
def testreturn
a = 10
b = 20
c = 30
return a, b, c
endvar1 = testreturn
puts var1
6. Método parametrizado en 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. Implementando bloque usando declaración de rendimiento
#!/usr/bin/ruby
def test
yield
end
test( puts "Hello world")
8. BEGIN y END blocks en 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. Sustitución de expresión de cadena en 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. Creación de matrices en Ruby
#!/usr/bin/ruby
names = Array.new(10)
puts names.size # returns 10
puts names.length # returns 10
Comandos avanzados de rubí
1. Métodos Getter y Setter en 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. Escribir scripts de interfaz de puerta de enlace comunes usando Ruby
#!/usr/bin/ruby "
require 'cgi'
cgi = CGI.new
puts cgi.header
puts "This is a test
3. Programación de socket usando Ruby
- 3.1. Un ejemplo simple de un servidor que usa 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. Un ejemplo simple de un cliente que usa 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. Ejemplo de subprocesos múltiples en 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)"
Consejos y trucos para usar los comandos de Ruby
Dado que trabajar en cualquier lenguaje de programación requiere conocimiento y disposición para actualizar, este caso no es una excepción. Usar los comandos básicos y practicar y dominar los comandos es la clave para dominar este hermoso lenguaje.
Conclusión: comandos de Ruby
El comando Ruby es un lenguaje de programación gratuito y de código abierto; Es flexible y tiene muchas funciones. Como su nombre lo indica, el rubí es un lenguaje joya que tiene un costo de entrada muy bajo. Su capacidad plug and play y su sintaxis fácilmente legible lo hacen muy fácil de usar. Su avanzada instalación de scripting también resume su popularidad.
Artículos recomendados
Esta ha sido una guía para los comandos de Ruby. Aquí hemos discutido los comandos básicos de Ruby y algunos comandos avanzados de Ruby. También puede consultar el siguiente artículo para obtener más información.
- ¿Cómo usar los comandos de selenio?
- Los mejores comandos de chispa
- Comandos HBase
- ¿Cómo usar los comandos de Tableau?
- Programación de sockets en Python