Pengenalan

Ini adalah satu tutorial ruby yang akan mengambil lebih kurang 20 minit untuk diselesaikan. Ia menganggap anda telahpun meng-install Ruby. (Jika belum, anda boleh mendapatkan Ruby dibahagian download pada ruby-lang.org dan install Ruby terdahulu sebelum bermula dengan tutorial ini).

Tutorial ini dialihbahasa daripada Ruby in Twenty Minutes Interactive Ruby (IRB)

Mulakan IRB

• Jika anda menggunakan Mac OS X, buka terminal dan taipkan sahaja irb dan tekan enter.
• Jika anda menggunakan Linux, buka shell dan taipkan irb. Tekan enter.
• Jika anda menggunakan Windows, start->Ruby->fxri.

[source:ruby] irb(main):001:0>

Daripada sini, taipkan "Hello World"

irb(main):001:0> "Hello World"
=> "Hello World"

Yang Menurut Perintah

Melihat daripada yang tertera pada console, adakah kita telah membuat program 'Hello World' paling ringkas di dunia? Sebenarnya barisan ke-2 itu adalah cara IRB memberitahu kita hasil aturcara terakhir dinilai. Jikalau kita mahu memaparkan 'Hello World' pada skrin, kita memerlukan sedikit tambahan.

irb(main):002:0> puts"Hello World"
Hello World
=> nil

puts adalah arahan Ruby yang asas untuk memaparkan sesuatu. Tapi apa pula '=> nil' yang ditunjukkan oleh irb? Ia adalah hasil aturcara puts yang sentiasa memulangkan nilai 'nil'. 'nil' bermaksud tanpa nilai.

Kalkulator percuma!

Sekarang kita akan menggunakan Ruby sebagai kalkulator.

irb(main):003:0> 3+2
=> 5

Tiga tambah dua. Mudah sahaja. Bagaimana pula dengan tiga darab dua? Anda boleh menaip semula statement ini atau dapatkan kembali statement tadi (3+2) dan menukarkan tanda operasi. Cuma gunakan up-arrow pada keyboard dan gunakan left/right arrow untuk pergi ke tanda + dan gantikan dengan tanda *.

irb(main):004:0> 3*2
=> 6

Sekarang, 3 kuasa 2:

irb(main):005:0> 3**2
=> 9

Dalam Ruby, x**y adalah bermaksud 'x kuasa y'. Bagaimana pula untuk dapatkan punca kuasa sesuatu nilai?

irb(main):006:0> Math.sqrt(9)
=> 3.0

Di sini kita diperkenalkan dengan salah satu module asas Ruby iaitu Maths. Module mempunyai 2 kegunaan didalam Ruby. Ia menghimpunkan kumpulan function-function yang bertujuan sama. Math menghimpunkan function-function seperti sin() dan tan().

Kegunaan kedua ialah titik perpuluhan. Titik perpuluhan ini digunakan untuk mengenalpasti siapakan penerima sesebuah message. Apakah message ini? Message adalah parameter atau nilai yang dimasukkan ke dalam sesuatu function. Dalam statement terakhir kita, sqrt() adalah function didalam module Math dan 9 itu adalah parameter yang digunakan.

Perhatikan hasil yang dipulangkan adalah bukan integer dan adalah jenis float (yang mempunyai titik perpuluhan). Ini kerana kebanyakan hasil punca kuasa sesuatu nombor adalah bukan integer, jadi method ini direka untuk memulangkan nombor float.

Jika kita hendak Ruby mengingati hasil function tadi untuk kegunaan tertentu, simpan nilai tadi di dalam sebuah variable.

irb(main):007:0> a = 3 ** 2
=> 9
irb(main):008:0> b = 4 ** 2
=> 16
irb(main):009:0> Math.sqrt(a+b)
=> 5.0

Kita kembali kepada tradisi tutorial awalan iaitu memfokuskan kepada aplikasi Hello World. Jika pada awalnya kita mahu ucapkan 'Hello World' hanya sekali, bagaimana pula kita hendak mengucapkan ia berkali-kali tanpa melenguhkan jari-jemari kita untuk menaip? Caranya mudah, kita definasikan ia sebagai sesuatu method (atau function, jika anda selesa dengan istilah ini).

