Hvordan lage en stor HELLO Melding i Ruby - dummies

Slik lager du noen superstore bokstaver for å skrive ut en stor "Hei" -melding i Ruby. Du vil bygge hvert brev fra en kombinasjon av strenger som, når de skrives ut, danner formene til et stort brev.

Opprette brevet H

Begynn med å lage strengdelene for storebrevet H:

1. Opprett den første h1-variabelen. Denne gangen bruker du ni tegn for strengenes totale størrelse. I dette trinnet vil det være syv mellomrom mellom de to H:

   2. 2. 2: 015> h1 = "H H" => "H H"
   

2. Lag h2 og h3-variablene, som er identiske med trinn 1:

   2. 2. 2: 017> h2 = "HH" => "HH" 2. 2. 2: 018> h3 = "HH" => "HH"
   

3. Kontroller at noen av variablene er riktig størrelse ved å bruke streng objekt lengde metode for å skrive ut antall tegn:

   2. 2. 2: 019> h3. lengde => 9
   

4. Lag h4-variabelen, som er midten av bokstaven H:

   2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
   

   Visste du at du har gjentatt deg mye for h2 og h3? Bokstaven H er interessant fordi bokstavens øverste og nederste del (i hvert fall for hovedversjonen vi bruker) er det samme.

   Programmører sier at de to delene av brevet er symmetriske. Du kan bruke det faktum at topp og bunn er det samme for å spare litt arbeid.

5. Lag h5 ved å tildele verdien av h1, fordi de ser like ut:

   2. 2. 2: 021> h5 = h1 => "H H"
   

6. Gjenta trinn 5 for variabler h6 og h7:

   2. 2. 2: 022> h6 = h1 => "H H" 2. 2. 2: 023> h7 = h1 => "H H"
   

7. Sett alle delene av brevet i en matrise for lagring og test det ut. Bruk variablen som heter h for å holde arrayet:

