Ruby (programmeerimiskeel)

Varased Ruby versioonid

Pärast Ruby versiooni 0.95 1995. aastal anti välja veel mitu stabiilset Ruby versiooni:

• Ruby 1.0 – 25. detsember 1996
• Ruby 1.2 – 1998. aasta detsember
• Ruby 1.4 – 1999. aasta august
• Ruby 1.6 – 2000. aasta september

Ruby 1.8

Ruby versioon 1.8 ilmus algselt 2003. aasta augustis ning oli pikka aega Ruby stabiilne versioon. Ruby 1.8 määratleti aegunud versioonina alles 2013. aasta juunis. Sellest hoolimata leiab veel palju koodi, mis on kirjutatud just selles versioonis. Ruby versioonil 1.8 kirjutati algne versioon veebiraamistikust Ruby on Rails, mis aitas muuta Ruby veelgi populaarsemaks.

Ruby 1.9

Ruby versioon 1.9 ilmus algselt 25. detsembril 2007. Versioon 1.9 erines päris palju varasematest versioonidest ning seetõttu võttis aega, et 1.9 omaks võetaks, kuna see nõudis suure osa koodi ümberkirjutamist ning ka kolmandate osapoolte kirjutatud gemide uuendamist.

Ruby 1.9 tõi keelde suuri muudatusi, näiteks:

• lokaalsed muutujad
• uue lambda süntaksi: f = ->(a,b) ( puts a + b )
• uue paisktabeli süntaksi: {võti: "väärtus"} == {:võti => "väärtus"}
• igale sõnele spetsiifilise tähemärgikodeeringu andmise võimaluse
• uue võrgusokli rakendusliidese (koos toetusega IPv6le)
• require_relative importide turvalisuse

Ruby 1.9 määratleti aegunud versioonina 23. veebruaril 2015.

Ruby 2.0

Ruby versioon 2.0 ilmus 24. veebruaril 2013. Peaaegu kogu Ruby 1.9 kood sobitub automaatselt Ruby versiooniga 2.0, esineda võib vaid üksikuid probleeme.

Ruby 2.0 tõi keelde veelgi muudatusi, näiteks:

• meetoditele võtmesõnade argumendid
• meetodi Module#prepend klasside laiendamiseks
• konstandi, mis sisaldab järjendit sümbolitest
• uue tava kasutada meetodit #to_h, et muuta objektid paisktabeliteks

Ruby 2.0 määratleti aegunud versioonina 22. veebruaril 2016.

Ruby 2.1

Ruby versioon 2.1.0 ilmus 25. detsembril 2013. See versioon aitas kaasa keele optimeerimisele ning parandas mõningaid vigu.

Ruby 2.1 määratleti aegunud versioonina 1. aprillil 2017, viimane versiooninumber oli 2.1.10.

Ruby 2.2

Ruby versioon 2.2.0 ilmus 25. detsembril 2014. Versioon optimeeris keelt veelgi ning parandas vigu, samuti uuendati teeke ning eemaldati mõningad aegunud rakendusliidesed. Suurimad muudatused Ruby 2.2.0 puhul on seotud mäluga, näiteks on mälukoristusvahendid nüüd inkrementaalsed ning töötavad ka sümbolitega.

Ruby 2.2 määratleti aegunud versioonina 31. märtsil 2018, viimane versiooninumber oli 2.2.10.

Ruby 2.3

Ruby versioon 2.3.0 ilmus 25. detsembril 2015. Mõned tähtsamad muudatused versioonis 2.3:

• sõneoperatsioone sõnekonstantide peal on võimalik muuta kiiremaks, muutes sõnekonstandid hangunuks
• paisktabelite võrdlemisel on võimalik võrrelda võtmeid ja väärtusi korraga, varem sai korraga võrrelda ainult võtmeid
• navigatsioonioperaator &., mis teeb nil väärtuste käitlemise lihtsamaks (näiteks if obj && obj.foo && obj.foo.bar asemel saab kasutada if obj&.foo&.bar)
• did_you_mean gem on nüüd baaskoodis ning aitab automaatselt leida sarnaseid objektide nimesid NameErrori või NoMethodErrori puhul
• meetod #dig järjendite ja paisktabelite jaoks, mis aitab kergemini saada andmestruktuuridest sügavamaid väärtusi (näiteks paisktabelist profiil = { sotsiaal: { vikipeedia: { nimi: 'Mari Mets' } } } saab väärtuse Mari Mets kätte kasutades koodi profiil.dig(:sotsiaal, :vikipeedia, :nimi))

