-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy pathfile.assignment.html
469 lines (300 loc) · 37.7 KB
/
file.assignment.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
<!DOCTYPE html>
<html>
<head>
<meta charset='UTF-8'>
<meta name='viewport' content='width=device-width, initial-scale=1.0, user-scalable=no'>
<meta name='apple-touch-fullscreen' content='yes'>
<meta name='apple-mobile-web-app-capable' content='yes'>
<meta name='apple-mobile-web-app-status-bar-style' content='rgba(228,228,228,1.0)'>
<title>File: Assignment — Ruby-2.6.10</title>
<link rel='stylesheet' type='text/css' href='../css/y_fonts.css' />
<link rel='stylesheet' type='text/css' href='../css/highlight.github.css' />
<link rel='stylesheet' type='text/css' href='../css/y_style.css' />
<link rel='stylesheet' type='text/css' href='../css/y_list.css' />
<link rel='stylesheet' type='text/css' href='../css/y_color.css' />
<script type='text/javascript'>
var pathId = "assignment",
relpath = '';
var t2Info = {
CSEP: '.',
ISEP: '#',
NSEP: '::'
};
</script>
<script type='text/javascript' charset='utf-8' src='../js/highlight.pack.js'></script>
<script type='text/javascript' charset='utf-8' src='../js/y_app.js'></script>
</head>
<body>
<svg id='y_wait' class viewBox='0 0 90 90'></svg>
<div id='settings' class='hidden'></div>
<div id='y_list' class='d h'>
<header id='list_header'></header>
<nav id= 'list_nav' class='y_nav l_nav'>
<ul id='list_items'></ul>
</nav>
</div>
<div id='y_toc' class='f h'>
<header id='toc_header'></header>
<nav id= 'toc_nav' class='y_nav t_nav'>
<ol id='toc_items'></ol>
</nav>
</div>
<div id='y_main' tabindex='-1'>
<header id='y_header'>
<div id='y_menu'>
<a id='home_no_xhr' href='/'>Home</a> »
<a href='.'>Ruby-2.6.10</a> »
<a href='_index.html'>Index</a> »
<span class='title'><a id='t2_doc_top' href='#'>File: Assignment ▲</a></span>
</div>
<a id='list_href' href="file_list.html"></a>
<div id='y_measure_em' class='y_measure'></div>
<div id='y_measure_vh' class='y_measure'></div>
<span id='y_measure_50pre' class='y_measure'><code>123456789_123456789_123456789_123456789_123456789_</code></span>
</header>
<div id='content' class='file'>
<h1 id="label-Assignment">Assignment</h1>
<p>In Ruby, assignment uses the <code>=</code> (equals sign) character. This example assigns the number five to the local variable <code>v</code>:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_v'>v</span> <span class='op'>=</span> <span class='int'>5</span></code></pre>
<p>Assignment creates a local variable if the variable was not previously referenced.</p>
<h2 id="label-Local+Variable+Names">Local Variable Names</h2>
<p>A local variable name must start with a lowercase US-ASCII letter or a character with the eight bit set. Typically local variables are US-ASCII compatible since the keys to type them exist on all keyboards.</p>
<p>(Ruby programs must be written in a US-ASCII-compatible character set. In such character sets if the eight bit is set it indicates an extended character. Ruby allows local variables to contain such characters.)</p>
<p>A local variable name may contain letters, numbers, an <code>_</code> (underscore or low line) or a character with the eighth bit set.</p>
<h2 id="label-Local+Variable+Scope">Local Variable Scope</h2>
<p>Once a local variable name has been assigned-to all uses of the name for the rest of the scope are considered local variables.</p>
<p>Here is an example:</p>
<pre class="code ruby"><code class="ruby"><span class='int'>1</span>.<span class='id identifier rubyid_times'>times</span> <span class='kw'>do</span>
<span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>1</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>local variables in the block: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_local_variables'>local_variables</span>.<span class='id identifier rubyid_join'>join</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>, </span><span class='tstring_end'>"</span></span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='kw'>end</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>no local variables outside the block</span><span class='tstring_end'>"</span></span> <span class='kw'>if</span> <span class='id identifier rubyid_local_variables'>local_variables</span>.<span class='id identifier rubyid_empty?'>empty?</span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby">local variables in the block: a
no local variables outside the block</code></pre>
<p>Since the block creates a new scope, any local variables created inside it do not leak to the surrounding scope.</p>
<p>Variables defined in an outer scope appear inner scope:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>0</span>
<span class='int'>1</span>.<span class='id identifier rubyid_times'>times</span> <span class='kw'>do</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>local variables: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_local_variables'>local_variables</span>.<span class='id identifier rubyid_join'>join</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>, </span><span class='tstring_end'>"</span></span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='kw'>end</span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_local'>local</span> <span class='label'>variables:</span> <span class='id identifier rubyid_a'>a</span></code></pre>
<p>You may isolate variables in a block from the outer scope by listing them following a <code>;</code> in the block’s arguments. See the documentation for block local variables in the <a href="file.calling_methods.html" title="calling methods">calling methods</a> documentation for an example.</p>
<p>See also Kernel#local_variables, but note that a <code>for</code> loop does not create a new scope like a block does.</p>
<h2 id="label-Local+Variables+and+Methods">Local Variables and Methods</h2>
<p>In Ruby local variable names and method names are nearly identical. If you have not assigned to one of these ambiguous names ruby will assume you wish to call a method. Once you have assigned to the name ruby will assume you wish to reference a local variable.</p>
<p>The local variable is created when the parser encounters the assignment, not when the assignment occurs:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>0</span> <span class='kw'>if</span> <span class='kw'>false</span> <span class='comment'># does not assign to a
</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_local_variables'>local_variables</span> <span class='comment'># prints [:a]
</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints nil</span></code></pre>
<p>The similarity between method and local variable names can lead to confusing code, for example:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>def</span> <span class='id identifier rubyid_big_calculation'>big_calculation</span>
<span class='int'>42</span> <span class='comment'># pretend this takes a long time
</span><span class='kw'>end</span>
<span class='id identifier rubyid_big_calculation'>big_calculation</span> <span class='op'>=</span> <span class='id identifier rubyid_big_calculation'>big_calculation</span>()</code></pre>
<p>Now any reference to <code>big_calculation</code> is considered a local variable and will be cached. To call the method, use <code>self.big_calculation</code>.</p>
<p>You can force a method call by using empty argument parentheses as shown above or by using an explicit receiver like <code>self.</code>. Using an explicit receiver may raise a NameError if the method’s visibility is not public.</p>
<p>Another commonly confusing case is when using a modifier <code>if</code>:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='kw'>if</span> <span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>0</span>.<span class='id identifier rubyid_zero?'>zero?</span></code></pre>
<p>Rather than printing “true” you receive a NameError, “undefined local variable or method ‘a’”. Since ruby parses the bare <code>a</code> left of the <code>if</code> first and has not yet seen an assignment to <code>a</code> it assumes you wish to call a method. Ruby then sees the assignment to <code>a</code> and will assume you are referencing a local method.</p>
<p>The confusion comes from the out-of-order execution of the expression. First the local variable is assigned-to then you attempt to call a nonexistent method.</p>
<h2 id="label-Instance+Variables">Instance Variables</h2>
<p>Instance variables are shared across all methods for the same object.</p>
<p>An instance variable must start with a <code>@</code> (“at” sign or commercial at). Otherwise instance variable names follow the rules as local variable names. Since the instance variable starts with an <code>@</code> the second character may be an upper-case letter.</p>
<p>Here is an example of instance variable usage:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>C</span>
<span class='kw'>def</span> <span class='id identifier rubyid_initialize'>initialize</span>(<span class='id identifier rubyid_value'>value</span>)
<span class='ivar'>@instance_variable</span> <span class='op'>=</span> <span class='id identifier rubyid_value'>value</span>
<span class='kw'>end</span>
<span class='kw'>def</span> <span class='id identifier rubyid_value'>value</span>
<span class='ivar'>@instance_variable</span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='id identifier rubyid_object1'>object1</span> <span class='op'>=</span> <span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>some value</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_object2'>object2</span> <span class='op'>=</span> <span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>other value</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_object1'>object1</span>.<span class='id identifier rubyid_value'>value</span> <span class='comment'># prints "some value"
</span><span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_object2'>object2</span>.<span class='id identifier rubyid_value'>value</span> <span class='comment'># prints "other value"</span></code></pre>
<p>An uninitialized instance variable has a value of <code>nil</code>. If you run Ruby with warnings enabled, you will get a warning when accessing an uninitialized instance variable.</p>
<p>The <code>value</code> method has access to the value set by the <code>initialize</code> method, but only for the same object.</p>
<h2 id="label-Class+Variables">Class Variables</h2>
<p>Class variables are shared between a class, its subclasses and its instances.</p>
<p>A class variable must start with a <code>@@</code> (two “at” signs). The rest of the name follows the same rules as instance variables.</p>
<p>Here is an example:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>A</span>
<span class='cvar'>@@class_variable</span> <span class='op'>=</span> <span class='int'>0</span>
<span class='kw'>def</span> <span class='id identifier rubyid_value'>value</span>
<span class='cvar'>@@class_variable</span>
<span class='kw'>end</span>
<span class='kw'>def</span> <span class='id identifier rubyid_update'>update</span>
<span class='cvar'>@@class_variable</span> <span class='op'>=</span> <span class='cvar'>@@class_variable</span> <span class='op'>+</span> <span class='int'>1</span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='kw'>class</span> <span class='const'>B</span> <span class='op'><</span> <span class='const'>A</span>
<span class='kw'>def</span> <span class='id identifier rubyid_update'>update</span>
<span class='cvar'>@@class_variable</span> <span class='op'>=</span> <span class='cvar'>@@class_variable</span> <span class='op'>+</span> <span class='int'>2</span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='const'>A</span>.<span class='id identifier rubyid_new'>new</span>
<span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='const'>B</span>.<span class='id identifier rubyid_new'>new</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>A value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>B value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_b'>b</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby"><span class='const'>A</span> <span class='label'>value:</span> <span class='int'>0</span>
<span class='const'>B</span> <span class='label'>value:</span> <span class='int'>0</span></code></pre>
<p>Continuing with the same example, we can update using objects from either class and the value is shared:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>update A</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_update'>update</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>A value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>B value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_b'>b</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>update B</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_b'>b</span>.<span class='id identifier rubyid_update'>update</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>A value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>B value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_b'>b</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>update A</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_update'>update</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>A value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_a'>a</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>B value: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_b'>b</span>.<span class='id identifier rubyid_value'>value</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_update'>update</span> <span class='const'>A</span>
<span class='const'>A</span> <span class='label'>value:</span> <span class='int'>1</span>
<span class='const'>B</span> <span class='label'>value:</span> <span class='int'>1</span>
<span class='id identifier rubyid_update'>update</span> <span class='const'>B</span>
<span class='const'>A</span> <span class='label'>value:</span> <span class='int'>3</span>
<span class='const'>B</span> <span class='label'>value:</span> <span class='int'>3</span>
<span class='id identifier rubyid_update'>update</span> <span class='const'>A</span>
<span class='const'>A</span> <span class='label'>value:</span> <span class='int'>4</span>
<span class='const'>B</span> <span class='label'>value:</span> <span class='int'>4</span></code></pre>
<p>Accessing an uninitialized class variable will raise a NameError exception.</p>
<p>Note that classes have instance variables because classes are objects, so try not to confuse class and instance variables.</p>
<h2 id="label-Global+Variables">Global Variables</h2>
<p>Global variables are accessible everywhere.</p>
<p>Global variables start with a <code>$</code> (dollar sign). The rest of the name follows the same rules as instance variables.</p>
<p>Here is an example:</p>
<pre class="code ruby"><code class="ruby"><span class='gvar'>$global</span> <span class='op'>=</span> <span class='int'>0</span>
<span class='kw'>class</span> <span class='const'>C</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>in a class: </span><span class='embexpr_beg'>#{</span><span class='gvar'>$global</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='kw'>def</span> <span class='id identifier rubyid_my_method'>my_method</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>in a method: </span><span class='embexpr_beg'>#{</span><span class='gvar'>$global</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='gvar'>$global</span> <span class='op'>=</span> <span class='gvar'>$global</span> <span class='op'>+</span> <span class='int'>1</span>
<span class='gvar'>$other_global</span> <span class='op'>=</span> <span class='int'>3</span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span>.<span class='id identifier rubyid_my_method'>my_method</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>at top-level, $global: </span><span class='embexpr_beg'>#{</span><span class='gvar'>$global</span><span class='embexpr_end'>}</span><span class='tstring_content'>, $other_global: </span><span class='embexpr_beg'>#{</span><span class='gvar'>$other_global</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby">in a class: 0
in a method: 0
at top-level, $global: 1, $other_global: 3</code></pre>
<p>An uninitialized global variable has a value of <code>nil</code>.</p>
<p>Ruby has some special globals that behave differently depending on context such as the regular expression match variables or that have a side-effect when assigned to. See the <a href="file.globals.html" title="global variables documentation">global variables documentation</a> for details.</p>
<h2 id="label-Assignment+Methods">Assignment Methods</h2>
<p>You can define methods that will behave like assignment, for example:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>C</span>
<span class='kw'>def</span> <span class='id identifier rubyid_value='>value=</span>(<span class='id identifier rubyid_value'>value</span>)
<span class='ivar'>@value</span> <span class='op'>=</span> <span class='id identifier rubyid_value'>value</span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='id identifier rubyid_c'>c</span> <span class='op'>=</span> <span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span>
<span class='id identifier rubyid_c'>c</span>.<span class='id identifier rubyid_value'>value</span> <span class='op'>=</span> <span class='int'>42</span></code></pre>
<p>Using assignment methods allows your programs to look nicer. When assigning to an instance variable most people use Module#attr_accessor:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>C</span>
<span class='id identifier rubyid_attr_accessor'>attr_accessor</span> <span class='symbeg'>:</span><span class='id identifier rubyid_value'>value</span>
<span class='kw'>end</span></code></pre>
<p>When using method assignment you must always have a receiver. If you do not have a receiver, Ruby assumes you are assigning to a local variable:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>C</span>
<span class='id identifier rubyid_attr_accessor'>attr_accessor</span> <span class='symbeg'>:</span><span class='id identifier rubyid_value'>value</span>
<span class='kw'>def</span> <span class='id identifier rubyid_my_method'>my_method</span>
<span class='id identifier rubyid_value'>value</span> <span class='op'>=</span> <span class='int'>42</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>local_variables: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_local_variables'>local_variables</span>.<span class='id identifier rubyid_join'>join</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>, </span><span class='tstring_end'>"</span></span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>@value: </span><span class='embexpr_beg'>#{</span><span class='ivar'>@value</span>.<span class='id identifier rubyid_inspect'>inspect</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span>.<span class='id identifier rubyid_my_method'>my_method</span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby">local_variables: value
@value: nil</code></pre>
<p>To use the assignment method you must set the receiver:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>class</span> <span class='const'>C</span>
<span class='id identifier rubyid_attr_accessor'>attr_accessor</span> <span class='symbeg'>:</span><span class='id identifier rubyid_value'>value</span>
<span class='kw'>def</span> <span class='id identifier rubyid_my_method'>my_method</span>
<span class='kw'>self</span>.<span class='id identifier rubyid_value'>value</span> <span class='op'>=</span> <span class='int'>42</span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>local_variables: </span><span class='embexpr_beg'>#{</span><span class='id identifier rubyid_local_variables'>local_variables</span>.<span class='id identifier rubyid_join'>join</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>, </span><span class='tstring_end'>"</span></span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='id identifier rubyid_puts'>puts</span> <span class='tstring'><span class='tstring_beg'>"</span><span class='tstring_content'>@value: </span><span class='embexpr_beg'>#{</span><span class='ivar'>@value</span>.<span class='id identifier rubyid_inspect'>inspect</span><span class='embexpr_end'>}</span><span class='tstring_end'>"</span></span>
<span class='kw'>end</span>
<span class='kw'>end</span>
<span class='const'>C</span>.<span class='id identifier rubyid_new'>new</span>.<span class='id identifier rubyid_my_method'>my_method</span></code></pre>
<p>This prints:</p>
<pre class="code ruby"><code class="ruby">local_variables:
@value: 42</code></pre>
<h2 id="label-Abbreviated+Assignment">Abbreviated Assignment</h2>
<p>You can mix several of the operators and assignment. To add 1 to an object you can write:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>1</span>
<span class='id identifier rubyid_a'>a</span> <span class='op'>+=</span> <span class='int'>2</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints 3</span></code></pre>
<p>This is equivalent to:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>1</span>
<span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='id identifier rubyid_a'>a</span> <span class='op'>+</span> <span class='int'>2</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints 3</span></code></pre>
<p>You can use the following operators this way: <code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code>, <code>**</code>, <code>&</code>, <code>|</code>, <code>^</code>, <code><<</code>, <code>>></code></p>
<p>There are also <code>||=</code> and <code>&&=</code>. The former makes an assignment if the value was <code>nil</code> or <code>false</code> while the latter makes an assignment if the value was not <code>nil</code> or <code>false</code>.</p>
<p>Here is an example:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>||=</span> <span class='int'>0</span>
<span class='id identifier rubyid_a'>a</span> <span class='op'>&&=</span> <span class='int'>1</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints 1</span></code></pre>
<p>Note that these two operators behave more like <code>a || a = 0</code> than <code>a = a || 0</code>.</p>
<h2 id="label-Implicit+Array+Assignment">Implicit Array Assignment</h2>
<p>You can implicitly create an array by listing multiple values when assigning:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints [1, 2, 3]</span></code></pre>
<p>This implicitly creates an Array.</p>
<p>You can use <code>*</code> or the “splat” operator or unpack an Array when assigning. This is similar to multiple assignment:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='op'>*</span>[<span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>]
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints [1, 2, 3]</span></code></pre>
<p>You can splat anywhere in the right-hand side of the assignment:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='op'>*</span>[<span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>]
<span class='id identifier rubyid_p'>p</span> <span class='id identifier rubyid_a'>a</span> <span class='comment'># prints [1, 2, 3]</span></code></pre>
<h2 id="label-Multiple+Assignment">Multiple Assignment</h2>
<p>You can assign multiple values on the right-hand side to multiple variables:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span> <span class='comment'># prints {:a=>1, :b=>2}</span></code></pre>
<p>In the following sections any place “variable” is used an assignment method, instance, class or global will also work:</p>
<pre class="code ruby"><code class="ruby"><span class='kw'>def</span> <span class='id identifier rubyid_value='>value=</span>(<span class='id identifier rubyid_value'>value</span>)
<span class='id identifier rubyid_p'>p</span> <span class='label'>assigned:</span> <span class='id identifier rubyid_value'>value</span>
<span class='kw'>end</span>
<span class='kw'>self</span>.<span class='id identifier rubyid_value'>value</span><span class='comma'>,</span> <span class='gvar'>$global</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span> <span class='comment'># prints {:assigned=>1}
</span>
<span class='id identifier rubyid_p'>p</span> <span class='gvar'>$global</span> <span class='comment'># prints 2</span></code></pre>
<p>You can use multiple assignment to swap two values in-place:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_old_value'>old_value</span> <span class='op'>=</span> <span class='int'>1</span>
<span class='id identifier rubyid_new_value'>new_value</span><span class='comma'>,</span> <span class='id identifier rubyid_old_value'>old_value</span> <span class='op'>=</span> <span class='id identifier rubyid_old_value'>old_value</span><span class='comma'>,</span> <span class='int'>2</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>new_value:</span> <span class='id identifier rubyid_new_value'>new_value</span><span class='comma'>,</span> <span class='label'>old_value:</span> <span class='id identifier rubyid_old_value'>old_value</span>
<span class='comment'># prints {:new_value=>1, :old_value=>2}</span></code></pre>
<p>If you have more values on the right hand side of the assignment than variables on the left hand side, the extra values are ignored:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span> <span class='comment'># prints {:a=>1, :b=>2}</span></code></pre>
<p>You can use <code>*</code> to gather extra values on the right-hand side of the assignment.</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='op'>*</span><span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span> <span class='comment'># prints {:a=>1, :b=>[2, 3]}</span></code></pre>
<p>The <code>*</code> can appear anywhere on the left-hand side:</p>
<pre class="code ruby"><code class="ruby"><span class='op'>*</span><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='id identifier rubyid_b'>b</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span> <span class='comment'># prints {:a=>[1, 2], :b=>3}</span></code></pre>
<p>But you may only use one <code>*</code> in an assignment.</p>
<h2 id="label-Array+Decomposition">Array Decomposition</h2>
<p>Like Array decomposition in <a href="file.methods.html" title="method arguments">method arguments</a> you can decompose an Array during assignment using parenthesis:</p>
<pre class="code ruby"><code class="ruby">(<span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='id identifier rubyid_b'>b</span>) <span class='op'>=</span> [<span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span>]
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span> <span class='comment'># prints {:a=>1, :b=>2}</span></code></pre>
<p>You can decompose an Array as part of a larger multiple assignment:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> (<span class='id identifier rubyid_b'>b</span><span class='comma'>,</span> <span class='id identifier rubyid_c'>c</span>) <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> [<span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span>]
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span><span class='comma'>,</span> <span class='label'>c:</span> <span class='id identifier rubyid_c'>c</span> <span class='comment'># prints {:a=>1, :b=>2, :c=>3}</span></code></pre>
<p>Since each decomposition is considered its own multiple assignment you can use <code>*</code> to gather arguments in the decomposition:</p>
<pre class="code ruby"><code class="ruby"><span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> (<span class='id identifier rubyid_b'>b</span><span class='comma'>,</span> <span class='op'>*</span><span class='id identifier rubyid_c'>c</span>)<span class='comma'>,</span> <span class='op'>*</span><span class='id identifier rubyid_d'>d</span> <span class='op'>=</span> <span class='int'>1</span><span class='comma'>,</span> [<span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span><span class='comma'>,</span> <span class='int'>4</span>]<span class='comma'>,</span> <span class='int'>5</span><span class='comma'>,</span> <span class='int'>6</span>
<span class='id identifier rubyid_p'>p</span> <span class='label'>a:</span> <span class='id identifier rubyid_a'>a</span><span class='comma'>,</span> <span class='label'>b:</span> <span class='id identifier rubyid_b'>b</span><span class='comma'>,</span> <span class='label'>c:</span> <span class='id identifier rubyid_c'>c</span><span class='comma'>,</span> <span class='label'>d:</span> <span class='id identifier rubyid_d'>d</span>
<span class='comment'># prints {:a=>1, :b=>2, :c=>[3, 4], :d=>[5, 6]}</span></code></pre>
<div id='footer'></div>
</div> <!-- content -->
</div> <!-- y_main -->
</body>
</html>