Ruby (programmeringsspråk)

Rubin
logotyp
Officiell logotyp
Grundläggande information
Paradigm : multi-paradigmatisk, djupt integrerad objektorientering
Utgivningsår: 1995
Designer: Yukihiro Matsumoto
Utvecklare: Yukihiro Matsumoto och andra
Nuvarande  version 3.0.1   (5 april 2021)
Skrivning : stark , dynamisk (" anttypning ")
Viktiga implementeringar : MR / CRuby (YARV), JRuby , Rubinius (se nedan )
Påverkad av: Smalltalk , Perl , Python , Lisp , CLU , Eiffel , Ada , Dylan , JavaScript
Påverkade: Crystal , D , Elixir , Groovy , Rust , Swift
Operativsystem : plattformsoberoende
Licens : 2-klausul BSD och egen (se användarvillkor )
ruby-lang.org

Ruby (engelska för Ruby ) är ett programmeringsspråk på hög nivå somdesignadesav japanen Yukihiro Matsumoto imitten av 1990-talet.

Ruby är objektorienterad , men stöder flera andra programmeringsparadigm (inklusive procedurell och funktionell programmering och samtidighet ), erbjuder dynamisk maskinskrivning , reflektion och automatisk sophämtning . Ett Ruby -program tolkas vid körning . År 2012 standardiserades Ruby -specifikationen som den internationella standarden ISO / IEC 30170.

Ursprung och historia

Ruby Creator, Yukihiro Matsumoto (2007)

Yukihiro "Matz" Matsumoto började arbeta med sitt eget språk 1993 och släppte den första versionen av Ruby, 0,95, den 21 december 1995. Han valde namnet, som härrör från ädelstenens rubin , som en anspelning på programmeringsspråket Perl . Matsumotos mål med att skapa det nya språket var att syntetisera delar av programmeringsspråken Perl , Smalltalk , Eiffel , Ada och Lisp, som han uppskattade , och att förena funktionella och imperativa programmeringsparadigm . Dessutom ska språket vara mer objektorienterat än Python och samtidigt mer kraftfullt än Perl . Flexibilitet, uttrycksfullhet och enkelhet spelade också en viktig roll.

Förutom de tekniska egenskaperna var Matsumotos särskilt viktiga sak med Ruby den känslomässiga påverkan på användare, medutvecklare och honom själv. Matsumotos syn på detta är följande:

”Naturligtvis skiljer sig Ruby från Perl eller Python på många sätt; det är trots allt Rubys existensberättigande. Rubys främsta mål är "glädje". Så vitt jag vet finns det inget annat språk som fokuserar så mycket på glädje. Rubys slutmål är att behaga - språkdesigners, användare, språkinlärare, alla. Glädje är dock inte allt. Ruby har också många användningsområden. Om du inte kunde använda det skulle det inte vara roligt heller. "

- Yukihiro Matsumoto : Förord ​​av språkskaparen i "Ruby プ ロ グ ラ ミ ン グ 入門" (översatt)

I Japan blev Ruby snabbt ryktbar efter att den släpptes. I väster om programmeringen hjälpte boken Programming Ruby (2000) (känd som Pickaxe -boken som en hänvisning till illustrationen på omslaget) och webbramen Ruby on Rails (2004) genombrott. Under de följande åren ökade dokumentation och litteratur på engelska och tyska. Kärnutvecklarnas lingua franca förändrades från japanska till engelska. Idag behålls språket som ett projekt med öppen källkod och är föremål för olika publikationer och kurser. Releaser med nya funktioner sker vanligtvis årligen vid jul.

En milstolpe i utvecklingen av Ruby var version 1.9 2007, som med många förändringar blev ganska oförenlig med de tidigare versionerna. Semantiken för vissa konstruktioner har förändrats i den här versionen. Den Tolken var helt omskriven, vilket gjorde Ruby program mycket snabbare. Strängar fick separata teckenkodningar , variabler i block blev block-lokala, IPv6- stöd och några syntaktiska förenklingar infördes.

Med Ruby 2.0 är nyckelordsparametrar (t.ex.: introducerade 0.step(by: 5, to: 20)), gardinerna (förbereder) moduler och behovsutvärdering (lat utvärdering) som introduceras av iteratorer. Dessutom har standardteckenkodningen ställts in på UTF-8 . Ruby 2.1 introducerade förfiningar (en metod för att begränsa klassöverträdelser lokalt). I Ruby 2.2 ersattes den befintliga sophämtaren med en inkrementell. Med Ruby 2.3 är det möjligt att automatiskt skapa skrivskyddade strängar och en ny operatör &. (Safe-Navigation-Operator) för att kringgå Nile-kontroller har införts. I Ruby 2.4 har Fixnum- och Bignum -klasserna standardiserats. Från och med Ruby 2.5, undantag kan fångas i do-end block utan separata delblock. Ruby 2.6 gav den första koden för en valfri JIT -kompilator och lade till Bundler (se nedan) till standarddistributionen. Ruby 2.7 lade till omfattande mönstermatchning och lite syntaktisk lättnad till språkkärnan. Varje ny Ruby -version från 1.9 och framåt gav också olika hastighetsoptimeringar med sig. Dessutom utökade varje version standardbiblioteket med användbara metoder. Nedåtkompatibilitet säkerställdes alltid , men inte alltid uppnåddes 100 procent.