Versioon 2.3 aitab kaasa ka keele üleüldisele optimeerimisele ning parandab muid vigu.

Ruby 2.3 määratleti aegunud versioonina 31. märtsil 2019, viimane versiooninumber oli 2.3.8.

Ruby 2.4

Ruby versioon 2.4.0 ilmus 25. detsembril 2016. Mõned tähtsamad muudatused versioonis 2.4:

• Fixnum ja Bignum objektid on nüüd mõlemad klassifitseeritud osana Integer klassist, ehk täisarvudena
• uus meetod Regexp#match?, mis on kiirem versioon meetodist Regexp#match ning tagastab tõeväärtuse

Ruby 2.4 viimane versiooninumber oli 2.4.10 ning see määratleti aegunud versioonina 1. aprillil 2020.

Ruby 2.5

Ruby versioon 2.5.0 ilmus 25. detsembril 2017. Mõned tähtsamad muudatused versioonis 2.5:

• rescue ja ensure laused kasutavad nüüd automaatselt do-end plokki
• paisktabelite muutmiseks meetodid #slice ja #transform_keys

Versioon 2.5 toob kaasa ka palju parandusi keele optimeerimiseks, näiteks plokkide läbimine on 3 korda kiirem ning mõned objektide liitmismeetodid on samuti kiiremad.

Ruby 2.5 viimane versiooninumber oli 2.5.9 ning see määratleti aegunud versioonina 31. märtsil 2021.

Ruby 2.6

Ruby versioon 2.6.0 ilmus 25. detsembril 2018. Versioon 2.6 tõi muu hulgas katselise käitusaegse kompilaatori (JIT) ning lõpmatud vahemikud ((1..)). Ruby 2.6 viimane versiooninumber oli 2.6.10 ning see määratleti aegunud versioonina 31. märtsil 2022.

Ruby 2.7

Ruby versioon 2.7.0 ilmus 25. detsembril 2019. Olulisemate uuenduste hulka kuulusid katseline mustrisobitus (pattern matching), positsiooni- ja võtmesõnaargumentide eristamine ning mälu tihendav prügikoristus. See oli ühtlasi viimane Ruby 2.x seeria versioon; sellele järgnes Ruby 3.0.

Ruby 3.0

Ruby versioon 3.0.0 ilmus 25. detsembril 2020. Versiooni nimetatakse ka "Ruby 3x3", mis viitab eesmärgile, et programmid töötaksid Ruby 3.0-s kolm korda kiiremini kui Ruby 2.0-s. Kiiruse saavutamiseks sisaldab Ruby 3.0 käitusaegseid kompilaatoreid MJIT ja hiljem YJIT, mis on vaikimisi keelatud ning lülitatakse sisse käivitamisel.

Teine Ruby 3.0 eesmärk oli parandada samaaegset töötlust (concurrency), mida toetavad Fiber Scheduler ja katseline Ractor. Ractor on kergekaaluline ja lõimeturvaline, kuna see vahetab andmeid sõnumite, mitte jagatud objektide kaudu. Ruby 3.0 tõi sisse ka RBS-keele, millega kirjeldatakse Ruby programmide tüüpe staatilise analüüsi jaoks, ning mitmeid süntaksi- ja teegimuudatusi.

Ruby 3.1

Ruby versioon 3.1.0 ilmus 25. detsembril 2021. See sisaldas Shopify arendatud katselist käitusaegset kompilaatorit YJIT, mille eesmärk oli parandada päriselu ärirakenduste jõudlust, samuti uut silurit (debugger). Võrguteegid FTP, SMTP, IMAP ja POP jaoks viidi vaikimisi gemide hulgast kaasapakitavate gemide hulka.

