Patrząc bliżej na nasz program, zauważamy początkowe linie, które
zaczynają się od (#). W Rubim wszystko w linii napisane za znakiem (#)
jest uważane za komentarz i ignorowane przez interpreter. Pierwsza linia
pliku jest wyjątkiem, system operacyjny Unix wskazuje przy jej pomocy
konsoli jakiego programu użyć do uruchomienia tego pliku. Reszta
komentarzy występuje po prostu dla przejrzystości:

Nasza metoda `say_hi` stała się trochę bardziej skomplikowana:

<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># Powiedz hi wszystkim</span>
<span class="k">def</span> <span class="nf">say_hi</span>
  <span class="k">if</span> <span class="vi">@names</span><span class="p">.</span><span class="nf">nil?</span>
    <span class="nb">puts</span> <span class="s2">"..."</span>
  <span class="k">elsif</span> <span class="vi">@names</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="s2">"each"</span><span class="p">)</span>
    <span class="c1"># @names to pewnego rodzaju lista, przejdź po elementach tej listy</span>
    <span class="vi">@names</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="o">|</span>
      <span class="nb">puts</span> <span class="s2">"Hello </span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">!"</span>
    <span class="k">end</span>
  <span class="k">else</span>
    <span class="nb">puts</span> <span class="s2">"Hello </span><span class="si">#{</span><span class="vi">@names</span><span class="si">}</span><span class="s2">!"</span>
  <span class="k">end</span>
<span class="k">end</span></code></pre></figure>

Metoda ta sprawdza teraz parametr `@names` i jeśli wynosi on nil to
wyświetla trzy kropki. Nie ma sensu witać kogoś kogo nie ma, prawda ?

## Iteracje i Pętle

Jeśli obiekt `@names` odpowiada na wywołanie metody `each`, wtedy można
po tym obiekcie iterować, więc zróbmy to i przywitajmy każdą osobę.
Jeśli `@names` jest czymkolwiek innym (nie odpowiada na `each`) zamieńmy
to na stringa i wyświetlmy domyśle powitanie.

Przyjrzyjmy się bliżej iteratorowi:

<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="vi">@names</span><span class="p">.</span><span class="nf">each</span> <span class="k">do</span> <span class="o">|</span><span class="nb">name</span><span class="o">|</span>
  <span class="nb">puts</span> <span class="s2">"Hello </span><span class="si">#{</span><span class="nb">name</span><span class="si">}</span><span class="s2">!"</span>
<span class="k">end</span></code></pre></figure>

`each` jest metodą, która przyjmuje blok kodu i wywołuje ten blok kodu
dla każdego elementu na liście. Kod pomiędzy `do` oraz `end` jest
własnie takim blokiem. Blok przypomina anonimową funkcję lub `lambda`.
Zmienna pomiędzy pionowymi liniami jest parametrem przekazywanym do
bloku.

Zmiennej `name` przypisywany jest każdy element listy, później
wywoływane jest wyrażenie “Hello #\{name}!”@ które wyświetla powitanie.

Większość innych języków programowania obsługuje iterację po elementach
listy za pomocą pętli `for`, w C wygląda to mniej więcej tak:

