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
|
---
title: Бітові оператори
slug: Web/JavaScript/Reference/Operators/Bitwise_Operators
tags:
- JavaScript
- Довідка
- Оператор
translation_of: Web/JavaScript/Reference/Operators
translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators
---
<div>{{jsSidebar("Operators")}}</div>
<p><strong>Бітові оператори</strong> опрацьовують свої операнди як послідовність 32-х бітів (нулів та одиниць), а не як десяткові, шістнадцяткові чи вісімкові <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Число">числа</a></code>. Наприклад, десяткове число дев'ять має бітове представлення 1001. Бітові оператори виконують операції над цими бітовими представленнями, але повертають стандартні числові значення JavaScript.</p>
<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div>
<p>Наступна таблиця наводить перелік бітових операторів JavaScript:</p>
<table class="standard-table">
<tbody>
<tr>
<th>Оператор</th>
<th>Застосування</th>
<th>Опис</th>
</tr>
<tr>
<td><a href="#Побітове_І">Побітове І (AND)</a></td>
<td><code>a & b</code></td>
<td>Повертає <code>1</code> на кожній позиції, де відповідні біти обох операндів дорівнюють <code>1</code>.</td>
</tr>
<tr>
<td><a href="#Побітове_АБО">Побітове АБО (OR)</a></td>
<td><code>a | b</code></td>
<td>Повертає <code>1</code> на кожній позиції, де відповідні біти одного чи обох операндів дорівнюють <code>1</code>.</td>
</tr>
<tr>
<td><a href="#Виключне_побітове_АБО">Виключне побітове АБО (XOR)</a></td>
<td><code>a ^ b</code></td>
<td>Повертає <code>1</code> на кожній позиції, де відповідний біт одного з двох, але не обох, операндів дорівнює <code>1</code>.</td>
</tr>
<tr>
<td><a href="#Побітове_НЕ">Побітове НЕ (NOT)</a></td>
<td><code>~ a</code></td>
<td>Виконує інверсію бітів операнду.</td>
</tr>
<tr>
<td><a href="#<<_Лівий_зсув">Лівий зсув</a></td>
<td><code>a << b</code></td>
<td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (< 32) бітів ліворуч, заповнюючи позиції справа нулями.</td>
</tr>
<tr>
<td><a href="#>>_Правий_зсув_з_розширенням_знаку">Правий зсув з розширенням знаку</a></td>
<td><code>a >> b</code></td>
<td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (< 32) бітів праворуч, відкидаючи зсунуті біти.</td>
</tr>
<tr>
<td><a href="#>>>_Правий_зсув_із_заповненням_нулями">Правий зсув із заповненням нулями</a></td>
<td><code>a >>> b</code> </td>
<td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (< 32) бітів праворуч, відкидаючи зсунуті біти та заповнюючи позиції зліва нулями.</td>
</tr>
</tbody>
</table>
<h2 id="32-бітні_цілі_числа_зі_знаком">32-бітні цілі числа зі знаком</h2>
<p>Операнди усіх бітових операторів перетворюються на 32-бітні цілі числа зі знаком у <a href="https://uk.wikipedia.org/wiki/%D0%94%D0%BE%D0%BF%D0%BE%D0%B2%D0%BD%D1%8F%D0%BB%D1%8C%D0%BD%D0%B8%D0%B9_%D0%BA%D0%BE%D0%B4">форматі доповняльного коду</a>, окрім оператора правого зсуву із заповненням нулями, який повертає беззнакове ціле 32-бітне число. Формат доповняльного коду означає, що від'ємний еквівалент числа (наприклад, 5 та -5) - це інвертовані біти числа (побітове НЕ, або обернений код числа) плюс один. Для прикладу, наступний код представляє ціле число 314:</p>
<pre class="brush: js">00000000000000000000000100111010
</pre>
<p>Наступний код представляє <code>~314</code>, тобто, обернений код числа <code>314</code>:</p>
<pre class="brush: js">11111111111111111111111011000101
</pre>
<p>Нарешті, наступний код представляє доповняльний код числа <code>-314</code>:</p>
<pre class="brush: js">11111111111111111111111011000110
</pre>
<p>Доповняльний код гарантує, що лівий біт дорівнює 0, коли число є додатним, і 1, коли число є від'ємним. Тому він відомий як <em>знаковий біт</em>.</p>
<p>Число <code>0</code> є цілим числом, усі біти якого дорівнюють 0.</p>
<pre class="brush: js">0 (основа 10) = 00000000000000000000000000000000 (основа 2)
</pre>
<p>Число <code>-1</code> є цілим числом, усі біти якого дорівнюють 1.</p>
<pre class="brush: js">-1 (основа 10) = 11111111111111111111111111111111 (основа 2)
</pre>
<p>Число <code>-2147483648</code> (шістнадцяткове представлення: <code>-0x80000000</code>) є цілим числом, усі біти якого дорівнюють 0, окрім першого (старшого) біта.</p>
<pre class="brush: js">-2147483648 (основа 10) = 10000000000000000000000000000000 (основа 2)
</pre>
<p>Число <code>2147483647</code> (шістнадцяткове представлення: <code>0x7fffffff</code>) є цілим числом, усі біти якого дорівнюють 1, окрім першого (старшого) біта.</p>
<pre class="brush: js">2147483647 (основа 10) = 01111111111111111111111111111111 (основа 2)
</pre>
<p>Числа <code>-2147483648</code> та <code>2147483647</code> є мінімальним та максимальним цілими числами, які можуть бути представлені 32-бітним знаковим числом.</p>
<h2 id="Побітові_логічні_оператори">Побітові логічні оператори</h2>
<p>Концептуально побітові логічні оператори працюють наступним чином:</p>
<ul>
<li>Операнди перетворюються на 32-бітні цілі числа та виражаються послідовністю бітів (нулів та одиниць). Числа, що мають більше 32 бітів, втрачають свої старші біти. Наприклад, наступне ціле число, що має більше 32 бітів, буде перетворено на 32-бітне ціле число:
<pre class="brush: js">До: 11100110111110100000000000000110000000000001
Після: 10100000000000000110000000000001</pre>
</li>
<li>Кожен біт першого операнду ставиться у пару до відповідного біту другого операнду: перший біт до першого біту, другий біт до другого, і так далі.</li>
<li>Оператор застосовується до кожної пари бітів, а результат будується побітово.</li>
</ul>
<h3 id="Побітове_І"><a id="Bitwise_AND" name="Bitwise_AND">& (Побітове І)</a></h3>
<p>Виконує операцію І (AND) над кожною парою бітів. <code>a</code> І <code>b</code> дає 1 тільки якщо обидва, <code>a</code> та <code>b</code>, дорівнюють <code>1</code>. Таблиця істинності для операції <code>І</code> наступна:</p>
<table class="standard-table">
<tbody>
<tr>
<td class="header">a</td>
<td class="header">b</td>
<td class="header">a AND b</td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>
<pre class="brush: js">. 9 (основа 10) = 00000000000000000000000000001001 (основа 2)
14 (основа 10) = 00000000000000000000000000001110 (основа 2)
--------------------------------
14 & 9 (основа 10) = 00000000000000000000000000001000 (основа 2) = 8 (основа 10)
</pre>
<p>Побітове І над будь-яким числом <code>x</code> та <code>0</code> дає <code>0</code>.</p>
<h3 id="Побітове_АБО"><a id="Bitwise_OR" name="Bitwise_OR">| (Побітове АБО)</a></h3>
<p>Виконує операцію АБО (OR) над кожною парою бітів. <code>a</code> АБО <code>b</code> дає 1, якщо або <code>a</code>, або <code>b</code> дорівнює <code>1</code>. Таблиця істинності для операції <code>АБО</code> наступна:</p>
<table class="standard-table">
<tbody>
<tr>
<td class="header">a</td>
<td class="header">b</td>
<td class="header">a OR b</td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>1</td>
</tr>
</tbody>
</table>
<pre class="brush: js">. 9 (основа 10) = 00000000000000000000000000001001 (основа 2)
14 (основа 10) = 00000000000000000000000000001110 (основа 2)
--------------------------------
14 | 9 (основа 10) = 00000000000000000000000000001111 (основа 2) = 15 (основа 10)
</pre>
<p>Побітове АБО над будь-яким числом <code>x</code> та <code>0</code> дає <code>x</code>.</p>
<h3 id="Виключне_побітове_АБО"><a id="Bitwise_XOR" name="Bitwise_XOR">^ (Виключне побітове АБО)</a></h3>
<p>Виконує операцію виключного АБО (XOR) над кожною парою бітів. <code>a</code> викл. АБО <code>b</code> дає 1, якщо <code>a</code> та <code>b</code> є різними. Таблиця істинності для операції <code>XOR</code> наступна:</p>
<table class="standard-table">
<tbody>
<tr>
<td class="header">a</td>
<td class="header">b</td>
<td class="header">a XOR b</td>
</tr>
<tr>
<td>0</td>
<td>0</td>
<td>0</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>
<pre class="brush: js">. 9 (основа 10) = 00000000000000000000000000001001 (основа 2)
14 (основа 10) = 00000000000000000000000000001110 (основа 2)
--------------------------------
14 ^ 9 (основа 10) = 00000000000000000000000000000111 (основа 2) = 7 (основа 10)
</pre>
<p>Виключне побітове АБО над будь-яким числом <code>x</code> та <code>0</code> дає x.</p>
<h3 id="Побітове_НЕ"><a id="Bitwise_NOT" name="Bitwise_NOT">~ (Побітове НЕ)</a></h3>
<p>Виконує операцію НЕ над кожним бітом. НЕ <code>a</code> повертає інвертоване значення (або обернений код) операнду <code>a</code>. Таблиця істинності для операції <code>НЕ</code> наступна:</p>
<table class="standard-table">
<tbody>
<tr>
<td class="header">a</td>
<td class="header">NOT a</td>
</tr>
<tr>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>1</td>
<td>0</td>
</tr>
</tbody>
</table>
<pre class="brush: js"> 9 (основа 10) = 00000000000000000000000000001001 (основа 2)
--------------------------------
~9 (основа 10) = 11111111111111111111111111110110 (основа 2) = -10 (основа 10)
</pre>
<p>Побітове НЕ над будь-яким числом <code>x</code> дає <code>-(x + 1)</code>. Наприклад, <code>~-5</code> дорівнює <code>4</code>.</p>
<p>Зауважте, що через використання 32-бітного представлення чисел і <code>~-1</code>, і <code>~4294967295</code> (2<sup>32</sup>-1) повернуть <code>0</code>.</p>
<h2 id="Оператори_бітового_зсуву">Оператори бітового зсуву</h2>
<p>Оператори бітового зсуву приймають два операнди: перший є величиною, в якій треба виконати зсув, а другий вказує кількість бітових позицій для зсуву. Напрямок операції зсуву контролюється застосованим оператором.</p>
<p>Оператори зсуву перетворюють свої операнди на 32-бітні цілі числа у порядку від старшого до молодшого байту та повертають результат того самого типу, до якого належить лівий операнд. Лише молодші п'ять бітів правого операнду будуть використані.</p>
<h3 id="<<_Лівий_зсув"><a id="Left_shift" name="Left_shift"><< (Лівий зсув)</a></h3>
<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів ліворуч. Надлишкові біти, зсунуті ліворуч, відкидаються. Біти, додані справа, заповнюються нулями.</p>
<p>Наприклад, <code>9 << 2</code> дорівнює 36:</p>
<pre class="brush: js">. 9 (основа 10): 00000000000000000000000000001001 (основа 2)
--------------------------------
9 << 2 (основа 10): 00000000000000000000000000100100 (основа 2) = 36 (основа 10)
</pre>
<p>Бітовий зсув будь-якого числа <code>x</code> ліворуч на <code>y</code> бітів дорівнює <code>x * 2 ** y</code>.<br>
Отже, для прикладу: <code>9 << 3</code> можна перекласти як: <code>9 * (2 ** 3) = 9 * (8) =</code><code> 72</code>.</p>
<h3 id=">>_Правий_зсув_з_розширенням_знаку"><a id="Right_shift" name="Right_shift">>> (Правий зсув з розширенням знаку)</a></h3>
<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються значенням старшого біта. Оскільки новий старший біт матиме те саме значення, що й попередній старший біт, знаковий (старший) біт не змінюється. Звідси назва "з розширенням знаку".</p>
<p>Наприклад, <code>9 >> 2</code> дорівнює 2:</p>
<pre class="brush: js">. 9 (основа 10): 00000000000000000000000000001001 (основа 2)
--------------------------------
9 >> 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
</pre>
<p>Аналогічно, <code>-9 >> 2</code> дорівнює <code>-3</code>, оскільки знак зберігається:</p>
<pre class="brush: js">. -9 (основа 10): 11111111111111111111111111110111 (основа 2)
--------------------------------
-9 >> 2 (основа 10): 11111111111111111111111111111101 (основа 2) = -3 (основа 10)
</pre>
<h3 id=">>>_Правий_зсув_із_заповненням_нулями"><a id="Unsigned_right_shift" name="Unsigned_right_shift">>>> (Правий зсув із заповненням нулями)</a></h3>
<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються нулями. Знаковий біт отримує значення 0, а отже, результат завжди невід'ємний. На відміну від інших бітових операторів, правий зсув із заповненням нулями повертає беззнакове ціле 32-бітне число.</p>
<p>Для невід'ємних чисел, правий зсув із заповненням нулями та правий зсув з розширенням знаку дають однаковий результат. Наприклад, <code>9 >>> 2</code> дорівнює 2, так само, як <code>9 >> 2</code>:</p>
<pre class="brush: js">. 9 (основа 10): 00000000000000000000000000001001 (основа 2)
--------------------------------
9 >>> 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
</pre>
<p>Однак, це не одне й те саме для від'ємних чисел. Наприклад, <code>-9 >>> 2</code> поверне 1073741821, що відрізняється від <code>-9 >> 2</code> (що дорівнює <code>-3</code>):</p>
<pre class="brush: js">. -9 (основа 10): 11111111111111111111111111110111 (основа 2)
--------------------------------
-9 >>> 2 (основа 10): 00111111111111111111111111111101 (основа 2) = 1073741821 (основа 10)
</pre>
<h2 id="Приклади">Приклади</h2>
<h3 id="Прапори_та_бітові_маски">Прапори та бітові маски</h3>
<p>Побітові логічні оператори часто використовуються для створення, маніпулювання та читання послідовностей <em>прапорів</em>, які грають роль двійкових змінних. Замість цих послідовностей можуть використовуватись зміні, але двійкові прапори займають набагато менше пам'яті (у 32 рази).</p>
<p>Припустимо, є 4 прапори:</p>
<ul>
<li>прапор A: ми маємо проблему з мурахами</li>
<li>прапор B: ми маємо кажана</li>
<li>прапор C: ми маємо кота</li>
<li>прапор D: ми маємо качку</li>
</ul>
<p>Ці прапори представлені послідовністю бітів: DCBA. Коли прапор <em>встановлений</em>, він має значення 1. Коли прапор <em>очищений</em>, він має значення 0. Припустимо, змінна <code>flags</code> має двійкове значення 0101:</p>
<pre class="brush: js">var flags = 5; // двійкове значення 0101
</pre>
<p>Це значення вказує:</p>
<ul>
<li>прапор A дорівнює true (ми маємо проблему з мурахами);</li>
<li>прапор B дорівнює false (ми не маємо кажана);</li>
<li>прапор C дорівнює true (ми маємо кота);</li>
<li>прапор D дорівнює false (ми не маємо качки);</li>
</ul>
<p>Оскільки бітові операнди 32-бітні, 0101 насправді дорівнює 00000000000000000000000000000101, але нулями попереду можна знехтувати, оскільки вони не містять корисної інформації.</p>
<p><em>Бітова маска</em> - це послідовність бітів, які можуть маніпулювати прапорами та/або читати їх. Зазвичай, визначається "примітивна" бітова маска для кожного прапора:</p>
<pre class="brush: js">var FLAG_A = 1; // 0001
var FLAG_B = 2; // 0010
var FLAG_C = 4; // 0100
var FLAG_D = 8; // 1000
</pre>
<p>Нові бітові маски можуть створюватись застовуванням побітових логічних операторів до цих примітивних бітових масок. Наприклад, бітова маска 1011 може бути створена операцією АБО з прапорів FLAG_A, FLAG_B та FLAG_D:</p>
<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
</pre>
<p>Індивідуальні значення прапорів можна витягнути застосуванням операції І до них та бітової маски, де кожний біт, що має значення один, "витягне" відповідний прапор. Бітова маска <em>маскує</em> невідповідні прапори, об'єднуючи їх операцією І з нулями (звідси термін "бітова маска"). Наприклад, бітову маску 0100 можна використати, щоб побачити, чи встановлений прапор C:</p>
<pre class="brush: js">// якщо ми маємо кота
if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
// зробити щось
}
</pre>
<p>Бітова маска з кількома встановленими прапорами діє як "або/або". Для прикладу, наступні два фрагменти еквівалентні:</p>
<pre class="brush: js">// якщо ми маємо кажана або ми маємо кота
// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
if ((flags & FLAG_B) || (flags & FLAG_C)) {
// зробити щось
}
</pre>
<pre class="brush: js">// якщо ми маємо кажана або кота
var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
if (flags & mask) { // 0101 & 0110 => 0100 => true
// зробити щось
}
</pre>
<p>Прапори можна встановити, об'єднавши їх операцією АБО з бітовою маскою, де кожний біт, що має значення один, встановить відповідний прапор, якщо прапор ще не встановлений. Наприклад, бітову маску 1100 можна використати, щоб встановити прапори C та D:</p>
<pre class="brush: js">// так, ми маємо кота та качку
var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
flags |= mask; // 0101 | 1100 => 1101
</pre>
<p>Прапори можна очистити, об'єднавши їх операцією І з бітовою маскою, де кожний біт, що має значення нуль, очистить відповідний прапор, якщо він ще не очищений. Ця бітова маска може бути створена застосуванням операції НЕ до примітивних бітових масок. Наприклад, бітову маску 1010 можна використати, щоб очистити прапори A та C:</p>
<pre class="brush: js">// ні, ми не маємо проблеми з мурахами або кота
var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
flags &= mask; // 1101 & 1010 => 1000
</pre>
<p>Маску також можна створити за допомогою <code>~FLAG_A & ~FLAG_C</code> (правило де Моргана):</p>
<pre class="brush: js">// ні, ми не маємо проблеми з мурахами і ми не маємо кота
var mask = ~FLAG_A & ~FLAG_C;
flags &= mask; // 1101 & 1010 => 1000
</pre>
<p>Прапори можна перемикати, об'єднуючи їх операцією виключне АБО з бітовою маскою, де кожний біт, що має значення один, переключить відповідний прапор. Наприклад, бітову маску 0110 можна використати, щоб переключити прапори B та C:</p>
<pre class="brush: js">// якщо ми не мали кажана, тепер ми його маємо,
// а якщо він в нас був, бувай, кажанчику
// те саме для котів
var mask = FLAG_B | FLAG_C;
flags = flags ^ mask; // 1100 ^ 0110 => 1010
</pre>
<p>Нарешті, усі прапори можна перевернути оператором НЕ:</p>
<pre class="brush: js">// входимо у паралельний всесвіт...
flags = ~flags; // ~1010 => 0101
</pre>
<h3 id="Перетворення_типів">Перетворення типів</h3>
<p>Перетворити двійковий <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/String">рядок</a></code> на десяткове <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Число">число</a></code>:</p>
<pre class="brush: js">var sBinString = '1011';
var nMyNumber = parseInt(sBinString, 2);
alert(nMyNumber); // виводить 11, тобто 1011
</pre>
<p>Перетворити десяткове <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Число">число</a></code> на двійковий <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/String">рядок</a></code>:</p>
<pre class="brush: js">var nMyNumber = 11;
var sBinString = nMyNumber.toString(2);
alert(sBinString); // виводить 1011, тобто 11
</pre>
<h3 id="Автоматизація_створення_маски">Автоматизація створення маски</h3>
<p>Ви можете створювати маски з набору <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Boolean">булевих</a></code> значень наступним чином:</p>
<pre class="brush: js">function createMask() {
var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
return nMask;
}
var mask1 = createMask(true, true, false, true); // 11, тобто: 1011
var mask2 = createMask(false, false, true); // 4, тобто: 0100
var mask3 = createMask(true); // 1, тобто: 0001
// і т.д.
alert(mask1); // виводить 11, тобто: 1011
</pre>
<h3 id="Зворотний_алгоритм_отримання_масиву_булевих_значень_з_маски">Зворотний алгоритм: отримання масиву булевих значень з маски</h3>
<p>Якщо ви бажаєте створити <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Array">масив</a></code> <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Boolean">булевих значень</a></code> з маски, можете скористатись цим кодом:</p>
<pre class="brush: js">function arrayFromMask(nMask) {
// Значенння nMask має бути між -2147483648 та 2147483647
if (nMask > 0x7fffffff || nMask < -0x80000000) {
throw new TypeError('arrayFromMask - out of range');
}
for (var nShifted = nMask, aFromMask = []; nShifted;
aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
return aFromMask;
}
var array1 = arrayFromMask(11);
var array2 = arrayFromMask(4);
var array3 = arrayFromMask(1);
alert('[' + array1.join(', ') + ']');
// виводить "[true, true, false, true]", тобто: 11, тобто: 1011
</pre>
<p>Ви можете перевірити обидва алгоритми одночасно…</p>
<pre class="brush: js">var nTest = 19; // наша користувацька маска
var nResult = createMask.apply(this, arrayFromMask(nTest));
alert(nResult); // 19
</pre>
<p>Суто з навчальною метою (оскільки існує метод <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code>) ми показуємо, як можна модифікувати алгоритм <code>arrayFromMask</code> для створення <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/String">рядка</a></code>, що містить двійкове представлення <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Число">числа</a></code>, а не <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Array">масиву</a></code> <code><a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Boolean">булевих значень</a></code>:</p>
<pre class="brush: js">function createBinaryString(nMask) {
// Значення nMask має бути між -2147483648 та 2147483647
for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
return sMask;
}
var string1 = createBinaryString(11);
var string2 = createBinaryString(4);
var string3 = createBinaryString(1);
alert(string1);
// виводить 00000000000000000000000000001011, тобто 11
</pre>
<h2 id="Специфікації">Специфікації</h2>
<table class="standard-table">
<tbody>
<tr>
<th scope="col">Специфікація</th>
<th scope="col">Статус</th>
<th scope="col">Коментар</th>
</tr>
<tr>
<td>{{SpecName('ES1')}}</td>
<td>{{Spec2('ES1')}}</td>
<td>Початкове визначення.</td>
</tr>
<tr>
<td>{{SpecName('ES5.1', '#sec-11.7')}}</td>
<td>{{Spec2('ES5.1')}}</td>
<td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Побітовий оператор НЕ</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Бітові оператори зсуву</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Двійкові побітові оператори</a></td>
</tr>
<tr>
<td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td>
<td>{{Spec2('ES6')}}</td>
<td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Побітовий оператор НЕ</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Бітові оператори зсуву</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Двійкові побітові оператори</a></td>
</tr>
<tr>
<td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td>
<td>{{Spec2('ESDraft')}}</td>
<td>Визначені у кількох розділах специфікації: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Побітовий оператор НЕ</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Бітові оператори зсуву</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Двійкові побітові оператори</a></td>
</tr>
</tbody>
</table>
<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
<div class="hidden">
<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
</div>
<p>{{Compat("javascript.operators.bitwise")}}</p>
<h2 id="Див._також">Див. також</h2>
<ul>
<li><a href="/uk/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Логічні оператори</a></li>
</ul>
|