Cara membuat pesan HELLO besar di Ruby - dummies

Inilah cara membuat beberapa huruf berukuran super untuk mencetak pesan "Halo" yang besar di Ruby. Anda akan membangun setiap huruf dari kombinasi string yang, bila dicetak, membentuk bentuk huruf besar.

Buat huruf H

Mulailah dengan membuat bagian string untuk huruf besar H:

Buat variabel h1 pertama. Kali ini, gunakan sembilan karakter untuk ukuran total string. Pada langkah ini, akan ada tujuh spasi di antara kedua H ini:
```
2. 2. 2: 015> h1 = "H H" => "H H"
```
Buat variabel h2 dan h3, yang identik dengan Langkah 1:
```
2. 2. 2. 2: 018> h3 = "HH" => "HH"
```
Periksa apakah salah satu variabel Anda adalah ukuran yang tepat dengan menggunakan metode panjang string object untuk mencetak jumlah karakternya:
```
2. 2. 2: 019> h3. length => 9
```
Buat variabel h4, yang merupakan bagian tengah dari huruf H:
```
2. 2. 2: 020> h4 = "HHHHHHHHH" => "HHHHHHHHH"
```
Apakah Anda memperhatikan bahwa Anda mengulangi diri Anda banyak untuk h2 dan h3? Huruf H menarik karena bagian atas dan bawah huruf (setidaknya untuk versi modal yang kita gunakan) adalah sama.

Pemrogram mengatakan bahwa dua bagian dari surat itu simetris. Anda dapat menggunakan fakta bahwa bagian atas dan bawah sama untuk menyimpan beberapa pekerjaan.
Buat h5 dengan menugaskannya nilai h1, karena warnanya sama:
```
2. 2. 2: 021> h5 = h1 => "H H"
```
Ulangi Langkah 5 untuk variabel h6 dan h7:
```
2. 2. 2. 2: 023> h7 = h1 => "H H"
```
Letakkan semua bagian huruf ke dalam array untuk disimpan dan ujilah. Gunakan variabel yang bernama h untuk menahan array:

2. 2, 02, h3, h4, h6, h3, h4, h5, h6, h7] => ["HH", "HH", "HH", "HHHHHHHHH", "HH", "HH" "HH"] 2. 2. 2: 025> h hHHHHH HHHHHH HHHHHH => nil

Membuat huruf E

Selanjutnya huruf E. Anda akan menggunakan teknik umum yang sama seperti yang baru saja Anda gunakan untuk huruf H.

Buat variabel e1 pertama. Gunakan sembilan karakter E untuk ukuran total string:
```
2. 2. 2: 026> e1 = "EEEEEEEEE" => "EEEEEEEEE"
```

Buat variabel berikutnya, e2. Yang ini agak rumit, karena untuk bagian vertikal huruf E, Anda perlu memastikan bahwa Anda memperhitungkan kedua bagian yang terlihat dari huruf dan spasi:

2. 2. Huruf E cukup berulang dan menggunakan salah satu dari dua bagian yang telah Anda buat. Dengan teknik timeaving yang Anda pelajari untuk huruf sebelumnya, buatlah variabel e3 sama dengan e2:

2.2. Variabel keempat, e4, akan menyimpan bagian horisontal tengah dari huruf. Untuk proyek ini, buatlah sama seperti bagian atas:
```
2. 2. 2: 029> e4 = e1 => "EEEEEEEEE"
```
Waktu untuk beberapa spasi lagi, jadi buat dua variabel berikut menyimpan nilai yang sama seperti e2:
```
2. 2. 2: 030> e5 = e2 => "E" 2. 2. 2: 031> e6 = e2 => "E"
```
Sekarang, buat e7 untuk memegang bagian bawah huruf:
```
2. 2. 2: 032> e7 = e1 => "EEEEEEEEE"
```

Simpan variabel terpisah dalam array dan tetapkan ke variabel e. Ujilah untuk memastikannya terlihat benar:

2. 2. "E", "E", "EEEEEEEEE", "E", "E", "E", "E", "E", "E", "E", e1, e6, e7, "EEEEEEEEE"] 2. 2. 2: 035> menempatkan e EEEEEEEEE EE EEEEEEEEE EE EEEEEEEEE => nil

Membuat huruf L

Huruf L lebih mudah, karena hanya terbuat dari dua bagian yang unik.

Buat variabel pertama l1 (itu huruf kecil huruf L dan angka untuk satu):

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