Ruby 3.0, släppt den 25 december 2020, är ​​den första versionen som uppfyller kraven som kallas "Ruby 3x3": tre gånger högre exekveringshastighet än Ruby 2.0 (via JIT -kompilator), samtidighet utan GIL (men fortfarande experimentell) och statisk typanalys (valfritt). Själva uppdateringen 3.0 är dock inget större steg än de tidigare årsversionerna och är nedåtkompatibel med Ruby 2.x.

egenskaper

Allt är ett objekt

Ruby är ett programmeringsspråk som, samtidigt som det stöder många andra programmeringsparadigm, i grunden är objektorienterat. Konkret betyder detta att i Ruby är varje värde ett objekt och varje funktion är en metod (dvs. tilldelas en klass). Det finns inga undantag för primitiva datatyper som i många andra objektorienterade programmeringsspråk. Klasser är också objekt. Objekt lagrar instansvariabler och har en klass. Klasser är objekt som lagrar metoder och har en arvshierarki. Instansvariabler kan endast nås med metoder. 

class TestKlasse
end
test_objekt = TestKlasse.new

puts 1.class            # => Integer
puts "text".class       # => String
puts test_objekt.class  # => TestKlasse
puts TestKlasse.class   # => Class
puts Class.class        # => Class

Om "funktioner" är definierade i Ruby, dessa är faktiskt metoder som läggs till för objektet objektet . I Ruby ärver alla objekt implicit från Object , varför "funktioner" definierade på detta sätt är tillgängliga i varje objekt och är därför allestädes närvarande. Dessa funktioner är dock markerade som privata , vilket innebär att de inte kan anropas från utsidan på ett objekt. 

# Definiere „Funktion“
def meine_funktion
  puts "Hier bin ich"
end

# Kann in andern Objekten wie eine Funktion benutzt werden
class ABC
  def gib_meine_funktion_aus
    meine_funktion
  end
end
mein_abc = ABC.new
mein_abc.gib_meine_funktion_aus # => Hier bin ich
mein_abc.meine_funktion # => Fehlermeldung, private method `meine_funktion' called

Eftersom objekt är dynamiska i Ruby kan du också programmera prototypbaserat med Ruby. Detta betyder ungefär att objekt kan ha sina egna metoder (utanför de som anges av klassen) och kan kopieras och ändras (eftersom endast klasser kan innehålla metoder skapas en ny dold klass bara i bakgrunden för det ena objektet). 

auto1 = Object.new
def auto1.beschleunigen
  puts "brumm brumm brumm"
end

auto1.beschleunigen # => "brumm brumm brumm"

auto2 = auto1.clone
def auto2.bremsen
  puts "quietsch"
end

auto2.beschleunigen # => "brumm brumm brumm"
auto2.bremsen       # => "quietsch"

block

På de flesta programmeringsspråk på hög nivå är det möjligt att vidarebefordra funktioner i vilken form som helst som parameterlogik, det vill säga genom förstklassiga funktioner eller förstklassiga objekt (vars metoder sedan ger logiken). Detta är inte annorlunda i Ruby, men Ruby har starkt optimerat specialfallet där exakt en funktion skickas, syntaktiskt (och även när det gäller datorkraft). Detta specialfall kommer att blockera kallad, menad som en blockprogrammeringslogik som måste använda funktionen.

Block överförs till funktioner som separata parametrar och följer som det sista argumentet, avgränsade av lockiga parenteser eller sökorden gör och slutar . I det följande, den gånger metoden är av objektet 10 kallas och ett block överförs. Båda samtalen är identiska. 

10.times {
  puts "Hallo Welt!"
}
10.times do
  puts "Hallo Welt!"
end

Dessutom kan block ges parametrar och de har också ett returvärde. Nyckelordet avkastning används inom den kallade metoden för att kalla blocket passerat . Om avkastningsparametrar specificeras skickas dessa till blocket, som antingen kan deklarera dem som lokala variabler i början eller ignorera dem. Block (liksom metoder) returnerar automatiskt blockets sista uttryck som ett returvärde ( men du kan också hoppa tillbaka till andra platser med paus och nästa ). 

def methode_die_block_aufruft(übergebener_parameter)
  eigene_variable = "Hallo"
  rückgabe = yield eigene_variable, übergebener_parameter
  if rückgabe == "ok"
    puts "☺"
  end
end

# Aufruf
methode_die_block_aufruft("aus Ruby") do |p1,p2| # die Blockargumente werden innerhalb || in Block-lokale Variablen umgewandelt
  puts p1 + " " + p2 + "!"
  "ok"
end
# Zuerst wird im Block „Hallo aus Ruby!“ ausgegeben,
# dann in der Methode ☺, da der Rückgabewert „ok“ war

Block kan också konverteras till funktionsobjekt. Om a & skrivs framför den sista parametern i parameterlistan för en metod, konverterar Ruby det överförda blocket till en proc (ett funktionsobjekt). Alternativt kan procs också skapas manuellt med sökorden proc , lambda och -> . Dessa objekt kallas med metoderna call , [] eller . () . Eftersom Ruby endast använder runda parenteser för gruppering kan procs inte kallas (som vanligt på andra programmeringsspråk) proc_name(). 