<figure class="highlight"><pre><code class="language-c" data-lang="c"><span class="k">for</span> <span class="p">(</span><span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">i</span><span class="o">&lt;</span><span class="n">number_of_elements</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
  <span class="n">do_something_with</span><span class="p">(</span><span class="n">element</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
<span class="p">}</span></code></pre></figure>

To działą, ale nie jest zbyt eleganckie. Potrzebujesz tu tymczasowej
zmiennej do przechowania rozmiaru listy `i` oraz musisz opisać jak
dostać się do kolejnych elementów listy. Sposób w jaki robi to Ruby jest
o wiele bardziej elegancki, wszystko ukryte jest za metodą `each`,
musisz jedynie wskazać co chcesz zrobić z każdym elementem. Wewnątrz,
metoda `each` tak naprawdę wywołuje `yield "Albert"`, później `yield
"Brenda"` i w końcu `yield "Charles"`, itd.

## Bloki, Błyszcząca Iskra Rubiego

Prawdziwa potęga bloków ujawnia się kiedy mamy do czynienia ze
strukturami bardziej skomplikowanymi niż listy. Poza obsługą prostej
funkcjonalności w metodzie, możesz także obsłużyć wstępne ustawienia,
zakończenie i błędy – wszystko ukryte przed użytkownikiem twoich metod.

<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="c1"># Powiedz wszystkim "do widzenia"</span>
<span class="k">def</span> <span class="nf">say_bye</span>
  <span class="k">if</span> <span class="vi">@names</span><span class="p">.</span><span class="nf">nil?</span>
    <span class="nb">puts</span> <span class="s2">"..."</span>
  <span class="k">elsif</span> <span class="vi">@names</span><span class="p">.</span><span class="nf">respond_to?</span><span class="p">(</span><span class="s2">"join"</span><span class="p">)</span>
    <span class="c1"># Połącz elementy listy przecinkiem</span>
    <span class="nb">puts</span> <span class="s2">"Goodbye </span><span class="si">#{</span><span class="vi">@names</span><span class="p">.</span><span class="nf">join</span><span class="p">(</span><span class="s2">", "</span><span class="p">)</span><span class="si">}</span><span class="s2">.  Come back soon!"</span>
  <span class="k">else</span>
    <span class="nb">puts</span> <span class="s2">"Goodbye </span><span class="si">#{</span><span class="vi">@names</span><span class="si">}</span><span class="s2">.  Come back soon!"</span>
  <span class="k">end</span>
<span class="k">end</span></code></pre></figure>

Metoda `say_bye` nie korzysta z `each`, zamiast tego sprawdza czy
`@names` odpowiada na wywołanie metody `join`, jeśli tak, to uzywa tej
metody. W przeciwnym wypadku, funkcja wyświetla po prostu zmienną jako
stringa. Ten sposób, który polega na nie przejmowaniu się faktycznym
*typem* zmiennej a poleganiu po prostu na metodach jakie są dostępne
nazywa się “Duck Typing” (dosł kacze typowanie), tak jak w powiedzeniu
“jeśli to chodzi jak kaczka, i kwacze jak kaczka to musi być kaczka…”.
Zaletą tego podejścia jest to, że nie musimy się niepotrzebnie
ograniczać typami jakie możemy wspierać. Jeśli ktoś wymyśli nowy typ
listy, to jeśli tylko ten nowy typ będzie wspierał metodę `join`
używając tej samej sematyki jak w przypadku innych list, wszystko będzie
działać tak jak powinno.

## Odpalanie Skryptu

Więc, oto jest klasa MegaGreeter , reszta pliku po prostu wywołuje
metody z tej klasy. Zwróćmy uwagę jeszcze na ostatni trik, to linia:

<figure class="highlight"><pre><code class="language-ruby" data-lang="ruby"><span class="k">if</span> <span class="kp">__FILE__</span> <span class="o">==</span> <span class="vg">$0</span></code></pre></figure>

`__FILE__` jest magiczną zmienną która zawiera nazwę obecnie używanego
pliku. `$0` jest nazwą pliku użytego do uruchomienia programu. To
przyrównanie oznacza: “Jeśli obecny plik to plik, który został
uruchomiony wtedy” takie rozwiązanie umożliwia użycie tego pliku jako
biblioteki w innych miejscach i nie wykonywanie tego kodu w tym
kontekście. Jeśli jednak plik jest użyty jako główny plik wykonywalny
wtedy kod zostanie wykonany.

## Zostałeś Wprowadzony

To by było na tyle jeśli chodzi o krótkie wprowadzenie do Rubiego. Do
odkrycia pozostało o wiele więcej np. różne struktury kontroli oferowane
przez Rubiego; użycie bloków i metody @yield@l; moduły i domieszkowanie
klas i wiele więcej. Mam nadzieję, że to wprowadzenie rozpaliło Twoją
ciekawość.

Jeśli tak, to zapraszam do przejścia do
[Dokumentacji](/pl/documentation/) , w której znajdziesz podsumowanie
linków, manuali i tutoriali, wszystkie dostępne za darmo w sieci.
