Den ultimate sammenbruddet: Ruby vs. Python

Likheter

Siden disse språkene kan inkluderes i samme kategori av dynamisk typede tolkede språk, er det ingen tvil om at de ligner på hverandre.

Dynamisk skriving

Begge Python og Ruby er dynamisk typede språk. Programmereren trenger derfor ikke å spesifisere variablenes type når han eller hun skriver kode. Typen bestemmes mens programmet kjører, og den kan endres. Typen til en variabel er avledet fra verdien som er lagret i den. Følgende kode vil kjøre korrekt i disse språkene:

 variabel = 1
 variabel += 2,5
 variabel = 'eksempelstreng'
 variabel = [2, 3,5, 'prøvestreng']

Ren syntaks

Dette henger blant annet sammen med punktet ovenfor. På grunn av at det ikke er behov for å deklarere typer, avslutte setninger med semikolon, og også det faktum at de er skriptspråk, er det enkelt både å skrive og lese det. Velskrevet kode vil kunne leses selv av personer som ikke har vært i kontakt med disse språkene tidligere.

De har interaktive konsolltolker

Når du vil utføre en enkel operasjon eller teste et stykke kode, trenger du ikke å opprette en fil og kjøre koden ved hjelp av en spesiell kommando. Både Ruby og Python har interaktive konsollfortolkere (REPL). For Python kan vi kjøre en slik tolk med kommandoen pyton (ellerpython3), mens det for Ruby for eksempel kan være irb:

 $ irb
 2.5.8 :001 > resultat = 2 + 1
 => 3
 2.5.8 :002 > resultat += 3,5
 => 6.5

Forskjeller

Ettersom disse er forskjellige programmeringsspråk, selvfølgelig må de ha forskjeller (jeg vet, for en avslørende uttalelse). Når det gjelder Python og Ruby, er disse forskjellene mange. Jeg vil beskrive noen av de viktigste etter min mening.

Innrykk

Innrykk er svært viktig i Python. Alle kodeblokker er definert av innrykk. Det er viktig at hver linje i en gitt blokk har samme innrykk. Ellers vil vi få IndentationError når vi prøver å kjøre koden. Ruby har en annen tilnærming. Her er kodeblokken begrenset av nøkkelord. Vi skiller mellom det første ordet (f.eks.begin, if, class, def) og det avsluttende ordet slutt. Det spiller ingen rolle hvordan koden er innrykket inne i kodeblokken.

Arv

En av de grunnleggende funksjonene i objektorientert programmering. I de rette hendene kan den gjøre underverker. Python støtter multi-base arv:

 eksempel.py
 class ClassA:
     def callA(self):
         print('callA')
 class ClassB:
     def callB(self):
         print('callB')
 class ClassAB(ClassA, ClassB):
     pass
 class_inst = ClassAB()
 class_inst.callA()
 class_inst.callB()

Som et resultat av dette får vi

 $ python3 example.py
 callA
 anropB

Ruby støtter som standard bare en-base-arv ved hjelp av <-operatoren. Det er imidlertid mulig å simulere flerbasert arv ved hjelp av moduler:

eksempel.rb
klasse ClassA
def calla
puts 'calla'
end
end

modul ModulB
def callb
puts 'callb'
end
end

class ClassAB < ClassA
include ModuleB
end

classinst = ClassAB.new
classinst.calla
classinst.call_b

Det som gir oss:

 $ ruby example.rb
 call_a
 call_b

inkluderer er bare en av de tilgjengelige mixinene i Ruby. Mixins er en måte å legge til ekstra funksjonalitet til klasser. Det finnes tre mixins i Ruby.

Inkludere

Når vi ringer inkluderer i klassedefinisjonen, blir den inkluderte modulen en direkte forfader til denne klassen. Det betyr at hver metode i modulen blir en instansmetode i denne klassen. Vi kan overstyre dem i klassen og også kalle den opprinnelige metoden (definert i modulen) ved hjelp av super nøkkelord.

eksempel.rb
modul ModulA
def print_something
puts 'Melding fra modul'
end
end

klasse ClassB
include ModuleA