Hampir semua huruf L terdiri dari pola yang sama seperti yang Anda simpan di l1, jadi Anda akan menggunakan kembali variabel itu saat Anda menyimpannya. dalam sebuah array Sebagai gantinya, lewati ke bagian ketujuh dari bentuk dan buat variabel l7:
```
2. 2. 2: 037> l7 = "LLLLLLLLL" => "LLLLLLLLL"
```
Sekarang, buat array l dengan mengulangi variabel l1 enam kali. Sekali lagi, Anda akhirnya menghemat banyak mengetik!
```
2. 2. 2: 038> l = [l1, l1, l1, l1, l1, l1, l7] => ["L", "L", "L", "L", "L", "L" "LLLLLLLLL"]
```
Uji huruf untuk memastikan semuanya terformat dengan benar:
```
2. 2. 2: 039> menempatkan l LLLLLL LLLLLLLLLL => nil
```
Membuat huruf O

Susunan huruf terakhir yang Anda perlukan untuk menguraikan HELLO adalah huruf O. Bentuk huruf O mirip dengan lingkaran atau oval, dan Anda bisa memanfaatkan simetri itu saat membuat bagian huruf Anda.

Buat variabel o1 untuk bagian atas huruf:

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

Buat o2:
```
2. 2. 2: 041> o2 = "O O" => "O O"
```
Buat o3:
```
2. 2. 2: 042> o3 = "O O" => "O O"
```
Variabel o4 dan o5 hanya mengulangi o3:
```
2. 2. 2: 044> o5 = o3 => "OO"
```

Variabel o6 dan o7 masing-masing sama dengan o2 dan o1:

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

Buat huruf O array dan tes:

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

Menggabungkan huruf menjadi sebuah kata

Sekarang saatnya untuk mengumpulkan HELLO. Hal pertama yang terlintas dalam pikiran adalah dengan hanya menggunakan menempatkan untuk mencetak setiap array. menempatkan dapat mengambil urutan variabel dipisahkan dengan koma.

Coba cetak huruf Anda:

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

Karya semacam itu, tapi dicetak secara vertikal.Alangkah baiknya jika surat-surat itu diatur secara horisontal agar mudah membacakan kata HELLO.

Ingat bahwa array seperti kotak dengan kompartemen? Nah, ternyata Anda bisa mendapatkan isi dari konten tersebut dengan meminta nomor kompartemen seperti ini:

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

Di sini, Anda menyediakan jumlah kompartemen dalam tanda kurung siku berikutnya untuk nama variabel array - h, dalam kasus ini.

Ikuti langkah-langkah ini untuk membuat huruf dicetak secara horisontal:

Gabungkan huruf dengan menggunakan interpolasi string untuk mengakses setiap array secara bersamaan:

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

Anda bisa melihat bagaimana huruf-hurufnya berbaris. Masalahnya adalah bahwa jika Anda menggunakan penempatan pada baris terpisah di IRB, tidak akan terlihat seperti baris huruf yang terhubung. Anda perlu beberapa cara untuk mengulangi perintah itu untuk masing-masing dari tujuh bagian.
```
Teknik yang lebih canggih yang akan banyak Anda gunakan dalam proyek kemudian disebut perulangan
```
Looping adalah cara agar kode Anda berulang beberapa kali. Di Ruby, ada metode perulangan praktis yang bisa Anda gunakan untuk menghitung angka ke nomor lain. Coba kode ini: 2. 2. 2: 055> 0. upto (6) do | count | 2. 2. 2: 056> menempatkan h [count] + "" + e [count] + "" + l [count] + "" + l [count] + "" + o [count] 2. 2. 2: 057? > akhir

Segera setelah Anda menekan Kembali atau Masukkan setelah baris akhir, Anda akan melihat:
```
H H EEEEEEEEE L L OOO H 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 O O H H EEEEEEEEE LLLLLLLLLL LLLLLLLLL OOO => 0
```
Kesuksesan! Baris pertama, 0. upto (6) do | count | mulai lingkaran Ini mempersiapkan Ruby untuk menghitung mulai dari nol, sampai dan termasuk enam. Sebagai Ruby menghitung setiap nomor, itu menempatkan nomor saat ini di variabel bernama count. Ruby kemudian melanjutkan ke baris berikutnya, yang memiliki metode penempatan Anda. Di dalam interpolasi string yang menggabungkan semua bagian huruf, ia meminta yang pertama dari zeroth, dan mencetak baris itu. Kemudian mengulangi enam kali lagi dan mencetak setiap bagian secara berurutan (total tujuh). Baris akhir memberitahu Ruby bahwa lingkaran itu harus berhenti di situ.