def mache_block_zu_proc &block
  block # ist der Rückgabewert, da letzter Ausdruck
end
a = mache_block_zu_proc{|a,b| a + b}
b = proc {|a,b| a - b} # ein return innerhalb des Blocks verlässt die beinhaltende Methode, break nur den Block
c = lambda {|a,b| a * b} # wie proc, aber return innerhalb des lambdas verlässt nur diesen Block
d = -> (a,b) {a / b} # neue Schreibweise für lambda, runde Klammern sind optional
a.call(1,2) # => 3
b[1,2]      # => -1
c.(1,2)     # => 2

# Beispiel für funktionale Programmierung
e = d.curry.(8) # neues Proc das den (oder die) ersten Parameter (den Dividenden hier) als 8 setzt
e.(2)       # => 4
# mit & können Proc-Objekte (eigentlich jede Klasse die eine call Methode hat) wieder in Blöcke umgewandelt werden
[8,4,2,1].map(&e) # => [1, 2, 4, 8]

Alla block är stängningar , så de lagrar t.ex. B. status för lokala variabler om de krävs permanent inom blocket.

Mixins

Ruby behärskar medvetet inte multipel arv, utan erbjuder istället ett koncept som kallas mixins (tyska: admixtures). Mixins är en samling metoder som kan läggas till i vilken klass som helst . En klass kan innehålla valfritt antal mixins. Mixins läggs till i arvshierarkin mellan klass och superklass i den ordning de skrevs. Alternativt är det också möjligt att hänga mixins framför den verkliga klassen (användbart för bland annat aspektorienterad programmering ). För att definiera mixins använder Ruby moduler, som är kvasiklasser (dvs. samlingar av metoder) som inte kan instansieras och namnområden i en. 

class Tier
  def sagt
    puts "#{self.class} sagt nichts" # "text#{logik}text" ist Rubys Textinterpolation
  end
end

module KannSchwimmen # Module, d.h. KannSchwimmen.new geht nicht
  def schwimmt
    puts "#{self.class} schwimmt" # self gibt die Instanz zurück,
  end                             #  jedes Objekt hat eine Methode .class die das Klassenobjekt zurück gibt
end

module KannNichtSchwimmen
  def schwimmt
    puts "#{self.class} geht unter"
  end
end

class Fisch < Tier # Vererbung wird durch den Kleiner-Als-Operator gekennzeichnet
  include KannSchwimmen # füge KannSchwimmen zwischen Fisch und Tier ein
end

class Vogel < Tier
  include KannNichtSchwimmen
  def sagt # übliches Vererben, überdecke sagt-Methode von Tier
    puts "#{self.class}: Piep"
  end
end

class Mensch < Tier
  include KannSchwimmen
  def sagt
    puts "#{self.class}: Ich kann mich besser ausdrücken"
  end
end

class NichtSchwimmer < Mensch
  prepend KannNichtSchwimmen # hänge KannNichtSchwimmen vor NichtSchwimmer ein,
end                          # dh, überdecke die schwimmt-Methode

fisch = Fisch.new
mensch = Mensch.new
vogel = Vogel.new
nicht_schwimmer = NichtSchwimmer.new

fisch.sagt                # => Fisch sagt nichts
vogel.sagt                # => Vogel: Piep
mensch.sagt               # => Mensch: Ich kann mich besser ausdrücken
nicht_schwimmer.sagt      # => NichtSchwimmer: Ich kann mich besser ausdrücken
puts
fisch.schwimmt            # => Fisch schwimmt
vogel.schwimmt            # => Vogel geht unter
mensch.schwimmt           # => Mensch schwimmt
nicht_schwimmer.schwimmt  # => NichtSchwimmer geht unter

Öppna klasser

Alla klasser är öppna i Ruby, vilket innebär att alla metoder kan utbytas senare i programmet. Detta gäller också alla rubininterna klasser. För att skriva över metoder behöver du bara skapa en ny klass med samma namn som klassen som ska skrivas över. Ruby byter eller lägger sedan till de nyligen definierade metoderna. Denna teknik är mycket kraftfull, men möjliggör också svåråtkomliga fel, särskilt i större projekt. Av denna anledning kallas det också något pejorativt apa -lapp . Förfiningar ger en åtgärd för de problem som uppstår , en möjlighet att begränsa överskrivningen lokalt. Vorzuhängen den tidigare presenterade metoden, de önskade modulklasserna (prepend) , är vanligtvis den säkra versionen (och möjligheten erbjuder också den täckta metoden att ringa direkt). 

class Numeric # ruby-interne Klasse
  def inverse # neue Methode, berechne den Kehrwert
    1.0 / self
  end
end

5.inverse # => 0.2

Domänspecifikt språk

Ruby används ofta för att skapa domänspecifika språk . Det här är textmoduler som ser mindre ut som programkod och mer som ett uppmärkningsspråk , men som faktiskt är normal Ruby -kod. Detta möjliggörs å ena sidan av den flexibla noteringen Ruby, till exempel parenteser efter metodanrop eller semikolon i slutet av raden är valfria. Å andra sidan erbjuder Ruby många möjligheter till metaprogrammering , vilket gör det möjligt att få överflödiga uttryck att försvinna och ändra programmet bakom kulisserna. Som ett exempel, konfigurationen av en testfabrik för FactoryBot : 

