-
Notifications
You must be signed in to change notification settings - Fork 0
/
active_support_core_extensions.html
3907 lines (3751 loc) · 375 KB
/
active_support_core_extensions.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
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Extensiones de Núcleo de Active Support — Ruby on Rails Guides</title>
<link rel="stylesheet" type="text/css" href="stylesheets/style.css" data-turbolinks-track="reload">
<link rel="stylesheet" type="text/css" href="stylesheets/print.css" media="print">
<link rel="stylesheet" type="text/css" href="stylesheets/prism/default.css" data-turbolinks-track="reload">
<link rel="stylesheet" type="text/css" href="stylesheets/prism/rails-guides.css" data-turbolinks-track="reload">
<link href="images/favicon.ico" rel="shortcut icon" type="image/x-icon" />
<script src="javascripts/prism.js" data-turbolinks-track="reload"></script>
<script src="javascripts/turbolinks.js" data-turbolinks-track="reload"></script>
<script src="javascripts/guides.js" data-turbolinks-track="reload"></script>
<script src="javascripts/responsive-tables.js" data-turbolinks-track="reload"></script>
<meta property="og:title" content="Extensiones de Núcleo de Active Support — Ruby on Rails Guides" />
<meta name="description" content="NO LEA ESTE ARCHIVO EN GITHUB, LAS GUÍAS SE PUBLICAN EN https://guides.rubyonrails.org.Extensiones de Núcleo de Active SupportActive Support es el componente Ruby on Rails responsable de proporcionar extensiones de lenguaje Ruby, utilidades y otras cosas transversales.Ofrece un resultado final más rico a nivel de lenguaje, dirigido tanto al desarrollo de aplicaciones Rails como al desarrollo de Ruby on Rails.Después de leer esta guía, sabrá: Qué son las extensiones principales. Cómo cargar todas las extensiones. Cómo seleccionar las extensiones que desee. Qué extensiones proporciona Active Support." />
<meta property="og:description" content="NO LEA ESTE ARCHIVO EN GITHUB, LAS GUÍAS SE PUBLICAN EN https://guides.rubyonrails.org.Extensiones de Núcleo de Active SupportActive Support es el componente Ruby on Rails responsable de proporcionar extensiones de lenguaje Ruby, utilidades y otras cosas transversales.Ofrece un resultado final más rico a nivel de lenguaje, dirigido tanto al desarrollo de aplicaciones Rails como al desarrollo de Ruby on Rails.Después de leer esta guía, sabrá: Qué son las extensiones principales. Cómo cargar todas las extensiones. Cómo seleccionar las extensiones que desee. Qué extensiones proporciona Active Support." />
<meta property="og:locale" content="en_US" />
<meta property="og:site_name" content="Ruby on Rails Guides" />
<meta property="og:image" content="https://avatars.githubusercontent.com/u/4223" />
<meta property="og:type" content="website" />
</head>
<body class="guide">
<div>
<!-- <img src="images/edge_badge.png" alt="edge-badge" id="edge-badge" />-->
</div>
<div id="topNav">
<div class="wrapper">
<strong class="more-info-label">Más en <a href="https://rubyonrails.org/">rubyonrails.org:</a> </strong>
<span class="red-button more-info-button">
Más Ruby on Rails
</span>
<ul class="more-info-links s-hidden">
<li class="more-info"><a href="https://weblog.rubyonrails.org/">Blog</a></li>
<li class="more-info"><a href="https://guides.rubyonrails.org/">Guías</a></li>
<li class="more-info"><a href="https://api.rubyonrails.org/">API</a></li>
<li class="more-info"><a href="https://stackoverflow.com/questions/tagged/ruby-on-rails">Pedir Ayuda</a></li>
<li class="more-info"><a href="https://github.com/rails/rails">Contribuir on GitHub</a></li>
</ul>
</div>
</div>
<div id="header">
<div class="wrapper clearfix">
<h1><a href="index.html" title="Guías de Ruby on Rails">Guías de Ruby on Rails </a></h1>
<ul class="nav">
<li><a class="nav-item" href="index.html">Inicio</a></li>
<li class="guides-index guides-index-large">
<a href="index.html" id="guidesMenu" class="guides-index-item nav-item">Index de Guías </a>
<div id="guides" class="clearfix" style="display: none;">
<hr />
<dl class="guides-section-container">
<div class="guides-section">
<dt>Empieza Aqui</dt>
<dd><a href="getting_started.html">Introducción a Rails</a></dd>
</div>
<div class="guides-section">
<dt>Modelos</dt>
<dd><a href="active_record_basics.html">Conceptos básicos de Active Record</a></dd>
<dd><a href="active_record_migrations.html">Migraciones de Active Record</a></dd>
<dd><a href="active_record_validations.html">Validaciones de Active Record</a></dd>
<dd><a href="active_record_callbacks.html">Devolución (callbacks) de Llamadas de Active Record</a></dd>
<dd><a href="association_basics.html">Asociaciones de Active Record</a></dd>
<dd><a href="active_record_querying.html">Interfaz de Consulta de Active Record</a></dd>
</div>
<div class="guides-section">
<dt>Vistas</dt>
<dd><a href="layouts_and_rendering.html">Diseños y Renderizado en Rails</a></dd>
<dd><a href="form_helpers.html">Ayudantes de Formulario de Action</a></dd>
</div>
<div class="guides-section">
<dt>Controladores</dt>
<dd><a href="action_controller_overview.html">Descripción General de Action Controller</a></dd>
<dd><a href="routing.html">Rails Routing Desde el Exterior Hacia Adentro</a></dd>
</div>
<div class="guides-section">
<dt>Otros Componentes</dt>
<dd><a href="active_support_core_extensions.html">Extensiones de Núcleo de Active Support</a></dd>
<dd><a href="action_mailer_basics.html">Conceptos Básicos de Action Mailer</a></dd>
<dd><a href="active_job_basics.html">Conceptos Básicos de Active Job</a></dd>
<dd><a href="active_storage_overview.html">Descripción General de Active Storage</a></dd>
<dd><a href="action_cable_overview.html">Descripción General de Action Cable</a></dd>
</div>
<div class="guides-section">
<dt>Temas Avanzados</dt>
<dd><a href="i18n.html">Rails API de Internacionalización (I18n)</a></dd>
<dd><a href="testing.html">Prueba de Aplicaciones de Rails</a></dd>
<dd><a href="security.html">Seguridad de Aplicaciones Rails</a></dd>
<dd><a href="debugging_rails_applications.html">Depuración de Applications Rails</a></dd>
<dd><a href="configuring.html">Configuración de Aplicaciones de Rails</a></dd>
<dd><a href="command_line.html">La Línea de Comandos de Rails</a></dd>
<dd><a href="asset_pipeline.html">La Canalización de Activos</a></dd>
<dd><a href="autoloading_and_reloading_constants.html">Constantes de Autocarga y Recarga (Zeitwerk Mode)</a></dd>
<dd><a href="autoloading_and_reloading_constants_classic_mode.html">Constantes de Autocarga y Recarga (modo clásico)</a></dd>
<dd><a href="caching_with_rails.html">Almacenamiento en Caché con Rails Descripción General</a></dd>
<dd><a href="api_app.html">Uso de Rails para Aplicaciones Solo API</a></dd>
</div>
<div class="guides-section">
<dt>Extending Rails (toda la sección necesita traducción)</dt>
<dd><a href="rails_on_rack.html">Rails on Rack</a></dd>
<dd><a href="generators.html">Creating and Customizing Rails Generators & Templates</a></dd>
</div>
</dl>
</div>
</li>
<li><a class="nav-item" href="contributing_to_ruby_on_rails.html">Contribuir</a></li>
<li class="guides-index guides-index-small">
<select class="guides-index-item nav-item">
<option value="index.html">Guides Index</option>
<optgroup label="Empieza Aqui">
<option value="getting_started.html">Introducción a Rails</option>
</optgroup>
<optgroup label="Modelos">
<option value="active_record_basics.html">Conceptos básicos de Active Record</option>
<option value="active_record_migrations.html">Migraciones de Active Record</option>
<option value="active_record_validations.html">Validaciones de Active Record</option>
<option value="active_record_callbacks.html">Devolución (callbacks) de Llamadas de Active Record</option>
<option value="association_basics.html">Asociaciones de Active Record</option>
<option value="active_record_querying.html">Interfaz de Consulta de Active Record</option>
</optgroup>
<optgroup label="Vistas">
<option value="layouts_and_rendering.html">Diseños y Renderizado en Rails</option>
<option value="form_helpers.html">Ayudantes de Formulario de Action</option>
</optgroup>
<optgroup label="Controladores">
<option value="action_controller_overview.html">Descripción General de Action Controller</option>
<option value="routing.html">Rails Routing Desde el Exterior Hacia Adentro</option>
</optgroup>
<optgroup label="Otros Componentes">
<option value="active_support_core_extensions.html">Extensiones de Núcleo de Active Support</option>
<option value="action_mailer_basics.html">Conceptos Básicos de Action Mailer</option>
<option value="active_job_basics.html">Conceptos Básicos de Active Job</option>
<option value="active_storage_overview.html">Descripción General de Active Storage</option>
<option value="action_cable_overview.html">Descripción General de Action Cable</option>
</optgroup>
<optgroup label="Temas Avanzados">
<option value="i18n.html">Rails API de Internacionalización (I18n)</option>
<option value="testing.html">Prueba de Aplicaciones de Rails</option>
<option value="security.html">Seguridad de Aplicaciones Rails</option>
<option value="debugging_rails_applications.html">Depuración de Applications Rails</option>
<option value="configuring.html">Configuración de Aplicaciones de Rails</option>
<option value="command_line.html">La Línea de Comandos de Rails</option>
<option value="asset_pipeline.html">La Canalización de Activos</option>
<option value="autoloading_and_reloading_constants.html">Constantes de Autocarga y Recarga (Zeitwerk Mode)</option>
<option value="autoloading_and_reloading_constants_classic_mode.html">Constantes de Autocarga y Recarga (modo clásico)</option>
<option value="caching_with_rails.html">Almacenamiento en Caché con Rails Descripción General</option>
<option value="api_app.html">Uso de Rails para Aplicaciones Solo API</option>
</optgroup>
<optgroup label="Extending Rails (toda la sección necesita traducción)">
<option value="rails_on_rack.html">Rails on Rack</option>
<option value="generators.html">Creating and Customizing Rails Generators & Templates</option>
</optgroup>
</select>
</li>
</ul>
</div>
</div>
<hr class="hide" />
<div id="feature">
<div class="wrapper">
<p><strong>NO LEA ESTE ARCHIVO EN GITHUB, LAS GUÍAS SE PUBLICAN EN <a href="https://guides.rubyonrails.org">https://guides.rubyonrails.org</a>.</strong></p><h2>Extensiones de Núcleo de Active Support</h2><p>Active Support es el componente Ruby on Rails responsable de proporcionar extensiones de lenguaje Ruby, utilidades y otras cosas transversales.</p><p>Ofrece un resultado final más rico a nivel de lenguaje, dirigido tanto al desarrollo de aplicaciones Rails como al desarrollo de Ruby on Rails.</p><p>Después de leer esta guía, sabrá:</p>
<ul>
<li>Qué son las extensiones principales.</li>
<li>Cómo cargar todas las extensiones.</li>
<li>Cómo seleccionar las extensiones que desee.</li>
<li>Qué extensiones proporciona Active Support.</li>
</ul>
<div id="subCol">
<h3 class="chapter"><img src="images/chapters_icon.gif" alt="" />Chapters</h3>
<ol class="chapters">
<li>
<a href="#how-to-load-core-extensions">How to Load Core Extensions</a>
<ul>
<li><a href="#stand-alone-active-support">Stand-Alone Active Support</a></li>
<li><a href="#active-support-within-a-ruby-on-rails-application">Active Support Within a Ruby on Rails Application</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-all-objects">Extensions to All Objects</a>
<ul>
<li><a href="#blank-questionmark-and-present-questionmark"><code>blank?</code> and <code>present?</code></a></li>
<li><a href="#presence"><code>presence</code></a></li>
<li><a href="#duplicable-questionmark"><code>duplicable?</code></a></li>
</ul>
</li>
<li>
<a href="#deep-dup"><code>deep_dup</code></a>
<ul>
<li><a href="#try"><code>try</code></a></li>
<li><a href="#class-eval-args-block"><code>class_eval(*args, &block)</code></a></li>
<li><a href="#acts-like-questionmark-duck"><code>acts_like?(duck)</code></a></li>
<li><a href="#to-param"><code>to_param</code></a></li>
<li><a href="#to-query"><code>to_query</code></a></li>
<li><a href="#with-options"><code>with_options</code></a></li>
<li><a href="#json-support">JSON support</a></li>
<li><a href="#instance-variables">Instance Variables</a></li>
<li><a href="#silencing-warnings-and-exceptions">Silencing Warnings and Exceptions</a></li>
<li><a href="#in-questionmark"><code>in?</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-module">Extensions to <code>Module</code></a>
<ul>
<li><a href="#attributes">Attributes</a></li>
<li><a href="#parents">Parents</a></li>
<li><a href="#anonymous">Anonymous</a></li>
<li><a href="#method-delegation">Method Delegation</a></li>
<li><a href="#redefining-methods">Redefining Methods</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-class">Extensions to <code>Class</code></a>
<ul>
<li><a href="#class-attributes">Class Attributes</a></li>
<li><a href="#subclasses-descendants">Subclasses & Descendants</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-string">Extensions to <code>String</code></a>
<ul>
<li><a href="#output-safety">Output Safety</a></li>
<li><a href="#transformation">Transformation</a></li>
<li><a href="#remove"><code>remove</code></a></li>
<li><a href="#squish"><code>squish</code></a></li>
<li><a href="#truncate"><code>truncate</code></a></li>
<li><a href="#truncate-bytes"><code>truncate_bytes</code></a></li>
<li><a href="#truncate-words"><code>truncate_words</code></a></li>
<li><a href="#inquiry"><code>inquiry</code></a></li>
<li><a href="#extensions-to-string-starts-with-questionmark-and-ends-with-questionmark"><code>starts_with?</code> and <code>ends_with?</code></a></li>
<li><a href="#strip-heredoc"><code>strip_heredoc</code></a></li>
<li><a href="#access">Access</a></li>
<li><a href="#inflections">Inflections</a></li>
<li><a href="#extensions-to-string-conversions">Conversions</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-symbol">Extensions to <code>Symbol</code></a>
<ul>
<li><a href="#extensions-to-symbol-starts-with-questionmark-and-ends-with-questionmark"><code>starts_with?</code> and <code>ends_with?</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-numeric">Extensions to <code>Numeric</code></a>
<ul>
<li><a href="#bytes">Bytes</a></li>
<li><a href="#extensions-to-numeric-time">Time</a></li>
<li><a href="#formatting">Formatting</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-integer">Extensions to <code>Integer</code></a>
<ul>
<li><a href="#multiple-of-questionmark"><code>multiple_of?</code></a></li>
<li><a href="#ordinal"><code>ordinal</code></a></li>
<li><a href="#ordinalize"><code>ordinalize</code></a></li>
<li><a href="#extensions-to-integer-time">Time</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-bigdecimal">Extensions to <code>BigDecimal</code></a>
<ul>
<li><a href="#extensions-to-bigdecimal-to-s"><code>to_s</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-enumerable">Extensions to <code>Enumerable</code></a>
<ul>
<li><a href="#sum"><code>sum</code></a></li>
<li><a href="#index-by"><code>index_by</code></a></li>
<li><a href="#index-with"><code>index_with</code></a></li>
<li><a href="#many-questionmark"><code>many?</code></a></li>
<li><a href="#exclude-questionmark"><code>exclude?</code></a></li>
<li><a href="#including"><code>including</code></a></li>
<li><a href="#excluding"><code>excluding</code></a></li>
<li><a href="#pluck"><code>pluck</code></a></li>
<li><a href="#pick"><code>pick</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-array">Extensions to <code>Array</code></a>
<ul>
<li><a href="#accessing">Accessing</a></li>
<li><a href="#extensions-to-array-extracting">Extracting</a></li>
<li><a href="#options-extraction">Options Extraction</a></li>
<li><a href="#extensions-to-array-conversions">Conversions</a></li>
<li><a href="#wrapping">Wrapping</a></li>
<li><a href="#duplicating">Duplicating</a></li>
<li><a href="#grouping">Grouping</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-hash">Extensions to <code>Hash</code></a>
<ul>
<li><a href="#extensions-to-hash-conversions">Conversions</a></li>
<li><a href="#merging">Merging</a></li>
<li><a href="#deep-duplicating">Deep duplicating</a></li>
<li><a href="#working-with-keys">Working with Keys</a></li>
<li><a href="#working-with-values">Working with Values</a></li>
<li><a href="#slicing">Slicing</a></li>
<li><a href="#extensions-to-hash-extracting">Extracting</a></li>
<li><a href="#indifferent-access">Indifferent Access`</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-regexp">Extensions to <code>Regexp</code></a>
<ul>
<li><a href="#multiline-questionmark"><code>multiline?</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-range">Extensions to <code>Range</code></a>
<ul>
<li><a href="#extensions-to-range-to-s"><code>to_s</code></a></li>
<li><a href="#overlaps-questionmark"><code>overlaps?</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-date">Extensions to <code>Date</code></a>
<ul>
<li><a href="#extensions-to-date-calculations">Calculations</a></li>
<li><a href="#extensions-to-date-conversions">Conversions</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-datetime">Extensions to <code>DateTime</code></a>
<ul>
<li><a href="#extensions-to-datetime-calculations">Calculations</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-time">Extensions to <code>Time</code></a>
<ul>
<li><a href="#calculations">Calculations</a></li>
<li><a href="#time-constructors">Time Constructors</a></li>
</ul>
</li>
<li>
<a href="#extensions-to-file">Extensions to <code>File</code></a>
<ul>
<li><a href="#atomic-write"><code>atomic_write</code></a></li>
</ul>
</li>
<li>
<a href="#extensions-to-marshal">Extensions to <code>Marshal</code></a>
<ul>
<li><a href="#load"><code>load</code></a></li>
</ul>
</li>
<li><a href="#extensions-to-nameerror">Extensions to <code>NameError</code></a></li>
<li><a href="#extensions-to-loaderror">Extensions to <code>LoadError</code></a></li>
</ol>
</div>
</div>
</div>
<div id="container">
<div class="wrapper">
<div id="mainCol">
<h3 id="how-to-load-core-extensions"><a class="anchorlink" href="#how-to-load-core-extensions">1 How to Load Core Extensions</a></h3><h4 id="stand-alone-active-support"><a class="anchorlink" href="#stand-alone-active-support">1.1 Stand-Alone Active Support</a></h4><p>Para tener una huella predeterminada cercana a cero, Active Support no carga nada de forma predeterminada. Está dividido en pedazos pequeños para que pueda cargar justo lo que necesita, y también tiene algunos puntos de entrada convenientes para cargar extensiones relacionadas de una sola vez, incluso todo.</p><p>Por lo tanto, después de un simple requerimiento como:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="nb">require</span> <span class="s2">"active_support"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='require "active_support"
'>Copy</button>
</div>
<p>objects do not even respond to <code>blank?</code>. Let's see how to load its definition.</p><h5 id="cherry-picking-a-definition"><a class="anchorlink" href="#cherry-picking-a-definition">1.1.1 Cherry-picking a Definition</a></h5><p>La forma más ligera de dejar <code>blank?</code> es seleccionar el archivo que lo define.</p><p>Para cada método definido como una extensión principal, esta guía tiene una nota que dice dónde se define dicho método. En el caso de <code>blank?</code>, La nota dice:</p><div class="note"><p>Definido en <code>active_support/core_ext/object/blank.rb</code>.</p></div><p>Eso significa que puede solicitarlo así:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="nb">require</span> <span class="s2">"active_support"</span>
<span class="nb">require</span> <span class="s2">"active_support/core_ext/object/blank"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='require "active_support"
require "active_support/core_ext/object/blank"
'>Copy</button>
</div>
<p>Active Support se ha revisado cuidadosamente para que la selección de un archivo solo cargue las dependencias estrictamente necesarias, si las hubiera.</p><h5 id="loading-grouped-core-extensions"><a class="anchorlink" href="#loading-grouped-core-extensions">1.1.2 Loading Grouped Core Extensions</a></h5><p>El siguiente nivel es simplemente cargar todas las extensiones en <code>Object</code>. Como regla general, las extensiones de <code>SomeClass</code> están disponibles de una sola vez cargando <code>active_support/core_ext/some_class</code>.</p><p>Por lo tanto, para cargar todas las extensiones a <code>Object</code> (incluyendo <code>blank?</code>):</p><div class="code_container">
<pre><code class="highlight ruby"><span class="nb">require</span> <span class="s2">"active_support"</span>
<span class="nb">require</span> <span class="s2">"active_support/core_ext/object"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='require "active_support"
require "active_support/core_ext/object"
'>Copy</button>
</div>
<h5 id="loading-all-core-extensions"><a class="anchorlink" href="#loading-all-core-extensions">1.1.3 Loading All Core Extensions</a></h5><p>Es posible que prefiera cargar todas las extensiones principales, hay un archivo para eso:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="nb">require</span> <span class="s2">"active_support"</span>
<span class="nb">require</span> <span class="s2">"active_support/core_ext"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='require "active_support"
require "active_support/core_ext"
'>Copy</button>
</div>
<h5 id="loading-all-active-support"><a class="anchorlink" href="#loading-all-active-support">1.1.4 Loading All Active Support</a></h5><p>Y finalmente, si desea tener disponible todo el Soporte activo, simplemente emita:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="nb">require</span> <span class="s2">"active_support/all"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='require "active_support/all"
'>Copy</button>
</div>
<p>Eso ni siquiera pone todo el Active Support en la memoria por adelantado, de hecho, algunas cosas se configuran mediante <code>autoload</code>, por lo que solo se carga si se usa.</p><h4 id="active-support-within-a-ruby-on-rails-application"><a class="anchorlink" href="#active-support-within-a-ruby-on-rails-application">1.2 Active Support Within a Ruby on Rails Application</a></h4><p>Una aplicación Ruby on Rails carga todo el soporte activo a menos que <code>config.active_support.bare</code> sea verdadero. En ese caso, la aplicación solo cargará lo que el propio marco elija para sus propias necesidades, y aún puede hacerlo en cualquier nivel de granularidad, como se explicó en la sección anterior.</p><h3 id="extensions-to-all-objects"><a class="anchorlink" href="#extensions-to-all-objects">2 Extensions to All Objects</a></h3><h4 id="blank-questionmark-and-present-questionmark"><a class="anchorlink" href="#blank-questionmark-and-present-questionmark">2.1 <code>blank?</code> and <code>present?</code></a></h4><p>The following values are considered to be blank in a Rails application:</p>
<ul>
<li><p><code>nil</code> y<code>false</code>,</p></li>
<li><p>cadenas compuestas solo de espacios en blanco (ver nota a continuación),</p></li>
<li><p>matrices y hashes vacíos, y</p></li>
<li><p>cualquier otro objeto que responda a "¿vacío?" y esté vacío.</p></li>
</ul>
<div class="info"><p>El predicado para cadenas utiliza la clase de caracteres compatible con Unicode <code>[:space:]</code>, por lo que, por ejemplo, U + 2029 (separador de párrafo) se considera un espacio en blanco.</p></div><div class="warning"><p>Tenga en cuenta que no se mencionan los números. En particular, 0 y 0.0 son ** no ** en blanco.</p></div><p>Por ejemplo, este método de <code>ActionController::HttpAuthentication::Token::ControllerMethods</code> usa <code>blank?</code> Para verificar si un token está presente:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">def</span> <span class="nf">authenticate</span><span class="p">(</span><span class="n">controller</span><span class="p">,</span> <span class="o">&</span><span class="n">login_procedure</span><span class="p">)</span>
<span class="n">token</span><span class="p">,</span> <span class="n">options</span> <span class="o">=</span> <span class="n">token_and_options</span><span class="p">(</span><span class="n">controller</span><span class="p">.</span><span class="nf">request</span><span class="p">)</span>
<span class="k">unless</span> <span class="n">token</span><span class="p">.</span><span class="nf">blank?</span>
<span class="n">login_procedure</span><span class="p">.</span><span class="nf">call</span><span class="p">(</span><span class="n">token</span><span class="p">,</span> <span class="n">options</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="def authenticate(controller, &login_procedure)
token, options = token_and_options(controller.request)
unless token.blank?
login_procedure.call(token, options)
end
end
">Copy</button>
</div>
<p>El método <code>present?</code> Es equivalente a <code>!blank?</code>. Este ejemplo está tomado de <code>ActionDispatch::Http::Cache::Response</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">def</span> <span class="nf">set_conditional_cache_control!</span>
<span class="k">return</span> <span class="k">if</span> <span class="nb">self</span><span class="p">[</span><span class="s2">"Cache-Control"</span><span class="p">].</span><span class="nf">present?</span>
<span class="o">...</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='def set_conditional_cache_control!
return if self["Cache-Control"].present?
...
end
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/blank.rb</code>.</p></div><h4 id="presence"><a class="anchorlink" href="#presence">2.2 <code>presence</code></a></h4><p>El método <code>presence</code> devuelve su receptor si <code>present?</code> y <code>nil</code> en caso contrario. Es útil para modismos como este:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">host</span> <span class="o">=</span> <span class="n">config</span><span class="p">[</span><span class="ss">:host</span><span class="p">].</span><span class="nf">presence</span> <span class="o">||</span> <span class="s1">'localhost'</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="host = config[:host].presence || 'localhost'
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/blank.rb</code>.</p></div><h4 id="duplicable-questionmark"><a class="anchorlink" href="#duplicable-questionmark">2.3 <code>duplicable?</code></a></h4><p>A partir de Ruby 2.5, la mayoría de los objetos se pueden duplicar mediante <code>dup</code> o <code>clone</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="s2">"foo"</span><span class="p">.</span><span class="nf">dup</span> <span class="c1"># => "foo"</span>
<span class="s2">""</span><span class="p">.</span><span class="nf">dup</span> <span class="c1"># => ""</span>
<span class="no">Rational</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nf">dup</span> <span class="c1"># => (1/1)</span>
<span class="no">Complex</span><span class="p">(</span><span class="mi">0</span><span class="p">).</span><span class="nf">dup</span> <span class="c1"># => (0+0i)</span>
<span class="mi">1</span><span class="p">.</span><span class="nf">method</span><span class="p">(:</span><span class="o">+</span><span class="p">).</span><span class="nf">dup</span> <span class="c1"># => TypeError (allocator undefined for Method)</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='"foo".dup # => "foo"
"".dup # => ""
Rational(1).dup # => (1/1)
Complex(0).dup # => (0+0i)
1.method(:+).dup # => TypeError (allocator undefined for Method)
'>Copy</button>
</div>
<p>Active Support proporciona <code>duplicable?</code> Para consultar un objeto sobre esto:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="s2">"foo"</span><span class="p">.</span><span class="nf">duplicable?</span> <span class="c1"># => true</span>
<span class="s2">""</span><span class="p">.</span><span class="nf">duplicable?</span> <span class="c1"># => true</span>
<span class="no">Rational</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nf">duplicable?</span> <span class="c1"># => true</span>
<span class="no">Complex</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nf">duplicable?</span> <span class="c1"># => true</span>
<span class="mi">1</span><span class="p">.</span><span class="nf">method</span><span class="p">(:</span><span class="o">+</span><span class="p">).</span><span class="nf">duplicable?</span> <span class="c1"># => false</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='"foo".duplicable? # => true
"".duplicable? # => true
Rational(1).duplicable? # => true
Complex(1).duplicable? # => true
1.method(:+).duplicable? # => false
'>Copy</button>
</div>
<div class="warning"><p>Cualquier clase puede prohibir la duplicación eliminando <code>dup</code> y <code>clone</code> o generando excepciones. Por lo tanto, solo "rescue" puede decir si un objeto arbitrario dado es duplicable. <code>duplicable?</code> depende de la lista codificada anterior, pero es mucho más rápido que <code>rescue</code>. Úselo solo si sabe que la lista codificada es suficiente en su caso de uso.</p></div><div class="note"><p>Definido en <code>active_support/core_ext/object/duplicable.rb</code>.</p></div><h3 id="deep-dup"><a class="anchorlink" href="#deep-dup">3 <code>deep_dup</code></a></h3><p>The <code>deep_dup</code> El método devuelve una copia profunda de un objeto dado. Normalmente, cuando <code>dup</code> un objeto que contiene otros objetos, Ruby no los "duplica", por lo que crea una copia superficial del objeto. Si tiene una matriz con una cadena, por ejemplo, se verá así:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">array</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'string'</span><span class="p">]</span>
<span class="n">duplicate</span> <span class="o">=</span> <span class="n">array</span><span class="p">.</span><span class="nf">dup</span>
<span class="n">duplicate</span><span class="p">.</span><span class="nf">push</span> <span class="s1">'another-string'</span>
<span class="c1"># the object was duplicated, so the element was added only to the duplicate</span>
<span class="n">array</span> <span class="c1"># => ['string']</span>
<span class="n">duplicate</span> <span class="c1"># => ['string', 'another-string']</span>
<span class="n">duplicate</span><span class="p">.</span><span class="nf">first</span><span class="p">.</span><span class="nf">gsub!</span><span class="p">(</span><span class="s1">'string'</span><span class="p">,</span> <span class="s1">'foo'</span><span class="p">)</span>
<span class="c1"># first element was not duplicated, it will be changed in both arrays</span>
<span class="n">array</span> <span class="c1"># => ['foo']</span>
<span class="n">duplicate</span> <span class="c1"># => ['foo', 'another-string']</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="array = ['string']
duplicate = array.dup
duplicate.push 'another-string'
# the object was duplicated, so the element was added only to the duplicate
array # => ['string']
duplicate # => ['string', 'another-string']
duplicate.first.gsub!('string', 'foo')
# first element was not duplicated, it will be changed in both arrays
array # => ['foo']
duplicate # => ['foo', 'another-string']
">Copy</button>
</div>
<p>Como puede ver, después de duplicar la instancia de <code>Array</code>, obtuvimos otro objeto, por lo tanto, podemos modificarlo y el objeto original permanecerá sin cambios. Sin embargo, esto no es cierto para los elementos de la matriz. Dado que <code>dup</code> no hace una copia profunda, la cadena dentro de la matriz sigue siendo el mismo objeto.</p><p>Si necesita una copia profunda de un objeto, debe usar <code>deep_dup</code>. Aquí hay un ejemplo:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">array</span> <span class="o">=</span> <span class="p">[</span><span class="s1">'string'</span><span class="p">]</span>
<span class="n">duplicate</span> <span class="o">=</span> <span class="n">array</span><span class="p">.</span><span class="nf">deep_dup</span>
<span class="n">duplicate</span><span class="p">.</span><span class="nf">first</span><span class="p">.</span><span class="nf">gsub!</span><span class="p">(</span><span class="s1">'string'</span><span class="p">,</span> <span class="s1">'foo'</span><span class="p">)</span>
<span class="n">array</span> <span class="c1"># => ['string']</span>
<span class="n">duplicate</span> <span class="c1"># => ['foo']</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="array = ['string']
duplicate = array.deep_dup
duplicate.first.gsub!('string', 'foo')
array # => ['string']
duplicate # => ['foo']
">Copy</button>
</div>
<p>Si el objeto no es duplicable, <code>deep_dup</code> simplemente lo devolverá:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">number</span> <span class="o">=</span> <span class="mi">1</span>
<span class="n">duplicate</span> <span class="o">=</span> <span class="n">number</span><span class="p">.</span><span class="nf">deep_dup</span>
<span class="n">number</span><span class="p">.</span><span class="nf">object_id</span> <span class="o">==</span> <span class="n">duplicate</span><span class="p">.</span><span class="nf">object_id</span> <span class="c1"># => true</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="number = 1
duplicate = number.deep_dup
number.object_id == duplicate.object_id # => true
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/deep_dup.rb</code>.</p></div><h4 id="try"><a class="anchorlink" href="#try">3.1 <code>try</code></a></h4><p>Cuando desea llamar a un método en un objeto solo si no es <code>nil</code>, la forma más sencilla de lograrlo es con declaraciones condicionales, agregando desorden innecesario. La alternativa es usar <code>try</code>. <code>try</code> es como<code>Object # send</code> excepto que devuelve <code>nil</code> si se envía a<code>nil</code>.</p><p>Aquí hay un ejemplo:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="c1"># without try</span>
<span class="k">unless</span> <span class="vi">@number</span><span class="p">.</span><span class="nf">nil?</span>
<span class="vi">@number</span><span class="p">.</span><span class="nf">next</span>
<span class="k">end</span>
<span class="c1"># with try</span>
<span class="vi">@number</span><span class="p">.</span><span class="nf">try</span><span class="p">(</span><span class="ss">:next</span><span class="p">)</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="# without try
unless @number.nil?
@number.next
end
# with try
@number.try(:next)
">Copy</button>
</div>
<p>Otro ejemplo es este código de <code>ActiveRecord::ConnectionAdapters::AbstractAdapter</code> donde <code>@logger</code> podría ser<code>nil</code>. Puede ver que el código usa <code>try</code> y evita una verificación innecesaria.</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">def</span> <span class="nf">log_info</span><span class="p">(</span><span class="n">sql</span><span class="p">,</span> <span class="nb">name</span><span class="p">,</span> <span class="n">ms</span><span class="p">)</span>
<span class="k">if</span> <span class="vi">@logger</span><span class="p">.</span><span class="nf">try</span><span class="p">(</span><span class="ss">:debug?</span><span class="p">)</span>
<span class="nb">name</span> <span class="o">=</span> <span class="s1">'%s (%.1fms)'</span> <span class="o">%</span> <span class="p">[</span><span class="nb">name</span> <span class="o">||</span> <span class="s1">'SQL'</span><span class="p">,</span> <span class="n">ms</span><span class="p">]</span>
<span class="vi">@logger</span><span class="p">.</span><span class="nf">debug</span><span class="p">(</span><span class="n">format_log_entry</span><span class="p">(</span><span class="nb">name</span><span class="p">,</span> <span class="n">sql</span><span class="p">.</span><span class="nf">squeeze</span><span class="p">(</span><span class="s1">' '</span><span class="p">)))</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="def log_info(sql, name, ms)
if @logger.try(:debug?)
name = '%s (%.1fms)' % [name || 'SQL', ms]
@logger.debug(format_log_entry(name, sql.squeeze(' ')))
end
end
">Copy</button>
</div>
<p><code>try</code> también se puede llamar sin argumentos pero un bloque, que solo se ejecutará si el objeto no es nil:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="vi">@person</span><span class="p">.</span><span class="nf">try</span> <span class="p">{</span> <span class="o">|</span><span class="nb">p</span><span class="o">|</span> <span class="s2">"</span><span class="si">#{</span><span class="nb">p</span><span class="p">.</span><span class="nf">first_name</span><span class="si">}</span><span class="s2"> </span><span class="si">#{</span><span class="nb">p</span><span class="p">.</span><span class="nf">last_name</span><span class="si">}</span><span class="s2">"</span> <span class="p">}</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='@person.try { |p| "#{p.first_name} #{p.last_name}" }
'>Copy</button>
</div>
<p>Tenga en cuenta que <code>try</code> se tragará los errores sin método, devolviendo nil en su lugar. Si desea protegerse contra errores tipográficos, utilice <code>try!</code> En su lugar:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="vi">@number</span><span class="p">.</span><span class="nf">try</span><span class="p">(</span><span class="ss">:nest</span><span class="p">)</span> <span class="c1"># => nil</span>
<span class="vi">@number</span><span class="p">.</span><span class="nf">try!</span><span class="p">(</span><span class="ss">:nest</span><span class="p">)</span> <span class="c1"># NoMethodError: undefined method `nest' for 1:Integer</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="@number.try(:nest) # => nil
@number.try!(:nest) # NoMethodError: undefined method `nest' for 1:Integer
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/try.rb</code>.</p></div><h4 id="class-eval-args-block"><a class="anchorlink" href="#class-eval-args-block">3.2 <code>class_eval(*args, &block)</code></a></h4><p>Puede evaluar código en el contexto de la clase singleton de cualquier objeto usando <code>class_eval</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">Proc</span>
<span class="k">def</span> <span class="nf">bind</span><span class="p">(</span><span class="n">object</span><span class="p">)</span>
<span class="n">block</span><span class="p">,</span> <span class="n">time</span> <span class="o">=</span> <span class="nb">self</span><span class="p">,</span> <span class="no">Time</span><span class="p">.</span><span class="nf">current</span>
<span class="n">object</span><span class="p">.</span><span class="nf">class_eval</span> <span class="k">do</span>
<span class="n">method_name</span> <span class="o">=</span> <span class="s2">"__bind_</span><span class="si">#{</span><span class="n">time</span><span class="p">.</span><span class="nf">to_i</span><span class="si">}</span><span class="s2">_</span><span class="si">#{</span><span class="n">time</span><span class="p">.</span><span class="nf">usec</span><span class="si">}</span><span class="s2">"</span>
<span class="n">define_method</span><span class="p">(</span><span class="n">method_name</span><span class="p">,</span> <span class="o">&</span><span class="n">block</span><span class="p">)</span>
<span class="nb">method</span> <span class="o">=</span> <span class="nb">instance_method</span><span class="p">(</span><span class="n">method_name</span><span class="p">)</span>
<span class="n">remove_method</span><span class="p">(</span><span class="n">method_name</span><span class="p">)</span>
<span class="nb">method</span>
<span class="k">end</span><span class="p">.</span><span class="nf">bind</span><span class="p">(</span><span class="n">object</span><span class="p">)</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class Proc
def bind(object)
block, time = self, Time.current
object.class_eval do
method_name = "__bind_#{time.to_i}_#{time.usec}"
define_method(method_name, &block)
method = instance_method(method_name)
remove_method(method_name)
method
end.bind(object)
end
end
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/kernel/singleton_class.rb</code>.</p></div><h4 id="acts-like-questionmark-duck"><a class="anchorlink" href="#acts-like-questionmark-duck">3.3 <code>acts_like?(duck)</code></a></h4><p>El método <code>acts_libe?</code> Proporciona una manera de comprobar si alguna clase actúa como otra clase basándose en una convención simple: una clase que proporciona la misma interfaz que define <code>String</code></p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">def</span> <span class="nf">acts_like_string?</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="def acts_like_string?
end
">Copy</button>
</div>
<p>que es solo un marcador, su cuerpo o valor de retorno son irrelevantes. Luego, el código del cliente puede consultar la seguridad del tipo pato de esta manera:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">some_klass</span><span class="p">.</span><span class="nf">acts_like?</span><span class="p">(</span><span class="ss">:string</span><span class="p">)</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="some_klass.acts_like?(:string)
">Copy</button>
</div>
<p>Rails tiene clases que actúan como <code>Date</code> o <code>Time</code> y siguen este contrato.</p><div class="note"><p>Definido en <code>active_support/core_ext/object/acts_like.rb</code>.</p></div><h4 id="to-param"><a class="anchorlink" href="#to-param">3.4 <code>to_param</code></a></h4><p>Todos los objetos en Rails responden al método <code>to_param</code>, que está destinado a devolver algo que los represente como valores en una cadena de consulta o como fragmentos de URL.</p><p>Por defecto, <code>to_param</code> solo llama a <code>to_s</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="mi">7</span><span class="p">.</span><span class="nf">to_param</span> <span class="c1"># => "7"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='7.to_param # => "7"
'>Copy</button>
</div>
<p>El valor de retorno de <code>to_param</code> <strong>no</strong> debe escaparse:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="s2">"Tom & Jerry"</span><span class="p">.</span><span class="nf">to_param</span> <span class="c1"># => "Tom & Jerry"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='"Tom & Jerry".to_param # => "Tom & Jerry"
'>Copy</button>
</div>
<p>Varias clases de Rails sobrescriben este método.</p><p>Por ejemplo, <code>nil</code>,<code>true</code> y <code>false</code> se devuelven ellos mismos. <code>Array#to_param</code> llama a <code>to_param</code> en los elementos y une el resultado con "/":</p><div class="code_container">
<pre><code class="highlight ruby"><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="kp">true</span><span class="p">,</span> <span class="no">String</span><span class="p">].</span><span class="nf">to_param</span> <span class="c1"># => "0/true/String"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='[0, true, String].to_param # => "0/true/String"
'>Copy</button>
</div>
<p>En particular, el sistema de enrutamiento Rails llama a <code>to_param</code> en los modelos para obtener un valor para el marcador de posición<code>: id</code>. <code>ActiveRecord :: Base # to_param</code> devuelve el <code>id</code> de un modelo, pero puedes redefinir ese método en tus modelos. Por ejemplo, dado</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">User</span>
<span class="k">def</span> <span class="nf">to_param</span>
<span class="s2">"</span><span class="si">#{</span><span class="nb">id</span><span class="si">}</span><span class="s2">-</span><span class="si">#{</span><span class="nb">name</span><span class="p">.</span><span class="nf">parameterize</span><span class="si">}</span><span class="s2">"</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class User
def to_param
"#{id}-#{name.parameterize}"
end
end
'>Copy</button>
</div>
<p>Nosotras obtenemos:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">user_path</span><span class="p">(</span><span class="vi">@user</span><span class="p">)</span> <span class="c1"># => "/users/357-john-smith"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='user_path(@user) # => "/users/357-john-smith"
'>Copy</button>
</div>
<p>ADVERTENCIA. Los controladores deben estar al tanto de cualquier redefinición de <code>to_param</code> porque cuando una solicitud como esa viene en "357-john-smith" es el valor de <code>params[:id]</code>.</p><p>NOTA: Definido en <code>active_support/core_ext/object/to_param.rb</code>.</p><h4 id="to-query"><a class="anchorlink" href="#to-query">3.5 <code>to_query</code></a></h4><p>A excepción de los hash, dada una <code>key</code> sin escape, este método construye la parte de una cadena de consulta que mapeará dicha clave a lo que devuelve <code>to_param</code>. Por ejemplo, dado</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">User</span>
<span class="k">def</span> <span class="nf">to_param</span>
<span class="s2">"</span><span class="si">#{</span><span class="nb">id</span><span class="si">}</span><span class="s2">-</span><span class="si">#{</span><span class="nb">name</span><span class="p">.</span><span class="nf">parameterize</span><span class="si">}</span><span class="s2">"</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class User
def to_param
"#{id}-#{name.parameterize}"
end
end
'>Copy</button>
</div>
<p>Nosotras obtenemos:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">current_user</span><span class="p">.</span><span class="nf">to_query</span><span class="p">(</span><span class="s1">'user'</span><span class="p">)</span> <span class="c1"># => "user=357-john-smith"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="current_user.to_query('user') # => "user=357-john-smith"
">Copy</button>
</div>
<p>Este método escapa a lo que sea necesario, tanto para la clave como para el valor:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">account</span><span class="p">.</span><span class="nf">to_query</span><span class="p">(</span><span class="s1">'company[name]'</span><span class="p">)</span>
<span class="c1"># => "company%5Bname%5D=Johnson+%26+Johnson"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="account.to_query('company[name]')
# => "company%5Bname%5D=Johnson+%26+Johnson"
">Copy</button>
</div>
<p>por lo que su salida está lista para usarse en una cadena de consulta.</p><p>Las matrices devuelven el resultado de aplicar <code>to_query</code> a cada elemento con <code>key[]</code> como clave, y unen el resultado con "&":</p><div class="code_container">
<pre><code class="highlight ruby"><span class="p">[</span><span class="mf">3.4</span><span class="p">,</span> <span class="o">-</span><span class="mf">45.6</span><span class="p">].</span><span class="nf">to_query</span><span class="p">(</span><span class="s1">'sample'</span><span class="p">)</span>
<span class="c1"># => "sample%5B%5D=3.4&sample%5B%5D=-45.6"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="[3.4, -45.6].to_query('sample')
# => "sample%5B%5D=3.4&sample%5B%5D=-45.6"
">Copy</button>
</div>
<p>Los hash también responden a <code>to_query</code> pero con una firma diferente. Si no se pasa ningún argumento, una llamada genera una serie ordenada de asignaciones de clave / valor que llaman a <code>to_query(key)</code> en sus valores. Luego une el resultado con "&":</p><div class="code_container">
<pre><code class="highlight ruby"><span class="p">{</span><span class="ss">c: </span><span class="mi">3</span><span class="p">,</span> <span class="ss">b: </span><span class="mi">2</span><span class="p">,</span> <span class="ss">a: </span><span class="mi">1</span><span class="p">}.</span><span class="nf">to_query</span> <span class="c1"># => "a=1&b=2&c=3"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='{c: 3, b: 2, a: 1}.to_query # => "a=1&b=2&c=3"
'>Copy</button>
</div>
<p>El método <code>Hash#to_query</code> acepta un espacio de nombre opcional para las claves:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="p">{</span><span class="ss">id: </span><span class="mi">89</span><span class="p">,</span> <span class="ss">name: </span><span class="s2">"John Smith"</span><span class="p">}.</span><span class="nf">to_query</span><span class="p">(</span><span class="s1">'user'</span><span class="p">)</span>
<span class="c1"># => "user%5Bid%5D=89&user%5Bname%5D=John+Smith"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="{id: 89, name: "John Smith"}.to_query('user')
# => "user%5Bid%5D=89&user%5Bname%5D=John+Smith"
">Copy</button>
</div>
<p>NOTA: Definido en <code>active_support/core_ext/object/to_query.rb</code>.</p><h4 id="with-options"><a class="anchorlink" href="#with-options">3.6 <code>with_options</code></a></h4><p>El método <code>with_options</code> proporciona una manera de descartar opciones comunes en una serie de llamadas a métodos.</p><p>Dado un hash de opciones predeterminado, <code>with_options</code> cede un objeto proxy a un bloque. Dentro del bloque, los métodos llamados en el proxy se envían al receptor con sus opciones fusionadas. Por ejemplo, se deshace de la duplicación en:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">Account</span> <span class="o"><</span> <span class="no">ApplicationRecord</span>
<span class="n">has_many</span> <span class="ss">:customers</span><span class="p">,</span> <span class="ss">dependent: :destroy</span>
<span class="n">has_many</span> <span class="ss">:products</span><span class="p">,</span> <span class="ss">dependent: :destroy</span>
<span class="n">has_many</span> <span class="ss">:invoices</span><span class="p">,</span> <span class="ss">dependent: :destroy</span>
<span class="n">has_many</span> <span class="ss">:expenses</span><span class="p">,</span> <span class="ss">dependent: :destroy</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="class Account < ApplicationRecord
has_many :customers, dependent: :destroy
has_many :products, dependent: :destroy
has_many :invoices, dependent: :destroy
has_many :expenses, dependent: :destroy
end
">Copy</button>
</div>
<p>de esta manera:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">Account</span> <span class="o"><</span> <span class="no">ApplicationRecord</span>
<span class="n">with_options</span> <span class="ss">dependent: :destroy</span> <span class="k">do</span> <span class="o">|</span><span class="n">assoc</span><span class="o">|</span>
<span class="n">assoc</span><span class="p">.</span><span class="nf">has_many</span> <span class="ss">:customers</span>
<span class="n">assoc</span><span class="p">.</span><span class="nf">has_many</span> <span class="ss">:products</span>
<span class="n">assoc</span><span class="p">.</span><span class="nf">has_many</span> <span class="ss">:invoices</span>
<span class="n">assoc</span><span class="p">.</span><span class="nf">has_many</span> <span class="ss">:expenses</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="class Account < ApplicationRecord
with_options dependent: :destroy do |assoc|
assoc.has_many :customers
assoc.has_many :products
assoc.has_many :invoices
assoc.has_many :expenses
end
end
">Copy</button>
</div>
<p>Ese idioma también puede transmitir <em>grouping</em> al lector. Por ejemplo, digamos que desea enviar un boletín cuyo idioma depende del usuario. En algún lugar del correo, podría agrupar bits dependientes de la configuración regional como este:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="no">I18n</span><span class="p">.</span><span class="nf">with_options</span> <span class="ss">locale: </span><span class="n">user</span><span class="p">.</span><span class="nf">locale</span><span class="p">,</span> <span class="ss">scope: </span><span class="s2">"newsletter"</span> <span class="k">do</span> <span class="o">|</span><span class="n">i18n</span><span class="o">|</span>
<span class="n">subject</span> <span class="n">i18n</span><span class="p">.</span><span class="nf">t</span> <span class="ss">:subject</span>
<span class="n">body</span> <span class="n">i18n</span><span class="p">.</span><span class="nf">t</span> <span class="ss">:body</span><span class="p">,</span> <span class="ss">user_name: </span><span class="n">user</span><span class="p">.</span><span class="nf">name</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='I18n.with_options locale: user.locale, scope: "newsletter" do |i18n|
subject i18n.t :subject
body i18n.t :body, user_name: user.name
end
'>Copy</button>
</div>
<div class="info"><p>Since <code>with_options</code> forwards calls to its receiver they can be nested. Each nesting level will merge inherited defaults in addition to their own.</p></div><div class="note"><p>Definido en <code>active_support/core_ext/object/with_options.rb</code>.</p></div><h4 id="json-support"><a class="anchorlink" href="#json-support">3.7 JSON support</a></h4><p>Active Support proporciona una mejor implementación de <code>to_json</code> que la gem <code>json</code> que normalmente proporciona para los objetos Ruby. Esto se debe a que algunas clases, como <code>Hash</code>, <code>OrderedHash</code> y <code>Process::Status</code> necesitan un manejo especial para proporcionar una representación JSON adecuada.</p><p>NOTA: Definido en <code>active_support/core_ext/object/json.rb</code>.</p><h4 id="instance-variables"><a class="anchorlink" href="#instance-variables">3.8 Instance Variables</a></h4><p>Active Support proporciona varios métodos para facilitar el acceso a las variables de instancia.</p><h5 id="instance-values"><a class="anchorlink" href="#instance-values">3.8.1 <code>instance_values</code></a></h5><p>El método <code>instance_values</code> devuelve un hash que asigna los nombres de las variables de instancia sin" @ "a su
valores correspondientes. Las claves son cadenas:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">C</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="vi">@x</span><span class="p">,</span> <span class="vi">@y</span> <span class="o">=</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">C</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">).</span><span class="nf">instance_values</span> <span class="c1"># => {"x" => 0, "y" => 1}</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class C
def initialize(x, y)
@x, @y = x, y
end
end
C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/instance_variables.rb</code>.</p></div><h5 id="instance-variable-names"><a class="anchorlink" href="#instance-variable-names">3.8.2 <code>instance_variable_names</code></a></h5><p>El método <code>instance_variable_names</code> devuelve una matriz. Cada nombre incluye el signo "@".</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">C</span>
<span class="k">def</span> <span class="nf">initialize</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="vi">@x</span><span class="p">,</span> <span class="vi">@y</span> <span class="o">=</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">C</span><span class="p">.</span><span class="nf">new</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">).</span><span class="nf">instance_variable_names</span> <span class="c1"># => ["@x", "@y"]</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class C
def initialize(x, y)
@x, @y = x, y
end
end
C.new(0, 1).instance_variable_names # => ["@x", "@y"]
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/instance_variables.rb</code>.</p></div><h4 id="silencing-warnings-and-exceptions"><a class="anchorlink" href="#silencing-warnings-and-exceptions">3.9 Silencing Warnings and Exceptions</a></h4><p>Los métodos <code>silent_warnings</code> y <code>enable_warnings</code> cambian el valor de <code>$VERBOSE</code> en consecuencia durante la duración de su bloqueo, y lo restablecen después:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="n">silence_warnings</span> <span class="p">{</span> <span class="no">Object</span><span class="p">.</span><span class="nf">const_set</span> <span class="s2">"RAILS_DEFAULT_LOGGER"</span><span class="p">,</span> <span class="n">logger</span> <span class="p">}</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }
'>Copy</button>
</div>
<p>También es posible silenciar las excepciones con <code>suppress</code>. Este método recibe un número arbitrario de clases de excepción. Si se genera una excepción durante la ejecución del bloque y es <code>kind_of?</code> Cualquiera de los argumentos, <code>suppress</code> la captura y regresa silenciosamente. De lo contrario, la excepción no se captura:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="c1"># If the user is locked, the increment is lost, no big deal.</span>
<span class="n">suppress</span><span class="p">(</span><span class="no">ActiveRecord</span><span class="o">::</span><span class="no">StaleObjectError</span><span class="p">)</span> <span class="k">do</span>
<span class="n">current_user</span><span class="p">.</span><span class="nf">increment!</span> <span class="ss">:visits</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="# If the user is locked, the increment is lost, no big deal.
suppress(ActiveRecord::StaleObjectError) do
current_user.increment! :visits
end
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/kernel/reporting.rb</code>.</p></div><h4 id="in-questionmark"><a class="anchorlink" href="#in-questionmark">3.10 <code>in?</code></a></h4><p>El predicado <code>in?</code> Prueba si un objeto está incluido en otro objeto. Se generará una excepción <code>ArgumentError</code> si el argumento pasado no responde a <code>include?</code>.</p><p>Ejemplos de <code>in?</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="mi">1</span><span class="p">.</span><span class="nf">in?</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span> <span class="c1"># => true</span>
<span class="s2">"lo"</span><span class="p">.</span><span class="nf">in?</span><span class="p">(</span><span class="s2">"hello"</span><span class="p">)</span> <span class="c1"># => true</span>
<span class="mi">25</span><span class="p">.</span><span class="nf">in?</span><span class="p">(</span><span class="mi">30</span><span class="o">..</span><span class="mi">50</span><span class="p">)</span> <span class="c1"># => false</span>
<span class="mi">1</span><span class="p">.</span><span class="nf">in?</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># => ArgumentError</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='1.in?([1,2]) # => true
"lo".in?("hello") # => true
25.in?(30..50) # => false
1.in?(1) # => ArgumentError
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/object/inclusion.rb</code>.</p></div><h3 id="extensions-to-module"><a class="anchorlink" href="#extensions-to-module">4 Extensions to <code>Module</code></a></h3><h4 id="attributes"><a class="anchorlink" href="#attributes">4.1 Attributes</a></h4><h5 id="alias-attribute"><a class="anchorlink" href="#alias-attribute">4.1.1 <code>alias_attribute</code></a></h5><div class="code_container">
<pre><code class="highlight ruby"><span class="k">class</span> <span class="nc">User</span> <span class="o"><</span> <span class="no">ApplicationRecord</span>
<span class="c1"># You can refer to the email column as "login".</span>
<span class="c1"># This can be meaningful for authentication code.</span>
<span class="n">alias_attribute</span> <span class="ss">:login</span><span class="p">,</span> <span class="ss">:email</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='class User < ApplicationRecord
# You can refer to the email column as "login".
# This can be meaningful for authentication code.
alias_attribute :login, :email
end
'>Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/module/aliasing.rb</code>.</p></div><h5 id="internal-attributes"><a class="anchorlink" href="#internal-attributes">4.1.2 Internal Attributes</a></h5><p>Cuando está definiendo un atributo en una clase que está destinado a ser subclasificado, las colisiones de nombres son un riesgo. Eso es muy importante para las bibliotecas.</p><p>Active Support define las macros <code>attr_internal_reader</code>, <code>attr_internal_writer</code> y <code>attr_internal_accessor</code>. Se comportan como sus contrapartes <code>attr_ *</code> incorporadas en Ruby, excepto que nombran la variable de instancia subyacente de una manera que hace que las colisiones sean menos probables.</p><p>La macro <code>attr_internal</code> es sinónimo de <code>attr_internal_accessor</code>:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="c1"># library</span>
<span class="k">class</span> <span class="nc">ThirdPartyLibrary::Crawler</span>
<span class="n">attr_internal</span> <span class="ss">:log_level</span>
<span class="k">end</span>
<span class="c1"># client code</span>
<span class="k">class</span> <span class="nc">MyCrawler</span> <span class="o"><</span> <span class="no">ThirdPartyLibrary</span><span class="o">::</span><span class="no">Crawler</span>
<span class="nb">attr_accessor</span> <span class="ss">:log_level</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="# library
class ThirdPartyLibrary::Crawler
attr_internal :log_level
end
# client code
class MyCrawler < ThirdPartyLibrary::Crawler
attr_accessor :log_level
end
">Copy</button>
</div>
<p>En el ejemplo anterior podría darse el caso de que <code>:log_level</code> no pertenezca a la interfaz pública de la biblioteca y solo se utilice para desarrollo. El código del cliente, inconsciente del posible conflicto, subclasifica y define su propio <code>: log_level</code>. Gracias a <code>attr_internal</code> no hay colisión.</p><p>De forma predeterminada, la variable de instancia interna se nombra con un guión bajo inicial, <code>@ _log_level</code> en el ejemplo anterior. Eso se puede configurar a través de <code>Module.attr_internal_naming_format</code>, sin embargo, puede pasar cualquier cadena de formato similar a<code>sprintf</code> con una <code>@</code> inicial y un <code>% s</code> en algún lugar, que es donde se colocará el nombre. El valor predeterminado es <code>" @ _% s "</code>.</p><p>Rails usa atributos internos en algunos puntos, como ejemplos de vistas:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">module</span> <span class="nn">ActionView</span>
<span class="k">class</span> <span class="nc">Base</span>
<span class="n">attr_internal</span> <span class="ss">:captures</span>
<span class="n">attr_internal</span> <span class="ss">:request</span><span class="p">,</span> <span class="ss">:layout</span>
<span class="n">attr_internal</span> <span class="ss">:controller</span><span class="p">,</span> <span class="ss">:template</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="module ActionView
class Base
attr_internal :captures
attr_internal :request, :layout
attr_internal :controller, :template
end
end
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/module/attr_internal.rb</code>.</p></div><h5 id="module-attributes"><a class="anchorlink" href="#module-attributes">4.1.3 Module Attributes</a></h5><p>Las macros <code>mattr_reader</code>, <code>mattr_writer</code> y <code>mattr_accessor</code> son las mismas que las macros <code>cattr_ *</code>definidas para la clase. De hecho, las macros <code>cattr_ *</code> son solo alias para las macros <code>mattr_ *</code>. Marque <a href="#class-attributes">Class Attributes</a>.</p><p>Por ejemplo, el mecanismo de dependencias las usa:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">module</span> <span class="nn">ActiveSupport</span>
<span class="k">module</span> <span class="nn">Dependencies</span>
<span class="n">mattr_accessor</span> <span class="ss">:warnings_on_first_load</span>
<span class="n">mattr_accessor</span> <span class="ss">:history</span>
<span class="n">mattr_accessor</span> <span class="ss">:loaded</span>
<span class="n">mattr_accessor</span> <span class="ss">:mechanism</span>
<span class="n">mattr_accessor</span> <span class="ss">:load_paths</span>
<span class="n">mattr_accessor</span> <span class="ss">:load_once_paths</span>
<span class="n">mattr_accessor</span> <span class="ss">:autoloaded_constants</span>
<span class="n">mattr_accessor</span> <span class="ss">:explicitly_unloadable_constants</span>
<span class="n">mattr_accessor</span> <span class="ss">:constant_watch_stack</span>
<span class="n">mattr_accessor</span> <span class="ss">:constant_watch_stack_mutex</span>
<span class="k">end</span>
<span class="k">end</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="module ActiveSupport
module Dependencies
mattr_accessor :warnings_on_first_load
mattr_accessor :history
mattr_accessor :loaded
mattr_accessor :mechanism
mattr_accessor :load_paths
mattr_accessor :load_once_paths
mattr_accessor :autoloaded_constants
mattr_accessor :explicitly_unloadable_constants
mattr_accessor :constant_watch_stack
mattr_accessor :constant_watch_stack_mutex
end
end
">Copy</button>
</div>
<p><code>active_support/core_ext/module/attribute_accessors.rb</code>.</p><h4 id="parents"><a class="anchorlink" href="#parents">4.2 Parents</a></h4><h5 id="module-parent"><a class="anchorlink" href="#module-parent">4.2.1 <code>module_parent</code></a></h5><p>El método <code>module_parent</code> en un módulo con nombre anidado devuelve el módulo que contiene su constante correspondiente:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">module</span> <span class="nn">X</span>
<span class="k">module</span> <span class="nn">Y</span>
<span class="k">module</span> <span class="nn">Z</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">M</span> <span class="o">=</span> <span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span>
<span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span><span class="p">.</span><span class="nf">module_parent</span> <span class="c1"># => X::Y</span>
<span class="no">M</span><span class="p">.</span><span class="nf">module_parent</span> <span class="c1"># => X::Y</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="module X
module Y
module Z
end
end
end
M = X::Y::Z
X::Y::Z.module_parent # => X::Y
M.module_parent # => X::Y
">Copy</button>
</div>
<p>Si el módulo es anónimo o pertenece al nivel superior, <code>module_parent</code> devuelve <code>Object</code>.</p><div class="warning"><p>Tenga en cuenta que en ese caso <code>module_parent_name</code> devuelve <code>nil</code>.</p></div><div class="note"><p>Definido en <code>active_support/core_ext/module/introspection.rb</code>.</p></div><h5 id="module-parent-name"><a class="anchorlink" href="#module-parent-name">4.2.2 <code>module_parent_name</code></a></h5><p>El método <code>module_parent_name</code> en un módulo con nombre anidado devuelve el nombre completo del módulo que contiene su constante correspondiente:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">module</span> <span class="nn">X</span>
<span class="k">module</span> <span class="nn">Y</span>
<span class="k">module</span> <span class="nn">Z</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">M</span> <span class="o">=</span> <span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span>
<span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span><span class="p">.</span><span class="nf">module_parent_name</span> <span class="c1"># => "X::Y"</span>
<span class="no">M</span><span class="p">.</span><span class="nf">module_parent_name</span> <span class="c1"># => "X::Y"</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text='module X
module Y
module Z
end
end
end
M = X::Y::Z
X::Y::Z.module_parent_name # => "X::Y"
M.module_parent_name # => "X::Y"
'>Copy</button>
</div>
<p>Para módulos anónimos o de nivel superior, <code>module_parent_name</code> devuelve <code>nil</code>.</p><div class="warning"><p>Tenga en cuenta que en ese caso <code>module_parent</code> devuelve <code>Object</code>.</p></div><div class="note"><p>Definido en <code>active_support/core_ext/module/introspection.rb</code>.</p></div><h5 id="module-parents"><a class="anchorlink" href="#module-parents">4.2.3 <code>module_parents</code></a></h5><p>El método <code>module_parents</code> llama a <code>module_parent</code> en el receptor y hacia arriba hasta que se alcanza el <code>Object</code>. La cadena se devuelve en una matriz, de abajo hacia arriba:</p><div class="code_container">
<pre><code class="highlight ruby"><span class="k">module</span> <span class="nn">X</span>
<span class="k">module</span> <span class="nn">Y</span>
<span class="k">module</span> <span class="nn">Z</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="no">M</span> <span class="o">=</span> <span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span>
<span class="no">X</span><span class="o">::</span><span class="no">Y</span><span class="o">::</span><span class="no">Z</span><span class="p">.</span><span class="nf">module_parents</span> <span class="c1"># => [X::Y, X, Object]</span>
<span class="no">M</span><span class="p">.</span><span class="nf">module_parents</span> <span class="c1"># => [X::Y, X, Object]</span>
</code></pre>
<button class="clipboard-button" data-clipboard-text="module X
module Y
module Z
end
end
end
M = X::Y::Z
X::Y::Z.module_parents # => [X::Y, X, Object]
M.module_parents # => [X::Y, X, Object]
">Copy</button>
</div>
<div class="note"><p>Definido en <code>active_support/core_ext/module/introspection.rb</code>.</p></div><h4 id="anonymous"><a class="anchorlink" href="#anonymous">4.3 Anonymous</a></h4><p>Un módulo puede tener o no un nombre:</p><div class="code_container">