irb(main):010:0> def h
irb(main):011:1> puts"Hello World!"
irb(main):012:1> end
=> nil

Kod ini bermula dengan 'def h'. h adalah nama method yang kita bina dan kata kunci def (untuk define) adalah untuk memberitahu Ruby bahawa kita ingin mendefinasikan satu method bernama h.

Barisan seterusnya kita masukkan statement untuk memaparkan 'Hello World' dan pada barisan terakhir definasi method ini, terdapat end untuk memberitahu Ruby yang kita selesai mendefinasikan method ini. irb melaporkan => nil untuk memberitahu kita bahawa Ruby memahami kita selesai mendefinasikan method.

Satu Method Yang Mudah Dan Berulang-Ulang

Mari kita gunakan method yang kita definasikan tadi:

irb(main):013:0> h
Hello World!
=> nil
irb(main):014:0> h()
Hello World!
=> nil

Mudah sahaja, kan? Memanggil method didalam Ruby adalah semudah menaip namanya di dalam Ruby. Jika method itu tiada parameter yang perlu kita isikan, itulah sahaja yangkita perlu buat: taipkan sahaja nama method tadi.

Bagaimana pula kita hendak mengatakan hello kepada seorang sahaja? Kita akan tukarkan definasi method h untuk mengambil nama orang itu sebagai parameter.

irb(main):015:0> def h(name)
irb(main):016:1> puts"Hello #{name}!"
irb(main):017:1> end
=> nil
irb(main):018:0> h("Matz")
Hello Matz!
=> nil

Ia berjaya tetapi mari kita lihat apa yang telah berlaku.

Pengisian String

Apakah maksud #{name}? Ia adalah cara memasukkan sesuatu nilai sesuatu variable ke dalam string. Ia akan menukarkan nilai yang tersimpan antara #{ dan } kepada string (jika ia bukannya string) dan memasukkan ke dalam string tadi. Kita akan membuat sedikit perubahan untuk memastikan huruf besar digunakan pada huruf pertama name.

irb(main):019:0> def h(name ="World")
irb(main):020:1> puts"Hello #{name.capitalize}!"
irb(main):021:1> end
=> nil
irb(main):022:0> h"chris"
Hello Chris!
=> nil
irb(main):023:0> h
Hello World!
=> nil

Evolusi Greeter

Pada bahagian ini, kita akan mula mendefinasikan class.

irb(main):024:0> class Greeter
irb(main):025:1> def initialize(name ="World")
irb(main):026:2> @name = name
irb(main):027:2> end
irb(main):028:1> def say_hi
irb(main):029:2> puts"Hi #{@name}!"
irb(main):030:2> end
irb(main):031:1> def say_bye
irb(main):032:2> puts"Bye #{@name}, come back soon."
irb(main):033:2> end
irb(main):034:1> end
=> nil

Kata kunci baru pada bahagian ini adalah 'class'. Ia memberitahu Ruby yang kita sedang mendefinasikan satu class bernama Greeter dan beberapa method untuk class itu. Perhatikan @name. Lihat juga dimana ia digunakan, di method say_hi dan di method say_bye. Ia adalah sejenis variable yang dipanggil instance variable. Apabila class ini digunakan untuk menjadi satu object, jika @name diberi satu nilai, nilai ini akan dapat digunakan pada kesemua method Greeter ini.

Mari kita bina satu object daripada class Greeter ini.

irb(main):035:0> g = Greeter.new("Pat")
=> #
irb(main):036:0> g.say_hi
Hi Pat!
=> nil
irb(main):037:0> g.say_bye
Bye Pat, come back soon.
=> nil

Apabila object g dibina, ia mengingati namanya adalah Pat. Bolehkah kita mendapatkan nama object itu secara terus?

irb(main):038:0> g.@name
SyntaxError: compile error (irb):52: syntax error from (irb):52

Ooops! Nampaknya tak boleh. :D