FactoryBot.define do
  factory :user do
    first_name "Max"
    last_name  "Mustermann"
    admin false
  end
  factory :admin, class: User do
    first_name "Admin"
    last_name  "Root"
    admin true
  end
end

Kraftfullt standardbibliotek

Kärnklasserna (sträng, heltal, float, array, hash, range, regexp) har en mängd metoder som kan användas omedelbart i alla rubinprogram. Den frekventa användningen av block i synnerhet gör att långa program kan reduceras till några rader med dessa metoder, varför Ruby är väl lämpad för att visa bevis på koncept . Enumerable -modulen , som ger många funktionella programmeringskoncept direkt in i Ruby -kärnan, sticker ut särskilt . Enumerable kan integreras i alla objekt som representerar en iterabel behållare och implementerar varje metod, t.ex. klasserna Array, Hash och Range. För slingor är därför oftast onödiga i Ruby. Metoderna reducera , räkna , sortera_by , varje_skiva och karta som visas nedan är alla metoder från Enumerable och kan därför enkelt läggas till klasser som du har skapat själv. 

# summiere die zahlen 1 bis 100 (ohne Summenformel), reduce entspricht fold aus der funktionalen Programmierung
(1..100).reduce{|counter,number| counter + number} # (1..100).sum geht auch
# Array aus den Zahlen von 0 bis 30 in 5er Schritten
(0..30).step(5).to_a
# Anzahl der Zeilen einer Datei die leer sind (ohne die Datei komplett in den Arbeitsspeicher zu laden)
IO.foreach("Dateiname").count{|line| line =~ /^\s*$/}
# Sortiere Array nach Länge der Nachnamen
["Max Mustermann", "John Doe", "Tarou Yamada"].sort_by{|name| name.split.last.length}
# Schreibe jedes dritte Wort im Satz in Großbuchstaben
"Franz jagt im komplett verwahrlosten Taxi quer durch Bayern.".split.each_slice(3).map{|drei_wörter| drei_wörter.last.upcase!; drei_wörter}.flatten.join(" ")

Förutom de integrerade modulerna levereras Ruby med många moduler som standard. Till exempel är stöd för JSON , YAML , HTTP , riktmärken, primtal, säkra slumpmässiga nummer, OpenSSL och loggning omedelbart tillgängligt.

Metaprogrammering

Ruby erbjuder omfattande möjligheter för metaprogrammering . Så det är z. B. möjligt att generera metoder, utbyta instansvariabler, ändra arvshierarkin eller redigera konstanter. Det är dock inte möjligt att ändra syntaxen eller lägga till ytterligare operatörer. En metod för att automatiskt generera setrar och getters listas här som ett exempel ( redan inkluderat i standarden under namnen attr_reader , attr_writer , attr_accessor ). 

class Object # Monkey-Patching aller Klassen
  def self.getter *args # self ist hier Object, es wird eine Klassenmethode erzeugt
    args.each do |arg| # es wird durch alle Parameter iteriert
      define_method arg do # define_method(arg){block} erzeugt eine neue Methode des Names arg mit dem Inhalt block
        instance_variable_get("@#{arg}".to_sym) # instance_variable get gibt den Wert der Instanzvariablen des übergeben Namens zurück
      end                                       # \- "@#{arg}" hängt ein @ vor den Inhalt von arg, to_sym wandelt den String um in ein Symbol
    end
  end
  def self.setter *args # *args packt alle Parameter in ein Array namens args
    args.each do |arg|
      define_method :"#{arg}=" do |new_value|              # define_method übergibt dem Block die übergeben Parameter
        instance_variable_set("@#{arg}".to_sym, new_value) # \- setter-methoden enden mit einem =
      end
    end
  end
end

class PaarMit2
  def initialize links # Konstruktor
    @links = links # Instanzvariblen werden bei Erwähnung in einer beliebigen Methode automatisch erzeugt
    @rechts = 2
  end
  getter :links, :rechts
  setter :links
end

paar = PaarMit2.new(4) # new ruft immer den Konstruktor auf
paar.links       # => 4
paar.rechts      # => 2
paar.links = 9   # => 9
paar.links       # => 9
paar.rechts = 8  # => Fehler: NoMethodError (undefined method `rechts=')

Dessa tekniker är också bra för att felsöka applikationer eller analysera dåligt dokumenterade applikationer eller bibliotek. Till exempel, när metoden anropas, svarar varje objekt methodsmed en lista över alla dess metoder och instance_variablesreturnerar en lista över alla instansvariabler.

Integration i Unix

Precis som Perl kan Ruby integreras direkt i Unix -skalets pipeline . Detta möjliggörs av kommandoradsparametrarna i Ruby -tolken, som gör att programlogik och vanligt programbeteende kan definieras (vanligtvis samma operation som ska utföras på varje rad). Ruby utökar Unix -standardverktygen med avancerade metoder för textanalys och ordbehandling.

Ruby erbjuder också möjlighet att enkelt starta processer inom ett program, styra deras ingång och läsa ut utgångs- och returvärden. Koden inom `` skickas direkt till Unix -skalet. Till exempel sparar kommandot os_string = `uname -a`operativsystemets namn direkt i en Ruby -variabel. Returvärdet för det senaste programanropet $?sparas automatiskt i den globala variabeln, analogt med skalet . Signalhantering, uttag och trådar stöds också direkt av språkkärnan utan ytterligare bibliotek. För att påskynda bearbetningen finns det en modul i Ruby som heter FileUtils , som kartlägger mycket av funktionaliteten i många Unix -filhanteringsprogram ( rm , cp , chmod ) direkt i Ruby.