2. 2. 2: 024> h = [h1, h2, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHH", "HH", "HH" "HH"] 2. 2. 2: 025> setter h HHHHHHHHHHHHHHHHHHHHH => nil

Opprette brevet E

Neste opp er bokstaven E. Du bruker de samme generelle teknikkene du nettopp brukte for bokstaven H.

1. Opprett den første e1-variabelen. Bruk ni E tegn for den totale størrelsen på strengen:

   2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
   

2. Opprett neste variabel, e2. Denne er litt vanskelig, fordi for den vertikale delen av bokstaven E, må du sørge for at du tar hensyn til både den synlige delen av brevet og hvite plass:

   2. 2. 2: 027> e2 = "E" => "E"
   

3. Bokstaven E er ganske repeterende og bruker den ene eller den andre av de to delene du allerede har opprettet. Bruk tidsbesparende teknikken du lærte for forrige brev, gjør e3-variabelen den samme som e2:

   2.2. 2: 028> e3 = e2 => "E"
   

4. Den fjerde variabelen, e4, lagrer den midterste horisontale delen av brevet. For dette prosjektet, gjør det det samme som den øverste delen:

   2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
   

5. Tid for litt mer hvite plass, så gjør de to neste variablene samme verdi som e2:

   2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
   

6. Lag nå e7 for å holde bunnen av brevet:

   2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
   

7. Lagre de separate variablene i en matrise og tilordne den til variabelen e. Test det for å sikre at det ser riktig ut:

2. 2. 2: 034> e = [e1, e2, e3, e4, e5, e6, e7] => ["EEEEEEEEE", "E", "E", "EEEEEEEEE", "E", "E" "EEEEEEEEE"] 2. 2. 2: 035> setter e EEEEEEEEE EE EEEEEEEEE EE EEEEEEEEE => nil

Opprett brevet L

Brevet L er enda enklere, fordi det egentlig bare er laget av to unike deler.

1. Opprett den første variabelen l1 (det er små bokstaver L og tallet for en):

   2. 2. 2: 036> l1 = "L" => "L"
   

2. Nesten hele bokstaven L består av det samme mønsteret som det du lagret i l1, så du vil bruke den variabelen når du lagrer den i en matrise. I stedet hopper du videre til det syvende stykket av formen og lager variabel l7:

   2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
   

3. Lag nå l-arrayet ved å gjenta l1-variabelen seks ganger. Igjen, ender du med å spare mye å skrive!

   2. 2. 2: 038> l = [l1, l1, l1, l1, l1, l1, l7] => ["L", "L", "L", "L", "L", "L" "LLLLLLLLL"]
   

4. Test brevet for å kontrollere at alt er formatert riktig:

2. 2. 2: 039> setter l LLLLLL LLLLLLLLL => null

Opprett brevet O

Den siste bokstavsarmen som du må stave ut HELLO er bokstaven O. Formen på brevet O ligner på en sirkel eller oval, og du kan dra nytte av den symmetrien når du lager dine brevdeler.

1. Lag variabel o1 for toppen av brevet:

   2. 2. 2: 040> o1 = "OOO" => "OOO"
   

2. Lag o2:

   2. 2. 2: 041> o2 = "O O" => "O O"
   

3. Opprett o3:

   2. 2. 2: 042> o3 = "O O" => "O O"
   

4. Variabler o4 og o5 gjentar bare o3:

   2. 2. 2: 043> o4 = o3 => "OO" 2. 2. 2: 044> o5 = o3 => "OO"
   

5. Variablene o6 og o7 er de samme som henholdsvis o2 og o1:

   2. 2. 2: 045> o6 = o2 => "O O" 2. 2. 2: 046> o7 = o1 => "OOO"
   

6. Opprett brevet O-array og test:

2. 2. 2: 047> o = [o1, o2, o3, o4, o5, o6, o7] => ["OOO", "OO", "OO", "OO", "OO", "OO" "OOO"] 2. 2. 2: 048> setter o OOO OOOOOOOOOO OOO => nil

Kombiner bokstavene til et ord

Nå er det på tide å samle HELLO. Det første som kommer til å tenke er å bare bruke puts til å skrive ut hver gruppe. puts kan ta en rekke variabler adskilt av kommaer.

Prøv å skrive ut bokstavene dine:

2. 2. 2: 049> setter h, e, l, l, o H H H H H H HHHHHHHH H H H H H E EEEEEEEEE E EEEEEEEEE E EEEEEEEEE L L L L L LLLLLLLLL L L L L L LLLLLLLLL OOO O O O O O O O O OOO OOO>> nil

Den slags arbeider, men den skriver vertikalt.Det ville være fint om bokstavene ble arrangert horisontalt for å gjøre det enkelt å lese ordet HELLO.

Husk at arrays er som bokser med rom? Vel, det viser seg at du kan få innholdet i noe av innholdet ved å be om romnummeret slik:

2. 2. 2: 050> h [0] => "HH" 2. 2. 2: 051> h [1] => "HH"

Her gir du nummeret til rommet i firkantede parenteser neste til navnet på arrayvariabelen - h, i dette tilfellet.

Følg disse trinnene for å få bokstavene til å skrives ut horisontalt:

1. Kombiner bokstavene ved hjelp av strenginterpolering for å få tilgang til hver rekke på samme tid:

   2. 2. 2: 053> setter "# {h [0]} # {e [0]} # {l [0]} # {l [0]} # {o [0]}" HH EEEEEEEEE LL OOO => nil
   

   Du kan se hvordan bokstavene passer opp. Problemet er at hvis du bruker setter på separate linjer i IRB, ser det ikke ut som bokstavene alle kobler sammen. Du trenger noen måte å gjenta kommandoen for hver av de syv delene.

2. En mer avansert teknikk som du vil bruke mye i senere prosjekter kalles looping.

   Looping er en måte å få koden til å gjenta seg et bestemt antall ganger. I Ruby er det en praktisk looping metode som du kan ringe på tall for å telle opp til et annet nummer. Prøv denne koden:

   2. 2. 2: 055> 0. upto (6) do | count | 2. 2: 056> setter h [telle] + "" + e [telle] + "" + l [telle] + "" + l [telle] + "" + o [telle] 2. 2. 2: 057? > ende
   

   Så snart du trykker på Retur eller Enter etter sluttlinjen, bør du se:

   H H EEEEEEEEE L L OOO H H LH HHHHHH EEEEEEEEE L L O O H H L L O O H H L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0
   

   Suksess! Den første linjen, 0. upto (6) do | count | starter sløyfen. Den forbereder Ruby å telle som starter ved null, opp til og med seks. Som Ruby teller hvert tall, plasserer det nåværende nummer i variabelen som heter telle. Ruby fortsetter deretter til neste linje, som har puts-metoden. Inne i strenginterpoleringen som kombinerer alle bokstavsdelene, spør den om den første en, og skriver den raden. Det gjentas deretter seks ganger og skriver hver del i rekkefølge (totalt syv). Den endelige sluttlinjen forteller Ruby at sløyfen skal stoppe der.