Didalam Objek

Instance variable disorok di dalam object. Akan tetapi ia tidak disorok dengan bersungguh-sungguh, kita masih dapat melihatnya apabila kita meneliti object dengan kaedah tertentu. Ini adalah pendekatan berorientasikan objek.

Bagaimana kita hendak mengetahui method-method yang ada untuk object Greeter?

irb(main):039:0> Greeter.instance_methods
=> ["method","send","object_id","singleton_methods",
"__send__","equal?","taint","frozen?",
"instance_variable_get","kind_of?",
"to_a","instance_eval","type",
"protected_methods","extend","eql?",
"display","instance_variable_set","hash","is_a?",
"to_s","class","tainted?","private_methods","untaint",
"say_hi","id","inspect","==","===","clone","public_methods",
"respond_to?","freeze","say_bye","__id__","=~","methods","nil?",
"dup","instance_variables","instance_of?"]

Banyak! Tetapi kita hanya mendefinasikan 2 method. Bagaimanakah senarai ini boleh menjadi begitu panjang? Ini sebenarnya kesemua method yang ada untuk object Greeter. Ini bermakna ia termasuk method yang telah diwarisi oleh object Greeter. Jika kita mahu yang didefinasikan untuk Greeter, kita perlu memberitahu Ruby yang kita tidak mahu method-method yang diwarisi dengan memberi parameter false.

irb(main):040:0> Greeter.instance_methods(false)
=> ["say_bye","say_hi"]

Sekarang baru betul. :) . Berikut adalah cara untuk melihat samada sesuatu method itu boleh terus dipanggil atau tidak.

irb(main):041:0> g.respond_to?("name")
=> false
irb(main):042:0> g.respond_to?("say_hi")
=> true
irb(main):043:0> g.respond_to?("to_s")
=> true

Kita dapat lihat say_hi dan to_s (ini untuk menukarkan sesuatu nilai kepada string. Ia didefinasikan secara automatik pada semua objek) boleh dipanggil secara terus tetapi tidak name. Menukarkan Class

Bagaimana pula jika kita mahu melihat atau menukar name pada object itu? Ruby memberikan kemudahan untuk kita berbuat demikian.

irb(main):044:0> class Greeter
irb(main):045:1> attr_accessor :name
irb(main):046:1> end
=> nil

Dalam Ruby, anda boleh mendapatkan kembali class itu dan mengubahnya. Perubahan ini akan dapat dilihat dalam object-object yang terbina daripada class tersebut.

irb(main):047:0> g = Greeter.new("Andy")
=> # irb(main):048:0> g.respond_to?("name")
=> true
irb(main):049:0> g.respond_to?("name=")
=> true irb(main):050:0> g.say_hi
Hi Andy!
=> nil
irb(main):051:0> g.name="Betty"
=>"Betty"
irb(main):052:0> g
=> #
irb(main):053:0> g.name
=>"Betty"
irb(main):054:0> g.say_hi
Hi Betty!
=> nil

Dengan menggunakan attr_accessor, kita mendefinasikan dua method baru iaitu name untuk mendapatkan nilai name dan name= untuk memberi nilai kepada variable itu.

MegaGreeter

Greeter class yang didefinasikan sebelum ini tidak begitu menarik kerana ia hanya dapat memberikan greetings kepada seorang sahaja pada sesuatu masa. Jadi kita akan membina MegaGreeter yang dapat greet lebih ramai orang. Kerana ia agak besar, kita akan menulis definasi class MegaGreeter? ini di dalam satu file.

Untuk keluar dari IRB, gunakan arahan exit. Atau dengan combinasi ctrl+d.

Gunakan editor anda dan masukkan aturcara Ruby berikut:

