remove retired locales (#699)

20 files changed, 0 insertions, 3340 deletions

diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/boolean/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/boolean/index.html
deleted file mode 100644
index 4cbc7d8fb6..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/boolean/index.html
+++ /dev/null
@@ -1,84 +0,0 @@
----
-title: Boolean.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/Boolean
-tags:
-  - Boolean
-  - JavaScript
-  - Властивість
-  - Поле
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Boolean/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Поле <strong><code>Boolean.prototype</code></strong> представляє прототип конструктора {{jsxref("Boolean")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<div>{{EmbedInteractiveExample("pages/js/boolean-constructor.html")}}</div>
-
-<p class="hidden">Джерело цих інтерактивних прикладів зберігається у репозиторії на GitHub. Якщо ви маєте бажання зробити свій внесок у проект інтерактивних прикладів - будь-ласка, зклонуйте репозиторій <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> та пришліть нам pull request.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Екземпляри {{jsxref("Boolean")}} наслідуються від <code>Boolean.prototype</code>. Ви можете використовувати об'єкт прототипа конструктора, щоб додавати свої поля та методи до всіх екземплярів {{jsxref("Boolean")}}.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>Boolean.prototype.constructor</code></dt>
- <dd>Повертає функцію, що створила прототип екземпляра. За замовчування це функція {{jsxref("Boolean")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<dl>
- <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Повертає строку, що містить сирець об'єкту {{jsxref("Boolean")}}; використавши її ви можете створити еквівалентний об'єкт. Перевизначає метод {{jsxref("Object.prototype.toSource()")}}.</dd>
- <dt>{{jsxref("Boolean.prototype.toString()")}}</dt>
- <dd>Повертає строку <code>"true"</code> чи <code>"false"</code> залежно від значення об'єкту. Перевизначає метод {{jsxref("Object.prototype.toString()")}}.</dd>
- <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt>
- <dd>Повертає примітив значення об'єкту {{jsxref("Boolean")}}. Перевизначає метод {{jsxref("Object.prototype.valueOf()")}}.</dd>
-</dl>
-
-<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>Первинне визначення. Реалізовано у JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-boolean.prototype', 'Boolean.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Підтримка_у_браузерах">Підтримка у браузерах</h2>
-
-<div>
-<div class="hidden">Таблиця сумісності на цій сторінці сформована автоматично із структурованих даних. Якщо ви маєте бажання зробити свій внесок до цих даних - будь-ласка, ось репозиторій <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>, надішліть нам свій pull request.</div>
-
-<p>{{Compat("javascript.builtins.Boolean.prototype")}}</p>
-</div>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/error/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/error/index.html
deleted file mode 100644
index d7c6bbabf9..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/error/index.html
+++ /dev/null
@@ -1,116 +0,0 @@
----
-title: Error.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/Error
-tags:
-  - Error
-  - JavaScript
-  - Властивість
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/Error
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Error/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>Error.prototype</strong></code> є прототипом для конструктора {{jsxref("Error")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("Error")}} та екземпляри {{jsxref("Global_Objects/Error", "базових конструкторів помилок", "#Типи_помилок", 1)}} успадковуються від <code>Error.prototype</code>. Як в усіх функціях-конструкторах, ви можете використовувати прототип конструктора, щоб додавати властивості чи методи до усіх екземплярів, створених цим конструктором. </p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<h3 id="Стандартні_властивості">Стандартні властивості</h3>
-
-<dl>
- <dt><code>Error.prototype.constructor</code></dt>
- <dd>Функція, яка створила прототип екземпляра.</dd>
- <dt>{{jsxref("Error.prototype.message")}}</dt>
- <dd>Повідомлення помилки.</dd>
- <dt>{{jsxref("Error.prototype.name")}}</dt>
- <dd>Ім'я помилки.</dd>
-</dl>
-
-<h3 id="Спеціальні_розширення">Спеціальні розширення</h3>
-
-<p>{{non-standard_header}}</p>
-
-<h4 id="Microsoft">Microsoft</h4>
-
-<dl>
- <dt><code><a href="/uk/docs/Web/JavaScript/Microsoft_Extensions/Error.description">Error.description</a></code></dt>
- <dd>Опис помилки. Властивість схожа на {{jsxref("Error.prototype.message", "message")}}.</dd>
- <dt><code><a href="/uk/docs/Web/JavaScript/Microsoft_Extensions/Error.number">Error.number</a></code></dt>
- <dd>Номер помилки.</dd>
-</dl>
-
-<h4 id="Mozilla">Mozilla</h4>
-
-<dl>
- <dt>{{jsxref("Error.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber")}}</dt>
- <dd>Номер рядка у файлі, що спричинив помилку.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у файлі, де виникла помилка.</dd>
- <dt>{{jsxref("Error.prototype.stack")}}</dt>
- <dd>Трасування стеку.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<dl>
- <dt>{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Повертає рядок з кодом, що спричинить створення заданого об'єкта {{jsxref("Error")}}; ви можете використати це значення, щоб створити новий об'єкт. Заміщує метод {{jsxref("Object.prototype.toSource()")}}.</dd>
- <dt>{{jsxref("Error.prototype.toString()")}}</dt>
- <dd>Повертає рядок, що представляє заданий об'єкт. Заміщує метод {{jsxref("Object.prototype.toString()")}}.</dd>
-</dl>
-
-<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>Початкове визначення Реалізовано у JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-error.prototype', 'Error')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Error.prototype")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error")}}</li>
- <li>{{jsxref("Object.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/evalerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/evalerror/index.html
deleted file mode 100644
index 2e030759d1..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/evalerror/index.html
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: EvalError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/EvalError
-tags:
-  - Error
-  - EvalError
-  - JavaScript
-  - помилка
-translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/EvalError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/EvalError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>EvalError.prototype</strong></code> є прототипом для конструктора {{jsxref("EvalError")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("EvalError")}} успадковуються від <code>EvalError.prototype</code>. Ви можете використати прототип, щоб додати властивості та методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>EvalError.prototype.constructor</code></dt>
- <dd>Функція, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("EvalError")}} повинен мати власну властивість <code>message</code>, у <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> він успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успадковано від {{jsxref("Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("EvalError")}} не містить власних методів, екземпляри {{jsxref("EvalError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.EvalError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/function/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/function/index.html
deleted file mode 100644
index e77a1ed5ef..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/function/index.html
+++ /dev/null
@@ -1,101 +0,0 @@
----
-title: Function.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/Function
-tags:
-  - Function
-  - JavaScript
-  - Властивість
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/Function
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Function/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>Function.prototype</strong></code> є об'єктом прототипу {{jsxref("Function")}}.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Об'єкти {{jsxref("Function")}} успадковуються від <code>Function.prototype</code>.  <code>Function.prototype</code> не можна змінити.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt>{{jsxref("Function.prototype.arguments")}} {{deprecated_inline}}</dt>
- <dd>Масив, що відповідає аргументам, переданим у функцію. Це застаріла властивість {{jsxref("Function")}}. Використовуйте натомість об'єкт {{jsxref("Functions/arguments", "arguments")}}, доступний всередині функції.</dd>
- <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Вказувала кількість аргументів, очікуваних функцією, але була видалена. Використовуйте натомість властивість {{jsxref("Function.length", "length")}}.</s></dd>
- <dt>{{jsxref("Function.prototype.caller")}} {{non-standard_inline}}</dt>
- <dd>Вказує функцію, що викликала функцію, яка виконується.</dd>
- <dt>{{jsxref("Function.prototype.length")}}</dt>
- <dd>Вказує кількість аргументів, очікуваних функцією.</dd>
- <dt>{{jsxref("Function.prototype.name")}}</dt>
- <dd>Ім'я функції.</dd>
- <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt>
- <dd>Ім'я, що відображається для функції.</dd>
- <dt><code>Function.prototype.constructor</code></dt>
- <dd>Вказує функцію, яка створює прототип об'єкта. Більше інформації дивіться на сторінці {{jsxref("Object.prototype.constructor")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<dl>
- <dt>{{jsxref("Function.prototype.apply()")}}</dt>
- <dd>Викликає функцію та встановлює її <em>this</em> надане значення, аргументи можуть передаватися об'єктом {{jsxref("Array")}}.</dd>
- <dt>{{jsxref("Function.prototype.bind()")}}</dt>
- <dd>Створює нову функцію, в якої під час виклику <em>this</em> присвоєне надане значення, з заданою послідовністю аргументів, що передують будь-якім іншим наданим аргументам під час виклику нової функції.</dd>
- <dt>{{jsxref("Function.prototype.call()")}}</dt>
- <dd>Викликає (виконує) функцію та присвоює її <em>this</em> надане значення, аргументи можуть передаватися як є.</dd>
- <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt>
- <dd>Повертає <code>true</code>, якщо функція є <a href="/uk/docs/Web/JavaScript/Guide/Iterators_and_Generators">генератором</a>; інакше повертає <code>false</code>.</dd>
- <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Повертає рядкове представлення першокоду функції. Заміщує метод {{jsxref("Object.prototype.toSource")}}.</dd>
- <dt>{{jsxref("Function.prototype.toString()")}}</dt>
- <dd>Повертає рядкове представлення першокоду функції. Заміщує метод {{jsxref("Object.prototype.toString")}}.</dd>
-</dl>
-
-<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>Початкове визначення. Реалізоване у JavaScript 1.1</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Function.prototype")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Function")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html
deleted file mode 100644
index e499707efa..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html
+++ /dev/null
@@ -1,67 +0,0 @@
----
-title: GeneratorFunction.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/GeneratorFunction
-tags:
-  - ECMAScript 2015
-  - GeneratorFunction
-  - JavaScript
-  - Ітератор
-  - Властивість
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction
-translation_of_original: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>GeneratorFunction.prototype</strong></code> відображає прототип {{jsxref("GeneratorFunction")}}.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Об'єкти {{jsxref("GeneratorFunction")}} успадковуються від <code>GeneratorFunction.prototype</code>. <code>GeneratorFunction.prototype</code> не можна змінювати.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code><strong>GeneratorFunction.constructor</strong></code></dt>
- <dd>Початковим значенням є {{jsxref("GeneratorFunction")}}.</dd>
- <dt><code><strong>GeneratorFunction.prototype.prototype</strong></code></dt>
- <dd>Значення дорівнює <code>%GeneratorPrototype%</code>.</dd>
-</dl>
-
-<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('ES2015', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.GeneratorFunction.prototype")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("GeneratorFunction")}}</li>
- <li>{{jsxref("Function")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/internalerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/internalerror/index.html
deleted file mode 100644
index 615851285c..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/internalerror/index.html
+++ /dev/null
@@ -1,64 +0,0 @@
----
-title: InternalError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/InternalError
-tags:
-  - Error
-  - InternalError
-  - JavaScript
-  - Властивість
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/InternalError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/InternalError/prototype
----
-<div>{{JSRef}} {{non-standard_header}}</div>
-
-<p>Властивість <code><strong>InternalError.prototype</strong></code> є прототипом конструктора {{jsxref("InternalError")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("InternalError")}} успадковуються від <code>InternalError.prototype</code>. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>InternalError.prototype.constructor</code></dt>
- <dd>Визначає функцію, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успаковано від {{jsxref("Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("InternalError")}} не має власних методів, екземпляри {{jsxref("InternalError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<h2 id="Специфікації">Специфікації</h2>
-
-<p>Не є частиною жодних специфікацій.</p>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.InternalError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/number/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/number/index.html
deleted file mode 100644
index a7589f1422..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/number/index.html
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: Number.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/Number
-tags:
-  - JavaScript
-  - Number
-  - Property
-  - Prototype
-translation_of: Web/JavaScript/Reference/Global_Objects/Number
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Число/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <strong><code>Number.prototype</code></strong> являє собою прототип для конструктора класу <code>{{jsxref("Global_Objects/Number", "Number")}}</code>.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Кожен примірник класу <code>{{jsxref("Global_Objects/Number", "Number")}}</code> успадковує властивості й методи з <code>Number.prototype</code>. Зміни, внесені до прототипа, позначаться на всіх об'єктах, що є примірниками класу <code>{{jsxref("Global_Objects/Number", "Number")}}</code>.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>Number.prototype.constructor</code></dt>
- <dd>Повертає функцію, що створила цей примірник об'єкта. Типово це об'єкт <code>{{jsxref("Global_Objects/Number", "Number")}}</code>, який водночас є і функцією.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<dl>
- <dt>{{jsxref("Number.prototype.toExponential()")}}</dt>
- <dd>Повертає рядок, що містить експоненціальний запис числа.</dd>
- <dt>{{jsxref("Number.prototype.toFixed()")}}</dt>
- <dd>Повертає рядок, що містить запис числа у форматі з нерухомою комою.</dd>
- <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt>
- <dd>Повертає рядок, що містить узалежнений від мови запис числа. Перекриває метод <code>{{jsxref("Object.prototype.toLocaleString()")}}</code>.</dd>
- <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt>
- <dd>Повертає рядок, що містить запис числа із зазначеною точністю у форматі з нерухомою комою чи експоненціальний.</dd>
- <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt>
- <dd>Повертає рядок, що містить код мовою JavaScript, який створює об'єкт класу {{jsxref("Global_Objects/Number", "Number")}} з відповідним значенням. Цей код можна використати для створення нового об'єкта. Перекриває метод <code>{{jsxref("Object.prototype.toSource()")}}</code>.</dd>
- <dt>{{jsxref("Number.prototype.toString()")}}</dt>
- <dd>Повертає рядок, що містить числовий запис значення об'єкта в зазначеній системі числення. Перекриває метод <code>{{jsxref("Object.prototype.toString()")}}</code>.</dd>
- <dt>{{jsxref("Number.prototype.valueOf()")}}</dt>
- <dd>Повертає {{Glossary("Primitive", "просте числове значення")}} об'єкта. Перекриває метод <code>{{jsxref("Object.prototype.valueOf()")}}</code>.</dd>
-</dl>
-
-<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>Первинне визначення. Реалізовано у JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Підтримка_веб-переглядачами">Підтримка веб-переглядачами</h2>
-
-<p class="hidden">Таблиця сумісності на цій сторінці створена зі структурованих даних. Якщо ви хочете долучитися до розробки цих даних, пропонуйте нам свої pull request до репозиторію <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
-
-<p>{{Compat("javascript.builtins.Number.prototype")}}</p>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Global_Objects/Number", "Number")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/promise/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/promise/index.html
deleted file mode 100644
index b5affe46e1..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/promise/index.html
+++ /dev/null
@@ -1,71 +0,0 @@
----
-title: Promise.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/Promise
-tags:
-  - JavaScript
-  - Promise
-  - ДжаваСкріпт
-  - Проміс
-translation_of: Web/JavaScript/Reference/Global_Objects/Promise
-translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Параметр <code><strong>Promise</strong></code><strong><code>.prototype</code></strong> відображає прототип для конструктора {{jsxref("Promise")}} constructor.</p>
-
-<div>{{js_property_attributes(0,0,0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Екземпляри {{jsxref("Promise")}} успадковуються від {{jsxref("Promise.prototype")}}. Ви можете використовувати прототип конструктора, щоб добавляти параметри або методи до всіх екземплярів <code>Promise</code>.</p>
-
-<h2 id="Параметри">Параметри</h2>
-
-<dl>
- <dt><code>Promise.prototype.constructor</code></dt>
- <dd>Повертає функцію, яка створила прототип екземпляра. Це є функція {{jsxref("Promise")}} по замовчуванню.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<dl>
- <dt>{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}</dt>
- <dd>Добавляє колбек обробник відхилення проміса, і повертає новий проміс, який вирішується значенням, яке повертається з функції колбеку, якщо вона була викликана, або його початковий результат виконання, якщо даний проміс був виконаний.</dd>
- <dt>{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}</dt>
- <dd>Добавляє до проміса функції колбеки для випадків, коли проміс був виконаний (onFulfilled) і відхилений (onRejected) і повертає новий проміс, який вирішується значенням, яке було повернуто з onFulfilled функції колбеку, або з початковим значенням, яке було вирішено, коли даний проміс не був оброблений (тобто коли обробники <code>onFulfilled</code> або <code>onRejected</code> не є функцією).</dd>
-</dl>
-
-<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('ES6', '#sec-promise.prototype', 'Promise.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_із_браузерами">Сумісність із браузерами</h2>
-
-<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p>
-
-<p>{{Compat("javascript/promise","Promise.prototype")}}</p>
-
-<h2 id="Дивитися_також">Дивитися також</h2>
-
-<ul>
- <li>{{jsxref("Promise")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/rangeerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/rangeerror/index.html
deleted file mode 100644
index a1688fe918..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/rangeerror/index.html
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: RangeError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/RangeError
-tags:
-  - Error
-  - JavaScript
-  - RangeError
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/RangeError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/RangeError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>RangeError.prototype</strong></code> є прототипом для конструктора {{jsxref("RangeError")}}</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("RangeError")}} успадковуються від <code>RangeError.prototype</code>. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>RangeError.prototype.constructor</code></dt>
- <dd>Визначає функцію, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("RangeError")}} має надавати власну властивість <code>message</code>, у <a href="/uk/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, він успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успаковано від {{jsxref("Error", "Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("RangeError")}} не містить власних методів, екземпляри {{jsxref("RangeError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.RangeError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/referenceerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/referenceerror/index.html
deleted file mode 100644
index 3d1102cf05..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/referenceerror/index.html
+++ /dev/null
@@ -1,92 +0,0 @@
----
-title: ReferenceError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/ReferenceError
-tags:
-  - Error
-  - JavaScript
-  - ReferenceError
-  - помилка
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/ReferenceError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>ReferenceError.prototype</strong></code> є прототипом для конструктора {{jsxref("ReferenceError")}}.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("ReferenceError")}} успадковуються від <code>ReferenceError.prototype</code>. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>ReferenceError.prototype.constructor</code></dt>
- <dd>Визначає функцію, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "ReferenceError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("ReferenceError")}} повинен мати власну властивість <code>message</code>, у <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> він успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "ReferenceError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "ReferenceError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "ReferenceError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "ReferenceError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "ReferenceError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успаковано від {{jsxref("Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("ReferenceError")}} не містить власних методів, екземпляри {{jsxref("ReferenceError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.ReferenceError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html
deleted file mode 100644
index f872f5d40c..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: SyntaxError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/SyntaxError
-tags:
-  - Error
-  - JavaScript
-  - Prototype
-  - SyntaxError
-  - помилка
-translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>SyntaxError.prototype</strong></code> є прототипом для конструктора {{jsxref("SyntaxError")}}.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі примірники {{jsxref("SyntaxError")}} успадковуються від <code>SyntaxError.prototype</code>, тож ви можете скористатися прототипом задля додавання властивостей чи методів до всіх примірників.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>SyntaxError.prototype.constructor</code></dt>
- <dd>Функція, що створює прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Попри те, що в ECMA-262 зазначено, що {{jsxref("SyntaxError")}} мусить мати свою властивість <code>message</code>, у <a href="/uk/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a> він насправді успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}</dt>
- <dd>Шлях до файла, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка у файлі, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}</dt>
- <dd>Номер символа у рядку, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}</dt>
- <dd>Стек викликів. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("SyntaxError")}} не містить власних методів, примірники {{jsxref("SyntaxError")}} успадковують деякі методи від ланцюжка прототипів.</p>
-
-<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('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Первинне визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначено як <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Підтримка_веб-переглядачами">Підтримка веб-переглядачами</h2>
-
-<div>
-<div class="hidden">Таблиця сумісності на цій сторінці створена зі структурованих даних. Якщо ви хочете долучитися до розробки цих даних, пропонуйте нам свої pull request до репозиторію <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</div>
-
-<p>{{Compat("javascript.builtins.SyntaxError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/typeerror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/typeerror/index.html
deleted file mode 100644
index 0caac5e6fa..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/typeerror/index.html
+++ /dev/null
@@ -1,89 +0,0 @@
----
-title: TypeError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/TypeError
-tags:
-  - Error
-  - JavaScript
-  - TypeError
-  - помилка
-translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/TypeError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/TypeError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>TypeError.prototype</strong></code> є прототипом для конструктора {{jsxref("TypeError")}}.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("TypeError")}} успадковуються від <code>TypeError.prototype</code>. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>TypeError.prototype.constructor</code></dt>
- <dd>Визначає функцію, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "TypeError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("TypeError")}} повинен мати власну властивість <code>message</code>, у <a href="https://developer.mozilla.org/uk/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, він успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "TypeError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "TypeError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "TypeError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "TypeError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "TypeError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успаковано від {{jsxref("Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("TypeError")}} не містить власних методів, екземпляри {{jsxref("TypeError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<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('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як  <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як  <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.TypeError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/global_objects/urierror/index.html b/files/uk/conflicting/web/javascript/reference/global_objects/urierror/index.html
deleted file mode 100644
index edc28b2064..0000000000
--- a/files/uk/conflicting/web/javascript/reference/global_objects/urierror/index.html
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: URIError.prototype
-slug: conflicting/Web/JavaScript/Reference/Global_Objects/URIError
-tags:
-  - Error
-  - JavaScript
-  - URIError
-  - помилка
-  - прототип
-translation_of: Web/JavaScript/Reference/Global_Objects/URIError
-translation_of_original: Web/JavaScript/Reference/Global_Objects/URIError/prototype
-original_slug: Web/JavaScript/Reference/Global_Objects/URIError/prototype
----
-<div>{{JSRef}}</div>
-
-<p>Властивість <code><strong>URIError.prototype</strong></code> є прототипом для конструктора {{jsxref("URIError")}}.</p>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Всі екземпляри {{jsxref("URIError")}} успадковуються від <code>URIError.prototype</code>. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.</p>
-
-<h2 id="Властивості">Властивості</h2>
-
-<dl>
- <dt><code>URIError.prototype.constructor</code></dt>
- <dd>Визначає функцію, яка створила прототип об'єкта.</dd>
- <dt>{{jsxref("Error.prototype.message", "URIError.prototype.message")}}</dt>
- <dd>Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("URIError")}} повинен мати власну властивість <code>message</code>, у <a href="https://developer.mozilla.org/uk/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, він успадковує {{jsxref("Error.prototype.message")}}.</dd>
- <dt>{{jsxref("Error.prototype.name", "URIError.prototype.name")}}</dt>
- <dd>Ім'я помилки. Успадковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.fileName", "URIError.prototype.fileName")}}</dt>
- <dd>Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.lineNumber", "URIError.prototype.lineNumber")}}</dt>
- <dd>Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.columnNumber", "URIError.prototype.columnNumber")}}</dt>
- <dd>Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.</dd>
- <dt>{{jsxref("Error.prototype.stack", "URIError.prototype.stack")}}</dt>
- <dd>Трасування стеку. Успаковано від {{jsxref("Error")}}.</dd>
-</dl>
-
-<h2 id="Методи">Методи</h2>
-
-<p>Хоча прототип {{jsxref("URIError")}} не містить власних методів, екземпляри {{jsxref("URIError")}} успадковують деякі методи через ланцюжок прототипів.</p>
-
-<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('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначено як  <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначено як  <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначено як  <code><em>NativeError</em>.prototype</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.URIError")}}</p>
-</div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Error.prototype")}}</li>
- <li>{{jsxref("Function.prototype")}}</li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/operators/index.html b/files/uk/conflicting/web/javascript/reference/operators/index.html
deleted file mode 100644
index 5afab5c852..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators/index.html
+++ /dev/null
@@ -1,315 +0,0 @@
----
-title: Арифметичні оператори
-slug: conflicting/Web/JavaScript/Reference/Operators
-tags:
-  - JavaScript
-  - Оператор
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators
-original_slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p><strong>Арифметичні оператори</strong> приймають числові значення (або літерали, або змінні) в якості операндів та повертають єдине числове значення. Стандартними арифметичними операторами є додавання (+), віднімання (-), множення (*) та ділення (/).</p>
-
-<div>{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}</div>
-
-
-
-<h2 id="Addition" name="Addition">Додавання (+)</h2>
-
-<p>Оператор додавання повертає суму числових операндів або об'єднання рядків.</p>
-
-<h3 id="Синтаксис">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x + y
-</pre>
-
-<h3 id="Приклади">Приклади</h3>
-
-<pre class="brush: js">// Number + Number -&gt; сума
-1 + 2 // 3
-
-// Boolean + Number -&gt; сума
-true + 1 // 2
-
-// Boolean + Boolean -&gt; сума
-false + false // 0
-
-// Number + String -&gt; об'єднання
-5 + 'foo' // "5foo"
-
-// String + Boolean -&gt; об'єднання
-'foo' + false // "foofalse"
-
-// String + String -&gt; об'єднання
-'foo' + 'bar' // "foobar"
-</pre>
-
-<h2 id="Subtraction" name="Subtraction">Віднімання (-)</h2>
-
-<p>Оператор віднімання проводить операцію віднімання між двома операндами, повертаючи різницю між ними.</p>
-
-<h3 id="Синтаксис_2">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x - y
-</pre>
-
-<h3 id="Приклади_2">Приклади</h3>
-
-<pre class="brush: js">5 - 3 // 2
-3 - 5 // -2
-'foo' - 3 // NaN</pre>
-
-<h2 id="Division" name="Division">Ділення (/)</h2>
-
-<p>Оператор ділення повертає частку своїх операндів, де лівий операнд є діленим, а правий операнд є дільником.</p>
-
-<h3 id="Синтаксис_3">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x / y
-</pre>
-
-<h3 id="Приклади_3">Приклади</h3>
-
-<pre class="brush: js">1 / 2      // повертає 0.5 у JavaScript
-1 / 2      // повертає 0 у Java
-// (жодне з чисел не є явно числом з рухомою комою)
-
-1.0 / 2.0  // повертає 0.5 у JavaScript та Java
-
-2.0 / 0    // повертає Infinity у JavaScript
-2.0 / 0.0  // також повертає Infinity
-2.0 / -0.0 // повертає -Infinity у JavaScript</pre>
-
-<h2 id="Multiplication" name="Multiplication">Множення (*)</h2>
-
-<p>Оператор множення повертає добуток операндів.</p>
-
-<h3 id="Синтаксис_4">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x * y
-</pre>
-
-<h3 id="Приклади_4">Приклади</h3>
-
-<pre class="brush: js">2 * 2 // 4
--2 * 2 // -4
-Infinity * 0 // NaN
-Infinity * Infinity // Infinity
-'foo' * 2 // NaN
-</pre>
-
-<h2 id="Remainder" name="Remainder">Остача (%)</h2>
-
-<p>Оператор остачі повертає остачу від ділення першого операнду на другий. Він завжди приймає знак діленого.</p>
-
-<h3 id="Синтаксис_5">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> var1 % var2
-</pre>
-
-<h3 id="Приклади_5">Приклади</h3>
-
-<pre class="brush: js">12 % 5 // 2
--1 % 2 // -1
-1 % -2 // 1
-NaN % 2 // NaN
-1 % 2 // 1
-2 % 3 // 2
--4 % 2 // -0
-5.5 % 2 // 1.5
-</pre>
-
-<h2 id="Exponentiation" name="Exponentiation">Піднесення до степеня (**)</h2>
-
-<p>Оператор піднесення до степеня повертає результат піднесення першого операнду до показника степеня другого операнду. Тобто, <code>var1</code><sup><code>var2</code></sup> у наведеній інструкції, де <code>var1</code> та <code>var2</code> є змінними. Оператор піднесення до степеня правоасоціативний. <code>a ** b ** c</code> дорівнює <code>a ** (b ** c)</code>.</p>
-
-<h3 id="Синтаксис_6">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> var1 ** var2
-</pre>
-
-<h3 id="Примітки">Примітки</h3>
-
-<p>У більшості мов, таких як PHP, Python та інших, які мають оператор піднесення до степеня (**), оператор піднесення до степеня має вищий пріоритет, ніж унарні оператори, такі як унарний + та унарний -, але існує кілька винятків. Наприклад, у Bash оператор ** має нижчий пріоритет, ніж унарні оператори. У JavaScript неможливо написати неоднозначний вираз піднесення до степеня, тобто, ви не можете поставити унарний оператор (<code>+/-/~/!/delete/void/typeof</code>) одразу перед числом основи степеня.</p>
-
-<pre class="brush: js">-2 ** 2;
-// 4 у Bash, -4 у інших мовах.
-// Це помилка у JavaScript, оскільки операція неоднозначна.
-
-
--(2 ** 2);
-// -4 у JavaScript, а наміри автора однозначні.
-</pre>
-
-<h3 id="Приклади_6">Приклади</h3>
-
-<pre class="brush: js">2 ** 3 // 8
-3 ** 2 // 9
-3 ** 2.5 // 15.588457268119896
-10 ** -1 // 0.1
-NaN ** 2 // NaN
-
-2 ** 3 ** 2 // 512
-2 ** (3 ** 2) // 512
-(2 ** 3) ** 2 // 64
-</pre>
-
-<p>Щоб поміняти знак результату виразу піднесення до степеня:</p>
-
-<pre class="brush: js">-(2 ** 2) // -4
-</pre>
-
-<p>Щоб зробити основу степеня у виразі від'ємним числом:</p>
-
-<pre class="brush: js">(-2) ** 2 // 4
-</pre>
-
-<div class="note">
-<p><strong>Заувага:</strong> JavaScript також має <a href="/uk/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">бітовий оператор ^ (логічний XOR)</a>. <code>**</code> та <code>^</code> відрізняються (наприклад: <code>2 ** 3 === 8</code>, тоді як <code>2 ^ 3 === 1</code>.)</p>
-</div>
-
-<h2 id="Increment" name="Increment">Інкремент (++)</h2>
-
-<p>Оператор інкременту збільшує свій операнд (додає одиницю) та повертає його значення.</p>
-
-<ul>
- <li>Якщо оператор використовується постфіксно, після операнду (наприклад, x++), тоді він збільшує значення та повертає його до збільшення.</li>
- <li>Якщо оператор використовується префіксно, перед операндом (наприклад, ++x), тоді він збільшує значення та повертає його після збільшення.</li>
-</ul>
-
-<h3 id="Синтаксис_7">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x++ або ++x
-</pre>
-
-<h3 id="Приклади_7">Приклади</h3>
-
-<pre class="brush: js">// Постфіксний
-var x = 3;
-y = x++; // y = 3, x = 4
-
-// Префіксний
-var a = 2;
-b = ++a; // a = 3, b = 3
-</pre>
-
-<h2 id="Decrement" name="Decrement">Декремент (--)</h2>
-
-<p>Оператор декременту зменшує свій операнд (віднімає одиницю) та повертає його значення.</p>
-
-<ul>
- <li>Якщо оператор використовується постфіксно, після операнду (наприклад, x--), тоді він зменшує значення та повертає його до зменшення.</li>
- <li>Якщо оператор використовується префіксно, перед операндом (наприклад, --x), тоді він зменшує значення та повертає його після зменшення.</li>
-</ul>
-
-<h3 id="Синтаксис_8">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x-- або --x
-</pre>
-
-<h3 id="Приклади_8">Приклади</h3>
-
-<pre class="brush: js">// Постфіксний
-var x = 3;
-y = x--; // y = 3, x = 2
-
-// Префіксний
-var a = 2;
-b = --a; // a = 1, b = 1
-</pre>
-
-<h2 id="Unary_negation" name="Unary_negation">Унарний мінус (-)</h2>
-
-<p>Унарний мінус ставиться перед своїм операндом та міняє його знак на протилежний.</p>
-
-<h3 id="Синтаксис_9">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> -x
-</pre>
-
-<h3 id="Приклади_9">Приклади</h3>
-
-<pre class="brush: js">var x = 3;
-y = -x; // y = -3, x = 3
-
-// Унарний мінус може перетворити нечислове значення на число
-var x = "4";
-y = -x; // y = -4
-</pre>
-
-<h2 id="Унарний_плюс"><a id="Unary_plus" name="Unary_plus">Унарний плюс (+)</a></h2>
-
-<p>Унарний плюс ставиться перед своїм операндом та повертає значення операнду, але намагається перетворити його на число, якщо він не є числом. Хоча унарний мінус (-) також вміє перетворювати нечислові значення, унарний плюс найшвидший та найкращий спосіб перетворити щось у число, тому що він не виконує ніяких інших операцій з числом. Він може перетворювати рядкові представлення цілих чисел та чисел з рухомою комою, а також нерядкові значення <code>true</code>, <code>false</code> та <code>null</code>. Підтримуються цілі числа у десятковому та шістнадцятковому форматах. Підтримуються від'ємні числа (хоча не у шістнадцятковому форматі). Якщо оператор не може розібрати певне значення, він поверне {{jsxref("NaN")}}.</p>
-
-<h3 id="Синтаксис_10">Синтаксис</h3>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> +x
-</pre>
-
-<h3 id="Приклади_10">Приклади</h3>
-
-<pre class="brush: js">+3     // 3
-+'3'   // 3
-+true  // 1
-+false // 0
-+null  // 0
-+function(val){ return val } // NaN
-</pre>
-
-<h2 id="Специфікації">Специфікації</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Специфікація</th>
-   <th scope="col">Статус</th>
-   <th scope="col">Коментар</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-additive-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2016', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2016')}}</td>
-   <td>Доданий <a href="https://github.com/rwaldron/exponentiation-operator">Оператор піднесення до степеня</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2017', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2017')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-postfix-expressions')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-additive-operators">Адитивні оператори</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-multiplicative-operators">мультиплікативні оператори</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-postfix-expressions">постфіксні вирази</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-unary-operators">унарні оператори</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Адитивні оператори</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">мультиплікативні оператори</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">постфіксні вирази</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">унарні оператори</a>.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Початкове визначення.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-
-
-<p>{{Compat("javascript.operators.arithmetic")}}</p>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li><a href="/uk/docs/Web/JavaScript/Reference/Operators/Оператори_присвоєння">Оператори присвоєння</a></li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/operators/spread_syntax/index.html b/files/uk/conflicting/web/javascript/reference/operators/spread_syntax/index.html
deleted file mode 100644
index fdf9637511..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators/spread_syntax/index.html
+++ /dev/null
@@ -1,284 +0,0 @@
----
-title: Оператор розпакування
-slug: conflicting/Web/JavaScript/Reference/Operators/Spread_syntax
-tags:
-  - Iterator
-  - JavaScript
-  - Operator
-  - Ітератор
-  - Оператор
-translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
-translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator
-original_slug: Web/JavaScript/Reference/Operators/Оператор_розпакування
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p><strong>Оператор розпакування</strong> дозволяє розкласти колекцію в місця, де потрібні нуль чи декілька аргументів (як от виклики функцій), або декілька елементів (масиви), чи декілька змінних (деструктуризаційне присвоєння). Також можна розкласти об’єкт у місця де потрібні нуль чи більше пар ключ-значення (для оголошення об’єктів).</p>
-
-<h2 id="Синтаксис">Синтаксис</h2>
-
-<p>Для виклику функцій:</p>
-
-<pre class="brush: js">myFunction(...iterableObj);
-</pre>
-
-<p>Для масивів:</p>
-
-<pre class="brush: js">[...iterableObj, 4, 5, 6];</pre>
-
-<p>Для об’єктів (нове в ECMAScript; чернетка в 3-ій стадії):</p>
-
-<pre class="brush: js">let objClone = { ...obj };</pre>
-
-<h2 id="Приклади">Приклади</h2>
-
-<h3 id="Розпакування_у_викликах_функції">Розпакування у викликах функції</h3>
-
-<h4 id="Заміна_apply">Заміна apply</h4>
-
-<p><strong>Приклад:</strong> {{jsxref( "Function.prototype.apply")}} прийнято використовувати у випадках, коли потрібно застосувати елементи масиву як аргументи функції.</p>
-
-<pre class="brush: js">function myFunction(x, y, z) { }
-var args = [0, 1, 2];
-myFunction.apply(null, args);</pre>
-
-<p>З розпакуванням тепер отак:</p>
-
-<pre class="brush: js">function myFunction(x, y, z) { }
-var args = [0, 1, 2];
-myFunction(...args);</pre>
-
-<p>Оператор розпакування може бути застосований до будь-якого аргументу та може бути застосований кілька разів.</p>
-
-<pre class="brush: js">function myFunction(v, w, x, y, z) { }
-var args = [0, 1];
-myFunction(-1, ...args, 2, ...[3]);</pre>
-
-<h4 id="Apply_для_new">Apply для new</h4>
-
-<p>Викликаючи конструктор з <code>new, </code>неможливо напряму використовувати на ньому <code>apply</code> (<code>apply</code> робить <code>[[Call]],</code> а не <code>[[Construct]]</code>). Проте з оператором розпакування можна легко розкладати масив у аргументи конструктора:</p>
-
-<pre class="brush: js">var dateFields = [1970, 0, 1]; // 1 Січ 1970
-// var d = new Date.apply(dateFields) не спрацює. Викине TypeError
-var d = new Date(...dateFields); // вуаля</pre>
-
-<h3 id="Розпакування_в_масивах">Розпакування в масивах</h3>
-
-<h4 id="Ліпше_оголошення_масивів">Ліпше оголошення масивів</h4>
-
-<p>Без розпакування, коли потрібно створити новий масив так, щоб якийсь існуючий був його частиною, старого синтаксису оголошення масиву не достатньо та необхідно використовувати комбінацію методів <code>push</code>, <code>splice</code>, <code>concat</code>, тощо. З оператором розпакування це стає значно лаконічніше:</p>
-
-<pre class="brush: js">var parts = ['shoulders', 'knees'];
-var lyrics = ['head', ...parts, 'and', 'toes'];
-// ["head", "shoulders", "knees", "and", "toes"]</pre>
-
-<p>Як і з розпакуванням списку аргументів, <code>...</code> можна використовувати будь-де в оголошенні масиву та будь-яку кількість разів.</p>
-
-<h4 id="Копіювання_масиву">Копіювання масиву</h4>
-
-<pre class="brush: js">var arr = [1, 2, 3];
-var arr2 = [...arr]; // так само як arr.slice()
-arr2.push(4);
-
-// arr2 стає [1, 2, 3, 4]
-// arr залишається незміненим</pre>
-
-<p><strong>Зауваження:</strong> оператор розпакування при копіюванні масиву йде лише на <strong>один</strong> рівень вглиб. Таким чином він не придатний для копіювання багатовимірних масивів, що видно з наступного прикладу (те саме з {{jsxref("Object.assign()")}} та розпакуванням об’єктів).</p>
-
-<pre class="brush: js">var a = [[1], [2], [3]];
-var b = [...a];
-b.shift().shift(); // 1
-// Тепер масив a також змінено: [[], [2], [3]]</pre>
-
-<h4 id="Ліпше_злиття_масивів">Ліпше злиття масивів</h4>
-
-<p>{{jsxref("Array.concat")}} часто використовується, щоб додати один масив у кінець іншого. Без розпакування це робиться так:</p>
-
-<pre class="brush: js">var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-// Доддати всі елементи з arr2 в arr1
-arr1 = arr1.concat(arr2);</pre>
-
-<p>З розпакуванням це стає:</p>
-
-<pre class="brush: js">var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-arr1 = [...arr1, ...arr2];</pre>
-
-<p>{{jsxref("Array.unshift")}} часто використовується для того, щоб вставити значення з одного масиву в початок іншого. Без розпакування це робиться так:</p>
-
-<pre class="brush: js">var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-// Вставити всі елементи з arr2 в початок arr1
-Array.prototype.unshift.apply(arr1, arr2) // arr1 тепер [3, 4, 5, 0, 1, 2]</pre>
-
-<p>З розпакуванням це стає:</p>
-
-<pre class="brush: js">var arr1 = [0, 1, 2];
-var arr2 = [3, 4, 5];
-arr1 = [...arr2, ...arr1]; // arr1 тепер [3, 4, 5, 0, 1, 2]</pre>
-
-<h4 id="Розпакування_об’єктів">Розпакування об’єктів</h4>
-
-<p>Пропозиція <a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript</a> (стадія 3) додає розпакування до <a href="/uk/docs/Web/JavaScript/Reference/Operators/%D0%86%D0%BD%D1%96%D1%86%D1%96%D0%B0%D0%BB%D1%96%D0%B7%D0%B0%D1%86%D1%96%D1%8F_%D0%BE%D0%B1%E2%80%99%D1%94%D0%BA%D1%82%D1%96%D0%B2">об’єктів</a>. It copies own enumerable properties from a provided object onto a new object.</p>
-
-<p>Однорівневе клонування (без прототипу) чи злиття об’єктів тепер можливе використовуючи коротший запис ніж {{jsxref("Object.assign()")}}.</p>
-
-<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 };
-var obj2 = { foo: 'baz', y: 13 };
-
-var clonedObj = { ...obj1 };
-// Object { foo: "bar", x: 42 }
-
-var mergedObj = { ...obj1, ...obj2 };
-// Object { foo: "baz", x: 42, y: 13 }</pre>
-
-<p>Зауваж, що {{jsxref("Object.assign()")}} викликає <a href="https://developer.mozilla.org/uk/docs/Web/JavaScript/Reference/Functions/set">сетери</a>, а оператор розпакування - ні.</p>
-
-<h4 id="Лише_для_ітерованих">Лише для ітерованих</h4>
-
-<p>Розпакування може бути застосоване лише для <a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator">ітерованик</a> об’єктів:</p>
-
-<pre class="brush: js">var obj = {'key1': 'value1'};
-var array = [...obj]; // TypeError: obj is not iterable</pre>
-
-<p><strong>Зауваження:</strong> наразі (липень 2017) можна говорити про появу розпакування об’єктів у специфікації (дивись попередній підзаголовок). Але ще не до кінця зрозуміло як працюватиме вищенаведений приклад, адже ще немає конкретного рішення щодо цього у спецефікації. Тобто тепер ти можеш розпакувати об’єкт в об’єкт, але не зрозуміло, що станеться, якщо об’єкт розпаковувати у масив і навпаки, масив у об’єкт. Наприклад транспілятор <a href="https://babeljs.io/">babel</a> вертає наступні результати:</p>
-
-<pre class="brush: js">var obj = {'key1': 'value1'};
-var array = [...obj]; // запише в array пустий масив []
-
-var arr = [1,1,1];
-var obj1 = {...arr}; // запише в obj1 {'0': 1, '1': 1, '2': 1}</pre>
-
-<h4 id="Розпакування_великих_колекцій">Розпакування великих колекцій</h4>
-
-<p>Використовуючи розпакування зважай на можливість досягнення ліміту аргументів, встановленого у JavaScript рушії, адже оператор розпакування витягує <strong>всі</strong> елементи колекції в стек, скільки б їх не було. Дивись <a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object)."><code>apply()</code></a> щоб дізнатись більше.</p>
-
-<h2 id="Оператор_решти">Оператор решти</h2>
-
-<p>Оператор решти виглядає точно так само як і оператор розпакування. До певної міри, він протилежний оператору розпакування - оператор розпакування розкладає колекцію на елементи, а оператор решти, натомість, складає кілька елементів у колекцію. Дивись <a href="/uk/docs/Web/JavaScript/Reference/Functions/%D1%80%D0%B5%D1%88%D1%82%D0%B0_%D0%BF%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D1%96%D0%B2">решта параметрів</a>.</p>
-
-<h2 id="Специфікація">Специфікація</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Специфікація</th>
-   <th scope="col">Стан</th>
-   <th scope="col">Коментар</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Визначено в деяких секціях специфікацій: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Без змін.</td>
-  </tr>
-  <tr>
-   <td><a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript</a></td>
-   <td>Чернетка</td>
-   <td>Чернетка в 3 стадії</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_браузерами">Сумісність з браузерами</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari (WebKit)</th>
-  </tr>
-  <tr>
-   <td>Spread operation in array literals</td>
-   <td>{{CompatChrome("46")}}</td>
-   <td>{{ CompatGeckoDesktop("16") }}</td>
-   <td>{{CompatIE("Edge/10240")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>7.1</td>
-  </tr>
-  <tr>
-   <td>Spread operation in function calls</td>
-   <td>{{CompatChrome("46")}}</td>
-   <td>{{ CompatGeckoDesktop("27") }}</td>
-   <td>{{CompatIE("Edge/10240")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>7.1</td>
-  </tr>
-  <tr>
-   <td>Spread operation in destructuring</td>
-   <td>{{CompatChrome("49")}}</td>
-   <td>{{ CompatGeckoDesktop("34") }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Android Webview</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-   <th>Chrome for Android</th>
-  </tr>
-  <tr>
-   <td>Spread operation in array literals</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatChrome("46")}}</td>
-   <td>{{ CompatGeckoMobile("16") }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-   <td>{{CompatChrome("46")}}</td>
-  </tr>
-  <tr>
-   <td>Spread operation in function calls</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatChrome("46")}}</td>
-   <td>{{ CompatGeckoMobile("27") }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-   <td>{{CompatChrome("46")}}</td>
-  </tr>
-  <tr>
-   <td>Spread operation in destructuring</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{ CompatGeckoDesktop("34") }}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/uk/docs/Web/JavaScript/Reference/Functions/%D1%80%D0%B5%D1%88%D1%82%D0%B0_%D0%BF%D0%B0%D1%80%D0%B0%D0%BC%D0%B5%D1%82%D1%80%D1%96%D0%B2">Решта параметрів</a></li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html b/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html
deleted file mode 100644
index 0eb03eb5a1..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html
+++ /dev/null
@@ -1,421 +0,0 @@
----
-title: Оператори присвоєння
-slug: >-
-  conflicting/Web/JavaScript/Reference/Operators_1cd48548c16282df3883f99267726c3e
-tags:
-  - JavaScript
-  - Оператор
-translation_of: Web/JavaScript/Reference/Operators#Assignment_operators
-translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators
-original_slug: Web/JavaScript/Reference/Operators/Оператори_присвоєння
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p><strong>Оператор присвоєння</strong> присвоює своєму лівому операнду значення, на підставі значення правого операнду.</p>
-
-<p>{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}</p>
-
-<div class="hidden">
-<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
-</div>
-
-<h2 id="Огляд">Огляд</h2>
-
-<p>Базовим оператором присвоєння є оператор дорівнює (<code>=</code>), який присвоює значення свого правого операнда лівому операнду. Таким чином, <code>x = y</code> присвоює змінній <code>x</code> значення змінної <code>y</code>. Інші оператори присвоєння у своїй більшості є скороченнями для стандарних операцій, як це вказано у наступній таблиці з визначеннями та прикладами.</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th>Назва</th>
-   <th>Оператор скороченого запису</th>
-   <th>Значення</th>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння">Присвоєння</a></td>
-   <td><code>x = y</code></td>
-   <td><code>x = y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_додаванням">Присвоєння з додаванням</a></td>
-   <td><code>x += y</code></td>
-   <td><code>x = x + y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_відніманням">Присвоєння з відніманням</a></td>
-   <td><code>x -= y</code></td>
-   <td><code>x = x - y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_множенням">Присвоєння з множенням</a></td>
-   <td><code>x *= y</code></td>
-   <td><code>x = x * y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_діленням">Присвоєння з діленням</a></td>
-   <td><code>x /= y</code></td>
-   <td><code>x = x / y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_остачі">Присвоєння остачі</a></td>
-   <td><code>x %= y</code></td>
-   <td><code>x = x % y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_піднесенням_до_степеня">Присвоєння з піднесенням до степеня</a></td>
-   <td><code>x **= y</code></td>
-   <td><code>x = x ** y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_лівим_зсувом">Присвоєння з лівим зсувом</a></td>
-   <td><code>x &lt;&lt;= y</code></td>
-   <td><code>x = x &lt;&lt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_правим_зсувом">Присвоєння з правим зсувом</a></td>
-   <td><code>x &gt;&gt;= y</code></td>
-   <td><code>x = x &gt;&gt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_беззнаковим_правим_зсувом">Присвоєння з беззнаковим правим зсувом</a></td>
-   <td><code>x &gt;&gt;&gt;= y</code></td>
-   <td><code>x = x &gt;&gt;&gt; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_побітовим_І">Присвоєння з побітовим І</a></td>
-   <td><code>x &amp;= y</code></td>
-   <td><code>x = x &amp; y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_виключним_побітовим_АБО">Присвоєння з виключним побітовим АБО</a></td>
-   <td><code>x ^= y</code></td>
-   <td><code>x = x ^ y</code></td>
-  </tr>
-  <tr>
-   <td><a href="#Присвоєння_з_побітовим_АБО">Присвоєння з побітовим АБО</a></td>
-   <td><code>x |= y</code></td>
-   <td><code>x = x | y</code></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Присвоєння"><a name="Assignment">Присвоєння</a></h2>
-
-<p>Простий оператор присвоєння використовується для присвоєння змінній значення. Оператор присвоєння обчислює значення, що присвоюється. Можна використовувати ланцюжок присвоюваннь, щоб присвоїти одне значення декільком змінним. Дивіться приклад нижче.</p>
-
-<h4 id="Синтаксис">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор:</strong> x = y
-</pre>
-
-<h4 id="Приклади">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  x = 5
-//  y = 10
-//  z = 25
-
-x = y     // x дорівнює 10
-x = y = z // x, y та z усі дорівнюють 25
-</pre>
-
-<h3 id="Присвоєння_з_додаванням"><a name="Addition_assignment">Присвоєння з додаванням</a></h3>
-
-<p>Оператор присвоєння з додаванням <strong>додає</strong> значення правого операнду до змінної (лівого перанду) та записує у неї отриманий результат. Типи двох операндів визначають поведінку оператора. Таким чином, його результатом може стати або додавання або конкатенація. Для більш детального огляду дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор додавання", "#Addition", 1)}}.</p>
-
-<h4 id="Синтаксис_2">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор:</strong>  x += y
-<strong>Значення:</strong>  x  = x + y
-</pre>
-
-<h4 id="Приклади_2">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  foo = 'foo'
-//  bar = 5
-//  baz = true
-
-
-// число + число -&gt; додавання
-bar += 2 // 7
-
-// булеве значення + число -&gt; додавання
-baz += 1 // 2
-
-// булеве значення + булеве значення -&gt; додавання
-baz += false // 1
-
-// число + рядок -&gt; конкатенація
-bar += 'foo' // "5foo"
-
-// рядок + булеве значення -&gt; конкатенація
-foo += false // "foofalse"
-
-// рядок + рядок -&gt; конкатенація
-foo += 'bar' // "foobar"
-</pre>
-
-<h3 id="Присвоєння_з_відніманням"><a name="Subtraction_assignment">Присвоєння з відніманням</a></h3>
-
-<p>Оператор присвоєння з відніманням <strong>віднімає</strong> значення правого операнду від змінної (лівого перанду) та записує у неї отриманий результат. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор віднімання", "#Subtraction", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_3">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x -= y
-<strong>Значення:</strong>  x  = x - y
-</pre>
-
-<h4 id="Приклади_3">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  bar = 5
-
-bar -= 2     // 3
-bar -= 'foo' // NaN
-</pre>
-
-<h3 id="Присвоєння_з_множенням"><a name="Multiplication_assignment">Присвоєння з множенням</a></h3>
-
-<p>Оператор присвоєння з множенням <strong>помножує</strong> змінну (лівий операнд) на значення правого операнду та записує отриманий результат у змінну. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор множення", "#Multiplication", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_4">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор:</strong>  x *= y
-<strong>Значення:</strong>  x  = x * y
-</pre>
-
-<h4 id="Приклади_4">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  bar = 5
-
-bar *= 2     // 10
-bar *= 'foo' // NaN
-</pre>
-
-<h3 id="Присвоєння_з_діленням"><a name="Division_assignment">Присвоєння з діленням</a></h3>
-
-<p>Оператор присвоєння з діленням <strong>ділить</strong> змінну (лівий операнд) на значення правого операнду та записує отриманий результат у змінну. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор ділення", "#Division", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_5">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x /= y
-<strong>Значення:</strong>  x  = x / y
-</pre>
-
-<h4 id="Приклади_5">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  bar = 5
-
-bar /= 2     // 2.5
-bar /= 'foo' // NaN
-bar /= 0     // Infinity
-</pre>
-
-<h3 id="Присвоєння_остачі"><a name="Remainder_assignment">Присвоєння остачі</a></h3>
-
-<p>Оператор присвоєння остачі <strong>ділить</strong> змінну на значення правого операнду та присвоює <strong>остачу</strong> змінній. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор остачі", "#Remainder", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_6">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор:</strong>  x %= y
-<strong>Значення:</strong>  x  = x % y
-</pre>
-
-<h4 id="Приклади_6">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  bar = 5
-
-bar %= 2     // 1
-bar %= 'foo' // NaN
-bar %= 0     // NaN
-</pre>
-
-<h3 id="Присвоєння_з_піднесенням_до_степеня"><a id="Exponentiation_assignment" name="Exponentiation_assignment">Присвоєння з піднесенням до степеня</a></h3>
-
-<p>Оператор присвоєння з піднесенням до степеня обчислює результат піднесення першого операнду до <strong>показника степеня</strong> другого операнду. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор піднесення до степеня", "#Exponentiation", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_7">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x **= y
-<strong>Значення:</strong>  x  = x ** y
-</pre>
-
-<h4 id="Приклади_7">Приклади</h4>
-
-<pre class="brush: js">// Розглянемо такі змінні:
-//  bar = 5
-
-bar **= 2     // 25
-bar **= 'foo' // NaN</pre>
-
-<h3 id="Присвоєння_з_лівим_зсувом"><a name="Left_shift_assignment">Присвоєння з лівим зсувом</a></h3>
-
-<p>Оператор присвоєння з лівим зсувом виконує зсув першого операнду на вказану кількість бітів ліворуч та присвоює результат у змінну. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор лівого зсуву", "#Left_shift", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_8">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x &lt;&lt;= y
-<strong>Значення:</strong>  x   = x &lt;&lt; y
-</pre>
-
-<h4 id="Приклади_8">Приклади</h4>
-
-<pre class="brush: js">var bar = 5; //  (00000000000000000000000000000101)
-bar &lt;&lt;= 2; // 20 (00000000000000000000000000010100)
-</pre>
-
-<h3 id="Присвоєння_з_правим_зсувом"><a name="Right_shift_assignment">Присвоєння з правим зсувом</a></h3>
-
-<p>Оператор присвоєння з правим зсувом виконує зсув першого операнду на вказану кількість бітів праворуч та присвоює результат у змінну. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор правого зсуву", "#Right_shift", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_9">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x &gt;&gt;= y
-<strong>Значення:</strong>  x   = x &gt;&gt; y
-</pre>
-
-<h4 id="Приклади_9">Приклади</h4>
-
-<pre class="brush: js">var bar = 5; //   (00000000000000000000000000000101)
-bar &gt;&gt;= 2;   // 1 (00000000000000000000000000000001)
-
-var bar -5; //    (-00000000000000000000000000000101)
-bar &gt;&gt;= 2;  // -2 (-00000000000000000000000000000010)
-</pre>
-
-<h3 id="Присвоєння_з_беззнаковим_правим_зсувом"><a name="Unsigned_right_shift_assignment">Присвоєння з беззнаковим правим зсувом</a></h3>
-
-<p>Оператор присвоєння з беззнаковим правим зсувом виконує зсув першого операнду на вказану кількість бітів праворуч та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", " оператор беззнакового правого зсуву", "#Unsigned_right_shift", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_10">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x &gt;&gt;&gt;= y
-<strong>Значення:</strong>  x    = x &gt;&gt;&gt; y
-</pre>
-
-<h4 id="Приклади_10">Приклади</h4>
-
-<pre class="brush: js">var bar = 5; //   (00000000000000000000000000000101)
-bar &gt;&gt;&gt;= 2;  // 1 (00000000000000000000000000000001)
-
-var bar = -5; // (-00000000000000000000000000000101)
-bar &gt;&gt;&gt;= 2; // 1073741822 (00111111111111111111111111111110)</pre>
-
-<h3 id="Присвоєння_з_побітовим_І"><a name="Bitwise_AND_assignment">Присвоєння з побітовим І</a></h3>
-
-<p>Оператор присвоєння з побітовим І використовує двійкове представлення обох операндів, виконує над ними операцію побітового І та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор побітового І", "#Bitwise_AND", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_11">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор:</strong>  x &amp;= y
-<strong>Значення:</strong>  x  = x &amp; y
-</pre>
-
-<h4 id="Приклади_11">Приклади</h4>
-
-<pre class="brush: js">var bar = 5;
-// 5:     00000000000000000000000000000101
-// 2:     00000000000000000000000000000010
-bar &amp;= 2; // 0
-</pre>
-
-<h3 id="Присвоєння_з_виключним_побітовим_АБО"><a name="Bitwise_XOR_assignment">Присвоєння з виключним побітовим АБО</a></h3>
-
-<p>Оператор присвоєння з виключним побітовим АБО використовує двійкове представлення обох операндів, виконує над ними операцію виключного побітового АБО (XOR) та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор виключного побітового АБО", "#Bitwise_XOR", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_12">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x ^= y
-<strong>Значення:</strong>  x  = x ^ y
-</pre>
-
-<h4 id="Приклади_12">Приклади</h4>
-
-<pre class="brush: js">var bar = 5;
-bar ^= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-</pre>
-
-<h3 id="Присвоєння_з_побітовим_АБО"><a name="Bitwise_OR_assignment">Присвоєння з побітовим АБО</a></h3>
-
-<p>Оператор присвоєння з побітовим АБО використовує двійкове представлення обох операндів, виконує над ними операцію побітового АБО та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор побітового АБО", "#Bitwise_OR", 1)}} для більш детального огляду.</p>
-
-<h4 id="Синтаксис_13">Синтаксис</h4>
-
-<pre class="syntaxbox"><strong>Оператор: </strong> x |= y
-<strong>Значення:</strong>  x  = x | y
-</pre>
-
-<h4 id="Приклади_13">Приклади</h4>
-
-<pre class="brush: js">var bar = 5;
-bar |= 2; // 7
-// 5: 00000000000000000000000000000101
-// 2: 00000000000000000000000000000010
-// -----------------------------------
-// 7: 00000000000000000000000000000111
-</pre>
-
-<h2 id="Приклади_14">Приклади</h2>
-
-<h3 id="Лівий_операнд_з_іншим_оператором_присвоєння">Лівий операнд з іншим оператором присвоєння</h3>
-
-<p>У незвичних ситуаціях оператор присвоєння (наприклад, <code> x += y</code>) не є ідентичним виразу, який він означає (в даному випадку <code>x = x + y</code>). Коли лівий операнд оператора присвоєння сам містить оператор присвоєння, лівий операнд обчислюється лише один раз. Наприклад:</p>
-
-<pre class="brush: js">a[i++] += 5         // i обчислюється лише один раз
-a[i++] = a[i++] + 5 // i обчислюється двічі
-</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('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Початкове визначення.</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.assignment")}}</p>
-
-<div id="compat-mobile"></div>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li><a href="/uk/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators">Арифметичні оператори</a></li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html b/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html
deleted file mode 100644
index a41371e7c0..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html
+++ /dev/null
@@ -1,562 +0,0 @@
----
-title: Бітові оператори
-slug: >-
-  conflicting/Web/JavaScript/Reference/Operators_7c8eb9475d97a4a734c5991857698560
-tags:
-  - JavaScript
-  - Довідка
-  - Оператор
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators
-original_slug: 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 &amp; 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="#&lt;&lt;_Лівий_зсув">Лівий зсув</a></td>
-   <td><code>a &lt;&lt; b</code></td>
-   <td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (&lt; 32) бітів ліворуч, заповнюючи позиції справа нулями.</td>
-  </tr>
-  <tr>
-   <td><a href="#>>_Правий_зсув_з_розширенням_знаку">Правий зсув з розширенням знаку</a></td>
-   <td><code>a &gt;&gt; b</code></td>
-   <td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (&lt; 32) бітів праворуч, відкидаючи зсунуті біти.</td>
-  </tr>
-  <tr>
-   <td><a href="#>>>_Правий_зсув_із_заповненням_нулями">Правий зсув із заповненням нулями</a></td>
-   <td><code>a &gt;&gt;&gt; b</code>  </td>
-   <td>Зсуває <code>a</code> у двійковому представленні на <code>b</code> (&lt; 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">&amp; (Побітове І)</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 &amp; 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="&lt;&lt;_Лівий_зсув"><a id="Left_shift" name="Left_shift">&lt;&lt; (Лівий зсув)</a></h3>
-
-<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів ліворуч. Надлишкові біти, зсунуті ліворуч, відкидаються. Біти, додані справа, заповнюються нулями.</p>
-
-<p>Наприклад, <code>9 &lt;&lt; 2</code> дорівнює 36:</p>
-
-<pre class="brush: js">.    9 (основа 10): 00000000000000000000000000001001 (основа 2)
-                  --------------------------------
-9 &lt;&lt; 2 (основа 10): 00000000000000000000000000100100 (основа 2) = 36 (основа 10)
-</pre>
-
-<p>Бітовий зсув будь-якого числа <code>x</code> ліворуч на <code>y</code> бітів дорівнює <code>x * 2 ** y</code>.<br>
- Отже, для прикладу: <code>9 &lt;&lt; 3</code> можна перекласти як: <code>9 * (2 ** 3) = 9 * (8) =</code><code> 72</code>.</p>
-
-<h3 id=">>_Правий_зсув_з_розширенням_знаку"><a id="Right_shift" name="Right_shift">&gt;&gt; (Правий зсув з розширенням знаку)</a></h3>
-
-<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються значенням старшого біта. Оскільки новий старший біт матиме те саме значення, що й попередній старший біт, знаковий (старший) біт не змінюється. Звідси назва "з розширенням знаку".</p>
-
-<p>Наприклад, <code>9 &gt;&gt; 2</code> дорівнює 2:</p>
-
-<pre class="brush: js">.    9 (основа 10): 00000000000000000000000000001001 (основа 2)
-                  --------------------------------
-9 &gt;&gt; 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
-</pre>
-
-<p>Аналогічно, <code>-9 &gt;&gt; 2</code> дорівнює <code>-3</code>, оскільки знак зберігається:</p>
-
-<pre class="brush: js">.    -9 (основа 10): 11111111111111111111111111110111 (основа 2)
-                   --------------------------------
--9 &gt;&gt; 2 (основа 10): 11111111111111111111111111111101 (основа 2) = -3 (основа 10)
-</pre>
-
-<h3 id=">>>_Правий_зсув_із_заповненням_нулями"><a id="Unsigned_right_shift" name="Unsigned_right_shift">&gt;&gt;&gt; (Правий зсув із заповненням нулями)</a></h3>
-
-<p>Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються нулями. Знаковий біт отримує значення 0, а отже, результат завжди невід'ємний. На відміну від інших бітових операторів, правий зсув із заповненням нулями повертає беззнакове ціле 32-бітне число.</p>
-
-<p>Для невід'ємних чисел, правий зсув із заповненням нулями та правий зсув з розширенням знаку дають однаковий результат. Наприклад, <code>9 &gt;&gt;&gt; 2</code> дорівнює 2, так само, як <code>9 &gt;&gt; 2</code>:</p>
-
-<pre class="brush: js">.     9 (основа 10): 00000000000000000000000000001001 (основа 2)
-                   --------------------------------
-9 &gt;&gt;&gt; 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
-</pre>
-
-<p>Однак, це не одне й те саме для від'ємних чисел. Наприклад, <code>-9 &gt;&gt;&gt; 2</code> поверне 1073741821, що відрізняється від <code>-9 &gt;&gt; 2</code> (що дорівнює <code>-3</code>):</p>
-
-<pre class="brush: js">.     -9 (основа 10): 11111111111111111111111111110111 (основа 2)
-                    --------------------------------
--9 &gt;&gt;&gt; 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 =&gt; 1011
-</pre>
-
-<p>Індивідуальні значення прапорів можна витягнути застосуванням операції І до них та бітової маски, де кожний біт, що має значення один, "витягне" відповідний прапор. Бітова маска <em>маскує</em> невідповідні прапори, об'єднуючи їх операцією І з нулями (звідси термін "бітова маска"). Наприклад, бітову маску 0100 можна використати, щоб побачити, чи встановлений прапор C:</p>
-
-<pre class="brush: js">// якщо ми маємо кота
-if (flags &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; true
-   // зробити щось
-}
-</pre>
-
-<p>Бітова маска з кількома встановленими прапорами діє як "або/або". Для прикладу, наступні два фрагменти еквівалентні:</p>
-
-<pre class="brush: js">// якщо ми маємо кажана або ми маємо кота
-// (0101 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
-if ((flags &amp; FLAG_B) || (flags &amp; FLAG_C)) {
-   // зробити щось
-}
-</pre>
-
-<pre class="brush: js">// якщо ми маємо кажана або кота
-var mask = FLAG_B | FLAG_C; // 0010 | 0100 =&gt; 0110
-if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; true
-   // зробити щось
-}
-</pre>
-
-<p>Прапори можна встановити, об'єднавши їх операцією АБО з бітовою маскою, де кожний біт, що має значення один, встановить відповідний прапор, якщо прапор ще не встановлений. Наприклад, бітову маску 1100 можна використати, щоб встановити прапори C та D:</p>
-
-<pre class="brush: js">// так, ми маємо кота та качку
-var mask = FLAG_C | FLAG_D; // 0100 | 1000 =&gt; 1100
-flags |= mask;   // 0101 | 1100 =&gt; 1101
-</pre>
-
-<p>Прапори можна очистити, об'єднавши їх операцією І з бітовою маскою, де кожний біт, що має значення нуль, очистить відповідний прапор, якщо він ще не очищений. Ця бітова маска може бути створена застосуванням операції НЕ до примітивних бітових масок. Наприклад, бітову маску 1010 можна використати, щоб очистити прапори A та C:</p>
-
-<pre class="brush: js">// ні, ми не маємо проблеми з мурахами або кота
-var mask = ~(FLAG_A | FLAG_C); // ~0101 =&gt; 1010
-flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
-</pre>
-
-<p>Маску також можна створити за допомогою <code>~FLAG_A &amp; ~FLAG_C</code> (правило де Моргана):</p>
-
-<pre class="brush: js">// ні, ми не маємо проблеми з мурахами і ми не маємо кота
-var mask = ~FLAG_A &amp; ~FLAG_C;
-flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
-</pre>
-
-<p>Прапори можна перемикати, об'єднуючи їх операцією виключне АБО з бітовою маскою, де кожний біт, що має значення один, переключить відповідний прапор. Наприклад, бітову маску 0110 можна використати, щоб переключити прапори B та C:</p>
-
-<pre class="brush: js">// якщо ми не мали кажана, тепер ми його маємо,
-// а якщо він в нас був, бувай, кажанчику
-// те саме для котів
-var mask = FLAG_B | FLAG_C;
-flags = flags ^ mask;   // 1100 ^ 0110 =&gt; 1010
-</pre>
-
-<p>Нарешті, усі прапори можна перевернути оператором НЕ:</p>
-
-<pre class="brush: js">// входимо у паралельний всесвіт...
-flags = ~flags;    // ~1010 =&gt; 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 &gt; 32 ? 32 : arguments.length;
-  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; 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 &gt; 0x7fffffff || nMask &lt; -0x80000000) {
-    throw new TypeError('arrayFromMask - out of range');
-  }
-  for (var nShifted = nMask, aFromMask = []; nShifted;
-       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 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 &lt; 32;
-       nFlag++, sMask += String(nShifted &gt;&gt;&gt; 31), nShifted &lt;&lt;= 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>
diff --git a/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html b/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html
deleted file mode 100644
index 1313c5b9c6..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html
+++ /dev/null
@@ -1,247 +0,0 @@
----
-title: Оператори порівняння
-slug: >-
-  conflicting/Web/JavaScript/Reference/Operators_a8aa9ce42ce1749862961c61113d120b
-tags:
-  - JavaScript
-  - Довідка
-  - Оператор
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators
-original_slug: Web/JavaScript/Reference/Operators/Оператори_порівняння
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p>JavaScript має як строге порівняння, так і порівняння з перетворенням типів. Строге порівняння (<code>===</code>) є істинним лише в тому випадку, якщо операнди мають однаковий тип, а їхній зміст співпадає. Найчастіше вживане абстрактне порівняння (<code>==</code>) приводить операнди до спільного типу перед виконанням порівняння. Для абстрактних порівнянь (наприклад, <code>&lt;=</code>) операнди спочатку приводяться до простих типів, потім приводяться до спільного типу, а вже тоді порівнюються.</p>
-
-<p>Рядки порівнюються на основі стандартного лексикографічного упорядкування, використовуючи значення Unicode.</p>
-
-<p>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</p>
-
-<div class="hidden">
-<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
-</div>
-
-<p>Особливості порівнянь:</p>
-
-<ul>
- <li>Два рядки строго рівні, якщо мають однакову послідовність символів, однакову довжину та однакові символи на відповідних позиціях.</li>
- <li>Два числа строго рівні, якщо вони чисельно рівні (мають однакове числове значення). <a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> не дорівнює нічому, в тому числі NaN. Додатні та від'ємні нулі дорівнюють один одному.</li>
- <li>Два булеві операнди строго рівні, якщо обидва є <code>true</code>, або обидва є <code>false</code>.</li>
- <li>Два окремі об'єкти ніколи не є рівними ні при строгому, ні при абстрактному порівнянні.</li>
- <li>Вираз, що порівнює об'єкти, істинний лише тоді, коли операнди посилаються на один і той самий об'єкт.</li>
- <li>Типи Null та Undefined строго рівні собі та абстрактно рівні один одному.</li>
-</ul>
-
-<h2 id="Оператори_рівності">Оператори рівності</h2>
-
-<h3 id="Рівність"><a name="Equality">Рівність (==)</a></h3>
-
-<p>Оператор рівності перетворює операнди, якщо вони <strong>не однакового типу</strong>, і після цього застосовує строге порівняння. Якщо <strong>обидва операнди є об'єктами</strong>, JavaScript порівнює внутрішні посилання, які є рівними, якщо операнди посилаються на один і той самий об'єкт у пам'яті.</p>
-
-<h4 id="Синтаксис">Синтаксис</h4>
-
-<pre class="syntaxbox">x == y
-</pre>
-
-<h4 id="Приклади">Приклади</h4>
-
-<pre class="brush: js">1    ==  1         // true
-'1'  ==  1         // true
-1    == '1'        // true
-0    == false      // true
-0    == null       // false
-var object1 = {'key': 'value'}, object2 = {'key': 'value'};
-object1.key == object2.key // true
-0    == undefined  // false
-null == undefined  // true
-</pre>
-
-<h3 id="Нерівність_!"><a name="Inequality">Нерівність (!=)</a></h3>
-
-<p>Оператор нерівності повертає <em>true</em>,  якщо операнди не є рівними. Якщо два операнда <strong>не належать до одного типу</strong>, JavaScript намагається привести операнди до відповідного типу для порівняння. Якщо <strong>обидва операнда є об'єктами</strong>, JavaScript порівнює внутрішні посилання, які є нерівними, якщо операнди посилаються на різні об'єкти у пам'яті.</p>
-
-<h4 id="Синтаксис_2">Синтаксис</h4>
-
-<pre class="syntaxbox">x != y</pre>
-
-<h4 id="Приклади_2">Приклади</h4>
-
-<pre class="brush: js">1 !=   2     // true
-1 !=  '1'    // false
-1 !=  "1"    // false
-1 !=  true   // false
-0 !=  false  // false
-</pre>
-
-<h3 id="Ідентичність_строга_рівність"><a name="Identity">Ідентичність / строга рівність (===)</a></h3>
-
-<p>Оператор ідентичності повертає true, якщо операнди строго рівні (див. вище) <strong>без приведення типів</strong>. </p>
-
-<h4 id="Синтаксис_3">Синтаксис</h4>
-
-<pre class="syntaxbox">x === y</pre>
-
-<h4 id="Приклади_3">Приклади</h4>
-
-<pre class="brush: js ">3 === 3   // true
-3 === '3' // false
-var object1 = {'key': 'value'}, object2 = {'key': 'value'};
-object1 === object2 //false</pre>
-
-<h3 id="Неідентичність_строга_нерівність_!"><a name="Nonidentity">Неідентичність / строга нерівність (!==)</a></h3>
-
-<p>Оператор неідентичності повертає true, якщо операнди <strong>не є рівними та/або не однакового типу</strong>.</p>
-
-<h4 id="Синтаксис_4">Синтаксис</h4>
-
-<pre class="syntaxbox">x !== y</pre>
-
-<h4 id="Приклади_4">Приклади</h4>
-
-<pre class="brush: js">3 !== '3' // true
-4 !== 3   // true
-</pre>
-
-<h2 id="Оператори_відношення">Оператори відношення</h2>
-
-<p>Кожен з цих операторів буде <a href="/uk/docs/Glossary/Type_coercion">примусово приведений</a> до простої величини перед порівнянням. Якщо обидва перетворюються на рядки, вони порівнюються з використанням лексикографічного порядку, інакше вони будуть перетворені на числа для порівняння. Порівняння із <code>NaN</code> завжди поверне <code>false</code>.</p>
-
-<h3 id="Більше_ніж_>"><a name="Greater_than_operator">Більше ніж (&gt;)</a></h3>
-
-<p>Оператор <em>більше ніж </em>повертає true, якщо значення лівого операнда більше за значення правого операнда.</p>
-
-<h4 id="Синтаксис_5">Синтаксис</h4>
-
-<pre class="syntaxbox">x &gt; y</pre>
-
-<h4 id="Приклади_5">Приклади</h4>
-
-<pre class="brush: js">4 &gt; 3 // true
-</pre>
-
-<h3 id="Більше_чи_дорівнює_>"><a name="Greater_than_or_equal_operator">Більше чи дорівнює (&gt;=)</a></h3>
-
-<p>Оператор <em>більше чи дорівнює</em> повертає true, якщо значення лівого операнда більше, або дорівнює значенню правого операнда.</p>
-
-<h4 id="Синтаксис_6">Синтаксис</h4>
-
-<pre class="syntaxbox"> x &gt;= y</pre>
-
-<h4 id="Приклади_6">Приклади</h4>
-
-<pre class="brush: js">4 &gt;= 3 // true
-3 &gt;= 3 // true
-</pre>
-
-<h3 id="Менше_ніж_&lt;"><a name="Less_than_operator">Менше ніж (&lt;)</a></h3>
-
-<p>Оператор <em>менше ніж</em> повертає true, якщо значення лівого операнда менше значення правого операнда.</p>
-
-<h4 id="Синтаксис_7">Синтаксис</h4>
-
-<pre class="syntaxbox"> x &lt; y</pre>
-
-<h4 id="Приклади_7">Приклади</h4>
-
-<pre class="brush: js">3 &lt; 4 // true
-</pre>
-
-<h3 id="Менше_чи_дорівнює_&lt;"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Менше чи дорівнює (&lt;=)</a></h3>
-
-<p>Оператор <em>менше чи дорівнює</em> повертає true, якщо значення лівого операнда менше або дорівнює значенню правого операнда.</p>
-
-<h4 id="Синтаксис_8">Синтаксис</h4>
-
-<pre class="syntaxbox"> x &lt;= y</pre>
-
-<h4 id="Приклади_8">Приклади</h4>
-
-<pre class="brush: js">3 &lt;= 4 // true
-</pre>
-
-<h2 id="Застосування_операторів_порівняння">Застосування операторів порівняння</h2>
-
-<p>Стандартні оператори рівності (<code>==</code> та <code>!=</code>) використовують <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">алгоритм абстрактної рівності</a> для порівняння двох операндів. Якщо операнди належать до різних типів, алгоритм спробує привести їх до спільного типу перед порівнянням; наприклад, у виразі <code>5 == '5'</code>, рядок праворуч буде приведений до {{jsxref("Число","числа")}} перед здійсненням порівняння.</p>
-
-<p>Оператори строгої рівності (<code>===</code> та <code>!==</code>) використовують <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">алгоритм строгої рівності</a> та призначені для виконання перевірки рівності операндів одного типу. Якщо операнди належать до різних типів, результат завжди буде <code>false</code>, тому <code>5 !== '5'</code>.</p>
-
-<p>Використовуйте оператори строгого порівняння, якщо операнди мають належати до вказаного типу, як і їх значення, або, якщо конкретний тип операндів має значення. Інакше, використовуйте стандартні оператори рівності, які дозволяють перевіряти ідентичність двох операндів, навіть якщо вони не належать до одного типу.</p>
-
-<p>Коли в порівнянні застосовується перетворення типів (тобто, це не строге порівняння), JavaScript перетворює типи операндів {{jsxref ("String")}}, {{jsxref ("Число","Number")}}, {{jsxref ("Boolean" )}} або {{jsxref ("Object")}} наступним чином:</p>
-
-<ul>
- <li>При порівнянні числа й рядка, рядок конвертується в числове значення. JavaScript намагається конвертувати число у рядковому літералі в значення типу <code>Number</code>. Спочатку математичне значення виводиться з рядкового літерала. Далі ця величина округлюється до найближчого значення типу <code>Number</code>.</li>
- <li>Якщо один з операндів належить до типу <code>Boolean</code>, цей операнд конвертується у 1, якщо він дорівнює <code>true</code>, і у +0, якщо він дорівнює <code>false</code>.</li>
- <li>Якщо об'єкт порівнюється з рядком або числом, JavaScript намагається повернути значення об'єкта за замовчуванням. Оператори намагаються перетворити об'єкти на просте значення, <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">рядок</span></font> або <code>число</code>, використовуючи методи об'єктів <code>valueOf</code> та <code>toString</code>. Якщо спроба перетворення була невдалою, генерується помилка виконання.</li>
- <li>Зауважте, що об'єкт перетворюється на просту величину тоді, й тільки тоді, коли порівнюється з простою величиною. Якщо обидва операнди є об'єктами, вони порівнюються як об'єкти, а тест на рівність істинний, тільки якщо вони обидва посилаються на один і той самий об'єкт.</li>
-</ul>
-
-<div class="note"><strong>Заувага:</strong> Рядкові об'єкти є об'єктами типу Object, а не String! Об'єкти типу String використовуються рідко, а отже, наведені нижче результати можуть бути несподіваними:</div>
-
-<pre class="brush:js">// true, оскільки обидва операнди мають тип String (є рядковими примітивами):
-'foo' === 'foo'
-
-var a = new String('foo');
-var b = new String('foo');
-
-// false, оскільки a та b мають тип Object і посилаються на різні об'єкти
-a == b
-
-// false, оскільки a та b мають тип Object і посилаються на різні об'єкти
-a === b
-
-// true, оскільки a та 'foo' мають різні типи, але об'єкт (а)
-// перетворюється на рядок 'foo' перед порівнянням
-a == 'foo'</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>Початкове визначення. Реалізовано у JavaScript 1.0</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Додані оператори <code>===</code> та <code>!==</code> . Реалізовано у JavaScript 1.3</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Дано визначення у декільках секціях специфікації: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Оператори відношення</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Оператори рівності</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Дано визначення у декільках секціях специфікації: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-relational-operators">Оператори відношення</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-equality-operators">Оператори рівності</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Дано визначення у декільках секціях специфікації: <a href="http://tc39.github.io/ecma262/#sec-relational-operators">Оператори відношення</a>, <a href="http://tc39.github.io/ecma262/#sec-equality-operators">Оператори рівності</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Підтримка_веб-переглядачами">Підтримка веб-переглядачами</h2>
-
-
-
-<p>{{Compat("javascript.operators.comparison")}}</p>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Object.is()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li><a href="/uk/docs/Web/JavaScript/Перевірка_на_рівність_та_однаковість">Перевірка на рівність та однаковість</a></li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html b/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html
deleted file mode 100644
index c2ae524fa3..0000000000
--- a/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: Логічні оператори
-slug: >-
-  conflicting/Web/JavaScript/Reference/Operators_f71733c8e7001a29c3ec40d8522a4aca
-tags:
-  - JavaScript
-  - Оператор
-  - логічний
-translation_of: Web/JavaScript/Reference/Operators
-translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators
-original_slug: Web/JavaScript/Reference/Operators/Logical_Operators
----
-<div>{{jsSidebar("Operators")}}</div>
-
-<p>Логічні оператори зазвичай застосовуються до {{jsxref("Boolean", "булевих")}} (логічних) значень. В цьому випадку вони повертають значення типу Boolean. Однак, оператори <code>&amp;&amp;</code> та <code>||</code> насправді повертають значення одного з заданих операндів, тому, якщо ці оператори використовуються зі значеннями не булевого типу, вони повернуть значення не булевого типу.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}</div>
-
-
-
-<h2 id="Опис">Опис</h2>
-
-<p>Логічні оператори описані у наведеній нижче таблиці (вирази <code><em>expr</em></code> можуть належати до будь-якого <a href="/uk/docs/Glossary/Data_structure">типу</a>, не лише булевого):</p>
-
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <th>Оператор</th>
-   <th>Синтаксис</th>
-   <th>Опис</th>
-  </tr>
-  <tr>
-   <td>Логічне І (<code>&amp;&amp;</code>)</td>
-   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
-   <td>Якщо вираз <code>expr<strong>1</strong></code> може бути приведений до <code>true</code>, вертає <code>expr<strong>2</strong></code>; інакше, вертає <code>expr<strong>1</strong></code>.</td>
-  </tr>
-  <tr>
-   <td>Логічне АБО (<code>||</code>)</td>
-   <td><code><em>expr1</em> || <em>expr2</em></code></td>
-   <td>Якщо вираз <code>expr<strong>1</strong></code> може бути приведений до <code>true</code>, вертає <code>expr<strong>1</strong></code>; інакше, вертає <code>expr<strong>2</strong></code>.</td>
-  </tr>
-  <tr>
-   <td>Логічне НЕ (<code>!</code>)</td>
-   <td><code>!<em>expr</em></code></td>
-   <td>Вертає <code>false</code>, якщо його єдиний операнд може бути приведений до <code>true</code>; інакше, вертає <code>true</code>.</td>
-  </tr>
- </tbody>
-</table>
-
-<p>Якщо значення може бути приведене до <code>true</code>, то воно називається {{Glossary("truthy","правдивим")}}. Якщо значення може бути приведене до <code>false</code>, воно називається {{Glossary("falsy","хибним")}}.</p>
-
-<p>Приклади виразів, які можуть бути приведені до false:</p>
-
-<ul>
- <li><code>null</code>;</li>
- <li><code>NaN</code>;</li>
- <li><code>0</code>;</li>
- <li>порожній рядок (<code>""</code>, або <code>''</code>, або <code>``</code>);</li>
- <li><code>undefined</code>.</li>
-</ul>
-
-<p>Хоча оператори <code>&amp;&amp;</code> та <code>||</code> можуть використовуватись з операндами не булевого (логічного) типу, вони все одно можуть вважатися логічними операторами, оскільки значення, які вони повертають, завжди можуть бути приведені до <a href="/uk/docs/Web/JavaScript/Data_structures#Тип_boolean">булевих примітивів</a>. Щоб явно перетворити повернені значення (або, взагалі, будь-який вираз) до відповідного булевого значення, скористайтесь подвійним <a href="/uk/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT">оператором НЕ</a> або конструктором <a href="/uk/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Boolean</a>.</p>
-
-<h3 id="Коротке_замикання_обчислення">Коротке замикання обчислення</h3>
-
-<p>Оскільки логічні вирази обчислюються зліва направо, вони перевіряються на можливе "коротке замикання" обчислення за наступними правилами:</p>
-
-<ul>
- <li><code>(якийсь хибний вираз) &amp;&amp; <em>expr</em></code> обчислюється як хибний вираз;</li>
- <li><code>(якийсь правдивий вираз) || <em>expr</em></code> обчислюється як правдивий вираз.</li>
-</ul>
-
-<p>Коротке замикання означає, що наведені вирази <em>expr</em> <strong>не обчислюються</strong>, тому будь-які побічні ефекти від цього не відбудуться (наприклад, якщо <em>expr</em> є викликом функції, виклик не відбувається). Це відбувається тому, що значення оператора вже визначене після обчислення першого операнду. Дивіться приклад:</p>
-
-<pre class="brush: js">function A(){ console.log('викликано A'); return false; }
-function B(){ console.log('викликано B'); return true; }
-
-console.log( A() &amp;&amp; B() );
-// виводить "викликано A" в результаті виклику функції,
-// потім виводить false (що є результатом виклику оператора)
-
-console.log( B() || A() );
-// виводить "викликано B" в результаті виклику функції,
-// потім виводить true (що є результатом виклику оператора)
-</pre>
-
-<h3 id="Пріоритет_операторів">Пріоритет операторів</h3>
-
-<p>Наступні вирази можуть виглядати еквівалентними, але це не так, оскільки оператор <code>&amp;&amp;</code> виконується перед оператором <code>||</code> (дивіться <a href="/uk/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Пріоритет операторів</a>).</p>
-
-<pre class="brush: js">true || false &amp;&amp; false      // вертає true, оскільки &amp;&amp; виконується першим
-(true || false) &amp;&amp; false    // вертає false, оскільки не можна застосувати пріоритет операторів</pre>
-
-<h3 id="Логічне_І"><a id="Logical_AND" name="Logical_AND">Логічне І (<code>&amp;&amp;</code>)</a></h3>
-
-<p>Наступний код наводить приклади оператора <code>&amp;&amp;</code> (логічне І).</p>
-
-<pre class="brush: js">a1 = true  &amp;&amp; true       // t &amp;&amp; t вертає true
-a2 = true  &amp;&amp; false      // t &amp;&amp; f вертає false
-a3 = false &amp;&amp; true       // f &amp;&amp; t вертає false
-a4 = false &amp;&amp; (3 == 4)   // f &amp;&amp; f вертає false
-a5 = 'Кіт' &amp;&amp; 'Пес'      // t &amp;&amp; t вертає "Пес"
-a6 = false &amp;&amp; 'Кіт'      // f &amp;&amp; t вертає false
-a7 = 'Кіт' &amp;&amp; false      // t &amp;&amp; f вертає false
-a8 = ''    &amp;&amp; false      // f &amp;&amp; f вертає ""
-a9 = false &amp;&amp; ''         // f &amp;&amp; f вертає false
-</pre>
-
-<h3 id="Логічне_АБО"><a id="Logical_OR" name="Logical_OR">Логічне АБО (<code>||</code>)</a></h3>
-
-<p>Наступний код наводить приклади оператора <code>||</code> (логічне АБО).</p>
-
-<pre class="brush: js">o1 = true  || true       // t || t вертає true
-o2 = false || true       // f || t вертає true
-o3 = true  || false      // t || f вертає true
-o4 = false || (3 == 4)   // f || f вертає false
-o5 = 'Кіт' || 'Пес'      // t || t вертає "Кіт"
-o6 = false || 'Кіт'      // f || t вертає "Кіт"
-o7 = 'Кіт' || false      // t || f вертає "Кіт"
-o8 = ''    || false      // f || f вертає false
-o9 = false || ''         // f || f вертає ""
-o10 = false || varObject // f || object вертає varObject
-</pre>
-
-<div class="blockIndicator note">
-<p><strong>Заувага:</strong> Якщо ви використовуєте цей оператор для присвоєння значення за замовчуванням якійсь змінній, пам'ятайте, що будь-яке <em>хибне</em> значення не буде використане. Якщо вам потрібно лише відфільтрувати {{jsxref("null")}} або {{jsxref("undefined")}}, розгляньте <a href="/uk/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">оператор null-об'єднання</a> (однак, станом на листопад 2019 ця функціональність ще не була широко реалізована і має вважатися експериментальною, оскільки знаходиться на Стадії 3).</p>
-</div>
-
-<h3 id="Логічне_НЕ_!"><a id="Logical_NOT" name="Logical_NOT">Логічне НЕ (<code>!</code>)</a></h3>
-
-<p>Наступний код демонструє приклади оператора <code>!</code> (логічне НЕ).</p>
-
-<pre class="brush: js">n1 = !true               // !t вертає false
-n2 = !false              // !f вертає true
-n3 = !''                 // !f вертає true
-n4 = !'Cat'              // !t вертає false
-</pre>
-
-<h4 id="Подвійне_НЕ_!!">Подвійне НЕ (<code>!!</code>)</h4>
-
-<p>Можна використовувати пару операторів НЕ поспіль, щоб явно викликати перетворення будь-якої величини на відповідний <a href="/uk/docs/Web/JavaScript/Data_structures#Тип_boolean">булевий примітив</a>. Перетворення базується на "правдивості" або "хибності" значення (дивіться {{Glossary("truthy")}} та {{Glossary("falsy")}}).</p>
-
-<p>Таке саме перетворення можна виконати функцією {{jsxref("Boolean")}}.</p>
-
-<pre class="brush: js">n1 = !!true                   // !!truthy вертає true
-n2 = !!{}                     // !!truthy вертає true: <strong>будь-який</strong> об'єкт є правдивим...
-n3 = !!(new Boolean(false))   // ...навіть об'єкти Boolean з false <em>.valueOf()</em>!
-n4 = !!false                  // !!falsy вертає false
-n5 = !!""                     // !!falsy вертає false
-n6 = !!Boolean(false)         // !!falsy вертає false
-</pre>
-
-<h3 id="Правила_перетворення_для_булевих_значень">Правила перетворення для булевих значень</h3>
-
-<h4 id="Перетворення_І_на_АБО">Перетворення І на АБО</h4>
-
-<p>Наступна операція з <strong>булевими значеннями</strong>:</p>
-
-<pre class="brush: js">умова1 &amp;&amp; умова2</pre>
-
-<p>завжди дорівнює:</p>
-
-<pre class="brush: js">!(!умова1 || !умова2)</pre>
-
-<h4 id="Перетворення_АБО_на_І">Перетворення АБО на І</h4>
-
-<p>Наступна операція з <strong>булевими значеннями</strong>:</p>
-
-<pre class="brush: js">умова1 || умова2</pre>
-
-<p>завжди дорівнює:</p>
-
-<pre class="brush: js">!(!умова1 &amp;&amp; !умова2)</pre>
-
-<h4 id="Перетворення_НЕ">Перетворення НЕ</h4>
-
-<p>Наступна операція з <strong>булевими значеннями</strong>:</p>
-
-<pre class="brush: js">!!умова</pre>
-
-<p>завжди дорівнює:</p>
-
-<pre class="brush: js">умова</pre>
-
-<h3 id="Прибирання_вкладених_дужок">Прибирання вкладених дужок</h3>
-
-<p>Оскільки логічні вирази обчислюються зліва направо, завжди можна прибрати дужки зі складного виразу, дотримуючись деяких правил.</p>
-
-<h4 id="Прибирання_вкладеного_І">Прибирання вкладеного І</h4>
-
-<p>Наступна складена операція з <strong>булевими значеннями</strong>:</p>
-
-<pre class="brush: js">умова1 || (умова2 &amp;&amp; умова3)</pre>
-
-<p>завжди дорівнює:</p>
-
-<pre class="brush: js">умова1 || умова2 &amp;&amp; умова3</pre>
-
-<h4 id="Прибирання_вкладеного_АБО">Прибирання вкладеного АБО</h4>
-
-<p>Наступна складена операція з <strong>булевими значеннями</strong>:</p>
-
-<pre class="brush: js">умова1 &amp;&amp; (умова2 || умова3)</pre>
-
-<p>завжди дорівнює:</p>
-
-<pre class="brush: js">!(!умова1 || !умова2 &amp;&amp; !умова3)</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.11')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.9">Логічний оператор НЕ</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.11">Бінарні логічні оператори</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-binary-logical-operators')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Визначені у кількох розділах специфікації: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-logical-not-operator">Логічний оператор НЕ</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-logical-operators">Бінарні логічні оператори</a></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-binary-logical-operators')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Визначені у кількох розділах специфікації: <a href="http://tc39.github.io/ecma262/#sec-logical-not-operator">Логічний оператор НЕ</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-logical-operators">Бінарні логічні оператори</a></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-
-
-<p>{{Compat("javascript.operators.logical")}}</p>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li><a href="/uk/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Бітові оператори</a></li>
- <li><a href="/uk/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator">Оператор null-об'єднання (<code>??</code>)</a></li>
- <li>{{jsxref("Boolean")}}</li>
- <li><a href="/uk/docs/Glossary/Truthy">Truthy</a></li>
- <li><a href="/uk/docs/Glossary/Falsy">Falsy</a></li>
-</ul>
diff --git a/files/uk/conflicting/web/javascript/reference/statements/switch/index.html b/files/uk/conflicting/web/javascript/reference/statements/switch/index.html
deleted file mode 100644
index d85d7dedc7..0000000000
--- a/files/uk/conflicting/web/javascript/reference/statements/switch/index.html
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: default
-slug: conflicting/Web/JavaScript/Reference/Statements/switch
-translation_of: Web/JavaScript/Reference/Statements/switch
-translation_of_original: Web/JavaScript/Reference/Statements/default
-original_slug: Web/JavaScript/Reference/Statements/default
----
-<div>{{jsSidebar("Statements")}}</div>
-
-<p>Ключове слово <strong>default</strong> може використовуватись у двох ситуаціях у<strong> </strong>JavaScript: у конструкції {{jsxref("Statements/switch", "switch")}} або з оператором {{jsxref("Statements/export", "export")}}.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/statement-default.html")}}</div>
-
-
-
-<h2 id="Синтаксис">Синтаксис</h2>
-
-<p>У конструкції {{jsxref("Statements/switch", "switch")}}:</p>
-
-<pre class="syntaxbox">switch (expression) {
-  case value1:
-    //Інструкції, що виконуються, коли значення expression дорівнює value1
-    [break;]
-  default:
-    //Інструкції, що виконуються, коли жодне значення не дорівнює значенню expression
-    [break;]
-}</pre>
-
-<p>З оператором {{jsxref("Statements/export", "export")}}:</p>
-
-<pre class="syntaxbox">export default <em>nameN</em> </pre>
-
-<h2 id="Опис">Опис</h2>
-
-<p>Більш детально дивіться на сторінках</p>
-
-<ul>
- <li>конструкції {{jsxref("Statements/switch", "switch")}} та</li>
- <li>оператора {{jsxref("Statements/export", "export")}}.</li>
-</ul>
-
-<h2 id="Приклади">Приклади</h2>
-
-<h3 id="Використання_default_у_конструкціях_switch">Використання <code>default</code> у конструкціях <code>switch</code></h3>
-
-<p>У наступному прикладі, якщо <code>expr</code> оцінюється як "Апельсини" або "Яблука", програма зайде або у блок case "Апельсини", або у "Яблука" та виконає відповідну інструкцію. Ключове слово <code>default</code> допоможе у будь-якому іншому випадку та виконає пов'язану інструкцію.</p>
-
-<pre class="brush: js">switch (expr) {
-  case 'Апельсини':
-    console.log('Апельсини коштують $0.59 за кілограм.');
-    break;
-  case 'Яблука':
-    console.log('Яблука коштують $0.32 за кілограм.');
-    break;
-  default:
-    console.log('На жаль, в нас закінчились ' + expr + '.');
-}</pre>
-
-<h3 id="Використання_default_з_export">Використання <code>default</code> з <code>export</code></h3>
-
-<p>Якщо ви хочете експортувати єдине значення, або вам потрібне запасне значення модуля, можна використати default у export:</p>
-
-<pre class="brush: js">// module "my-module.js"
-let cube = function cube(x) {
-  return x * x * x;
-};
-export default cube;</pre>
-
-<p>Тоді у іншому скрипті буде прямий імпорт експорту за замовчуванням:</p>
-
-<pre class="brush: js">// module "another-module.js"
-import cube from 'my-module';  //default export gave us the liberty to say import cube, instead of import cube from 'my-module'
-console.log(cube(3)); // 27
-</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('ES6', '#sec-switch-statement', 'switch statement')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>
-
-
-
-<p>{{Compat("javascript.statements.default")}}</p>
-
-<h2 id="Див._також">Див. також</h2>
-
-<ul>
- <li>{{jsxref("Statements/export", "export")}}</li>
- <li>{{jsxref("Statements/switch", "switch")}}</li>
-</ul>