Syntax och grunder

Namnkonvention

Ruby följer den vanliga metoden för metod- och variabelnamn, ett namn måste börja med en liten bokstav eller understreck, sedan kan alla bokstäver (enligt Unicode ), siffror och understreck följa. Metoder kan också sluta med ett utropstecken eller frågetecken. Enligt den vanliga konventionen fungerar den förra som en indikation på att denna metod är en skarpare version av samma metod utan ett utropstecken (ändrar objektets tillstånd, kastar fel, ...), det senare betyder att funktionen returnerar en booleskt (sant eller falskt). Om ett variabelnamn börjar med stor bokstav är det en konstant. Variabler kan också börja med ett specialtecken som beskriver giltighetsområdet.

Variabel identifierare

Ruby skiljer mellan fem giltighetsområden:

  • Vanligtvis är en variabel giltig lokalt inom det omgivande blocket eller metoden.
  • En @tidigare variabler deklarerade instansvariabel, de är sedan permanent instansen tilldelad och är endast synliga i denna. Instansvariabler kan endast nås utifrån med metoder. Åtkomst till icke-existerande instansvariabler ger ett fel, men ger noll avkastning
  • Ett föregående @@gör variabler klassvariabler som tillhör den omgivande klassen.
  • Med $variabler blir globala och är därmed synliga i hela programmet.
  • Giltighetsintervallet för konstanter beror på det lokala häckdjupet och kan ::specificeras med

Metodsamtal och uttryck

I Ruby är metodsamtal inte nödvändigtvis markerade med följande parenteser. gets.chompär därför likvärdig med gets().chomp(). Om metoder kräver parametrar måste dessa sättas inom parentes om en annan operation ska utföras på resultatet. "a,b,c".split ","är ok, "a,b,c".split(",").join(" ")men behöver absolut det första paret av fästen. Eftersom parentes också används för gruppering bör det aldrig placeras ett mellanslag mellan metodnamnet och parentes när metoden anropas ( [1,2].join␣("|") * 2 != [1,2].join("|") * 2 => [1,2].join(("|") * 2) != ([1,2].join("|")) * 2 => "1||2" != "1|21|2").

Varje sats bildar ett uttryck som kan tilldelas en variabel. Individuella uttalanden separeras med radbrytningar eller semikolon. Det sista uttrycket inom en metod bildar automatiskt sitt returvärde. Det är dock också möjligt att hoppa tillbaka tidigt med sökordet return .

Datatyper

De elementära datatyperna har bekvämare konstruktörer än de vanliga Klasse.new

  • Sträng: "Text", 'Text'eller %{Text} text
  • Heltal: 3(tiosystem) 0775eller 0o775(oktalsystem), 0xFF(hexadecimalt system) 0b1001(binärt system) heltal (obegränsad storlek)
  • Float: 3.0 floating point number (begränsad precision)
  • Rationellt: 1/2r Rationellt nummer
  • Komplex: 1 + 1i komplext tal
  • Array: [1,2,3] Collection, kan innehålla valfritt antal olika datatyper
  • Hash: { 1 => "eins", 2 => "zwei" } Tilldelning, tilldelar exakt ett värde till varje värde framför pilarna (nyckel)
  • Regexp: /\A(eins|zwei)\z/eller %r{\A(eins|zwei)\z} reguljärt uttryck
  • Område: 1..3eller 1...4(exklusive rätt element) intervall
  • Symbol: :zeichen Symbol, se nedan

Dynamiska strängar

Som standard kan strängar ändras i Ruby; Det vill säga ett strängobjekt kan ändra dess värde vid körning. text = "Felar"; text[2..3] = "hle"; puts textändrar värdet på textdirekt (och returnerar fel ). Många strängmetoder är tillgängliga både i en modifierande variant och i en variant som skapar ett nytt strängobjekt. 

a = "ABC"
b = a.downcase
puts a, b # => ABC abc
a.downcase!
puts a, b # => abc abc

Liksom alla Ruby -objekt kan strängar freezefrysas genom att anropa metoden (t.ex. "ABC".freeze) och är sedan oföränderliga.

Symboler

Denna något ovanliga och kontroversiella datatyp är en slags blandning av heltal och sträng. Det fungerar främst som ett minneshjälpmedel för nycklar med hash, eftersom dynamiska strängar är opraktiska här och heltal kräver lite minne. Symboler har inte textmanipuleringsmetoderna för String, men kan när som helst konverteras till strängar. Om symboler i hash används som nycklar kan en förenklad notation användas. Istället kan { :a => 1, :b => 2 }du också { a: 1, b: 2 }skriva. Symboler används också ofta internt i Ruby, så metoder kan också kallas med deras symbolnamn: 1 < 4kan också 1.send(:<, 4)skrivas som. Enkla block som bara kallar en metod för det överförda objektet kan skrivas på ett förenklat sätt med hjälp av symboler, varigenom symbolen anger metoden som ska kallas. [1,2,3].map{|i| i.to_s}kan också [1,2,3].map(&:to_s)skrivas som (& konverterar symbolen till ett block).

