«Ruby» har flere betydninger.

**Ruby** er et objektorientert programmeringsspråk som kombinerer syntaks inspirert av Perl med Smalltalks objektorienterte egenskaper. Språket deler også egenskaper med Python, Lisp, Dylan og CLU. Det er et tolket programmeringsspråk. Hovedimplementasjonen er fri programvare.

Historie
--------

Språket ble lagd av Yukihiro "Matz" Matsumoto, som startet jobben med Ruby den 24. februar 1993 og lanserte språket i 1995. Navnet «Ruby» ble valgt som en litt humoristisk referanse til Perl.

Ruby har blitt spesielt populært i webprogrammeringsmiljøer takket være utviklingsmiljøet Ruby on Rails.

Filosofi
--------

Ifølge skaperen ble Ruby utformet etter prinsippet om *færrest mulige overraskelser*. Med dette mener han at språket skal være fritt for feller og inkonsekvenser som preger andre språk.

Ruby er objektorientert, som vil si at alle databiter er et objekt. Dette omfatter typer, som andre språk ofte definerer som primitive datatyper, som for eksempel et heltall. Hver funksjon er en metode. Alle variabler er en referanse til et objekt, og ikke objektet selv. Ruby støtter arv og import av moduler som såkalte *MixIns* (å endre deler av funksjonaliteten i en klasse). Prosedyre-syntaks er inkludert, men alle slike prosedyrer skrevet utenfor en selvdefinert klasse blir gjort på klassen av type Object. Siden denne klassen er forelder til alle andre klasser, blir slike prosedyrer synlige for alle klasser og objekter.

Implementasjoner
----------------

Det finnes flere vanlige implementasjoner av Ruby. Den offisielle Ruby-tolkeren, ofte kalt MRI (Matz’ Ruby Implementation), er den mest utbredte etter Ruby versjon 1.9 (denne basert på YARV, en virtuell maskin-implementasjon som skal gi høyere ytelse).
JRuby er en versjon basert på Javas virtuelle maskin. Denne integreres lett med Java-baserte tjenerløsninger som for eksempel Tomcat og Glassfish, og kan sømløst kalle Java-API-er fra Ruby og vice versa.
Tilsvarende finnes også IronRuby, som kjører på .NET-/Mono-plattformen. Rubinius er en implementasjon basert på LLVM som virtuell maskin. Også MacRuby er basert på LLVM, men er kun tilgjengelig for Apples eget operativsystem, macOS. MacRuby har som mål å være et alternativ til Objective-C som utviklingsmiljø på Mac.

### Lisensiering

Ruby blir distribuert under GPL og Ruby License Arkivert 26. august 2011 hos Wayback Machine.. De øvrige implementasjonene distribueres under en rekke forskjellige lisenser for åpen kildekode.

Egenskaper
----------

* Objektorientert
* Avvikshåndtering
* Iteratorer
* Å sende blokker av kode som parameter
* Closures
* Overstyring av operatorer
* Automatisk fjerning av objekt som ikke lenger er i bruk (*garbage collection*)
* Flertrådshandtering
* Lasting av DLL-bibliotek (under Microsoft Windows)
* *Introspection* og *reflection*.
* Stort standardbibliotek.
* Støtter innsetting av avhengigheter.

### Ruby er objektorientert

Ruby støtter utvikling basert på klasser, og klasser kan arve hverandre:

```
class Person
  def set_name(n)
    @name = n
  end

  def name
    @name
  end
end

class Worker < Person
  def set_title(t)
    @title = t
  end

  def title
    @title
  end
end
```

Vi kan nå instansiere en arbeider slik:

```
w = Worker.new
w.set_name("Petter")
w.set_title("Overbuljongterningpakkmesterassistent")
```

Siden arbeideren er en person, har han et navn:

```
w.name
=> "Petter"
```

Han har også en tittel:

```
w.title
=> "Overbuljongterningpakkmesterassistent"
```

Vi kan spørre om objektet (arbeideren vår) er av en gitt klasse:

```
w.instance_of? Worker
=> true
```

Vi kan også spørre om objekter er av, eller arvet av en gitt klasse:

```
w.is_a? Person
=> true
```

Klasser som ikke oppgir en moderklasse arver automatisk klassen Object. Ruby støtter ikke multippel arv, men gjør bruk av såkalte *mixins* som lar en klasse gjøre bruk av andre klasser selv om de ikke arver dem direkte.