Ruby 3.2

Ruby versioon 3.2.0 ilmus 25. detsembril 2022. See tõi toe Ruby käitamiseks WebAssembly keskkonnas WASI-liidese kaudu. Regulaaravaldised said mitmeid täiendusi, sealhulgas kiirema sobitusalgoritmi ja seadistatava ajalõpu kaitseks teatud ReDoS-rünnakute eest. YJIT, Rustil põhinev kompilaator, toetab nüüd Linuxis rohkem arhitektuure.

Ruby 3.3

Ruby versioon 3.3.0 ilmus 25. detsembril 2023. Olulisemate uuenduste hulka kuulusid uus parser Prism, puhtas Rubys kirjutatud kompilaator RJIT ning suured jõudlusparandused YJIT-is. Lisaks toodi sisse M:N-lõimeajastaja ning tehti parandusi mälukasutuses ja standardteegis.

Ruby 3.4

Ruby versioon 3.4.0 ilmus 25. detsembril 2024. See lisas ploki parameetri viite it, määras Prismi vaikeparseriks, lisas teegi soklitoe Happy Eyeballs Version 2 jaoks, parandas YJIT-i ning tõi sisse modulaarse prügikoristaja.

Ruby 4.0

Ruby versioon 4.0 ilmus 25. detsembril 2025 ning sellega läks Ruby üle uuele põhiversioonile. Praegune stabiilne versioon on 4.0.5, mis ilmus 20. mail 2026.

Sõned

Rubys on sõnesid võimalik defineerida mitmel viisil. Järgnevad muutujad on sama väärtusega:

a = "\nSee on jutumärkides sõne\n"
b = %Q{\nSee on jutumärkides sõne\n}
c = %{\nSee on jutumärkides sõne\n}
d = %/\nSee on jutumärkides sõne\n/
e = <<-BLOCK

See on jutumärkides sõne
BLOCK

Sõnedes saab muutujaid interpoleerida:

var = 3.14159
"pi on #{var}"
=> "pi on 3.14159"

Sõnekonstante saab defineerida järgnevalt:

a = 'See on ülakomades sõne'
a = %q{See on ülakomades sõne}

Andmestruktuurid

Rubys on kasutusel mitmed andmestruktuurid.

Järjendite kasutamine käib järgmiselt:

a = [1, 'hi', 3.14, 1, 2, [4, 5]]

a[2]             # => 3.14
a.[](2)          # => 3.14
a.reverse        # => [[4, 5], 2, 1, 3.14, 'hi', 1]
a.flatten.uniq   # => [1, 'hi', 3.14, 2, 4, 5]

Rubys on olemas ka sõnastiku tüüpi andmestruktuur, mida nimetatakse paisktabeliks (inglise keeles hash)

hash = Hash.new                               # samaväärne kui hash = {}
hash = { :vesi => 'märg', :tuli => 'kuum' }   # defineerib hash objekti ümber
puts hash[:tuli]                              # prindib ekraanile "kuum"

hash.each_pair do |key, value|                # või ka: hash.each do |key, value|
  puts "#{key} on #{value}"
end
# tagastab {:vesi =>"märg", :tuli=>"kuum"} ja prindib:
# vesi on märg
# tuli on kuum

hash.delete :vesi                             # kustutab paari :vesi => 'märg' ja tagastab "märg"
hash.delete_if {|key,value| value == 'kuum'}  # kustutab paari :tuli => 'kuum' ja tagastab {}

Tingimuslaused

If-lause:

# Genereerib suvalise arvu ning prindib välja kas tegemist on paaris- või paaritu arvuga
if rand(100).even?
  puts "Paaris"
else
  puts "Paaritu"
end

Plokid ja korduslaused

Rubys on kaks süntaksit koodiplokkide loomiseks:

{ puts 'Hello, World!' }
# või:
do
  puts 'Hello, World!'
end

