Hoe maak je een groot HELLO-bericht in Ruby - dummies

Hier leest u hoe u supergrote letters kunt maken om een groot "Hallo" -bericht in Ruby af te drukken. U bouwt elke letter op basis van een combinatie van tekenreeksen die, wanneer ze worden afgedrukt, de vorm hebben van een grote letter.

De letter H

maken Begin met het maken van de reeksonderdelen voor de grote letter H:

Maak de eerste h1-variabele. Gebruik deze keer negen tekens voor de totale grootte van de reeks. In deze stap zijn er zeven spaties tussen de twee H's:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```

Creëer de variabelen h2 en h3, die identiek zijn aan Stap 1:

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

Controleer of al uw variabelen de juiste maat hebben met behulp van de string object's length methode om het aantal karakters af te drukken:
```
2. 2. 2: 019> h3. length => 9
```
Maak de h4-variabele, die het midden van de letter H is:
```
2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
```
Is het u opgevallen dat u uzelf vaak herhaalde voor h2 en h3? De letter H is interessant omdat de bovenste en onderste delen van de letter (in ieder geval voor de hoofdversie die we gebruiken) hetzelfde zijn.

Programmeurs zeggen dat de twee delen van de letter symmetrisch zijn. U kunt het feit gebruiken dat de boven- en onderkant hetzelfde zijn om wat werk te besparen.
Maak h5 door hem de waarde van h1 toe te wijzen, omdat ze er hetzelfde uitzien:
```
2. 2. 2: 021> h5 = h1 => "H H"
```

Herhaal stap 5 voor variabelen h6 en h7:

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

Plaats alle delen van de letter in een array voor opslag en test deze. Gebruik de variabele met de naam h om de array vast te houden:

