Hur man skapar ett stort HELLO-meddelande i Ruby-dummies

Så här skapar du några superstora bokstäver för att skriva ut ett stort "Hej" -meddelande i Ruby. Du kommer att bygga varje brev från en kombination av strängar som, när de skrivs ut, bildar formerna av ett stort brev.

Skapa brevet H

Börja med att skapa strängdelarna för storbokstaven H:

1. Skapa den första h1-variabeln. Den här gången, använd nio tecken för strängens totala storlek. I detta steg kommer det att finnas sju mellanslag mellan de två H: s:

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

2. Skapa h2- och h3-variablerna, vilka är identiska med Steg 1:

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

3. Kontrollera att någon av dina variabler är rätt storlek med hjälp av strängobjektets längdmetod för att skriva ut sitt antal tecken:

   2. 2. 2: 019> h3. längd => 9
   

4. Skapa h4-variabeln, som är mitten av bokstaven H:

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

   Visste du att du upprepade dig mycket för h2 och h3? Bokstaven H är intressant, eftersom bokens övre och nedre del (i alla fall för huvudversionen vi använder) är densamma.

   Programmerare säger att de två delarna av brevet är symmetriska. Du kan använda det faktum att topp och botten är desamma för att spara lite arbete.

5. Skapa h5 genom att tilldela värdet av h1, eftersom de ser lika ut:

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

6. Upprepa steg 5 för variablerna h6 och h7:

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

7. Lägg alla delar av brevet i en matris för lagring och testa det. Använd variabeln heter h för att hålla arrayen:

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

Skapa bokstaven E

Nästa upp är bokstaven E. Du använder samma allmänna tekniker som du just använt för bokstaven H.

1. Skapa den första e1-variabeln. Använd nio E-tecken för strängens totala storlek:

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

2. Skapa nästa variabel, e2. Det här är lite knepigt, för den vertikala delen av bokstaven E måste du se till att du tar hänsyn till både den synliga delen av bokstaven och blankutrymmet:

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

3. Brevet E är ganska repetitivt och använder en eller annan av de två delarna du redan har skapat. Använd den tidsbesparande tekniken du lärde dig för föregående brev, gör e3-variabeln samma som e2:

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

4. Den fjärde variabeln, e4, lagrar den mellersta horisontella delen av brevet. För det här projektet gör du detsamma som den övre delen:

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

5. Tid för mer whitespace, så gör de följande två variablerna samma värde som e2:

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

6. Skapa nu e7 för att hålla botten av brevet:

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

7. Spara de separata variablerna i en array och tilldela den till variabeln e. Testa det för att se till att det ser rätt ut:

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

Skapa brevet L

Brevet L är ännu enklare, eftersom det egentligen bara är gjord av två unika delar.

1. Skapa den första variabeln l1 (det är små bokstaven L och siffran för en):

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

2. Nästan hela bokstaven L består av samma mönster som det du lagrade i l1, så du kommer att återanvända den variabeln när du lagrar den i en array. Gå istället framåt i den sjunde delen av formen och skapa variabeln l7:

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

3. Skapa nu l-arrayen genom att upprepa l1-variabeln sex gånger. Än en gång sparar du mycket skrivning!

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

4. Testa brevet för att se till att allt är formaterat korrekt:

2. 2. 2: 039> sätter l LLLLLL LLLLLLLLL => nil

Skapa brevet O

Den sista bokstavsuppsättningen som du behöver stava ut HELLO är bokstaven O. Formen på bokstaven O liknar en cirkel eller oval, och du kan utnyttja den symmetri när du skapar dina brevdelar.

1. Skapa variabel o1 överst på brevet:

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

2. Skapa o2:

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

3. Skapa o3:

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

4. Variablerna o4 och o5 repeterar bara o3:

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

5. Variablerna o6 och o7 är desamma som o2 respektive o1:

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

6. Skapa bokstaven O-matris och test:

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

Kombinera bokstäverna till ett ord

Nu är det dags att montera HELLO. Det första som kommer att tänka på är att bara använda puts för att skriva ut varje array. puts kan ta en sekvens av variabler separerade med kommatecken.

Försök skriva ut dina bokstäver:

2. 2. 2: 049> sätter 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 LLLLLLL L L L L L LLLLLLLLL OOO O O O O O O O O OOO O>Det skulle vara trevligt om bokstäverna var ordnade horisontellt så att det var lätt att läsa ordet HELLO.

Kom ihåg att arrays är som lådor med fack? Tja, det visar sig att du kan hämta innehållet i något av innehållet genom att be om facknummer så här:

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

Här ger du numret på facket i hakparenteser nästa till namnet på arrayvariabeln - h, i det här fallet.

Följ dessa steg för att få bokstäverna att skrivas ut horisontellt:

Kombinera bokstäverna genom att använda stränginterpolering för att komma åt varje array samtidigt:

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

   Du kan se hur bokstäverna klarar sig. Problemet är att om du använder sätter på separata linjer i IRB, kommer det inte att se ut som bokstaven rader alla ansluta. Du behöver något sätt att upprepa det kommandot för var och en av de sju delarna.
   

   En mer avancerad teknik som du kommer att använda mycket i senare projekt kallas

2. looping. Looping är ett sätt att få din kod att upprepa sig ett visst antal gånger. I Ruby finns det en praktisk looping metod som du kan ringa på nummer för att räkna upp till ett annat nummer. Prova denna kod:

   2. 2. 2: 055> 0. upto (6) do | count | 2. 2. 2: 056> sätter h [count] + "" + e [count] + "" + l [count] + "" + l [count] + "" + o [count] 2. 2. 2: 057? > slutet

   Så snart du trycker på Retur eller Retur efter slutlinjen ska du se:
   

   H H EEEEEEEEE L L OOO H H L L O O H H E L O O HHHHHHHHH EEEEEEEEE L L O O H H E L O O H H L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0

   Framgång! Den första raden, 0. upp till (6) gör | count | startar slingan. Det förbereder Ruby att räkna med att börja vid noll, upp till och med sex. När Ruby räknar varje nummer placeras det nuvarande numret i variabeln som heter count. Ruby fortsätter sedan till nästa rad, som har din puts metod. Inuti stränginterpolationen som kombinerar alla bokstavsdelarna frågar den för den ena ena först och skrivs ut den raden. Det upprepar sedan sex gånger och skriver ut varje del i följd (totalt sju). Den slutliga ändlinjen berättar Ruby att slingan ska stanna där.