Einführung von Ruby-Befehlen
1. Was ist Ruby?
Ruby ist eine Open Source Programmiersprache. Es ist sowohl interpretiert als auch objektorientiert. Ruby wurde von Yukihiro Matsumoto erstellt. Ruby ist nach einem Edelstein benannt und wird daher vom Schöpfer als Juwel der Programmiersprachen bezeichnet. Hier werden wir die verschiedenen Arten von Ruby-Befehlen diskutieren.
Das Design von Ruby berücksichtigt die folgenden Faktoren: Einfachheit, Umfang, Vollständigkeit und Portabilität. Ruby funktioniert auf den meisten UNIX-basierten Plattformen. Ein Großteil von Ruby basiert auf Linux. Ruby funktioniert auch auf gängigen Plattformen wie Windows, DOS, Mac usw.
B asische Ruby-Befehle
1. Einfacher Befehl zum Drucken einer Zeichenfolge in Ruby
#!/usr/bin/ruby –w
puts “Hello, Ruby!”
2. Einfacher Befehl zum Drucken einer mehrzeiligen Zeichenfolge mit 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. Einfacher Befehl zum Drucken einer mehrzeiligen Zeichenfolge durch Ausführen eines Befehls
#!/usr/bin/ruby –w
print <<`EOC` # execute commands
echo First Statement
echo Second Statement
EOC
4. Einfacher Befehl zum Drucken einer mehrzeiligen Zeichenfolge durch Stapeln.
#!/usr/bin/ruby –w
print <<"a", <<"b" # you can stack them
I said foo.
a
I said bar.
b
5. Ruby BEGIN-Anweisung
#!/usr/bin/ruby
puts "This statement comes later"
BEGIN (
puts "This statement will be printed in the beginning"
)
6. Ruby END-Anweisung
#!/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. Ruby einzeiliger Kommentar
#!/usr/bin/ruby
# This is a single line comment.
uts "This is not a comment" # This is again a single line
comment.
8. Ruby mehrzeiliger Kommentar
#!/usr/bin/ruby=begin
This is a multiple line comment.=end
puts "This is not a comment" # This is a single line comment.
9. Mitgliedsfunktion in der Ruby-Klasse. Ein Objekt erstellen und eine Methode aufrufen.
#!/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. Globale Variablen in 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
Zwischenbefehle
1. WENN… SONST in 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. Fall in 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. Schleifen in Ruby
- 3.1. While-Schleife
#!/usr/bin/ruby
$i = 0
$num = 10
while $i <
$num do
puts("Inside the loop i = #$i" )
$i = $i + 1
end
- 3.2. Bis zur Schleife
#!/usr/bin/ruby
$i = 0
$num = 4
until $i > $num do
puts("Inside the loop i = #$i" )
$i = $i + 1;
end
- 3.3. Für Schleife
#!/usr/bin/ruby
for i in 0..9
puts "Local variable value is #(i)"
end
- 3.4. Break-Anweisung
#!/usr/bin/ruby
for i in 0..5
if i > 3 then
break
end puts "Local variable is #(i)"
end
- 3.5. Nächste Aussage
#!/usr/bin/ruby
for i in 0..10
if i < 6 then
next
end
puts "Local variable is #(i)"
end
4. Methodensyntax in 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. Return-Anweisung in Ruby
#!/usr/bin/ruby
def testreturn
a = 10
b = 20
c = 30
return a, b, c
endvar1 = testreturn
puts var1
6. Parametrisierte Methode in 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. Implementieren des Blocks mithilfe der Yield-Anweisung
#!/usr/bin/ruby
def test
yield
end
test( puts "Hello world")
8. BEGIN- und END-Blöcke in 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. Ersetzen von Zeichenfolgenausdrücken in 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. Array-Erstellung in Ruby
#!/usr/bin/ruby
names = Array.new(10)
puts names.size # returns 10
puts names.length # returns 10
Erweiterte Ruby-Befehle
1. Getter- und Setter-Methoden in 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. Schreiben von allgemeinen Gateway-Schnittstellenskripten mit Ruby
#!/usr/bin/ruby "
require 'cgi'
cgi = CGI.new
puts cgi.header
puts "This is a test
3. Socket-Programmierung mit Ruby
- 3.1. Ein einfaches Beispiel für einen Server mit 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. Ein einfaches Beispiel für einen Client, der Ruby verwendet
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. Multithreading-Beispiel in 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)"
Tipps und Tricks zur Verwendung von Ruby-Befehlen
Da die Arbeit an jeder Programmiersprache Kenntnisse und Bereitschaft zum Upgrade erfordert, ist dieser Fall keine Ausnahme. Die grundlegenden Befehle zu verwenden und die Befehle zu üben und zu beherrschen, ist der Schlüssel, um diese schöne Sprache zu beherrschen.
Fazit - Ruby-Befehle
Ruby-Befehl ist eine freie und Open-Source-Programmiersprache; es ist flexibel und funktionsreich. Wie der Name schon sagt, ist Ruby in der Tat eine Juwelensprache, die zu sehr geringen Einstiegskosten angeboten wird. Die Plug-and-Play-Fähigkeit und die leicht lesbare Syntax machen es sehr benutzerfreundlich. Die fortschrittliche Scripting-Funktion fasst auch ihre Beliebtheit zusammen.
Empfohlene Artikel
Dies war eine Anleitung zu Ruby-Befehlen. Hier haben wir grundlegende Ruby-Befehle und einige erweiterte Ruby-Befehle besprochen. Sie können auch den folgenden Artikel lesen, um mehr zu erfahren.
- Wie benutze ich Selen-Befehle?
- Top-Most Spark-Befehle
- HBase-Befehle
- Wie verwende ich Tableau-Befehle?
- Socket-Programmierung in Python