2. 2. 2: 024> h = [h1, h2, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHHH", "HH", "HH", "HH"] 2. 2. 2: 025> zet h HHHHHH HHHHHHHHH HHHHHH => nil

De letter E

maken Volgende is de letter E. U gebruikt dezelfde algemene technieken die u net voor de letter H.

Maak de eerste e1-variabele. Gebruik negen E-tekens voor de totale grootte van de tekenreeks:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```
Maak de volgende variabele, e2. Deze is een beetje lastig, omdat je voor het verticale deel van de letter E moet zorgen dat je zowel het zichtbare deel van de letter als de witruimte rekenschap geeft:
```
2. 2. 2: 027> e2 = "E" => "E"
```
De letter E is vrij repetitief en gebruikt de ene of de andere van de twee delen die u al hebt gemaakt. Met behulp van de tijdbesparende techniek die je voor de vorige letter hebt geleerd, maak je de e3-variabele gelijk aan e2:
```
2.2. 2: 028> e3 = e2 => "E"
```
De vierde variabele, e4, slaat het middelste horizontale deel van de letter op. Maak voor dit project hetzelfde als het bovenste gedeelte:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Tijd voor wat meer witruimte, dus zorg dat de volgende twee variabelen dezelfde waarde opslaan als e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```
Maak nu e7 om de onderkant van de letter vast te houden:
```
2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
```
Sla de afzonderlijke variabelen op in een array en wijs dat toe aan de variabele e. Test het om te controleren of het er goed uitziet:

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

De letter L

maken De letter L is nog eenvoudiger omdat deze eigenlijk alleen uit twee unieke delen bestaat.

Maak de eerste variabele l1 (dat is de kleine letter L en het cijfer voor één):
```
2. 2. 2: 036> l1 = "L" => "L"
```
Vrijwel alle letter L bestaat uit hetzelfde patroon als wat u in l1 hebt opgeslagen, dus u gebruikt die variabele opnieuw wanneer u deze opslaat in een array. Ga in plaats daarvan verder naar het zevende deel van de vorm en maak variabele 17:
```
2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
```
Maak nu de l-array door de l1-variabele zes keer te herhalen. Nogmaals, u bespaart veel typwerk!
```
2. 2. 2: 038> l = [l1, l1, l1, l1, l1, l1, l7] => ["L", "L", "L", "L", "L", "L", "LLLLLLLLL"]
```
Test de brief om te controleren of alles goed is geformatteerd:

2. 2. 2: 039> puts l LLLLLL LLLLLLLLL => nil

De letter O

maken De laatste letterreeks die u moet spellen HELLO is de letter O. De vorm van de letter O is vergelijkbaar met een cirkel of ovaal, en u kunt van die symmetrie profiteren bij het maken van uw letterdelen.

Maak variabele o1 voor de bovenkant van de letter:
```
2. 2. 2: 040> o1 = "OOO" => "OOO"
```
Maak o2:
```
2. 2. 2: 041> o2 = "O O" => "O O"
```
Maak o3:
```
2. 2. 2: 042> o3 = "O O" => "O O"
```

Variabelen o4 en o5 herhalen zich gewoon o3:

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

Variabelen o6 en o7 zijn hetzelfde als respectievelijk o2 en o1:
```
2. 2. 2: 045> o6 = o2 => "O O" 2. 2. 2: 046> o7 = o1 => "OOO"
```
Maak de letter O array en test:

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

Combineert de letters in een woord

Nu is het tijd om HELLO samen te stellen. Het eerste dat in me opkomt, is om putten te gebruiken om elke array af te drukken. put kan een reeks variabelen nemen, gescheiden door komma's.

Probeer uw brieven af te drukken:

2. 2. 2: 049> legt h, e, l, l, o H H H H H H HHHHHHHHHH H H H H H EEEEEEEEE E E EEEEEEEEE E E EEEEEEEEE L L L L L LLLLLLLL L L L L LLLLLLLLL OOO O O O O O O O O O O OOO => nil

Dat soort werken, maar het drukt verticaal.Het zou mooi zijn als de letters horizontaal zijn gerangschikt om het gemakkelijk te maken om het woord HELLO te lezen.

Bedenk dat arrays lijken op vakken met compartimenten? Nou, het blijkt dat je de inhoud van een van die inhoud kunt krijgen door het compartimentnummer als volgt te vragen:

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

Hier geeft u het nummer van het vak tussen vierkante haakjes weer naar de naam van de array-variabele - h, in dit geval.

Voer de volgende stappen uit om de letters horizontaal te laten afdrukken:

Combineer de letters met tekenreeksinterpolatie om elke array tegelijkertijd te openen:
```
2. 2. 2: 053> zet "# {h [0]} # {e [0]} # {l [0]} # {l [0]} # {o [0]}" HH EEEEEEEEE LL OOO => nul
```
Je kunt zien hoe de letters in de rij staan. Het probleem is dat als u putten op afzonderlijke regels in IRB gebruikt, het er niet op zal lijken dat de letterrijen allemaal verbinden. Je hebt een manier nodig om dat commando voor elk van de zeven delen te herhalen.
Een meer geavanceerde techniek die u veel zult gebruiken in latere projecten wordt -lussen genoemd.

Looping is een manier om uw code een bepaald aantal keren te laten herhalen. In Ruby is er een handige looping-methode die u op nummers kunt gebruiken om op te tellen tot een ander nummer. Probeer deze code:
```
2. 2. 2: 055> 0. t / m (6) do | count | 2. 2. 2: 056> zet h [tel] + "" + e [tel] + "" + l [tel] + "" + l [tel] + "" + o [tel] 2. 2. 2: 057? > einde
```
Zodra u na de eindregel op Return of Enter drukt, ziet u:
```
H H EEEEEEEEE L L OOO H E L L O O H H E L L O O HHHHHHHHH EEEEEEEEE L L O O H H E L L O O H H E L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0
```
Succesvol! De eerste regel, 0. tot (6) do | count | begint de lus. Het bereidt Ruby voor om vanaf nul te tellen, tot en met zes. Omdat Ruby elk nummer telt, wordt het huidige nummer in de variabele met de naam count geplaatst. Ruby gaat vervolgens naar de volgende regel, die je puts-methode heeft. Binnen de tekenreeksinterpolatie die alle letterdelen combineert, wordt eerst om de nulde gevraagd en wordt die rij afgedrukt. Daarna herhaalt het nog zes keer en wordt elk deel in volgorde afgedrukt (in totaal zeven). De laatste eindregel vertelt Ruby dat de lus daar moet stoppen.