-
Notifications
You must be signed in to change notification settings - Fork 106
/
Copy pathruby-guide-es.html_
668 lines (668 loc) · 45.8 KB
/
ruby-guide-es.html_
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
<html>
<body>
<div class="stretcher">
<h3>Usando El Prompt</h3>
<p>La ventana azul de arriba es el prompt de Ruby. ¡Escribe una línea de código Ruby, aprieta <em>Enter</em>
y velo correr!</p>
<p>Por ejemplo, trata de escribir algo matemático. Como: <code class="cmd">2 + 6</code></p>
<div class="answer">\d+</div>
</div>
<div class="stretcher">
<h3>Números & Matemática</h3>
<p>¡Bien! Hiciste algo de matemática. ¿Ves como la respuesta salta a la vista?</p>
<p>Ruby reconoce números y símbolos matemáticos. Puedes probar otras cosas como:</p>
<ul><li><code>4 * 10</code></li>
<li><code>5 - 12</code></li>
<li><code>40 / 4</code></li></ul>
<p>Seguro, las computadoras son habilidosas y rápidas con las matemáticas. Sigamos... ¿Quieres ver tu nombre al revés?
Escribe tu primer nombre entre comillas así: <code class="cmd">"Jimmy"</code></p>
<div class="answer">"(\w+)"</div>
</div>
<div class="stretcher">
<h3>Decir Tu Nombre Al Revés</h3>
<p>Perfecto, has formado un <strong>string</strong> de las letras de tu nombre. Un string
es un juego de caracteres que la computadora puede procesar.</p>
<p>Imagina que las letras están en una cuerda donde
se cuelga la ropa y las comillas son los broches que sostienen los bordes. Las comillas marcan el comienzo y el final.</p>
<p>Para invertir tu nombre, escribe: <code class="cmd">"Jimmy".reverse</code> (<em>¡No olvides el punto!</em>)</p>
<div class="answer">"(\w+)"</div>
</div>
<div class="stretcher">
<h3>Contando Las Letras</h3>
<p>¡Has usado el <strong>método</strong> <code>reverse</code> sobre tu nombre! Poniendo tu nombre entre comillas,
hiciste un string. Luego llamaste al método <code>reverse</code>, que funciona sobre un string cambiando
todas las letras de atrás para adelante.</p>
<p>Ahora, vamos a ver cuantas letras tiene tu nombre: <code class="cmd">"Jimmy".length</code></p>
<div class="answer">\d+</div>
</div>
<div class="stretcher">
<h3>Repitiendo</h3>
<p>Ahora, estoy seguro que te estarás preguntando para que sirve todo esto. Bueno, estoy seguro que habrás estado en alguna
pagina web donde te gritaron, <em>¡Hey, tu password es muy corto!</em> Ves, algunos programas
usan este código tan simple.</p>
<p>Mira esto. Vamos a multiplicar tu nombre por 5. <code class="cmd">"Jimmy" * 5</code></p>
<div class="answer">"(\w+)"</div>
</div>
<div class="stretcher chapmark">
<h3>Hey, Sumario #1 Listo</h3>
<p>Vamos a ver que es lo que has aprendido en el primer minuto.</p>
<ul>
<li><strong>El prompt.</strong> Escribiendo código en el prompt verde obtienes
una respuesta del prompt rojo. Todo código te da una respuesta.</li>
<li><strong>Números y strings</strong> son objetos matemáticos y de texto de Ruby.</li>
<li><strong>Métodos</strong> Has usado métodos en Ingles como <code>reverse</code>
y métodos simbólicos como <code>*</code> (el método de multiplicación.) ¡Los métodos son acciones!</li>
</ul>
<p>Esta es la esencia del aprendizaje. Tomar cosas simples, jugar con ellas
y trasformarlas en cosas nuevas. ¿Te sientes cómodo con todo? Te aseguro que lo estas.</p>
<p>Bien, vamos a hacer algo incomodo. Trata de invertir un número: <code>40.reverse</code></p>
<div class="stdout">NoMethodError: undefined method `reverse' for (\d+):Fixnum</div>
</div>
<div class="stretcher">
<h3>¡Basta, Te Volviste Loco!</h3>
<p>No puedes invertir el numero cuarenta. Supongo que puedes poner tu monitor en
frente de un espejo, pero invertir un numero no tiene sentido. Ruby lanza un
mensaje de error. Ruby te dice que no hay un método <code>reverse</code> para los números.</p>
<p>Tal vez si lo conviertes en un string: <code class="cmd">40.to_s.reverse</code>.</p>
<div class="answer">\"(\d+)\"</div>
</div>
<div class="stretcher">
<h3>Los Chicos Son Diferentes De Las Chicas</h3>
<p>Y los números son diferentes de los strings. Aunque puedes usar métodos en cualquier objeto
en Ruby, algunos métodos solo funcionan en cierto tipo de cosas. Pero siempre puedes
convertir entre diferentes tipos usando el método "to" de Ruby.</p>
<ul><li><strong>to_s</strong> convierte cosas a <strong>s</strong>trings.</li>
<li><strong>to_i</strong> convierte cosas a <strong>i</strong>ntegers (números.)</li>
<li><strong>to_a</strong> convierte cosas a <strong>a</strong>rrays.</li>
</ul>
<p><em>¿Que son los arrays?!</em> Son listas. Escribe entre un par de corchetes: <code class="cmd">[]</code>.</p>
<div class="answer">\[\]</div>
</div>
<div class="stretcher">
<h3>Mantenerse en Cola</h3>
<p>Genial, eso es una lista vacía. Las listas guardan cosas <strong>en orden</strong>.
Como esperando en la cola para palomitas de maíz. Estas atrás de alguien y jamás
pensarías en empujarlo a un costado, ¿no es así? Y con respecto al tipo detrás de ti,
mantienes un ojo sobre el, ¿correcto?</p>
<p>Acá hay una lista para ti. Números de la lotería: <code class="cmd">[12, 47, 35]</code>.</p>
<div class="answer">\[(\d+(, )?){2,}\]</div>
</div>
<div class="stretcher">
<h3>Uno Levanta La Mano</h3>
<p>Una lista de números de la lotería. ¿Cual es el mayor?</p>
<p>Prueba: <code class="cmd">[12, 47, 35].max</code>.</p>
<div class="answer">(\d+)</div>
</div>
<div class="stretcher">
<h3>Manteniendo la Lista</h3>
<p>Bien, bien. Pero es un fastidio el tener que reescribir esa lista, ¿no es así?</p>
<p>Guardemos nuestros números en un <code>ticket</code> de esta manera: <code class="cmd">ticket = [12, 47, 35]</code></p>
<div class="answer">\[(\d+(, )?){2,}\]</div>
</div>
<div class="stretcher">
<h3>Ahora Escribe Ticket</h3>
<p>Ahora, escribe: <code class="cmd">ticket</code></p>
<div class="answer">\[(\d+(, )?){2,}\]</div>
</div>
<div class="stretcher">
<h3>Guardado, Escondido</h3>
<p>¡Fantástico! Te has aferrado a tus números de la lotería, escondiéndolos dentro de una
<strong>variable</strong> llamada <code>ticket</code>.</p>
<p>Vamos a poner tus números en orden, que te parece? Usa: <code class="cmd">ticket.sort!</code></p>
<div class="answer">\[(\d+(, )?){2,}\]</div>
</div>
<div class="stretcher chapmark">
<h3>Sumario #2 Está Sobre Nosotros</h3>
<p>Tenías una lista. Ordenaste la lista. La variable <code>ticket</code> ahora esta cambiada.</p>
<p>¿Te diste cuenta que el método <code>sort!</code> tiene un claro y llamativo signo de exclamación al final?
Muchas veces los métodos de Ruby gritan así si es que alteran la variable para bien. No es nada
especial, solo una marca.</p>
<p>Ahora, mira como te fue en tu segundo minuto:</p>
<ul>
<li><strong>Errors.</strong> Si tratas de invertir un número o hacer algo sospechoso,
Ruby salteara el prompt para avisarte.</li>
<li><strong>Arrays</strong> son listas para ordenar cosas en orden.</li>
<li><strong>Variables</strong> guardan cosas y le dan un nombre. Usaste el
signo igual para hacerlo.<br>Like: <code>ticket = [14, 37, 18]</code>.</li>
</ul>
<p>En total hay ocho lecciones. Estás a dos octavos de camino!
Esto es cosa simple, no te parece? Las cosas buenas están mas adelante.</p>
<p>Cambiemos de dirección por un momento. Rellené con un poco de poesía cierta
variable para ti. Hecha un vistazo. Escribe <code class="cmd">print poem</code></p>
<div class="load">poem = "My toast has flown from my hand\nAnd my toast has gone to the
moon.\nBut when I saw it on television,\nPlanting our flag on Halley's
comet,\nMore still did I want to eat it.\n"</div>
<div class="stdout">My toast (.+)</div>
</div>
<div class="stretcher">
<h3>Desgraciadamente, Tú Odias la poesía de Tostadas</h3>
<p>Mira, esta bien. No tiene que gustarte. Hackéalo, yo invito.</p>
<p>En vez de tostada, ve por un melón o algo. Prueba esto: <code class="cmd">poem['toast'] = 'honeydew'</code></p>
<p>Y luego escribe <code class="cmd">print poem</code> para ver el nuevo poema.</p>
<div class="stdout">My honey(.+)</div>
</div>
<div class="stretcher">
<h3>Listo, Apuntado</h3>
<p>Los corchetes que acabas de usar son muy comunes en Ruby. Recuerda, escribiste: <code>poem['toast'] = 'honeydew'</code>. Esa casilla con la palabra <em>toast</em> tiene corchetes a ambos lados, ¿ves?</p>
<p>Los
corchetes son como una mira para alinear un objetivo. Exacto. Estos
corchetes significan, "Estoy buscando ____." Listo, apuntado. Aquí estas buscando
una costada e intercambiándola por una fruta.</p>
<p>Aquí hay una pregunta: ¿Que pasa si volteamos el poema entero? <code class="cmd">poem.reverse</code>
</p><div class="answer">"\\n.ti tae ot (.+)"</div>
</div>
<div class="stretcher">
<h3>Demasiado Invertido</h3>
<p>Está bien, seguro. Entonces todo el poema fue puesto al revés. Letra por letra. Sin embargo, yo realmente solo quería
invertir las líneas. Mover la última línea a la primera y la primera hacia abajo a la ultima. Al revés, pero no
<em>ése</em> revés.</p>
<p>Aquí esta como lograrlo: <code class="cmd">poem.lines.to_a.reverse</code></p>
<div class="answer">\["More still did I(.+)"\]</div>
</div>
<div class="stretcher">
<h3>Rizos de Metodos Concatenados</h3>
<p>Dime, que es lo que ves? Que paso acá? Escribiste <code>poem.lines.to_a.reverse</code> y ¿que pasó?</p>
<p>Dos cosas pasaron. Convertiste <code>poem</code> en una lista usando
<code>lines.to_a</code>. <code>lines</code> decide la forma en que
el string se divide, luego <code>to_a</code> lo
convierte en un Array. (<strong>To a</strong>rray.) Diferentes métodos, como
<code>bytes</code> y <code>chars</code> pueden ser usadas en lugar de
<code>lines</code>. Usando lines, Ruby retornará cada línea de poem.</p>
<p>Luego, tu revertiste, <code>reverse</code>d, esa lista. Tenías cada línea. Las revertiste. Eso es todo.</p>
<p>Vamos a hilar un método más al final de todo esto: <code class="cmd">print poem.lines.to_a.reverse.join</code>
</p><div class="stdout">More still did I(.+)</div>
</div>
<div class="stretcher chapmark">
<h3>De Todos los Sumarios, el #3 esta aquí</h3>
<p>Buen espectáculo, mi amigo! El método <code>join</code> toma la lista de líneas revertidas y las pone juntas en un string.
(Seguro, también podrías haber usado <code>to_s</code>.)</p>
<p>Tiempo de Revisión.</p>
<ul>
<li><strong>Exclamaciones.</strong> Métodos pueden tener signos de exclamación (y también de interrogación) en
sus nombres. No es la gran cosa. Prueba: <code>poem.include? "my hand"</code></li>
<li><strong>Corchetes.</strong> Establece objetivos y busca cosas. Busca y reemplaza.</li>
<li><strong>Concatenar</strong> métodos te permite hacer mas cosas juntas. Partir poem, revertirlo,
reensamblarlo: <code>poem.lines.to_a.reverse.join</code></li>
</ul>
<p>En este punto, querras manosear un poco más el poema. Una lista completa de métodos
<code>String</code> estan
<!--<a href="http://www.whytheluckystiff.net/ruby/pickaxe/html/ref_c_string.html" target="_new">here</a>.-->
<a href="http://ruby-doc.org/core/classes/String.html" target="_blank">acá</a>.
No temas y prueba algunos (como <code>poem.downcase</code> o <code>poem.delete</code>.)</p>
<p>Cuando estés listo para seguir adelante, escribe: <code class="cmd">books = {}</code></p>
<div class="answer">\{\}</div>
</div>
<div class="stretcher">
<h3>Un Pequeñín Libro en Blanco</h3>
<p>Has hecho un <strong>hash</strong> vacío. (también conocido como: un <em>diccionario</em> vacío.)</p>
<p>Vamos a rellenar con un libro de críticas en miniatura. Acá esta nuestro sistema de calificación:</p>
<ul>
<li><code>:splendid</code> → una obra maestra.</li>
<li><code>:quite_good</code> → disfrutable, por supuesto que sí.</li>
<li><code>:mediocre</code> → partes iguales de bueno y malo.</li>
<li><code>:quite_not_good</code> → notablemente malo.</li>
<li><code>:abysmal</code> → una perdida de tiempo.</li>
</ul>
<p>Para calificar un libro, pon el título entre corchetes y la calificación luego del signo igual.</p>
<p>Por ejemplo: <code class="cmd">books["Gravity's Rainbow"] = :splendid</code></p>
<div class="answer">:\w+</div>
</div>
<div class="stretcher">
<h3>Mas Críticas Tamaño Bocadillo</h3>
<p>Tú sigue, agrega mas críticas. Y, si quieres ver toda la lista,
implemente escribe: <code>books</code></p>
<p>De nuevo, las calificaciones son: <code>:splendid</code>, <code>:quite_good</code>, <code>:mediocre</code>,
<code>:quite_not_good</code>, and <code>:abysmal</code>.</p>
<p>Estas calificaciones no son strings. Cuando colocas dos puntos frente a una palabra simple, obtienes un
<strong>symbol</strong>. Los símbolos son más baratos que los strings (en términos de memoria de la computadora.) Si usas
una palabra una y otra vez en un programa, usa un símbolo. En vez de tener miles de
copias de una palabra en memoria, la computadora guardara el símbolo solamente <em>una vez</em>.</p>
<p>Una vez que tengas <strong>tres</strong> o <strong>cuatro</strong> libros allí
dentro, escribe: <code class="cmd">books.length</code>.</p>
<div class="answer">[3-9]</div>
</div>
<div class="stretcher">
<h3>Espera, ¿Me gustó <em>Gravity's Rainbow</em>?</h3>
<p>Ves, el método <code>length</code> funciona sobre strings, list y hashes. Una gran cosa acerca de
Ruby es que los nombres usualmente se reutilizan, lo que significa menos nombres para recordar.</p>
<p>Si quisieras ver una de tus críticas hechas, vuelve a poner el título entre corchetes. Pero deja de lado el
signo igual.</p>
<p>Al igual que aquí: <code class="cmd">books["Gravity's Rainbow"]</code></p>
<div class="answer">:\w+</div>
</div>
<div class="stretcher">
<h3>Hashes como Pares</h3>
<p>Ten en mente que los hashes no mantienen las cosas en orden. Ese no es su trabajo. Solo emparejará dos
cosas: una <strong>key</strong> (llave) y un <strong>valor</strong>. En tus críticas, la key es el
titulo del libro y el valor es la calificación.</p>
<p>Si simplemente quieres ver los títulos de los libros que calificaste: <code class="cmd">books.keys</code></p>
<div class="answer">\[".*"\]</div>
</div>
<div class="stretcher">
<h3>¿Eres Duro?</h3>
<p>¿Estás dando duras injustas críticas? Sigamos puntuando con rigurosidad: <br><code class="cmd">ratings = Hash.new {0}</code></p>
<p>Entonces, bien, ahora vamos a contar tus críticas. Trata de seguirme. Escribe: <br>
<code class="cmd">books.values.each { |rate| ratings[rate] += 1 }</code></p>
<p><em>(La línea vertical es el signo de tubería, probablemente lo logres con AltGr+1 con tu teclado.)</em></p>
<div class="answer">\[:.+\]</div>
</div>
<div class="stretcher">
<h3>Un Recuento</h3>
<p>Genial, wow! Has hecho un recuento de tus calificaciones. Escribe <code>ratings</code> para ver las cuenta. Este nuevo
hash muestra las calificaciones y luego el numero de veces que has dado esa calificación.</p>
<p>Una de las asombrosas cosas nuevas que acabamos de usar es un bloque, <strong>block</strong>. Vamos a explorar
explore these more in the next summary. más esto en el próximo sumario. Pero, básicamente, un bloque es un pedazo de código Ruby
rodeado por llaves.</p>
<p>Probemos otro bloque: <code class="cmd">5.times { print "Odelay!" }</code></p>
<div class="stdout">Odelay!Od.*</div>
</div>
<div class="stretcher chapmark">
<h3>Ahora Arribamos al Sumario #4</h3>
<p>Los bloques están siempre apegados a métodos. Como el método <code>times</code>, que toma el bloque y lo corre
repetidas veces. (En este caso: <strong>cinco</strong> veces.)</p>
<p>Esta última lección fue algo mas larga. Probablemente usaste unos tres minutos aprendiendo sobre:</p>
<ul>
<li><strong>Hashes.</strong> El pequeño diccionario con páginas arrugadas: <code>{}</code>.</li>
<li><strong>Symbols.</strong> Pequeñas, eficientes palabras con dos puntos: <code>:splendid</code>.</li>
<li><strong>Blocks.</strong> Pedazos de código que pueden ser clavados a muchos métodos de Ruby. Aquí
esta el código que usaste para crear el recuento: <br><code>books.values.each { |rate| ratings[rate] += 1 }</code>.</li>
</ul>
<p>En tu computadora, probablemente tienes muchos archivos diferentes. Archivos con fotos en ellos,
archivos con programas dentro. Y los archivos usualmente se organizan en carpetas, también llamadas:
<strong>directorios</strong>.</p>
<p>He preparado algunos directorios para ti. Echa un vistazo:
<code class="cmd">Dir.entries "/"</code></p>
<div class="answer">\["\.", .+\]</div>
</div>
<div class="stretcher">
<h3>La Privada Colección de Dr. Dir</h3>
<p>Acabas de listar todo lo existente en el directorio superior. El directorio raíz, indicado
por la barra en diagonal. Conteniendo algunos programas y otros tutoriales y semejantes.</p>
<p>Entonces, ¿que es el método <code>Dir.entries</code>? Bueno, es solo un método ¿si?,
<code>entries</code> es el método llamado sobre la variable <code>Dir</code>.
Y <code>Dir</code> tiene una colección de métodos para chequear los archivos de los directorios.</p>
<p>Otra pequeña cosa de la que no hemos hablado abiertamente. Argumentos de los métodos, resaltados en verde.</p>
<ul>
<li><code>Dir.entries <strong>"/"</strong></code>: Cualquier cosa listada luego de un método
es considerado acoplamiento.</li>
<li><code>print <strong>poem</strong></code>: Ves, <code>print</code> es un método ordinario.
Y el poema esta acoplado. Para ser impreso.</li>
<li><code>print <strong>"pre", "event", "ual", "ism"</strong></code> posee varios argumentos,
con comas entre ellos.</li>
</ul>
<p>Para listar solamente archivos de texto en el directorio: <code class="cmd">Dir["/*.txt"]</code></p>
<div class="answer">\["\/comics\.txt"\]</div>
</div>
<div class="stretcher">
<h3>Ven, Lee Historietas Conmigo</h3>
<p>El método <code>Dir[]</code> hace como <code>entries</code> pero tu buscas por archivos
archivos con carácteres de comodín. ¡Aquí, vemos esos corchetes otra vez! Te das
cuenta como todavía significan, "Estoy buscando _____.".</p>
<p>Mas específicamente: "Estoy buscando archivos que terminen con <code>.txt</code>."</p>
<p>Abramos este archivo con historietas de una vez. Aquí esta la manera:<br>
<code class="cmd">print File.read("/comics.txt")</code></p>
<div class="stdout">Achewood.+</div>
</div>
<div class="stretcher">
<h3>Mi Comicas, Tu Comicas</h3>
<p>¡De acuerdo! Podemos comenzar a usar archivos para guardar cosas. Esto es excelente
porque normalmente cuando salimos de Ruby, todas nuestras variables desaparecerán.
Ruby, por si mismo, olvida estas cosas. Pero si salvamos cosas en archivos,
podemos leer esos archivos en futuras escapadas a Ruby.</p>
<p>Hey, y ¿adivina que? ¡El directorio <code>/Home</code> es tuyo! ¡Te lo entrego a ti! ¡Soy generoso! Hagamos una copia del archivo de la historieta.</p>
<p>Querrás hacer lo siguiente: <code class="cmd">FileUtils.copy('/comics.txt', '/Home/comics.txt')</code>
</p><p><em>Si ya has creado el archivo, usa File.delete('/Home/comics.txt') para arrojarlo a la basura.</em></p>
<div class="answer">nil</div>
</div>
<div class="stretcher">
<h3>Tu Propio Territorio</h3>
<p>Ok, tienes una copia. Chequéala: <code>Dir["/Home/*.txt"]</code></p>
<p>Para agregar tu propia historieta a la lista, abramos el archivo en modo <strong>append</strong>.</p>
<p>Empieza asi: <code class="cmd">File.open("/Home/comics.txt", "a") do |f|</code>.</p>
<div class="stdout">..</div>
</div>
<div class="stretcher">
<h3>Y Ahora, para la Sorprendente Conclusión</h3>
<p>Asi que tu prompt ha <em>cambiado</em>. ¿Lo notas? Tu prompt es <strong>doble</strong> punto ahora.</p>
<p>En este tutorial, este prompt significa que Ruby espera que escribas más. A
medida que vayas completando con líneas de código, los doble puntos se mantendrán
hasta que hallas finalizado.</p>
<p>Hot tip: si quieres parar de trabajar en el código y salirte de los doble puntos, usa el comando <code>reset</code>.
Si quieres volver a la pagina previa del tutorial, usa el comando <code>back</code>.</p>
<p>Aquí esta tu código. Ya has escrito la primera línea, asi que simplemente ingresa la segunda. (El <code>\n</code>
es el carácter de <em>Enter</em>.</p>
<ul><li><code class="faded">File.open("/Home/comics.txt", "a") do |f|</code></li>
<li><code> f << "Cat and Girl: http://catandgirl.com/\n"</code></li>
<li><code class="faded">end</code></li>
</ul>
<p>Y, como te has vuelto avanzado y capaz aquí, otro tip: puedes usar las flechas hacia
arriba y hacia abajo para editar tus viejos comandos o correrlos otra vez.</p>
<div class="stdout">..</div>
</div>
<div class="stretcher">
<h3>Ruby se Sienta y Espera</h3>
<p>Esa ultima línea agrega la historieta <em>Cat and Girl</em> a la lista, pero Ruby seguirá esperando
hasta que hallas terminado por completo para tomar acción.</p>
<p>Ahora, para finalizar el código que has empezado. Empezaste un nuevo bloque cuando escribiste <code>do</code>.
Hasta ahora los bloques que hemos visto usaban llaves. Esta vez usaremos <code>do</code> y <code>end</code> en lugar
de las llaves. Muchos Rubyistas usan <code>do...end</code> cuando el bloque ocupa varias líneas.</p>
<p>Terminemos ese bloque ahora mismo, con: <code class="cmd">end</code></p>
<ul><li><code class="faded">File.open("/Home/comics.txt", "a") do |f|</code></li>
<li><code class="faded"> f << "Cat and Girl: http://catandgirl.com/\n"</code></li>
<li><code>end</code></li>
</ul>
<div class="answer">#.File:/Home/comics\.txt.</div>
</div>
<div class="stretcher">
<h3>El Reloj Clavado en el Archivo</h3>
<p>¡Bien, bien! Has añadido esa historieta al archivo. Puedes verlo por ti mismo: <code>print File.read("/Home/comics.txt")</code></p>
<p>¿Qué hora era cuando cambiaste el archivo? Veamos. Escribe: <code class="cmd">File.mtime("/Home/comics.txt")</code></p>
<div class="answer">\w+ \w+ \d+ \d{2}:\d{2}:\d{2} [+-]\d{4} \d{4}</div>
</div>
<div class="stretcher">
<h3>Sólo la Manecilla de la Hora</h3>
<p>Estupendo, allí esta la hora. La hora exacta en la que agregaste la historieta al archivo. El <code>mtime</code> te devuelve un objeto Time de Ruby.</p>
<p>Si sólo quieres ver la hora que era, aprieta la flecha para arriba y cambia la línea a: <code class="cmd">File.mtime("/Home/comics.txt").hour</code></p>
<div class="answer">\d+</div>
</div>
<div class="stretcher chapmark">
<h3>Hola, ¿Quién Anda Ahí? Y el Sumario #5 Agita su Sombrero!</h3>
<p>Bien hecho, bien hecho, bien hecho, ¡bien hecho! Realmente, realmente, realmente, realmente, ¡reaaaaaaaaalllmente!</p>
<p>Aquí esta tu último minuto de tu vida en retrospectiva:</p>
<ul>
<li><strong>Archivos.</strong> ¿Que más se puede decir? Muchos métodos para editar archivos y revisar directorios.</li>
<li><strong>Argumentos.</strong> Los argumentos son listas de cosas mandadas en un método. Separadas con comas. </li>
<li>También hablamos sobre <strong>do</strong> y <strong>end</strong> que es otra manera de hacer un bloque.</li>
</ul>
<p>Ahora ya sabes como usar Ruby por completo. Me refiero a que tienes lo esencial. Solo necesitas seguir
aprendiendo métodos y probar bloques más complejos.</p>
<p>Pero existe un lado de Ruby que no hemos hablado. Hacer tus propios métodos y clases.</p>
<p><em>Ahem!</em> Acabemos con ello de una vez.</p>
<p>Empieza con: <code class="cmd">def load_comics( path )</code></p>
<div class="stdout">..</div>
</div>
<div class="stretcher">
<h3>En Ruby, Def Leppard Significa <em>¡Define Leppard (un Método)!</em></h3>
<p>Hey, bueno, lo hiciste. Estas haciendo tu propio método. Comenzaste con <code>def</code>, seguido por el nombre del método.
Y una lista de argumentos que va a necesitar el método. ¡Esto no da tanto miedo ni es peligroso!</p>
<p>Todo lo que debemos hacer es rellenar con Ruby y terminarlo con <code>end</code>.</p>
<p>Aquí esta el código:</p>
<ul><li><code class="faded">def load_comics( path )</code></li>
<li><code> comics = {}</code></li>
<li><code> File.foreach(path) do |line|</code></li>
<li><code> url, name = line.split(': ')</code></li>
<li><code> comics[url] = name.strip</code></li>
<li><code> end</code></li>
<li><code> comics</code></li>
<li><code>end</code></li>
</ul>
<p>No necesitas indentar, si no quieres. Lo hice solo para que sea más legible.</p>
<div class="answer">nil</div>
</div>
<div class="stretcher">
<h3>La Madura Fruta de tu Propia Creación</h3>
<p>Un nuevo método ha nacido. Vamos a usarlo: <code class="cmd">comics = load_comics('/comics.txt')</code></p>
<p><em>Si tienes un problema, puedes haberlo escrito mal. Usa el comando <code>back</code> y prueba otra vez.</em></p>
<div class="answer">\{.*"Achewood"=."http://achewood.com/".*\}</div>
</div>
<div class="stretcher">
<h3>Hey, Cool, Una Cosa de Historietas</h3>
<p>En tu ventana de Ruby arriba, mira el código que has escrito para el método <code>load_comics</code>. ¿Qué esta pasando? Tu estas
pasando en la variable <code>path</code> y estas recibiendo la variable <code>comics</code>. Ruby permite filtrar el hash <code>comics</code>
que es devuelto al final del método.</p>
<p>Una cantidad de métodos se usaron para realizar el trabajo. Fíjate si puedes hallarlos.</p>
<ul><li><strong>File.foreach</strong> es el método que abre un archivo y manda cada línea al bloque. La variable <code>line</code>
dentro del bloque <code>do...end</code> va turnando con cada línea del archivo.</li>
<li><strong>split</strong> es un método para strings, que rompe los string en colocándolo en un array. Un hacha es arrojada sobre las comas
y las líneas se cortan en dos, dándonos la <code>url</code> y el nombre, <code>name</code>, de las historietas.</li>
<li><strong>strip</strong> remueve los espacios extra alrededor de name. Por si acaso.</li>
</ul>
<p>Justo allí. Bravo. Tienes las historietas en un hash de Ruby. ¿Pero ahora qué? ¿Qué tan bueno es en verdad?</p>
<p>Hagamos una página de links. ¿Qué te parece? Vamos a necesitar una pequeña librería que hice para ti.</p>
<p>Escribe: <code class="cmd">require 'popup'</code></p>
<div class="answer">true</div>
</div>
<div class="stretcher">
<h3>El Navegador de Títere</h3>
<p>Excelente, has cargado la librería <em>popup</em>. Está guardada en un archivo en el directorio <em>Libraries</em>. Mira: <code>Dir["/Libraries/*"]</code></p>
<p>La librería popup contiene un puñado de métodos que he escrito y te dejaran controlar ventanas emergentes aquí en Try Ruby.</p>
<p>Mira, prueba esto: <code class="cmd">Popup.goto "http://google.com/"</code></p>
<div class="stdout">\033\[1;JSm.*popup_goto\(.*\)\033\[m.*</div>
</div>
<div class="stretcher">
<h3>Haciendo Links e Hilando Redes</h3>
<p>Nuestro propio adorable, pequeño popup para manipular. también puedes rellenarlo con tus cositas. Empecemos por algo pequeño:</p>
<ul><li><code>Popup.make {</code></li>
<li><code> h1 "My Links"</code></li>
<li><code> link "Go to Google", "http://google.com/"</code></li>
<li><code>}</code></li>
</ul>
<p>El termino <code>h1</code> (<em>h-uno</em>) significa encabezado de nivel uno. En HTML, es el encabezado más grande.</p>
<div class="stdout">\033\[1;JSm.*popup_make\(.*h1.*a href.*\)\033\[m.*</div>
</div>
<div class="stretcher">
<h3>Los Popups son tan fáciles, es una Locura</h3>
<p>Se ve bien, lo hiciste perfecto, tal como se te pidió. Hagamos una lista entonces.</p>
<p>Aquí esta como haces una lista con la librería de popup:</p>
<ul><li><code>Popup.make do</code></li>
<li><code> h1 "Things To Do"</code></li>
<li><code> list do</code></li>
<li><code> p "Try out Ruby"</code></li>
<li><code> p "Ride a tiger"</code></li>
<li><code> p "(down River Euphrates)"</code></li>
<li><code> end</code></li>
<li><code>end</code></li>
</ul>
<p>El método <code>p</code> es la manera corta para "párrafo".</p>
<div class="stdout">\033\[1;JSm.*popup_make\(.*h1.*ul.*li.*li.*\)\033\[m.*</div>
</div>
<div class="stretcher">
<h3>Expandiendo las Historietas en la Tabla</h3>
<p>Bien, esto esta yendo maravilloso. Esto es algo simple, pero mantén en mente que no sabias <em>nada sobre Ruby</em> hace quince minutos atrás!<</p>
<p>Ultimo paso. Vamos a juntar todo, ¿sabes? ¡Juntémoslo como esos juegos de
campanillas hermosas que tintinean en los pórticos bajo la hermosa luz del sol
en la playa!</p>
<p>Asegúrate de que las historietas están cargadas: <code>comics = load_comics( '/comics.txt' )</code></p>
<p>Ahora, hagamos una lista de links para cada historieta:</p>
<ul><li><code>Popup.make do</code></li>
<li><code> h1 "Comics on the Web"</code></li>
<li><code> list do</code></li>
<li><code> comics.each do |name, url|</code></li>
<li><code> link name, url</code></li>
<li><code> end</code></li>
<li><code> end</code></li>
<li><code>end</code></li>
</ul>
<p>Puedes clickear en los links y leer las historietas ¡inclusive en la ventana principal! ¡Bárbaro!</p>
<div class="stdout">\033\[1;JSm.*popup_make\(.*h1.*ul.*li.*a href.*li.*a href.*\)\033\[m.*</div>
</div>
<div class="stretcher chapmark">
<h3>Sumario #6 lo que Significa que has Llegado Muy Lejos</h3>
<p>Eres un clérigo nivel 6 de Ruby. Quiero decir que buen trabajo has hecho. Vamos a revisar:</p>
<ul>
<li>Agregaste tu propio método con <strong>def</strong> y usaste ese método <code>load_comics</code> varias veces.</li>
<li><strong>Librerias.</strong> Tú usaste el método <code>require</code> para cargar la librería popup.<br>Escribiendo: <code>require 'popup'</code></li>
<li>Y como si no fuera suficiente, hiciste tu propia página web para listar los archivos de historietas. <strong>¡Hiciste un programa real!</strong></li>
</ul>
<p>Entonces ¿Qué podrá venir luego? ¿Qué deberías aprender posiblemente ahora?
Ja, esta es la mejor parte. Has recorrido un largo camino y ahora descubrirás
las clases. En dos lecciones mas y ya estarás hecho.</p>
<p>Tempranamente, creamos un hash como este: <code class="cmd">Hash.new</code> pruébalo.</p>
<div class="answer">\{\}</div>
</div>
<div class="stretcher">
<h3>No una Clase de Escuela, Una Clase Trabajadora</h3>
<p>Ves, las llaves vacías <code>{}</code> son abreviaciones para <code>Hash.new</code>. El método <code>new</code>
es usado para hacer objetos de cierta clase. (Piensa "clase" como en "clase
trabajadora" — un grupo especifico de objetos similares, tienen el
mismo trabajo, la misma camisa.)</p>
<p>Pregúntate esto: <em>¿Cómo haría mi blog en Ruby?</em> ¿Dónde deberías
comenzar? Bien, deberías guardar tus entradas del blog en un archivo, ¿cierto?
Pero ¿cómo seguirías los títulos de las entradas y el momento en que fue creado?
Y cuando cargas el archivo, ¿cómo se vería en Ruby? ¿Sería un Hash? ¿O un Array? ¿O
un Array de Arrys? ¿O alguna otra cosa?</p><p>Yo realmente creo que querrás usar una clase. Ya estas familiarizado con varias clases: <code>Hash</code>, <code>Array</code>, <code>String</code>.</p>
<p>Hagamos una clase nueva: <code class="cmd">class BlogEntry</code>.</p>
<div class="stdout">..</div>
</div>
<div class="stretcher">
<h3>El Relleno del Blog esta Hecho de</h3>
<p>Has abierto una nueva clase <code>BlogEntry</code>. ¿De que están hechas las entradas de tu blog? Un titulo, seguro. también,
la fecha en la que fue creada. El texto entero de la entrada.</p>
<p>Vamos a poner el estado de ánimo, también, tal como LiveJournal. <img src="intro_files/sick.gif"> La internet ha traído de vuelta las personas de palitos y emoticones
fuera de la bancarrota.<em>¡Que emoción!</em></p>
<p>Bueno, ya tienes la primera línea de la clase, aquí esta el resto:/p>
<ul><li><code class="faded">class BlogEntry</code></li>
<li><code> attr_accessor :title, :time, :fulltext, :mood</code></li>
<li><code>end</code></li>
</ul>
<div class="answer">nil</div>
</div>
<div class="stretcher">
<h3>Accessors Son las Extremidades Colgantes</h3>
<p>Hey, buena clase, colega. Tienes una nueva clase <code>BlogEntry</code>. Para comenzar una entrada: <br><code class="cmd">entry = BlogEntry.new</code>.</p>
<p>En la definición de la clase, usaste un método llamado <code>attr_accessor</code>. Existen varios métodos <strong>attr</strong>ibute
atributo, como este que agregan pequeñas configuraciones a la clase. Estos atributos son simplemente variables adosadas a la clase.</p>
<p>Piénsalo de este modo. Una clase es como una persona. Esa forma de estrella
del humano. Y los atributos son las extremidades, las diferentes partes que
hacen un cuerpo.</p>
<p>Para crear el titulo de tu entrada: <code class="cmd">entry.title = "Today Mt. Hood Was Stolen!"</code></p>
<div class="answer">".+"</div>
</div>
<div class="stretcher">
<h3>Un Objeto, Ese Estupendo Paquete Pequeño</h3>
<p>Sigue adelante y pon la hora: <code class="cmd">entry.time = Time.now</code></p>
<p>Y el estado de animo: <code class="cmd">entry.mood = :sick</code></p>
<p>Y el anuncio en si: <code class="cmd">entry.fulltext = "I can't believe Mt. Hood was stolen! I am speechless! It was stolen by a giraffe who drove away
in his Cadillac Seville very nonchalant!!"</code></p>
<p>Para ver toda la configuración, simplemente escribe en el prompt: <code class="cmd">entry</code>.</p>
<div class="answer">#.BlogEntry:0x[0-9a-f]+ ((@title|@mood|@time|@fulltext)=.*?, ){3}.*</div>
</div>
<div class="stretcher">
<h3>Agilizando</h3>
<p>Genial, tu blog es impresionante. Hey, hagamos las cosas algo mas fácil. No querrás
poner la hora asi todas las veces que postees. Solo quieres escribir el titulo,
el contenido y el emoticon rápido, ¿verdad?</p>
<p>Vamos a agregar un método <code>initialize</code>.</p>
<ul><li><code>class BlogEntry</code></li>
<li><code> def initialize( title, mood, fulltext )</code></li>
<li><code> @time = Time.now</code></li>
<li><code> @title, @mood, @fulltext = title, mood, fulltext</code></li>
<li><code> end</code></li>
<li><code>end</code></li>
</ul>
<p>Una vez que lo hallas escrito, prueba hacer una nueva entrada: <code class="cmd">BlogEntry.new</code></p>
<div class="stdout">ArgumentError: wrong number of arguments \(0 for 3\).*</div>
</div>
<div class="stretcher">
<h3>Tu le Has Enseñado al Blog a Rechazar lo Malo</h3>
<p>¿Viste como usamos dentro de la clase el símbolo arroba? De este modo: <code>@time = Time.now</code></p>
<p>Fuera de la clase, usamos accesos (accessors): <code>entry.time = Time.now</code> Pero dentro <em>variables de instancia</em>: <code>@time = Time.now</code>
Son exactamente lo mismo, pero expresado en dos partes diferentes de tu programa.</p>
<p>tu blog ahora necesita un titulo, estado de ánimo y el post para funcionar. Cuando un nuevo <code>BlogEntry</code> es creado, el método <code>initialize</code>
es usado para chequear cualquier argumento para <code>new</code>. ¡Uh, necesitamos tres argumentos!</p>
<p>Prueba de nuevo con los tres.</p><p>
</p><p><code class="cmd">entry2
= BlogEntry.new( "I Left my Hoodie on the Mountain!", :confused, "I am
never going back to that mountain and I hope a giraffe steals it." )</code></p>
<div class="answer">#.BlogEntry:0x[0-9a-f]+ ((@title|@mood|@time|@fulltext)=.*?, ){3}.*</div>
</div>
<div class="stretcher chapmark">
<h3>Una Jirafa No Ha Robado el Sumario #7</h3>
<p>Aha, estas aquí. Y todo en una pieza. Todavía vamos a hacer tu blog realidad, pero hasta entonces, vamos a revisar, ¿bien?</p>
<ul>
<li><strong>Clases.</strong> Todo en Ruby es algún tipo de objeto. Las clases explican los objetos. Como ciertos objetos
trabajan. Por ejemplo, haces algunas entradas de blog y estos objetos están explicados en la clase <code>BlogEntry</code>.
En otras palabras: los llamas objetos del tipo BlogEntry.</li>
<li><strong>Accessors</strong> son variables adosadas a un objeto que pueden ser usadas <em>fuera</em> del objeto. (<code>entry.time = Time.now</code>)</li>
<li><strong>Variables de instancia</strong> son las mismas variables para accesos <em>dentro</em> del objeto.
Como en la definición de un método. (<code>@time = Time.now</code>)</li>
</ul>
<p>Bueno, vamos a envolver las cosas, niño. Aquí esta el ultimo capitulo de la FASCINANTE épica
historia de Try Ruby! Ahora que ya has probado como todo funciona, ¿cómo vas a
usar eso alrededor de la casa y en tu tienda de comestibles? Eres una
gran persona (una de mis favoritas), pero necesitas dirección.</p>
<p>Vamos a terminar tu blog. Tienes entradas de blog, pero no un blog.</p>
<p>Pon las entradas en un array: <code class="cmd">blog = [entry, entry2]</code></p>
<div class="answer">\[#.BlogEntry:0x[0-9a-f]+.*, #.BlogEntry:0x[0-9a-f]+.*\]</div>
</div>
<div class="stretcher">
<h3>Todo Se Trata de Combinar Cosas</h3>
<p>Cosas hermosas pueden hacerse de partes simples de Ruby, especialmente
cuando las combinas entre ellas para formar algo nuevo. Aquí tenemos un blog
hecho de un array de clases. Y, en realidad, Ruby realmente hace buenas cosas
con este tipo de criaturas.</p>
<p>Aquí hay un puñado de cosas que puedes hacer con tu blog array:</p>
<ul><li>Querrás ordenar tus entradas de mas reciente a viejas. Puedes hacerlo con:<br>
<code>blog.sort_by { |entry| entry.time }.reverse</code><br>Ve <a href="http://ruby-doc.org/core/classes/Enumerable.html#method-i-sort_by" target="_new">sort_by</a> para más explicación.</li>
<li>Si quieres buscar en el blog por cualquier cosa relacionada con "cadillac": <br>
<code>blog.find_all { |entry| entry.fulltext.match(/cadillac/i) }</code><br>
Lee mas en <a href="http://ruby-doc.org/core-2.0/Enumerable.html#method-i-find_all" target="_new">find_all</a>
y <a href="http://ruby-doc.org/core-2.0/String.html#method-i-match" target="_new">match</a>
para descubrir como funciona. También: <code>/giraffe/i</code> es un objeto Regexp, usado para concordar palabras.</li>
<li>Y agregar nuevas entradas con <code>blog << new_entry</code><br>
Y aquí la documentación del método <a href="http://ruby-doc.org/core-2.0/Array.html#method-i-3C-3C" target="_new"><<</a>.</li>
</ul>
<p>Puedes buscar entre la lista de los métodos con los que viene Ruby en <a href="http://ruby-doc.org/core/" target="_new">ruby-doc.org's core</a>.
Otra buena lista hay en <a href="http://www.whytheluckystiff.net/ruby/pickaxe/html/builtins.html">online pickaxe</a>.</p>
<p>Un método <em>realmente</em> útil (probablemente yo uso esto mas que otra cosa) es <code>map</code>. Escribe: <code class="cmd">blog.map { |entry| entry.mood }</code></p>
<div class="answer">\[(:\w+, )+:\w+\]</div>
</div>
<div class="stretcher">
<h3>Mira Su Cara — La Transformación Ha Comenzado</h3>
<p>El método <code>map</code> recorre un array y reemplaza cada ítem con algo nuevo. ¿Dices que quieres reemplazar cada entrada de tu blog
con el nombre de <em>Bruce Willis?</em>. Hazlo entonces: <code>blog.map { "Bruce Willis" }</code></p>
<p>Como el bloque siempre devuelve el string "Bruce Willis", eso es lo que obtienes. En el código que acabas de usar, la entrada <code>entry</code> wfue reemplazada
por solo el <code>entry.mood</code>.</p>
<p>Ahora, quiero que hagas un popup con las entradas de tu blog. Yo no te voy a
dar todo el código. Solo te voy a dar una parte.</p>
<ul><li><code>blog.each do |entry|</code></li>
<li><code> h2 entry.title</code></li>
<li><code> p entry.fulltext</code></li>
<li><code>end</code></li>
</ul>
<p>Ahora, yo espero que pongas el código del popup alrededor y agregues un titulo con el nombre de tu blog usando <code>h1</code>. Como extra, tienes la hora de cada entrada para mostrar.</p>
<div class="stdout">\033\[1;JSm.*popup_make\(.*h1.*h2.*li.*h2.*li.*\)\033\[m.*</div>
</div>
<div class="stretcher">
<h3>Eres Una Especie de Gurú Web, Tengo Estrellas en Mis Ojos</h3>
<p>Bien, ¡eso es! Este es exactamente el código que puedes usar para escribir tu
propio blog real en Ruby. Si te sientes aventurero, yo chequearía el video de
Rails <a href="http://rubyonrails.org/screencasts" target="_new">videos</a> donde muestran a un joven compañero creando un blog en 15 minutos. Solo sientete cómodo y mira.</p>
<p>Debo mencionar a Rails. Tú has estado aprendiendo el lenguaje Ruby, como
hablarlo. Pero Rails es grupo de librerías (algo asi como la librería de popup
que hemos estado usando.) Es un poderoso conjunto de herramientas para crear
sitios web. Si estas interesado en aprender sobre Rails, yo miraría <a href="http://rubyonrails.org/" target="_new">head
por aquí</a> directamente. ¡Empieza a usar tus habilidades en Ruby apropiadamente!</p>
<p>Algo que tiene Rails son métodos para manejar fechas fácilmente. Como, prueba: <code class="cmd">Time.now - 2.weeks</code></p>
<div class="load">class Integer; def weeks; self * 7*24*60*60; end; end</div>
<div class="answer">\w+ \w+ \d+ \d{2}:\d{2}:\d{2} .*</div>
</div>
<div class="stretcher">
<h3>Si Quieres Empezar Poco a Poco</h3>
<p>Si quieres comenzar escribiendo pequeños programas en Ruby para practicar, tengo un proyecto llamado <a href="http://code.whytheluckystiff.net/mouseHole/" target="_new">MouseHole</a>
que es una pequeña caja de herramientas en la web para escribir programas cortos en Ruby. Puedes ver aquí <a href="http://code.whytheluckystiff.net/mouseHole/wiki/UserScripts" target="_new">algunos
scripts</a> para ver que quiero decir.</p>
<p>MouseHole no es para escribir sitios web en realidad. Es para escribir
pequeños programas y correrlos dentro del navegador. Como hay un programa block
de notas para MouseHole y un programa que agrega una imagen de un ratón a los
links de la web que linkean a programas de MouseHole.</p>
<p>Tengo un script de MouseHole dentro de un archivo aquí mismo:<br>
<code class="cmd">print File.read("/MouseHole/flickrpedia.user.rb")</code></p>
<div class="stdout">.*Inserts Wikipedia links for Flickr tags.*</div>
</div>
<div class="stretcher chapmark">
<h3>Sumario #8, El Sumario Hey-Relájate-Lo-Hiciste-Bien</h3>
<p>Esta ultima sección se tomó un momento para relajarse, para darte algunos consejos de como
puedes usar Ruby. Si lo has disfrutado, descarga Ruby e instálalo.</p>
<ul><li>Para Mac: <a href="http://homepage.mac.com/discord/Ruby/" target="_new">Paquete instalador OS X de Ruby</a></li>
<li>Para Windows: <a href="http://rubyforge.org/frs/download.php/4174/ruby182-15.exe" target="_new">Instalador para Windows de Ruby</a></li>
<li>Otras plataformas: <a href="http://www.ruby-lang.org/en/20020102.html" target="_new">Fuentes</a></li></ul>
<p>Una vez que tengas Ruby instalado, puedes usar Ruby Interactivo ejecutando el comando <code>irb</code> en el prompt de tu sistema. Para mas sobre Irb, esta
<a href="http://poignantguide.net/ruby/expansion-pak-1.html" target="_new">The Tiger's Vest</a> para ayudarte.</p>
<p>Tú realmente mereces una torta doble-capa con doble-doble azúcar glaseado y
un tipo tocando una de esas guitarras que son doble-guitarra. Quiero decir
terminaste, ¡lo hiciste! No hay dudas de eso, ¡eres un gran ser certificado!</p>
<br>
</div>
</body>
</html>