Introduction des commandes Ruby

1. Qu'est-ce que Ruby?

Ruby est un langage de programmation open source. Il est interprété aussi bien qu'orienté objet. Ruby a été créé par Yukihiro Matsumoto. Ruby doit son nom à une pierre précieuse et le créateur l'a donc décrite comme le joyau des langages de programmation. ici, nous allons discuter des différents types de commandes Ruby.

La conception de Ruby prend en compte les facteurs suivants: simplicité, extensibilité, exhaustivité et portabilité. Ruby fonctionne sur la plupart des plates-formes UNIX. Une grande partie de Ruby est construite sur Linux. Ruby fonctionne également sur des plateformes courantes telles que Windows, DOS, Mac, etc.

Commandes Rubic B asic

1. Commande simple pour imprimer une chaîne en Ruby

#!/usr/bin/ruby –w
puts “Hello, Ruby!”

2. Commande simple pour imprimer une chaîne de plusieurs lignes en utilisant 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. Commande simple pour imprimer une chaîne de plusieurs lignes en utilisant exécuter une commande

#!/usr/bin/ruby –w
print <<`EOC` # execute commands
echo First Statement
echo Second Statement
EOC

4. Commande simple pour imprimer une chaîne de plusieurs lignes par empilement.

#!/usr/bin/ruby –w
print <<"a", <<"b" # you can stack them
I said foo.
a
I said bar.
b

5. Déclaration Ruby BEGIN

#!/usr/bin/ruby
puts "This statement comes later"
BEGIN (
puts "This statement will be printed in the beginning"
)

6. Instruction 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. Commentaire sur une seule ligne Ruby

#!/usr/bin/ruby
# This is a single line comment.
uts "This is not a comment" # This is again a single line
comment.

8. Commentaire sur plusieurs lignes 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. Fonction membre dans la classe Ruby. Création d'un objet et appel d'une méthode.

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

Commandes intermédiaires

1. SI… AILLEURS 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. Affaire en 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. Boucles en rubis

  • 3.1. Boucle while

#!/usr/bin/ruby
$i = 0
$num = 10
while $i <
$num do
puts("Inside the loop i = #$i" )
$i = $i + 1
end

  • 3.2. Jusqu'à la boucle

#!/usr/bin/ruby
$i = 0
$num = 4
until $i > $num do
puts("Inside the loop i = #$i" )
$i = $i + 1;
end

  • 3.3. Pour boucle

#!/usr/bin/ruby
for i in 0..9
puts "Local variable value is #(i)"
end

  • 3.4. Déclaration de pause

#!/usr/bin/ruby
for i in 0..5
if i > 3 then
break
end puts "Local variable is #(i)"
end

  • 3.5. Prochaine déclaration

#!/usr/bin/ruby
for i in 0..10
if i < 6 then
next
end
puts "Local variable is #(i)"
end

4. Syntaxe de la méthode dans 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. Déclaration de retour en Ruby

#!/usr/bin/ruby
def testreturn
a = 10
b = 20
c = 30
return a, b, c
endvar1 = testreturn
puts var1

6. Méthode paramétrée 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. Implémentation d'un bloc à l'aide de la déclaration de rendement

#!/usr/bin/ruby
def test
yield
end
test( puts "Hello world")

8. Blocs BEGIN et END dans 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. Substitution d'expression de chaîne dans 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. Création de tableaux dans Ruby

#!/usr/bin/ruby
names = Array.new(10)
puts names.size # returns 10
puts names.length # returns 10

Commandes Ruby avancées

1. Méthodes Getter et 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. Écriture de scripts d'interface de passerelle communs à l'aide de Ruby

#!/usr/bin/ruby
require 'cgi'
cgi = CGI.new
puts cgi.header
puts "This is a test
"

3. Programmation des sockets avec Ruby

  • 3.1. Un exemple simple d'un serveur utilisant 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 exemple simple d'un client utilisant 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. Exemple de multithreading 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)"

Trucs et astuces pour utiliser les commandes Ruby

Étant donné que travailler sur n'importe quel langage de programmation nécessite des connaissances et une volonté de mise à niveau, ce cas ne fait pas exception. Utiliser les commandes de base et pratiquer et maîtriser les commandes est la clé pour maîtriser cette belle langue.

Conclusion - Commandes Ruby

La commande Ruby est un langage de programmation gratuit et open source; il est flexible et riche en fonctionnalités. Comme son nom l'indique, le rubis est en effet une langue de bijou qui vient à un coût d'entrée très faible. Sa capacité plug and play et sa syntaxe facilement lisible le rendent très convivial. Son installation de script avancée résume également sa popularité.

Articles recommandés

Cela a été un guide pour les commandes Ruby. Ici, nous avons discuté des commandes Ruby de base et de certaines commandes Ruby avancées. Vous pouvez également consulter l'article suivant pour en savoir plus.

  1. Comment utiliser les commandes Selenium?
  2. Commandes Spark les plus performantes
  3. Commandes HBase
  4. Comment utiliser les commandes Tableau?
  5. Programmation des sockets en Python