#!/usr/bin/env ruby
class MegaGreeter
attr_accessor :names
# Create the object
def initialize(names = "World")
@names = names
end
# Say hi to everybody
def say_hi
if @names.nil?
puts "..."
elsif @names.respond_to?("each")
# @names is a list of some kind, iterate!
@names.each do |name|
puts "Hello #{name}!"
end
else
puts "Hello #{@names}!"
end
end
# Say bye to everybody
def say_bye
if @names.nil?
puts "..."
elsif @names.respond_to?("join")
# Join the list elements with commas
puts "Goodbye #{@names.join(", ")}.  Come back soon!"
else
puts "Goodbye #{@names}.  Come back soon!"
end
end
end
if __FILE__ == $0
mg = MegaGreeter.new
mg.say_hi
mg.say_bye
# Change name to be"Zeke"
mg.names ="Zeke"
mg.say_hi
mg.say_bye
# Change the name to an array of names
mg.names = ["Albert","Brenda","Charles",
"Dave","Englebert"]
mg.say_hi
mg.say_bye
# Change to nil
mg.names = nil
mg.say_hi
mg.say_bye
end

Simpan file ini sebagai 20min.rb, dan kita mulakan aplikasi ini dengan menaip 'ruby 20min.rb' di terminal. Output aplikasi ini sepatutnya seperti:

Hello World!
Goodbye World. Come back soon!
Hello Zeke!
Goodbye Zeke. Come back soon!
Hello Albert!
Hello Brenda!
Hello Charles!
Hello Dave!
Hello Englebert!
Goodbye Albert, Brenda, Charles, Dave, Englebert. Come back soon!
…
…

Melihat kepada aplikasi ini, perhatikan pada file 20min.rb ini, ia bermula dengan '#!/usr/bin/env ruby'. Pada kebiasaannya, tanda # adalah untuk komen-komen di dalam aplikasi dan ianya tidak diendahkan oleh Ruby. Tetapi untuk OS Unix dan sepertinya, ia memberi maklumat kepada shell/terminal berkenaan bagaimana file ini akan dijalankan.

Selepas itu, komen-komen lain hanyalah untuk kefahaman pembaca coding ini.

Method say_hi telahpun berubah.

Say hi to everybody

def say_hi
if @names.nil?
puts"…"
elsif @names.respond_to?("each")
# @names is a list of some kind, iterate!
@names.each do |name|
puts"Hello #{name}!"
end
else
puts"Hello #{@names}!"
end
end

Ia sekarang mencari @names dan membuat pilihan berdasarkan nilai @names itu. Jika ia nil(jangan lupa, ini bermakna tiada nilai), say_hi hanya akan memaparkan 3 titik perpuluhan.

Gelung dan Rentetan

Jikalau @names mempunyai method each, ini bermakna ia dapat melalui satu per satu nilai dalam @names dan melakukan fungsi-fungsi yang diaturkan. Jikalau @names tidak mempunyai method each ini, ia akan ditukarkan menjadi string dan greeting biasa akan diberikan.

Mari kita lihat rentetan ini dengan lebih mendalam.

@names.each do |name|
puts"Hello #{name}"
end

each adalah satu method yang menerima satu blok aturcara dan kemudiannya menjalankan blok aturcara tersebut untuk setiap elemen dalam list itu. Kesemua antara do dan end itu adalah satu blok. Blok itu bolehlah kita anggap seperti sebuah function yang tidak diketahui atau istilahnya lambda. Variable diantara huruf pipe '|' adalah parameter untuk blok ini.

Apa yang terjadi ialah untuk setiap iterasi, satu nilai dimasukkan ke dalam variable name. Apabila iterasi itu selesai, nilai seterusnya pula diberi kepada variable name itu. Untuk contoh diatas, setiap iterasi akan memaparkan nilai name, jadi semua nilai name itu akan dipaparkan sehingga habis senarai nama dalam @names.

Jika anda pernah mengaturcara dalam C, anda mungkin akan membuat aturacara di atas seperti ini:

for (i=0; i < 10; i++) {
do_something_with(element[i]);
}

Ini tidak dianggap kemas kerana ia memerlukan satu variable sementara iaitu i, mendapatkan dan menerangkan bagaimana cara untuk ke iterasi seterusnya. Ruby, bagaimanapun, mengambil pendekatan yang lebih kemas dengan hanya meminta kita memberitahu apa yang hendak dibuat pada setiap nilai yang dilalui.