¿Qué tal si queremos decir “Hola” muchas veces sin cansar nuestros dedos
con el teclado? ¡Necesitamos definir un método!

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):010:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span>
<span class="gp">irb(main):011:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Hola Mundo"</span>
<span class="gp">irb(main):012:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

La expresión `def h` inicia la definición del método. Le dice a Ruby que
estamos definiendo un método, cuyo nombre es `h`. La siguiente línea es
el cuerpo del método, la misma expresión que vimos anteriormente: `puts
"Hola Mundo"`. Finalmente, la última línea `end` la dice a Ruby que
terminamos de definir el método. La respuesta de Ruby `=> nil` nos
comunica que él sabe que terminamos de definir el método.

## Las breves y repetitivas vidas de un método

Ahora intentemos ejecutar ese método algunas veces:

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):013:0&gt;</span><span class="w"> </span><span class="n">h</span>
<span class="go">Hola Mundo
</span><span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):014:0&gt;</span><span class="w"> </span><span class="n">h</span><span class="p">()</span>
<span class="go">Hola Mundo
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Bien, eso fue fácil. Ejecutar un método en Ruby es tan fácil como sólo
mencionar su nombre. Si el método no requiere parámetros para
ejecutarse, eso es todo lo que necesitas. Puedes agregar paréntesis
vacíos, pero no son necesarios.

¿Y qué tal si queremos saludar sólo a una persona y no a todo el mundo?
Simplemente redefine `h` para que tome un nombre como parámetro.

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):015:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span><span class="p">(</span><span class="n">nombre</span><span class="p">)</span>
<span class="gp">irb(main):016:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Hola </span><span class="si">#{</span><span class="n">nombre</span><span class="si">}</span><span class="s2">"</span>
<span class="gp">irb(main):017:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):018:0&gt;</span><span class="w"> </span><span class="n">h</span><span class="p">(</span><span class="s2">"Matz"</span><span class="p">)</span>
<span class="go">Hola Matz
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Así que eso funciona… pero tomémonos un segundo para ver más en detalle
qué es lo que está sucediendo.

## Reservando espacios en un String

¿Qué significa la expresión `#{nombre}`? Esa es la forma que tiene Ruby
para insertar algo en un String. La expresión entre las llaves es
transformada en un String (si todavía no lo es) y posteriormente
sustituida en ese punto del String que la contiene. También puedes usar
esto para asegurarte que el nombre comience con mayúscula:

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):019:0&gt;</span><span class="w"> </span><span class="k">def</span> <span class="nf">h</span><span class="p">(</span><span class="n">nombre</span> <span class="o">=</span> <span class="s2">"Mundo"</span><span class="p">)</span>
<span class="gp">irb(main):020:1&gt;</span><span class="w"> </span><span class="nb">puts</span> <span class="s2">"Hola </span><span class="si">#{</span><span class="n">nombre</span><span class="p">.</span><span class="nf">capitalize</span><span class="si">}</span><span class="s2">"</span>
<span class="gp">irb(main):021:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):022:0&gt;</span><span class="w"> </span><span class="n">h</span> <span class="s2">"pedro"</span>
<span class="go">Hola Pedro
</span><span class="p">=&gt;</span> <span class="kp">nil</span>
<span class="gp">irb(main):023:0&gt;</span><span class="w"> </span><span class="n">h</span>
<span class="go">Hola Mundo
</span><span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

Algunos otros trucos para destacar. Uno es que otra vez estamos llamando
al método sin utilizar los paréntesis. Si lo que quieres hacer es obvio,
los paréntesis son opcionales. El otro truco es el parámetro por defecto
`Mundo`. Esto significa “si no se provee un nombre, utiliza el nombre
por defecto `"Mundo"`”.

## Convirtiéndolo en un Anfitrión

¿Qué hacemos si queremos tener un anfitrión más “en serio”? Uno que
recuerde tu nombre, te dé la bienvenida y te trate con respeto. Puedes
querer utilizar un objeto para eso. Vamos a crear la clase “Anfitrion” (ojo, sin acento)

<figure class="highlight"><pre><code class="language-irb" data-lang="irb"><span class="gp">irb(main):024:0&gt;</span><span class="w"> </span><span class="k">class</span> <span class="nc">Anfitrion</span>
<span class="gp">irb(main):025:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">nombre</span> <span class="o">=</span> <span class="s2">"Mundo"</span><span class="p">)</span>
<span class="gp">irb(main):026:2&gt;</span><span class="w">     </span><span class="vi">@nombre</span> <span class="o">=</span> <span class="n">nombre</span>
<span class="gp">irb(main):027:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):028:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">decir_hola</span>
<span class="gp">irb(main):029:2&gt;</span><span class="w">     </span><span class="nb">puts</span> <span class="s2">"Hola </span><span class="si">#{</span><span class="vi">@nombre</span><span class="si">}</span><span class="s2">"</span>
<span class="gp">irb(main):030:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):031:1&gt;</span><span class="w">   </span><span class="k">def</span> <span class="nf">decir_adios</span>
<span class="gp">irb(main):032:2&gt;</span><span class="w">     </span><span class="nb">puts</span> <span class="s2">"Adiós </span><span class="si">#{</span><span class="vi">@nombre</span><span class="si">}</span><span class="s2">, vuelve pronto."</span>
<span class="gp">irb(main):033:2&gt;</span><span class="w">   </span><span class="k">end</span>
<span class="gp">irb(main):034:1&gt;</span><span class="w"> </span><span class="k">end</span>
<span class="p">=&gt;</span> <span class="kp">nil</span></code></pre></figure>

La nueva palabra clave aquí es `class`. Esto define una nueva clase
llamada Anfitrion y un par de métodos para esa clase. También toma nota
de `@nombre`. Esta es una variable de instancia y está disponible para
todos los métodos de la clase. Como puedes ver es utilizada por
`decir_hola` y `decir_adios`.

¿Así que cómo hacemos para que esta clase Anfitrion nos sea de utilidad?
[Crea un objeto](../3/).
