Ruby for Newbies Operatører og deres metoder

Ruby er et av de mest populære språkene som brukes på nettet. Vi har startet en ny screencast-serie her på Nettuts + som vil introdusere deg til Ruby, samt de flotte rammene og verktøyene som følger med Ruby-utviklingen. I denne leksjonen tar vi dypere titt på operatører i Ruby, og hvorfor de er forskjellige fra alt du noensinne har sett før.


operatører

Du har kjent med operatører.

1 + 2 # 3 person [: name] = "Joe"

Operatører er ting som plustegnet (en av de aritmetiske operatørene), eller likestillingsmerket (oppdragsoperatøren). Disse tingene ser ikke så mye annerledes ut enn de du bruker i JavaScript, PHP eller et annet språk. Men som det meste av Ruby-det er mye mer enn det som møter øyet som skjer her.

Her er hemmeligheten: Operatører i Ruby er virkelig metallsamtaler. Prøv dette:

1. + (2) # 3

Her ringer vi til + operatør på objektet 1, passerer inn i objektet 2 som en parameter. Vi kommer tilbake objektet 3. Vi kan også gjøre dette med strenger:

navn = "Joe" navn. + ("Smith") # "Joe Smith", men "navn" er fortsatt "Joe" navn + = "Smith" # navn er nå "Joe Smith"

Som du kan se, kan vi gjøre strengforbindelser med + metode. Som en bonus her definerer ruby ​​+ = operatøren basert på + operatøren (merk: du kan ikke bruke + = som metode).

Som du kanskje skjønner, gir dette oss utrolig kraft. Vi kan tilpasse betydningen av å legge til, subtrahere og tilordne objekter i våre egendefinerte klasser. Vi så hvordan dette fungerer med egenskaper på objekter i vår leksjon på klasser (vi definerte en eiendom og eiendommen = metode i klassen, og fikk forventet syntaks sukker for å bruke dem). Det vi ser på her, tar det et skritt videre.


Bygg våre egne operatørmetoder

La oss prøve å lage en av disse metodene oss selv. For dette eksempelet, la oss lage et kjøleskapobjekt, som vi kan legge til ting til via + operatør og ta ting ut av via - operatør.

Her er starten på vår klasse:

klasse kjøleskap def initialisere (drikkevarer = [], mat = []) @beverages = drikkevarer @foods = matvarer slutt def + (element) ende def -

Våre initial funksjonen er ganske enkel: vi tar to parametere (som faller tilbake til tomme arrays hvis ingenting gis), og tilordner dem til eksempel variabler. La oss nå bygge disse to funksjonene:

def + (element) hvis item.is_a? Drikke @ drinks.push elementet annet @ foods.push-elementets endeend

Dette er ganske enkelt. Hvert objekt har en er en? metode som tar en enkelt parameter: en klasse. Hvis objektet er en forekomst av den klassen, vil den returnere sann; ellers vil den returnere falsk. Så sier dette at hvis varen vi legger til kjøleskapet er a Drikke, vi legger til den i @beverages array. Ellers legger vi det til @mat matrise.

Det er bra; nå, hva med å ta ting ut av kjøleskapet? (Merk: Denne metoden er forskjellig fra den som vises i videoen, dette viser at disse operatørmetoden gir oss stor fleksibilitet, de er egentlig bare normale metoder som du kan gjøre noe med. Også, jeg tror dette er en bedre versjon av metoden, men det er mer komplisert.)

def - (item) ret = @ drinks.find do | drink | beverage.name.downcase == item.downcase ende retur @ drinks.delete rett med mindre ret.nil? ret = @ foods.find do | food | food.name.downcase == item.downcase slutten @ foods.delete ret end

Her skjer hva som skjer når vi bruker minusoperatøren. Parameteren som det tar er en streng, med navnet på elementet vi leter etter (Forresten, vil vi opprette Drikke og Mat klasser snart). Vi begynner med å bruke finne metode som arrays har. Det er noen måter å bruke denne metoden på; Vi overfører det en blokk; Denne blokken sier at vi prøver å finne varen i arrayet som har en Navn eiendom som er den samme som strengen vi passerte inn; Legg merke til at vi konverterer begge strenger til små bokstaver, for å være trygge.

Hvis det er et element som samsvarer i arrayet, blir det lagret i ret; ellers, ret vil være nil. Deretter returnerer vi resultatet av @ beverage.delete rett, som fjerner elementet fra matrisen og returnerer det. Legg merke til at vi bruker en setningsmodifikator på slutten av linjen: Vi gjør dette med mindre ret er nil.

