Hva er betydningen av å gjøre i Ruby?

Ruby er et utrolig programmeringsspråk fullpakket med moderne funksjoner og verktøy for de fleste utviklingsmiljøer. Ruby har en kraftig, ofte oversett funksjon: blokker.

Essensen av denne artikkelen er å diskutere og forstå hva Ruby -blokker er, hvordan de fungerer og hvordan vi kan bruke dem i rubinprogrammene våre.

Vi vil starte med den grunnleggende syntaksen og deretter diskutere funksjoner som utbytte, noe som kan være skremmende for nye Ruby -brukere.

Hva er rubinblokker?

Som tilfellet er i andre programmeringsspråk, er en blokk eller lukking en anonym funksjon som du omslutter i en DO- og End -nøkkelord for inline -blokker.

Blokker lar deg gruppere en kodeblokk i separate komponenter som du kan passere under metodesamtalen som parametere.

Det er to måter å definere en blokk i Ruby: den første bruker DO… end nøkkelord, den andre bruker et par krøllete seler.

Do ... End Block brukes hovedsakelig når du definerer en kodeblokk som spenner over flere linjer, mens krøllete seler brukes når du definerer en kodeblokk som spenner over en enkelt linje.

Du passerer argumentene til en blokk mellom et par rørkarakterer | |

HINT: Enten du bruker en enkelt linje eller flerlinjeblokk, endres ikke funksjonaliteten. For lesbarhetsformål, bruk imidlertid krøllete seler for en enkelt linjeblokk og gjør-end for multi-line blokker.

Grunnleggende eksempel

Følgende er to enkle eksempler på en rubinblokk, den ene bruker krøllete seler mens den andre bruker ... slutt.

# enkel linje -
['Java', 'C', 'C ++'].Hver | i | setter jeg
# multi -line -> do… slutt
['Java', 'C', 'C ++'].Hver gjør | i |
setter i
slutt

Begge eksemplene ovenfor gir lignende resultater:

• Java
• C
• C++

Eksemplet ovenfor bruker Ruby -blokker i den enkleste formen: vi passerer blokken i hver metode i matriseobjektet. Passere blokkens argumenter i et par rørkarakterer; I eksemplet ovenfor er argumentet jeg. Til slutt sender vi ut blokkeringsfunksjonaliteten inne i blokkenes kropp (i dette eksemplet, setter).

Forstå rubinutbytte nøkkelord

Du kan bruke rubinblokker i en standardmetode. Funksjonaliteten for å utføre den handlingen er høflighet av avkastningsnøkkelordet.

La oss diskutere nøkkelordet.

Hva er avkastning i Ruby?

Nøkkelordutbyttet i Ruby lar deg ringe en definert blokk inne i en Ruby -metode.

Hvordan det fungerer

La oss vurdere et eksempel som vil hjelpe oss å forstå hvordan avkastningsnøkkelordet fungerer. Tenk på den enkle rubinmetoden vist nedenfor:

def hei
setter "Hei!""
slutt

Eksemplet over er en enkel Ruby -metode som skriver ut “Hei!”.

Hvis vi ønsker å legge til programmet mer fleksibilitet, kan vi tillate brukeren å formidle et argument under metoden påkallelse.

Derfor kan vi kode metoden som:

def hei (navn)
setter "hei," + navn
slutt
Hei ("USA")

I det andre eksemplet har vi litt fleksibilitet da vi kan gi ethvert navn til metoden som et argument.

Vi kan utvide dette enda lenger ved å bruke en rubinblokk. Når vi passerer blokken inne i metoden, vil den bli utført og returnere resultatene.

Definisjon av avkastningsmetode

For å lage en metode som godtar en blokk, bruker vi nøkkelordutbyttet. Den generelle syntaksen er som vist:

def hei
utbytte
slutt

Etter definisjon kan vi kalle metoden og passere en kodeblokk. Metoden vil utføre koden og returnere resultatet.

Sende en rubinblokk til en metode

Vi kan gi en blokk til metoden ved hjelp av blokkens syntaks. For eksempel kan vi kalle metoden ovenfor med en syntaks som:

hei setter "hei verden"

Så lenge metoden inneholder avkastningsnøkkelordet, kan du passere en hvilken som helst kodeblokk og utføre den.

MERK: Når du har definert et avkastningsnøkkelord i en metode, må du passere en blokk når du ringer til metoden. Ellers vil du få en "ingen blokk gitt (avkastning)" -feil.

Eksempel 2

La oss ta et annet eksempel:

def hei
setter "før avkastning.""
utbytte
setter "etter avkastning.""
slutt
hei setter "jeg gir"

Eksemplet ovenfor illustrerer hvordan utførelsen av en metode som bruker avkastning fungerer. Programutgangen er under:

før avkastning
Jeg er avkastning
Etter avkastning

Ruby blokkerer argumenter

Ruby lar deg overføre argumenter til Ruby -blokken. Blokkargumenter er definert i avkastningsblokken og fungerer som blokkparametere.

Rekkefølgen du passerer argumentet er kritisk ettersom blokken vil akseptere dem i den faste ordren.

def hei
avkastning ("John Doe", 20)
slutt
Hei | Navn, alder | Setter "Hei #Navn, du er #Age år gammel"

Parametrene som er definert inne i blokken har et lokalt omfang og er bare tilgjengelige i sammenheng med blokken.

Derfor vil du få en udefinert variabel som brukes utenfor blokkomfanget.

Eksempel 3

Blokkens funksjonalitet endres ikke på en-linjen eller flerlinjeblokker. Vi kan illustrere dette ved hjelp av eksemplet nedenfor:

Def Area
avkastning (7)
slutt
område gjør
Setter "Cirle -området er #7 * 3.14159 cm2 "
slutt

Utgangen fra eksemplet ovenfor er:

Cirle -området er 21.99113cm2

Dette viser at enten flerlinje- eller enkeltlinjeblokker forblir den samme.

Eksplisitte blokker

I de foregående eksemplene har vi definert blokkene som implisitte. Vi kan imidlertid også beskrive dem som eksplisitte.

Eksplisitte blokker betyr at vi tildeler et navn til parameterlisten over metoden.

DEF Eksempel (& Block)
blokkere.anrop
slutt
Eksempel setter "eksplisitt blokkeksempel"

Du passerer navnet på blokken inne etter ampersand. Ved hjelp av blokkens navn kan du overføre den lagrede blokken til en annen metode.

Blokker feilhåndtering

I de foregående seksjonene nevnte vi at avkastningsblokken er obligatorisk. Du kan imidlertid implementere en enkel feilhåndteringslogikk hvis avkastningen er gitt. Vi gjør dette ved å bruke Block_Given? Kernelmetode.

Metoden returnerer en boolsk verdi av sant hvis utbyttet er tilgjengelig og falsk hvis annet.

Tenk på det enkle eksemplet nedenfor:

def hei
Hvis block_Given?
utbytte
ellers
Setter "Ingenting skjedde ... [Feil]"
slutt
slutt

Hvis vi kaller metoden med den nødvendige avkastningsverdien, vil utgangen være:

Hei setter "Hei der!"
Hei der!

På den annen side vil det å kalle metoden uten avkastning utføre den andre blokken som:

Hallo
Ingenting skjedde ... [Feil]

Bruker verdien fra block_given? Metode, du kan implementere feilhåndteringslogikk når det ikke er noen avkastningsverdi.

Konklusjon

I denne guiden diskuterte vi Ruby -blokker, hva de er, hvordan de fungerer og hvordan du bruker dem i prosjektene dine.

Takk for at du leser!