Sanningsvärden

I Ruby finns det tre olika sanningvärden true, falseoch nil. Nil står för ett saknat resultat och, liksom falskt, bedöms det som falskt . Sant och alla andra objekt utvärderas som sanna . puts "Ja!" if 0så utvärderas till sant , "Ja!" matas ut.

Felhantering

På de flesta programmeringsspråk måste programdelen som ska kontrolleras för fel uttryckligen markeras (vanligtvis med hjälp av sökorden try and catch ); i Ruby, för de vanligaste fallen, innehåller programdelen hela metoden eller hela blocket, inget extra området måste markeras. Om en avgränsning skulle vara nödvändig kan området markeras med början och slut . 

def gib_summe_aus arg1, arg2
  # Methodenlogik
  unless arg1.is_a?(Numeric) && arg2.is_a?(Numeric)
    raise ArgumentError.new("Bitte nur Zahlen eingeben") # raise wirft Fehler
  end
  puts arg1 + arg2
rescue ArgumentError => e # Fange ArgumentError ab
  puts "Es ist ein Fehler bei der Parameterübergabe aufgetreten"
rescue => e # Fange alle weiteren Fehler ab
  puts e.message
ensure # wird auf jeden Fall ausgeführt
  puts 'Methodenende'
end

Alternativa förhållanden / slingor

Villkor och slingor ger både postfix -notation och sitt eget sökord för det inversa (inspirerat av Perl ). 

a = 5
if a < 10;  puts a; end
puts a if a < 10 # Suffixform
unless a >= 10; puts a; end # Invers
puts a unless a >= 10 # Invers + Suffixform

while a < 10;  puts a;  a += 1; end
(puts a; a+=1) while a < 20 # Suffixform
until a >= 30;  puts a;  a += 1; end # Invers
(puts a; a +=1) until a >= 40 # Invers + Suffixform

Vanliga uttryck

Ruby innehåller reguljära uttryck direkt i språkkärnan. Ruby använder sin egen regex -motor som heter Onigmo , vars syntax och funktionalitet för det mesta är kompatibel med PCRE . Dessutom är det möjligt att interpolera Ruby -variabler direkt i reguljära uttryck och använda valfri programlogik genom block för sökning och ersättning. Till exempel lägger följande kommando till alla nummer i en text i taget:puts "test, 1, 2, 3".gsub(/(\d+)/){|zahl| zahl.to_i + 1} # => test, 2, 3, 4

Konstanter

I Ruby är konstanter alla variabler som börjar med stor bokstav. Alla klasser och moduler är därför konstanter. Det speciella med konstanter i Ruby är deras häckning. Konstanter inom konstanter kan ::kallas med och är inte föremål för åtkomsträttigheter (t.ex. metoder eller instansvariabler). Det är därför moduler kan användas som namnområden, alla variabler förblir dolda i dem, alla konstanter (t.ex. klasser) kan kvalificeras (till exempel MeinModul::MeineKlasse.new) via modulnamnet .

Komponenter

Interaktivt Ruby Shell

Interactive Ruby ( irb ) är en Read-Eval-Print Loop (REPL) med vilken användaren kan programmera Ruby interaktivt. Irb levereras med Ruby -tolk och kan användas för analys och testning: 

irb(main):001:0> (5 + 7) * 2
=> 24
irb(main):002:0> ((5 + 7) * 2).to_s.reverse
=> "42"
irb(main):003:0> "Ein Beispielstring".size
=> 18

Som ett alternativ till Irb finns Pry , en REPL, som ger mycket djupare möjligheter för introspektion och felsökning .

RDoc och ri

RDoc är ett dokumentationsverktyg för programvara som automatiskt skapar HTML -dokumentationsfiler från Ruby- och C -källtexter . Dessutom skapas en databas som kan sökas med ri -verktyget. RDoc och ri ingår i standarddistributionen och levereras tillsammans med tolk.

Räfsa

Rake är Ruby Make och är ett alternativ till att från C . Eftersom det inte finns någon kompileringsfas i Ruby används rakefiler för att automatisera repetitiva uppgifter, t.ex. generera dokumentation, ladda upp filer eller packa projekt. Precis som Make kan rake lösa beroenden, om uppgift A måste slutföras först för uppgift B, utför raken automatiskt uppgift A. Rake är ett domänspecifikt språk ; Det vill säga att den kan läsas bekvämt som ett markeringsspråk, men erbjuder Rubys fulla kapacitet.

Pakethantering

Rubinbibliotek förpackas vanligtvis som ädelstenar (RubyGems) och publiceras på rubygems.org, det centrala pärlregistret. RubyGems löser automatiskt de beroenden som anges i paketet rekursivt under installation eller uppdateringar och erbjuder till och med möjlighet att tillhandahålla paket i olika versioner samtidigt. Sedan Ruby 1.9 har Rubygems varit en del av standard Ruby -biblioteket. Idag används det mestadels tillsammans med Bundler (också en del av standardbiblioteket, sedan Ruby 2.6), ett program som tar ögonblicksbilder från en samling pärlor och kan återställa detta arrangemang på andra maskiner (eller andra projektmappar).

Implementeringar

Referensimplementering

