Hvordan man laver en stor HELLO-meddelelse i Ruby-dummies

Sådan oprettes nogle superstore bogstaver for at udskrive en stor "Hej" -meddelelse i Ruby. Du vil bygge hvert brev fra en kombination af strenge, der, når de udskrives, danner formen af et stort bogstav.

Oprettelse af brevet H

Start med at oprette strengenhederne til storbogen H:

Opret den første h1-variabel. Denne gang skal du bruge ni tegn til den samlede størrelse af strengen. I dette trin vil der være syv mellemrum mellem de to H'er:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```

Opret h2 og h3-variablerne, som er identiske med Trin 1:

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

Kontroller, at en af dine variabler er den rigtige størrelse ved hjælp af streng objektlængde metode til at udskrive dens antal tegn:
```
2. 2. 2: 019> h3. længde => 9
```
Opret h4-variablen, som er midten af bogstavet H:
```
2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
```
Har du bemærket, at du gentog dig meget for h2 og h3? Bogstavet H er interessant, fordi de øverste og nederste dele af brevet (i det mindste for den kapitalversion vi bruger) er det samme.

Programmører siger, at de to dele af brevet er symmetriske. Du kan bruge det faktum, at toppen og bunden er de samme for at spare noget arbejde.
Opret h5 ved at tildele værdien af h1, fordi de ser ens ud:
```
2. 2. 2: 021> h5 = h1 => "H H"
```

Gentag trin 5 for variablerne h6 og h7:

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

Sæt alle dele af brevet i et array for opbevaring og test det. Brug variablen hedder h for at holde arrayet:

2. 2. 2: 024> h = [h1, h2, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHHH", "HH", "HH" "HH"] 2. 2. 2: 025> sætter hHHHHHHHHHHHHHHHHHHHHH => nil

Oprettelse af bogstavet E

Næste op er bogstavet E. Du bruger de samme generelle teknikker, som du lige har brugt til brevet H.

Opret den første e1-variabel. Brug ni E tegn for den samlede størrelse af strengen:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```
Opret den næste variabel, e2. Denne er lidt vanskelig, fordi for den lodrette del af bogstavet E skal du sørge for, at du tegner sig for både den synlige del af brevet og hvide rum:
```
2. 2. 2: 027> e2 = "E" => "E"
```
Bogstavet E er ret gentagne og bruger en eller anden af de to dele, du allerede har oprettet. Brug den tidsbesparende teknik, du lærte for det foregående brev, til at gøre e3-variablen den samme som e2:
```
2.2. 2: 028> e3 = e2 => "E"
```
Den fjerde variabel, e4, gemmer den midterste horisontale del af brevet. For dette projekt gør det det samme som den øverste del:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Tid til noget mere whitespace, så få de to næste variabler til at gemme samme værdi som e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```
Opret nu e7 for at holde bunden af brevet:
```
2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
```
Gem de separate variable i et array og tildel det til variablen e. Test det for at sikre, at det ser rigtigt ud:

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

Oprettelse af brevet L

Brevet L er endnu lettere, fordi det kun er lavet af to unikke dele.

Opret den første variabel l1 (det er små bogstaver L og tallet for en):
```
2. 2. 2: 036> l1 = "L" => "L"
```
Næsten hele bogstavet L består af det samme mønster som det du lagrede i l1, så du genbruger den variabel, når du gemmer den i en matrix. I stedet skal du springe frem til det syvende stykke af formen og oprette variabel l7:
```
2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
```
Opret nu l-arrayet ved at gentage l1-variablen seks gange. Endnu engang slutter du med at spare meget!
```
2. 2. 2: 038> l = [11, 111, 111, l1, 111, l7] => ["L", "L", "L", "L", "L", "L" "LLLLLLLLL"]
```
Test brevet for at sikre, at alt er formateret korrekt:

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

Oprettelse af brevet O

Den sidste bogstav array, som du skal stave HELLO, er bogstavet O. Bogstavets form O svarer til en cirkel eller oval, og du kan udnytte den symmetri, når du opretter dine brevdele.

Opret variabel o1 til toppen af brevet:
```
2. 2. 2: 040> o1 = "OOO" => "OOO"
```
Opret o2:
```
2. 2. 2: 041> o2 = "O O" => "O O"
```
Opret o3:
```
2. 2. 2: 042> o3 = "O O" => "O O"
```

Variabler o4 og o5 gentager kun o3:

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

Variablerne 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"

Opret bogstavet 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> sætter o OOO OOOOOOOOOO OOO => nil

Kombination af bogstaverne til et ord

Nu er det på tide at samle HELLO. Det første, der kommer til at tænke på, er at bare bruge sæt til at udskrive hvert array. sætninger kan tage en række variabler adskilt af kommaer.

Prøv at udskrive dine bogstaver:

2. 2. 2: 049> sætter h, e, l, l, o H H H H H H HHHHHHHH H H H H H H 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 O> 0> Den slags værker, men den udskriver vertikalt.Det ville være rart, hvis bogstaverne blev arrangeret vandret for at gøre det let at læse ordet HELLO.

Husk at arrayer er som kasser med rum? Nå viser det sig, at du kan få indholdet af et hvilket som helst af disse indhold ved at bede om kammernummeret som sådan:

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

Her giver du nummeret til rummet i firkantede parenteser til navnet på array-variablen - h, i dette tilfælde.

Følg disse trin for at få bogstaverne til at udskrive vandret:

Kombiner bogstaverne ved hjælp af strenginterpolation for at få adgang til hvert array på samme tid:

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

Du kan se, hvordan bogstaverne passer op. Problemet er, at hvis du bruger sætter på separate linjer i IRB, ser det ikke ud som brevet rækker alle forbinder. Du har brug for en eller anden måde at gentage den kommando for hver af de syv dele.

En mere avanceret teknik, som du vil bruge meget i senere projekter kaldes

looping. Looping er en måde at få din kode til at gentage sig selv et bestemt antal gange. I Ruby er der en praktisk looping metode, som du kan ringe til tal for at tælle op til et andet nummer. Prøv denne kode:

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

Så snart du trykker på Retur eller Indtast efter slutlinjen, skal du se:

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

Succes! Den første linje, 0. upto (6) do | count | starter sløjfen. Det forbereder Ruby at tælle starter ved nul, op til og med seks. Som Ruby tæller hvert nummer, placerer det det nuværende tal i variablen, der hedder tæller. Ruby fortsætter derefter til næste linje, som har din sætningsmetode. Inde i strenginterpolationen, som kombinerer alle bogstavdelene, beder den om den første først og udskriver den pågældende række. Det gentager derefter seks gange og udskriver hver del i rækkefølge (i alt syv). Den endelige ende linje fortæller Ruby at sløjfen skal stoppe der.