Wprowadzenie poleceń Ruby

1. Co to jest Ruby?

Ruby jest językiem programowania typu open source. Jest interpretowany zarówno zorientowany obiektowo. Ruby został stworzony przez Yukihiro Matsumoto. Nazwa Ruby pochodzi od klejnotu, dlatego twórca nazwał ją klejnotem języków programowania. tutaj omówimy różne typy poleceń Ruby.

Projekt Ruby bierze pod uwagę następujące czynniki - prostotę, ekstensywność, kompletność i przenośność. Ruby działa na większości platform opartych na UNIX. Znaczna część Ruby jest zbudowana na Linuksie. Ruby działa również na popularnych platformach, takich jak Windows, DOS, Mac itp.

Podstawowe komendy Ruby

1. Proste polecenie, aby wydrukować ciąg w Ruby

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

2. Proste polecenie, aby wydrukować ciąg wielu linii za pomocą 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. Proste polecenie, aby wydrukować ciąg wielu wierszy za pomocą polecenia wykonania

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

4. Proste polecenie drukowania wielu wierszy przez układanie w stos.

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

5. Instrukcja Ruby BEGIN

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

6. Instrukcja 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. Rubinowy komentarz jednowierszowy

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

8. Rubinowy komentarz wieloliniowy

#!/usr/bin/ruby=begin
This is a multiple line comment.=end
puts "This is not a comment" # This is a single line comment.

9. Funkcja członka w klasie Ruby. Tworzenie obiektu i wywoływanie metody.

#!/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. Globalne zmienne w Rubim

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

Polecenia pośrednie

1. JEŻELI… ELSE w 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. Case 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. Pętle w Ruby

  • 3.1 Podczas pętli

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

  • 3.2 Aż do pętli

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

  • 3.3 Dla pętli

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

  • 3.4 Oświadczenie o złamaniu

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

  • 3.5 Następne oświadczenie

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

4. Składnia metody w 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. Zwróć instrukcję w Ruby

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

6. Sparametryzowana metoda w 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. Wdrożenie bloku przy użyciu instrukcji dochodu

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

8. BEGIN i END bloki w 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. Podstawienie wyrażenia łańcuchowego w 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. Tworzenie tablic w Ruby

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

Zaawansowane komendy Ruby

1. Metody Gettera i Settera w Rubim

#!/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. Pisanie wspólnych skryptów interfejsu bramy przy użyciu Ruby

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

3. Programowanie gniazd za pomocą Ruby

  • 3.1 Prosty przykład serwera używającego 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 Prosty przykład klienta używającego 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. Przykład wielowątkowości w 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)"

Wskazówki i porady dotyczące używania poleceń Ruby

Ponieważ praca nad dowolnym językiem programowania wymaga wiedzy i chęci uaktualnienia, ten przypadek nie jest wyjątkiem. Używanie podstawowych poleceń oraz ćwiczenie i opanowanie poleceń jest kluczem do opanowania tego pięknego języka.

Wniosek - komendy Ruby

Polecenie Ruby jest wolnym i otwartym językiem programowania; jest elastyczny i bogaty w funkcje. Jak sama nazwa wskazuje, rubin jest rzeczywiście językiem klejnotów, który kosztuje bardzo niewiele. Dzięki możliwości plug and play oraz łatwej do odczytania składni jest bardzo przyjazny dla użytkownika. Jego zaawansowana funkcja skryptowa również podsumowuje swoją popularność.

Polecane artykuły

To był przewodnik po Ruby Commands. Omówiliśmy tutaj podstawowe komendy Ruby i niektóre zaawansowane komendy Ruby. Możesz także spojrzeć na następujący artykuł, aby dowiedzieć się więcej.

  1. Jak korzystać z poleceń Selenium?
  2. Najważniejsze polecenia Spark
  3. Polecenia HBase
  4. Jak korzystać z poleceń Tableau?
  5. Programowanie gniazd w Pythonie