Koodiploki saab anda meetodile argumendiks. Paljud meetodid kasutavad neid argumente:

File.open('fail.txt', 'w') do |fail|
  fail.puts 'Kirjutasin midagi.'
end # fail suletakse automaatselt

File.readlines('fail.txt').each do |rida|
  puts rida
end
# => Kirjutasin midagi.

Anonüümsed funktsioonid:

proc {|arg| puts arg}
Proc.new {|arg| puts arg}
lambda {|arg| puts arg}
->(arg) {puts arg}         # alates Ruby versioonist 1.9

Korduslaused vahemike ja järjendite puhul kasutavad plokke:

järjend = [1, 'hi', 3.14]
järjend.each {|item| puts item }
# prindib:
# 1
# 'hi'
# 3.14

järjend.each_index {|index| puts "#{index}: #{array[index]}" }
# prindib:
# 0: 1
# 1: 'hi'
# 2: 3.14

# (a..b) vahemik
(3..6).each {|num| puts num }
# prindib:
# 3
# 4
# 5
# 6

# (a...b) vahemik
(3...6).each {|num| puts num }
# prindib:
# 3
# 4
# 5

Klassid

Järgnev kood defineerib klassi nimega Inimene. Lisaks initialize meetodile, millega klass konstrueeritakse, on sellel veel kaks meetodit: üks, mis kirjutab üle võrdlusoperaatori <=> (nii, et Array#sort saab sorteerida vanuse järgi) ja teine, mis kirjutab üle #to_s meetodi (nii, et Kernel#puts saab väljundit vormindada). attr_reader on Ruby metaprogrammeerimise näide: attr_accessor defineerib nii getteri kui ka setteri meetodid, kuid attr_reader defineerib ainult getter-meetodi. Viimane lause meetodis on väärtus, mille see väljastab, seega ei ole vaja defineerida return lauset.

class Inimene
  attr_reader :nimi, :vanus
  def initialize(nimi, vanus)
    @nimi, @vanus = nimi, vanus
  end
  def <=>(person) # võrdlusoperaator sorteerimiseks
    @vanus <=> person.vanus
  end
  def to_s
    "#{@nimi} (#{@vanus})"
  end
end

grupp = [
  Inimene.new("Mari", 33),
  Inimene.new("Marina", 16),
  Inimene.new("Martina", 23)
]

puts grupp.sort.reverse

# prindib:
# Mari (33)
# Martina (23)
# Marina (16)

Inimene on siin konstant ja viitab Class objektile.

Erindid

Erindeid saab tekitada raise lause abil:

raise

Erindile saab juurde lisada ka mingi sõnumi:

raise "See on sõnum"

Võimalik on defineerida ka erindi tüüpi:

raise ArgumentError, "Mittesobivad argumendid!"
# või ka
# raise ArgumentError.new("Mittesobivad argumendid!")

Erindeid käsitletakse rescue lausega. See lause püüab kõiki erindeid, mis pärinevad StandardError klassist. Erindite püüdmisel saab kasutada ka else ja ensure lauseid:

begin
  # tee midagi
rescue
  # käsitle erindit
else
  # tee seda juhul kui erindit ei tekkinud
ensure
  # tee seda, vahet pole kas tekkis erind või mitte
end

StandardError ja Exception on Rubys eraldi klassid, StandardError pärineb Exceptionist, kuid kuna rescue käsitleb vaid erindeid, mis pärinevad StandardError klassist, ei pruugi ta alati kinni püüda kõiki erindeid. Selleks peab eraldi defineerima:

begin
  # tee midagi
rescue Exception
  # käsitle erindit 
end

Või kinni püüdma mõne kindla erindi:

begin
  # tee midagi
rescue RuntimeError
  # käsitle ainult RuntimeErrorit ja kõiki teisi sellest pärinevaid erindeid
end

Erindi objekti saab kätte sedasi:

begin
  # tee midagi
rescue RuntimeError => e
  # käsitle RuntimeErrorit ning tee midagi muutujaga e, näiteks
  puts e.to_s
end