def print_something
puts 'Melding fra klassen'
super
end
end

ClassB.new.print_something

Resultat:

 $ ruby eksempel.rb
 Melding fra klasse
 Melding fra modul
 

Prepend

Det fungerer nesten som inkluderermen den prependede modulen blir en direkte etterkommer av klassen. Det betyr at vi ikke kan overstyre modulens metode i klassen, men metoden i modulen kan kalle klassens metode ved hjelp avsuper nøkkelord.

eksempel.rb
modul ModulA
def print_something
puts 'Melding fra modul'
super
end
end

klasse ClassB
prepend ModulA

def print_something
puts 'Melding fra klassen'
end
end

ClassB.new.print_something 

Resultat:

 $ ruby example.rb
 Melding fra modul
 Melding fra klasse

Forleng

Det fungerer på samme måte som include, bortsett fra at metodene som er definert i modulen, blir klassemetoder i klassen.

Resultat:

 $ ruby eksempel.rb Melding fra modulen

Funksjoner og blokker

Python har funksjoner. Ruby støtter bare metoder. Hva innebærer det? Blant annet kan Python holde en funksjon i en variabel og sende den som et argument til en annen funksjon. I Ruby kan vi ikke gjøre det så enkelt. Dette henger også sammen med parentesene. Gitt en funksjon uten argumenter i Python, eller med standardargumenter, vil funksjonen bli returnert hvis du bruker navnet uten parenteser. Bare det å legge til parenteser fører til at den kjøres. I Ruby kan vi kalle funksjoner uten parenteser:

eksempel.py
def inner_function():
print('Indre funksjon')

def wrapper_function(funksjon):
print('Wrapper-funksjon')
#-funksjon er en variabel som inneholder funksjonsobjektet
function() # indre funksjon kalles her

wrapperfunction(indrefunksjon)

Resultat:

 $ python3 example.py
 Omslagsfunksjon
 Indre funksjon

I Ruby:

eksempel.rb
def inner_function
puts 'Indre funksjon'
end

def wrapper_function(funksjon)
puts 'Omslagsfunksjon'
function
end

wrapperfunction(innerfunction) # inner_function kalles her

Resultat:

 $ ruby eksempel.rb
 Indre funksjon
 Omslagsfunksjon

I dette tilfellet kan du selvfølgelig gjøre noen triks i Ruby for å oppnå ønsket effekt. For det første kan vi bruke Proc-objektet:

eksempel.rb
def inner_function
puts 'Indre funksjon'
end

def wrapper_function(funksjon)
puts 'Omslagsfunksjon'
function.call
end

func = Proc.new { innerfunksjon }
wrapperfunction(func)

Resultat:

 $ ruby example.rb
 Omslagsfunksjon
 Indre funksjon

Den andre tilnærmingen er å bruke blokker:

eksempel.rbdef inner_function
puts 'Indre funksjon'
end

def wrapper_function
puts 'Omslagsfunksjon'
yield
end

wrapperfunction do
innerfunction
end

Resultat:

 $ ruby example.rb
 Omslagsfunksjon
 Indre funksjon

Listeforståelse

Dette er en svært nyttig funksjon i Python. Den går ut på å lage en liste basert på en annen liste. La oss anta at vi har en slik oppgave: Gitt en liste med tall, lag en liste med kvadrater av oddetall. I Python bruker vi listeforståelse:

 tall = [1, 3, 4, 7, 8, 12, 15]
 resultat = [num*num for num i numbers if num % 2]

Fordelen er at vi bare har to lister i minnet.

I Ruby er ting litt annerledes. Det finnes flere måter å løse denne oppgaven på. Jeg vil presentere den mest lesbare av dem:

 tall = [1, 3, 4, 7, 8, 12, 15]
 result = []
 numbers.each { |num| result << num * num if num.odd? }

eksempel.rb
klasse String
def atob!
self.gsub!(/a/, 'b')
end
end

string = 'Eksempel på streng med mange a-bokstaver'
setter streng
string.atob!
setter streng

 $ ruby eksempel.rb
 Eksempel på streng med mange a-bokstaver
 Eksempel på streng med mange b-bokstaver