Du lurer kanskje på hvorfor vi bruker søkeordet komme tilbake her, siden det ikke er nødvendig i Ruby. Hvis vi ikke brukte det her, ville funksjonen ikke returnere enda, siden det er mer kode til funksjonen. Ved hjelp av komme tilbake her tillater oss å returnere en verdi fra et sted som funksjonen vanligvis ikke ville returnere.

Hvis vi ikke kommer tilbake, betyr det at varen ikke ble funnet i @beverages. Derfor antar vi at den er i @foods. Vi gjør det samme for å finne varen i @foods og deretter returnere den.

Før du tester dette ut, trenger vi vår Mat og drikkevarer klasser:

klasse Drikke attr_accessor: navn def initialiser navn @name = navn @time = Time.now slutt sluttklasse Mat attr_accessor: navn def initialiser navn @name = navn @time = Time.now ende ende

Merk at i videoen gjorde jeg ikke @Navn tilgjengelig fra utsiden av objektet. Her gjør jeg det med attr_accessor: navn, slik at vi kan sjekke navnet på disse objektene når de er inne i et kjøleskap.

Så, la oss teste det ut i irb; Vi starter med å kreve filen som inneholder koden; så gi klassene et forsøk; Legg merke til at jeg har lagt til linjeskift i utgangen for å lese lettere.

> krever './lesson_6' => true> f = Fridge.new => # > f + Beverage.new ("vann") => [#]> f + Food.new ("brød") => [#]> f + Food.new ("eggs") => [#, # ]> f + Beverage.new ("appelsinjuice") => [#, # ]> f => #, # ], mat [#, # ]> f - "brød" => # > f => #, #], mat [#]

Når vi går sammen, kan du se at ting blir lagt til @beverages og @foods arrays, og deretter fjernet.


Få og sett operatører

La oss nå skrive metoder for de get og sett operatørene som brukes med hashes. Du har sett dette før:

person =  person [: name] = "joe"

Men siden disse operatørene er metoder, kan vi gjøre det på denne måten:

person. [] = (: alder, 35) # for å sette person. [] (: navn) # for å få

Det er riktig; Dette er normale metoder, med spesielt sukker til bruk.

La oss gi dette et forsøk; vi lager en Klubb klasse. Vår klubb har medlemmer med ulike roller. Imidlertid vil vi kanskje ha mer enn ett medlem med en gitt rolle. Så, vår Klubb eksempel vil holde styr på medlemmer og deres roller med en hash. Hvis vi prøver å tildele et annet medlem til en rolle, i stedet for å overskrive den første, legger vi til den.

klasse Club def initialiser @members =  end def [] (rolle) @medlemmer [rolle] ende def [] = (rolle, medlem) endeend

Få versjonen er ganske enkel; Vi videresender det bare til @members array. Men sett er litt mer komplisert:

def [] == (rolle, medlem) hvis @members [rolle] .nil? @medlemmer [rolle] = medlem elsif @members [rolle] .is_a? String @medlemmer [rolle] = [@medlemmer [rolle], medlem] ellers @medlemmer [rolle]

Hvis den rollen ikke er satt, vil vi bare sette verdien av nøkkelen til medlemmets hash. Hvis den er satt som en streng, ønsker vi å konvertere den til en matrise, og sette det opprinnelige medlemmet og det nye medlemmet i den gruppen. Til slutt, hvis ingen av disse alternativene er sanne, er det allerede en matrise, og så skyver vi bare medlemmet inn i matrisen. Vi kan teste denne klassen på denne måten:

c [: engineer] = "Sue" c [: stol] # "Joe" c [: engingeer] # ["John" c [: engineer] = "John" "," Sue "]

Der går du!


Andre operatører

Dette er ikke de eneste operatørene som vi selvfølgelig kan gjøre med dette. Her er hele listen:

  • Aritmetiske operatører: + - * \
  • Få og sett operatører: [] [] =
  • Skovloperatør: <<
  • Sammenligningsoperatører: == < > <= >=
  • Case Equality Operator: ===
  • Bitvis Operatør: | & ^

Takk for at du leste!

Hvis du har noen spørsmål om denne leksjonen, eller noe annet vi har diskutert i Ruby, spør deg bort i kommentarene!