So erstellen Sie eine große HELLO-Nachricht in Ruby - Dummies

So erstellen Sie einige großformatige Buchstaben, um eine große "Hello" -Nachricht in Ruby auszudrucken. Sie werden jeden Buchstaben aus einer Kombination von Strings zusammensetzen, die beim Ausdrucken die Formen eines großen Buchstabens bilden.

Erstellen des Buchstabens H

Erstellen Sie zunächst die String-Teile für den Großbuchstaben H:

Erstellen Sie die erste h1-Variable. Verwenden Sie dieses Mal neun Zeichen für die Gesamtgröße der Zeichenfolge. In diesem Schritt gibt es sieben Leerzeichen zwischen den beiden H's:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```
Erstellen Sie die Variablen h2 und h3, die mit Schritt 1 identisch sind:
```
2. 2. 2: 017> h2 = "HH" => "HH" 2. 2. 2: 018> h3 = "HH" => "HH"
```
Überprüfen Sie, ob eine Ihrer Variablen die richtige Größe hat, indem Sie die Methode zum Zeichnen der Länge von Zeichenfolgenobjekten, um die Anzahl der Zeichen auszudrucken:
```
2. 2. 2: 019> h3. length => 9
```
Erstellen Sie die Variable h4, die die Mitte des Buchstabens H:
```
2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
```
Haben Sie bemerkt, dass Sie sich für h2 und h3 viel wiederholt haben? Der Buchstabe H ist interessant, weil der obere und untere Teil des Buchstabens (zumindest für die Capital-Version, die wir verwenden) die gleiche ist.

Programmierer sagen, dass die beiden Teile des Buchstabens symmetrisch sind. Sie können die Tatsache nutzen, dass oben und unten gleich sind, um etwas Arbeit zu sparen.
Erstellen Sie h5, indem Sie ihm den Wert von h1 zuweisen, da sie gleich aussehen:
```
2. 2. 2: 021> h5 = h1 => "H H"
```

Wiederholen Sie Schritt 5 für die Variablen h6 und h7:

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

Alle Teile des Briefs in ein Array legen und dort testen. Verwenden Sie die Variable h, um das Array zu halten:

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

Den Buchstaben E

erstellen Als nächstes ist der Buchstabe E. Sie verwenden die gleichen allgemeinen Techniken, die Sie gerade für der Buchstabe H.

Erstellen Sie die erste e1-Variable. Verwenden Sie neun E-Zeichen für die Gesamtgröße der Zeichenfolge:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```
Erstellen Sie die nächste Variable, e2. Dieses ist ein wenig schwierig, weil Sie für den vertikalen Teil des Buchstabens E sicherstellen müssen, dass Sie sowohl den sichtbaren Teil des Briefes als auch den Leerraum berücksichtigen:
```
2. 2. 2: 027> e2 = "E" => "E"
```
Der Buchstabe E ist ziemlich repetitiv und verwendet den einen oder anderen der beiden Teile, die Sie bereits erstellt haben. Verwenden Sie die zeitsparende Technik, die Sie für den vorherigen Buchstaben gelernt haben, und stellen Sie die e3-Variable wie e2 ein:
```
2.2. 2: 028> e3 = e2 => "E"
```
Die vierte Variable, e4, speichert den mittleren horizontalen Teil des Buchstabens. Machen Sie für dieses Projekt dasselbe wie den oberen Teil:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Zeit für etwas mehr Whitespace, also lassen Sie die nächsten beiden Variablen den gleichen Wert speichern wie e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```
Erstellen Sie nun e7, um den unteren Rand des Buchstabens zu halten:
```
2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
```
Speichern Sie die separaten Variablen in einem Array und ordnen Sie dies der Variablen e zu. Testen Sie es, um sicherzustellen, dass es richtig aussieht:

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

Den Buchstaben L

schreiben Der Buchstabe L ist noch einfacher, weil er wirklich nur aus zwei einzigartigen Teilen besteht.

Erstellen Sie die erste Variable l1 (das ist der Kleinbuchstabe L und die Ziffer für einen):
```
2. 2. 2: 036> l1 = "L" => "L"
```
Nahezu der gesamte Buchstabe L besteht aus dem gleichen Muster wie in l1, sodass Sie diese Variable beim Speichern wiederverwenden können. in einem Array. Stattdessen springt man weiter zum siebten Teil der Form und erzeugt die Variable l7:
```
2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
```
Erstellen Sie nun das L-Array, indem Sie die Variable l1 sechsmal wiederholen. Noch einmal, Sie sparen am Ende viel Tippen!
```
2. 2. 2: 038> l = [l1, l1, l1, l1, l1, l1, l7] => ["L", "L", "L", "L", "L", "L", "LLLLLLLLLL"]
```
Testen Sie den Brief, um sicherzustellen, dass alles korrekt formatiert ist:

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