### Ruby støtter avvikshåndtering

Ruby definerer en rekke avviksklasser, og støtter også brukerdefinerte avvik. Avvik fanges opp av en *rescue*-linje i en *begin* – *end*-blokk, eller i en metodedefinisjon:

```
MyError = Class.new(RuntimeError)

def smell
  raise MyError.new("Pang!")
end

def safe_method
  smell
  puts "Denne linjen vil aldri kjøres..."
rescue RuntimeError => ex
  puts ex.message
  puts ex.class
end
```

Kjører vi *safe\_method* vil ruby svare slik:

```
Pang!
MyError
```

Kjører vi imidlertid *smell* direkte, så fanger vi ikke feilen og ruby skriver ut feilinformasjon og avslutter programmet.

Ruby mangler, per dags dato, full støtte for Unicode, men har delvis støtte for UTF-8. I versjon 2.0 er målet full støtte av unicode-strenger.

Mulige overraskelser
--------------------

Selv om Ruby er utformet etter prinsippet om *færrest mulige overraskelser* er det store forskjeller fra andre språk som C og Perl.

* Lokale variabler må ha navn som starter med små bokstaver, ellers blir de betraktet som konstanter.
* 0, "" (tom streng) og [] (tom liste/array) evalueres til sant (true). I C blir uttrykket 0 ? 1 : 0 tolket som 0. I Ruby blir dette tolket som 1.
* For å indikere flyttall er det ikke nok å legge til et punktum (99.). Fordi nummer kan forveksles med metoder må man legge til en ekstra null (99.0) eller oppgi konverteringen eksplisitt (99.to\_f).
* Det er ingen egen datatype for skrifttegn. I Ruby versjon 1.8 og tidligere kunne dette føre til et uventet resultat ved avkutting av strenger: "abc"[0] ga 97 som er den numeriske  ASCII-koden for det første tegnet i strengen. I Ruby versjon 1.9 og senere gir dette resultatet "a" som er mer som ventet.

Eksempler
---------

Et klassisk Hello World-eksempel:

```
puts "Hello World!"

```

Litt grunnleggende Ruby-kode:

```
# Alt er objekter
-199.abs # 199
"ruby is cool".length # 12
"Rick".index("c") # 2
"Nice Day Isn't It?".split(//).uniq.sort.join # "'?DINaceinsty"

```

### Lister

Et array:

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

a[2] # 3.14
a.reverse # [[4, 5], 2, 1, 3.14, "hi", 1]
a.flatten.uniq # [1, "hi", 3.14, 2, 4, 5]

```

En hash-tabell:

```
hash = {'water' => 'wet', 'fire' => 'hot'}
puts hash['fire'] 

hash.each\_pair do |key, value| 
 puts "#{key} is #{value}"
end

# Skriver ut: water is wet
# fire is hot

hash.delete\_if {|key, value| key == 'water'} # Sletter 'water' => 'wet'

```

### Blokker og iteratorer

To måter å opprette en kodeblokk:

```
{puts "Hello, World!"}

do puts "Hello, World!" end

```

Sende en blokk som parameter:

```
def remember &p
 @block =p
end
# Sender med en kodeblokk som parameter og navngir den
remember {|name| puts "Hello, "+ name + "!"}

# Kall funksjonen
@block.call("Johnny")
# Skriver ut "Hello, Johnny!"

```

Iterere over array og enumeratorer:

```
a =[1, 'hi', 3.14]
a.each {|item| puts item} # Skriver ut hvert element
(3..6).each {|num| puts num} # Skriver ut 1 -6.

```

Blokker fungerer med mange innebygde metoder:

```
IO.readlines('file.txt') do |line|
 # gjør noe med linjen her.
end

```

Kvadrere 1 til 10:

```
(1..10).collect {|x| x\*x} => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

```

### Klasser

Følgende kode definerer klassen Person. I tillegg til å initialisere den vanlige konstruktøren, har klassen to metoder: En for å overstyre `<=>`-operatoren for å sortere etter alder. Den andre overstyrer `to_s` for å få korrekt formatering.

```
class Person
 def initialize(name, age)
 @name, @age = name, age
 end

 def <=>(person)
 @age <=> person.age
 end

 def to\_s
 "#{@name} (#{@age})"
 end

 attr\_reader :name, :age
end

group = [ Person.new("John", 20), 
 Person.new("Markus", 63), 
 Person.new("Ash", 16) 
 ]

puts group.sort.reverse