Referensimplementeringen av Ruby designades av Yukihiro "Matz" Matsumoto som tolk i C. Detta brukar kallas MR (Matz's Ruby Interpreter) eller CRuby och är för närvarande den mest utbredda. Kärnan är YARV (Yet Another Ruby VM) , en virtuell maskin . Istället för att köra ett Ruby -program direkt översätts det först till bytekod och tolkas sedan av YARV, vilket resulterar i en hastighetsfördel. Denna version innehåller också en kraftfull regexp- motor som heter Oniguruma och stöder multibyte-teckenuppsättningar som UTF-8 .

Den officiella tolken körs på följande operativsystem:

Alternativa implementeringar

Det finns många alternativa Ruby -implementeringar av varierande omfattning och mål:

  • JRuby , en ny implementering av Ruby -tolken i Java med syftet att sömlöst integrera Ruby i Java -plattformen . JRuby är nästan helt kompatibel med Ruby 2.3. JRuby är också kompatibel med vissa Ruby-tillägg från Rubinius (Foreign Function Interface, Multi-VM-API), men inte med C- tillägg från CRuby.
  • Rubinius , enimplementering inspireradav Smalltalk-80 . Förutom den virtuella maskinen är Rubinius helt och hållet skrivet i Ruby. Rubinius är nästan helt kompatibel med Ruby 2.3. Rubinius använder den virtuella maskinen på låg nivå (LLVM) och är kompatibel med C -tillägg för referensimplementeringen.
  • Mruby är en annan Ruby -implementering skapad av Ruby -skaparen Yukihiro Matsumoto. Mruby är enversion av Ruby skräddarsyddför inbäddade system , som kännetecknas av låga minneskrav och hög modulering. Mruby tillhandahåller inte CRubys fulla funktionalitet. Mruby kan översätta källkoden till bytekod, som sedan kantolkasutan ett kompileringssteg ellerinbäddasi C -program.
  • Opal är en ruby ​​till JavaScript -kompilator. Det är en implementering av Ruby Corelib och Stdlib, liksom tillhörande pärlor. Med Opal kan webbapplikationer på klientsidan implementeras i Ruby. Det finns vissa begränsningar som beror på implementeringen enligt JavaScript.
  • TruffleRuby är en Ruby -implementering som körs på GraalVM. Målet med implementeringen är att göra fördelarna med GraalVM användbara med hjälp av Ruby. Dessa är hastighet (start och körning), parallellisering och kontrollerat utförande av C -tillägg. TruffleRuby är till stor del utvecklad av Oracle .
  • Fullstaqruby är en MR-baserad implementering som är utformad för användning på webbservrar. Jämfört med referensimplementeringen lovar Fullstaqruby bättre prestanda med lägre minnesförbrukning.

Historiska Ruby -implementeringar:

Kompatibiliteten med referensimplementeringen kontrolleras av RubySpec -projektet. Den representerar både en testsvit och en specifikation för Ruby. RubySpec var ursprungligen en del av Rubinius, men outsourcades och marknadsfördes sedan av ett stort antal andra utvecklare. Det används i många Ruby -implementeringar.

Med hjälp av Ruby Version Manager eller Rbenv är det möjligt att driva flera Ruby -implementeringar och Gem -versioner parallellt.

En viktig egenskap hos implementeringarna är om de kan köra Ruby on Rails . För närvarande kan bara JRuby och Rubinius göra detta utöver referensimplementeringen.

Sprid och använd

Ruby är fritt tillgängligt för alla vanliga stationära operativsystem, i de flesta Linux -distributioner ingår det i de medföljande paketkällorna och under macOS är det till och med förinstallerat.

Ruby används ofta som skriptspråk för webbserver. Det vanligaste ramverket här är Ruby on Rails , även om det finns många alternativ av olika storlekar (t.ex. Sinatra och Hanami). Listan över stora järnvägsprojekt är lång, de mest kända är möjligen kommersiella webbplatser som GitHub , Airbnb eller Shopify eller samhällsprojekt som Diaspora , Redmine och Discourse . Webbteknik skriven i Ruby, som Sass och Haml, används också utanför Ruby -ekosystemet.
Ruby används i stor utsträckning som ett skriptspråk för att hantera och automatisera serveruppgifter, som en ersättning för mer komplexa Bash -skript såväl som för större applikationer, t.ex. Puppet (serverkonfiguration över nätverket), Metasploit ( penetrationstest ) , YaST ( OpenSUSE serveradministration) och Vagrant (hantering av virtuell maskin).
Ruby används också ofta som ett domänspecifikt språk på grund av dess flexibla syntax. Med mruby finns det också en Ruby -variant som specialiserat sig på inbäddade system . Ibland används Ruby också som skriptspråk i spel, t.ex. i RPG Maker .

kritik

Kritik mot språket framfördes av flera skäl:

  • Eftersom variabler inte behöver deklareras före användning kan skrivfel leda till oväntade körningsfel. Statisk kodanalys, som har lagts till i Ruby 3.0, kan förhindra några av dessa problem.
  • Metaprogrammering och appatchning gör att en kodbit kan ändra alla klasser och objekt i processen där den körs.

Kritiker kritiserar också flera aspekter av referensimplementeringen:

  • YARVs globala tolklås innebär att flera trådar i en process inte kan köras på olika processorkärnor samtidigt . Sedan Ruby 3.0 finns det ett alternativt system för samtidighet, kallat Ractor , som fungerar utan GIL. Men befintlig kod måste skrivas om för detta.

diverse

Villkor

Ruby är gratis programvara . Därför kan den användas gratis och är tillgänglig i källkoden . Detta gör det möjligt att anpassa språket till dina egna behov eller att integrera det i dina egna program.

Ruby-tolken och standardbiblioteket kan användas under villkoren i 2-klausul BSD-licensen . Du kan också använda Ruby under din egen gratis licens. Ruby-licensen är GPL-kompatibel och accepteras som "gratis" av Free Software Foundation .

Äldre versioner av Ruby (1.9.2 och tidigare) använde GPL V2 istället för BSD -licensen . Skälen för ändringen var oförenligheter mellan den gamla licensen och GPL V3.

RubyForge

RubyForge var ett samarbetsvilligt File Hosting - Tjänster för skrivet i Ruby -mjukvaruprojekt. Det startades av Ruby Central 2003 för att förse Ruby -gemenskapen med ett hem för sina projekt med öppen källkod .

Den 29 november 2009 genomfördes över 9 300 projekt och mer än 94 683 användare där, och tjänsten avbröts slutligen den 15 maj 2014.

litteratur

För programmering nybörjare

Ingångsnivå för programmerare

  • Peter Cooper: Början Ruby. Från nybörjare till proffs . 3. Utgåva. Apress, New York City 2016, ISBN 978-1-4842-1279-0 (engelska, källkod ).
  • Dave Thomas, Chad Fowler, Andy Hunt: Programming Ruby 1.9 & 2.0 . 2: a upplagan. The Pragmatic Bookshelf, Raleigh / Dallas 2013, ISBN 978-1-937785-49-9 (engelska, errata , källkod ).

Specialisering för programmerare

  • David A. Black: The Well-Grounded Rubyist . 2: a upplagan. Manning, Shelter Island 2014, ISBN 978-1-61729-169-2 (engelska, errata , källkod ).
  • Hal Fulton, André Arko: The Ruby Way. Lösningar och tekniker inom Ruby -programmering . 3. Utgåva. Addison-Wesley, Upper Saddle River, et al. 2015, ISBN 978-0-321-71463-3 (engelska, utdrag [PDF]).

Övergripande representationer

  • David Flanagan, Yukihiro Matsumoto: The Ruby Programming Language . O'Reilly Media, 2008, ISBN 978-3-89721-874-1

För avancerade

  • Lucas Carlson, Leonard Richardson: Ruby Cookbook . O'Reilly Media, andra upplagan 2015, ISBN 1-4493-7371-2 (engelska)
  • Pat Shaughnessy: Ruby Under a Microscope . No Starch Press, första upplagan 2013, ISBN 1-59327-527-7 (engelska)
  • Russ Olsen: vältalig Ruby . Addison-Wesley Professional, 2011, ISBN 978-0-321-58410-6 (engelska)
  • Russ Olsen: Designmönster i Ruby . Addison-Wesley Professional, 2007, ISBN 978-0-321-49045-2 (engelska)

Normer och standarder

  • ISO / IEC 30170 (engelska; standardiserad Ruby på över 317 sidor). Första versionen april 2012.

webb-länkar

Commons : Ruby  - samling av bilder, videor och ljudfiler
Wikibooks: Ruby Programming  - Inlärnings- och undervisningsmaterial

Individuella bevis

  1. ↑ www.ruby-lang.org .
  2. ↑ www.ruby-lang.org .
  3. ^ D Programmeringsspråk 1.0, Intro. Digital Mars
  4. ↑ iso.org
  5. ↑ RubyConf: Rubins historia
  6. ↑ En intervju med skaparen av Ruby
  7. ↑ Om Ruby. Hämtad 4 oktober 2018 .
  8. ↑ Ruby 1.9 släppt. Hämtad 5 september 2020 .
  9. ^ RVM: Ruby Version Manager - RVM Ruby Version Manager - Dokumentation. Hämtad 4 oktober 2018 .
  10. ↑ rbenv / rbenv. Hämtad 4 oktober 2018 .
  11. ↑ JRuby Wiki. Hämtad 23 februari 2017 .
  12. ↑ Evan Phoenix: Rails on Rubinius. 17 maj 2008, arkiverad från originalet den 22 mars 2016 ; öppnas den 23 februari 2017 (engelska).
  13. ↑ Avdi Grimm: Monkeypatching förstör Ruby. 23 februari 2008, åtkomst 23 februari 2017 .
  14. ↑ infoq.com
  15. ↑ igvita.com
  16. ↑ Rubys licensvillkor. Hämtad 23 februari 2017 .
  17. ↑ Lista över GPL-kompatibla licenser. Hämtad 23 februari 2017 .
  18. ↑ Diskussioner i e -postlista om licensändring. Arkiverad från originalet den 11 juni 2015 ; Hämtad 8 juli 2012 .
  19. ↑ Beslut om att ändra licenser vid Ruby Developers Meeting 2010. Åtkomst den 23 februari 2017 .
  20. ↑ RubyForge ( Memento från 31 maj 2014 i Internetarkivet )
  21. ↑ Twittermeddelande från Evan Phoenix. Hämtad 28 mars 2014 .