Erstellen des Buchstabens O

Das letzte Buchstaben-Array, das Sie buchstabieren müssen HALLO ist der Buchstabe O. Die Form des Buchstabens O ähnelt ein Kreis oder ein Oval, und Sie können diese Symmetrie ausnutzen, wenn Sie Ihre Briefteile erstellen.

Erstellen Sie die Variable o1 für den Anfang des Buchstabens:
```
2. 2. 2: 040> o1 = "OOO" => "OOO"
```
Erstelle o2:
```
2. 2. 2: 041> o2 = "O O" => "O O"
```
Erstelle o3:
```
2. 2. 2: 042> o3 = "O O" => "O O"
```

Die Variablen o4 und o5 wiederholen o3:

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

Die Variablen o6 und o7 sind die gleichen wie o2 bzw. o1:

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

Erstellen Sie den Buchstaben O array und testen Sie:

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

Kombination der Buchstaben zu einem Wort

Jetzt ist es an der Zeit, HALLO zu montieren. Das erste, was mir in den Sinn kommt, ist Puts zu benutzen, um jedes Array zu drucken. Puts können eine durch Kommata getrennte Folge von Variablen enthalten.

Versuchen Sie, Ihre Buchstaben zu drucken:

2. 2. 2: 049> setzt h, e, l, l, o H H H H H HHHHHHHHH H H H H H EEEEEEEEEEE E EEEEEEEEEEE E EEEEEEEEE L L L L L LLLLLLLLLLLLLLLLLLLLLLLL OOO OO O OO OO O O O OOO => nil

Das funktioniert, aber es druckt vertikal.Es wäre schön, wenn die Buchstaben horizontal angeordnet wären, um das Wort HALLO leicht lesbar zu machen.

Denken Sie daran, dass Arrays Kästen mit Fächern sind. Nun, es stellt sich heraus, dass Sie den Inhalt eines dieser Inhalte erhalten können, indem Sie nach der Compartment-Nummer wie folgt fragen:

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

Hier geben Sie die Nummer des Fachs in eckigen Klammern an auf den Namen der Array-Variablen - h, in diesem Fall.

Führen Sie die folgenden Schritte aus, um die Buchstaben horizontal zu drucken:

Kombinieren Sie die Buchstaben mithilfe der String-Interpolation, um auf jedes Array gleichzeitig zuzugreifen:
```
2. 2. 2: 053> setzt "# {h [0]} # {e [0]} # {l [0]} # {l [0]} # {o [0]}" HH EEEEEEEEE LL OOO => nil
```
Sie können sehen, wie sich die Buchstaben aneinanderreihen. Das Problem ist, dass, wenn Sie separate Zeilen in IRB verwendet, es nicht wie die Buchstabenzeilen aussieht, die alle verbinden. Sie müssen diesen Befehl für jeden der sieben Teile wiederholen.
Eine fortgeschrittenere Technik, die Sie in späteren Projekten häufig verwenden werden, heißt Schleifen.

Mit Looping können Sie Ihren Code eine bestimmte Anzahl von Wiederholungen durchführen lassen. In Ruby gibt es eine praktische Schleifenmethode, mit der Sie Zahlen anrufen können, um zu einer anderen Zahl zu zählen. Versuchen Sie diesen Code:
```
2. 2. 2: 055> 0. bis (6) erledigen | 2. 2. 2: 056> setzt h [count] + "" + e [count] + "" + l [zählt] + "" + l [zählt] + "" + o [zählt] 2. 2. 2: 057? > end
```
Sobald Sie Return oder Enter nach der Endzeile drücken, sollten Sie sehen:
```
H H EEEEEEEEE L LOO H E L L O O H H E HHHHHHHHH EEEEEEEEE L L O O H E L L O O H H E L L O O H H EEEEEEEEE LLLLLLLLL LLLLLLLLL OOO => 0
```
Erfolg! Die erste Zeile, 0. bis (6), erledigt | startet die Schleife. Es bereitet Ruby vor, beginnend bei Null bis einschließlich sechs zu zählen. Wenn Ruby jede Zahl zählt, wird die aktuelle Zahl in die Variable count gesetzt. Ruby geht dann zur nächsten Zeile, die Ihre Puts-Methode hat. Innerhalb der Zeichenketteninterpolation, die alle Teile des Zeichensatzes kombiniert, wird zuerst die nullte Stelle angefordert und diese Zeile ausgegeben. Es wiederholt sich dann sechsmal und druckt jeden Teil in Folge (insgesamt sieben). Die letzte Endzeile teilt Ruby mit, dass die Schleife dort anhalten soll.