```

Koden over skriver ut en liste sortert med den eldste først:

```
Markus (63)
John (20)
Ash (16)
```

Referanser
----------

1. ↑   www.ruby-lang.org[Hentet fra Wikidata]
2. ↑  
«An Interview with the Creator of Ruby». Besøkt 5. august 2010.
3. ↑  «YARV - Yet Another Ruby VM». Arkivert fra originalen 8. mars 2009. Besøkt 28. juli 2010.
4. ↑  
«Using Java Classes in JRuby». Arkivert fra originalen 6. august 2009. Besøkt 28. juli 2010.
5. ↑  
«MacRuby Home». Besøkt 28. juli 2010.
6. ↑  «Ruby 1.9.1 release notes». Arkivert fra originalen 17. januar 2022. Besøkt 1. mars 2011.

Eksterne lenker
---------------

* (en) Offisielt nettsted Rediger på Wikidata

* (bg) Mate-URL Rediger på Wikidata

* (de) Mate-URL Rediger på Wikidata

* (en) Mate-URL Rediger på Wikidata

* (es) Mate-URL Rediger på Wikidata

* (fr) Mate-URL Rediger på Wikidata

* (id) Mate-URL Rediger på Wikidata

* (it) Mate-URL Rediger på Wikidata

* (ja) Mate-URL Rediger på Wikidata

* (ko) Mate-URL Rediger på Wikidata

* (pl) Mate-URL Rediger på Wikidata
* Ruby Application Archive Arkivert 5. august 2013 hos Wayback Machine. (RAA)
* JRuby
* The Ruby Documentation project
* Ruby Forum
* RubyForge
* Norske ruby klubb
* Full Ruby on Rails Tutorial

| * v
* d
* r
Programmeringsspråk |
| --- |
| Tidslinje |
| A# **·** ActionScript **·** Ada **·** Alef **·** ALGOL **·** ALGOL 58 **·** ALGOL 60 **·** ALGOL 68 **·** ALTRAN **·** APL **·** AppleScript **·** Argus **·** Assembler **·** Autokode **·** awk **·** B **·** BASIC **·** BCPL **·** BETA **·** BitC **·** BLISS **·** Bourne Shell **·** C **·** C++ **·** C-- **·** CHILL **·** C# **·** C shell **·** Caml **·** Ch **·** Cilk **·** Cilk++ **·** Cilk Plus **·** Clarion **·** Clipper **·** CLISP **·** Clojure **·** CLU **·** COBOL **·** COMAL **·** Common Lisp **·** Concurrent C **·** Concurrent Euclid **·** Concurrent Pascal **·** C shell **·** D **·** Delphi **·** Dylan **·** ECMAScript **·** Eiffel **·** Emacs Lisp **·** Erlang **·** Euclid **·** F\* **·** F# **·** Forth **·** Fortran **·** GNU Common Lisp **·** GNU Pascal **·** Go **·** Haskell **·** HyperTalk **·** Incr Tcl **·** INTERCAL **·** Interlisp **·** Java **·** JavaScript **·** JRuby **·** LaTeX **·** Legoscript **·** LilyPond **·** Limbo **·** Lisp **·** LPC **·** Lua **·** Lynx **·** Mary **·** MATLAB **·** Mesa **·** ML **·** MML **·** Modula **·** Modula-2 **·** MUMPS **·** Objective-C **·** Objective-C++ **·** OCaml **·** OpenVera **·** O'Haskell **·** Pascal **·** Perl **·** PHP **·** Pike **·** PL/I **·** Plankalkül **·** PLEX **·** Prolog **·** Protel **·** Pure Data **·** Python **·** R **·** Ratfor **·** REXX **·** RTL/2 **·** Ruby **·** Rust **·** SAS **·** Scala **·** Scheme **·** Scratch **·** Simula **·** SML **·** Smalltalk **·** SNOBOL **·** Tcsh **·** Tcl **·** TECO **·** TOM **·** Turbo Basic **·** Turbo Pascal **·** Verilog **·** Visual Prolog **·** Turing **·** TypeScript **·** Vala **·** VHDL **·** Visual Basic **·** Flere.. |
| 
* Kategori **Kategori**

 |

|  |  |
| --- | --- |
| Oppslagsverk/autoritetsdata | Store Danske Encyklopædi **·** GND **·** LCCN **·** BNF **·** BNF (data) **·** SUDOC **·** NKC **·** BNE
 |