From daa1a2aff136fa9da1fcc97d7da97a2036fabc77 Mon Sep 17 00:00:00 2001 From: Florian Merz Date: Thu, 11 Feb 2021 14:51:47 +0100 Subject: unslug uk: move --- .../web/api/windoworworkerglobalscope/index.html | 126 +++++ .../reference/global_objects/boolean/index.html | 83 +++ .../reference/global_objects/error/index.html | 115 +++++ .../reference/global_objects/evalerror/index.html | 90 ++++ .../reference/global_objects/function/index.html | 100 ++++ .../global_objects/generatorfunction/index.html | 66 +++ .../global_objects/internalerror/index.html | 63 +++ .../reference/global_objects/number/index.html | 90 ++++ .../reference/global_objects/promise/index.html | 70 +++ .../reference/global_objects/rangeerror/index.html | 90 ++++ .../global_objects/referenceerror/index.html | 91 ++++ .../global_objects/syntaxerror/index.html | 89 ++++ .../reference/global_objects/typeerror/index.html | 88 ++++ .../reference/global_objects/urierror/index.html | 89 ++++ .../web/javascript/reference/operators/index.html | 314 ++++++++++++ .../reference/operators/spread_syntax/index.html | 283 +++++++++++ .../index.html | 419 +++++++++++++++ .../index.html | 560 +++++++++++++++++++++ .../index.html | 245 +++++++++ .../index.html | 253 ++++++++++ .../reference/statements/switch/index.html | 118 +++++ 21 files changed, 3442 insertions(+) create mode 100644 files/uk/conflicting/web/api/windoworworkerglobalscope/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/boolean/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/error/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/evalerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/function/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/internalerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/number/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/promise/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/rangeerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/referenceerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/typeerror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/global_objects/urierror/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators/spread_syntax/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html create mode 100644 files/uk/conflicting/web/javascript/reference/statements/switch/index.html (limited to 'files/uk/conflicting/web') diff --git a/files/uk/conflicting/web/api/windoworworkerglobalscope/index.html b/files/uk/conflicting/web/api/windoworworkerglobalscope/index.html new file mode 100644 index 0000000000..d28752bde7 --- /dev/null +++ b/files/uk/conflicting/web/api/windoworworkerglobalscope/index.html @@ -0,0 +1,126 @@ +--- +title: WindowTimers +slug: Web/API/WindowTimers +tags: + - API + - HTML DOM + - Interface + - Intervals + - Mixin + - NeedsTranslation + - Reference + - Timers + - TopicStub + - Workers +translation_of: Web/API/WindowOrWorkerGlobalScope +translation_of_original: Web/API/WindowTimers +--- +
{{APIRef("HTML DOM")}}
+ +

WindowTimers is a mixin used to provide utility methods which set and clear timers. No objects of this type exist; instead, its methods are available on {{domxref("Window")}} for the standard browsing scope, or on {{domxref("WorkerGlobalScope")}} for workers.

+ +

Properties

+ +

This interface neither inherits nor provides any properties.

+ +

Methods

+ +

This interface does not inherit any methods. It offers the following methods.

+ +
+
{{domxref("WindowTimers.clearInterval()")}}
+
Cancels the repeated execution set using {{domxref("WindowTimers.setInterval()")}}.
+
{{domxref("WindowTimers.clearTimeout()")}}
+
Cancels the delayed execution set using {{domxref("WindowTimers.setTimeout()")}}.
+
{{domxref("WindowTimers.setInterval()")}}
+
Schedules a function to execute every time a given number of milliseconds elapses.
+
{{domxref("WindowTimers.setTimeout()")}}
+
Schedules a function to execute in a given amount of time.
+
+ +

Specifications

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
SpecificationStatusComment
{{SpecName('HTML WHATWG', '#windowtimers', 'WindowTimers')}}{{Spec2('HTML WHATWG')}}No change since the latest snapshot, {{SpecName("HTML5.1")}}.
{{SpecName('HTML5.1', '#windowtimers', 'WindowTimers')}}{{Spec2('HTML5.1')}}Snapshot of {{SpecName("HTML WHATWG")}}. No change.
{{SpecName("HTML5 W3C", "#windowtimers", "WindowTimers")}}{{Spec2('HTML5 W3C')}}Snapshot of {{SpecName("HTML WHATWG")}}. Creation of WindowBase64 (properties where on the target before it).
+ +

Browser compatibility

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureFirefox (Gecko)ChromeInternet ExplorerOperaSafari
Basic support{{CompatGeckoDesktop(1)}}1.04.04.01.0
+
+ +
+ + + + + + + + + + + + + + + + + + + +
FeatureFirefox Mobile (Gecko)AndroidIE MobileOpera MobileSafari Mobile
Basic support{{CompatGeckoMobile(1)}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}{{CompatVersionUnknown}}
+
+ +

 

+ +

See also

+ + 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 new file mode 100644 index 0000000000..dd69fe02f7 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/boolean/index.html @@ -0,0 +1,83 @@ +--- +title: Boolean.prototype +slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +tags: + - Boolean + - JavaScript + - Властивість + - Поле + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/Boolean +translation_of_original: Web/JavaScript/Reference/Global_Objects/Boolean/prototype +--- +
{{JSRef}}
+ +

Поле Boolean.prototype представляє прототип конструктора {{jsxref("Boolean")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +
{{EmbedInteractiveExample("pages/js/boolean-constructor.html")}}
+ + + +

Опис

+ +

Екземпляри {{jsxref("Boolean")}} наслідуються від Boolean.prototype. Ви можете використовувати об'єкт прототипа конструктора, щоб додавати свої поля та методи до всіх екземплярів {{jsxref("Boolean")}}.

+ +

Властивості

+ +
+
Boolean.prototype.constructor
+
Повертає функцію, що створила прототип екземпляра. За замовчування це функція {{jsxref("Boolean")}}.
+
+ +

Методи

+ +
+
{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}
+
Повертає строку, що містить сирець об'єкту {{jsxref("Boolean")}}; використавши її ви можете створити еквівалентний об'єкт. Перевизначає метод {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Boolean.prototype.toString()")}}
+
Повертає строку "true" чи "false" залежно від значення об'єкту. Перевизначає метод {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("Boolean.prototype.valueOf()")}}
+
Повертає примітив значення об'єкту {{jsxref("Boolean")}}. Перевизначає метод {{jsxref("Object.prototype.valueOf()")}}.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусПримітка
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-boolean.prototype', 'Boolean.prototype')}}{{Spec2('ESDraft')}} 
+ +

Підтримка у браузерах

+ +
+ + +

{{Compat("javascript.builtins.Boolean.prototype")}}

+
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 new file mode 100644 index 0000000000..c0bcaf8739 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/error/index.html @@ -0,0 +1,115 @@ +--- +title: Error.prototype +slug: Web/JavaScript/Reference/Global_Objects/Error/prototype +tags: + - Error + - JavaScript + - Властивість + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/Error +translation_of_original: Web/JavaScript/Reference/Global_Objects/Error/prototype +--- +
{{JSRef}}
+ +

Властивість Error.prototype є прототипом для конструктора {{jsxref("Error")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Всі екземпляри {{jsxref("Error")}} та екземпляри {{jsxref("Global_Objects/Error", "базових конструкторів помилок", "#Типи_помилок", 1)}} успадковуються від Error.prototype. Як в усіх функціях-конструкторах, ви можете використовувати прототип конструктора, щоб додавати властивості чи методи до усіх екземплярів, створених цим конструктором. 

+ +

Властивості

+ +

Стандартні властивості

+ +
+
Error.prototype.constructor
+
Функція, яка створила прототип екземпляра.
+
{{jsxref("Error.prototype.message")}}
+
Повідомлення помилки.
+
{{jsxref("Error.prototype.name")}}
+
Ім'я помилки.
+
+ +

Спеціальні розширення

+ +

{{non-standard_header}}

+ +

Microsoft

+ +
+
Error.description
+
Опис помилки. Властивість схожа на {{jsxref("Error.prototype.message", "message")}}.
+
Error.number
+
Номер помилки.
+
+ +

Mozilla

+ +
+
{{jsxref("Error.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку.
+
{{jsxref("Error.prototype.lineNumber")}}
+
Номер рядка у файлі, що спричинив помилку.
+
{{jsxref("Error.prototype.columnNumber")}}
+
Номер стовпця у файлі, де виникла помилка.
+
{{jsxref("Error.prototype.stack")}}
+
Трасування стеку.
+
+ +

Методи

+ +
+
{{jsxref("Error.prototype.toSource()")}} {{non-standard_inline}}
+
Повертає рядок з кодом, що спричинить створення заданого об'єкта {{jsxref("Error")}}; ви можете використати це значення, щоб створити новий об'єкт. Заміщує метод {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Error.prototype.toString()")}}
+
Повертає рядок, що представляє заданий об'єкт. Заміщує метод {{jsxref("Object.prototype.toString()")}}.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення Реалізовано у JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.11.3.1', 'Error')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-error.prototype', 'Error')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-error.prototype', 'Error')}}{{Spec2('ESDraft')}}
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.Error.prototype")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..567dad0c0b --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/evalerror/index.html @@ -0,0 +1,90 @@ +--- +title: EvalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +tags: + - Error + - EvalError + - JavaScript + - помилка +translation_of: Web/JavaScript/Reference/Global_Objects/EvalError +translation_of_original: Web/JavaScript/Reference/Global_Objects/EvalError/prototype +--- +
{{JSRef}}
+ +

Властивість EvalError.prototype є прототипом для конструктора {{jsxref("EvalError")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Всі екземпляри {{jsxref("EvalError")}} успадковуються від EvalError.prototype. Ви можете використати прототип, щоб додати властивості та методи до усіх екземплярів.

+ +

Властивості

+ +
+
EvalError.prototype.constructor
+
Функція, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "EvalError.prototype.message")}}
+
Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("EvalError")}} повинен мати власну властивість message, у SpiderMonkey він успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "EvalError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "EvalError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "EvalError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "EvalError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "EvalError.prototype.stack")}}
+
Трасування стеку. Успадковано від {{jsxref("Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("EvalError")}} не містить власних методів, екземпляри {{jsxref("EvalError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Визначено як NativeError.prototype.
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.EvalError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..aefa5cad6b --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/function/index.html @@ -0,0 +1,100 @@ +--- +title: Function.prototype +slug: Web/JavaScript/Reference/Global_Objects/Function/prototype +tags: + - Function + - JavaScript + - Властивість + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/Function +translation_of_original: Web/JavaScript/Reference/Global_Objects/Function/prototype +--- +
{{JSRef}}
+ +

Властивість Function.prototype є об'єктом прототипу {{jsxref("Function")}}.

+ +

Опис

+ +

Об'єкти {{jsxref("Function")}} успадковуються від Function.prototype.  Function.prototype не можна змінити.

+ +

Властивості

+ +
+
{{jsxref("Function.prototype.arguments")}} {{deprecated_inline}}
+
Масив, що відповідає аргументам, переданим у функцію. Це застаріла властивість {{jsxref("Function")}}. Використовуйте натомість об'єкт {{jsxref("Functions/arguments", "arguments")}}, доступний всередині функції.
+
{{jsxref("Function.arity")}} {{obsolete_inline}}
+
Вказувала кількість аргументів, очікуваних функцією, але була видалена. Використовуйте натомість властивість {{jsxref("Function.length", "length")}}.
+
{{jsxref("Function.prototype.caller")}} {{non-standard_inline}}
+
Вказує функцію, що викликала функцію, яка виконується.
+
{{jsxref("Function.prototype.length")}}
+
Вказує кількість аргументів, очікуваних функцією.
+
{{jsxref("Function.prototype.name")}}
+
Ім'я функції.
+
{{jsxref("Function.displayName")}} {{non-standard_inline}}
+
Ім'я, що відображається для функції.
+
Function.prototype.constructor
+
Вказує функцію, яка створює прототип об'єкта. Більше інформації дивіться на сторінці {{jsxref("Object.prototype.constructor")}}.
+
+ +

Методи

+ +
+
{{jsxref("Function.prototype.apply()")}}
+
Викликає функцію та встановлює її this надане значення, аргументи можуть передаватися об'єктом {{jsxref("Array")}}.
+
{{jsxref("Function.prototype.bind()")}}
+
Створює нову функцію, в якої під час виклику this присвоєне надане значення, з заданою послідовністю аргументів, що передують будь-якім іншим наданим аргументам під час виклику нової функції.
+
{{jsxref("Function.prototype.call()")}}
+
Викликає (виконує) функцію та присвоює її this надане значення, аргументи можуть передаватися як є.
+
{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}
+
Повертає true, якщо функція є генератором; інакше повертає false.
+
{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}
+
Повертає рядкове представлення першокоду функції. Заміщує метод {{jsxref("Object.prototype.toSource")}}.
+
{{jsxref("Function.prototype.toString()")}}
+
Повертає рядкове представлення першокоду функції. Заміщує метод {{jsxref("Object.prototype.toString")}}.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення. Реалізоване у JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}{{Spec2('ESDraft')}}
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.Function.prototype")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..0c20812347 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/generatorfunction/index.html @@ -0,0 +1,66 @@ +--- +title: GeneratorFunction.prototype +slug: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype +tags: + - ECMAScript 2015 + - GeneratorFunction + - JavaScript + - Ітератор + - Властивість + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/GeneratorFunction +translation_of_original: Web/JavaScript/Reference/Global_Objects/GeneratorFunction/prototype +--- +
{{JSRef}}
+ +

Властивість GeneratorFunction.prototype відображає прототип {{jsxref("GeneratorFunction")}}.

+ +

Опис

+ +

Об'єкти {{jsxref("GeneratorFunction")}} успадковуються від GeneratorFunction.prototype. GeneratorFunction.prototype не можна змінювати.

+ +

Властивості

+ +
+
GeneratorFunction.constructor
+
Початковим значенням є {{jsxref("GeneratorFunction")}}.
+
GeneratorFunction.prototype.prototype
+
Значення дорівнює %GeneratorPrototype%.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES2015', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}{{Spec2('ES2015')}}Початкове визначення.
{{SpecName('ESDraft', '#sec-generatorfunction.prototype', 'GeneratorFunction.prototype')}}{{Spec2('ESDraft')}}
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.GeneratorFunction.prototype")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..44dc74ec1a --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/internalerror/index.html @@ -0,0 +1,63 @@ +--- +title: InternalError.prototype +slug: Web/JavaScript/Reference/Global_Objects/InternalError/prototype +tags: + - Error + - InternalError + - JavaScript + - Властивість + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/InternalError +translation_of_original: Web/JavaScript/Reference/Global_Objects/InternalError/prototype +--- +
{{JSRef}} {{non-standard_header}}
+ +

Властивість InternalError.prototype є прототипом конструктора {{jsxref("InternalError")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Всі екземпляри {{jsxref("InternalError")}} успадковуються від InternalError.prototype. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.

+ +

Властивості

+ +
+
InternalError.prototype.constructor
+
Визначає функцію, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}
+
Повідомлення помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}
+
Трасування стеку. Успаковано від {{jsxref("Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("InternalError")}} не має власних методів, екземпляри {{jsxref("InternalError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ +

Не є частиною жодних специфікацій.

+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.InternalError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..3cd9d811cc --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/number/index.html @@ -0,0 +1,90 @@ +--- +title: Number.prototype +slug: Web/JavaScript/Reference/Global_Objects/Число/prototype +tags: + - JavaScript + - Number + - Property + - Prototype +translation_of: Web/JavaScript/Reference/Global_Objects/Number +translation_of_original: Web/JavaScript/Reference/Global_Objects/Number/prototype +--- +
{{JSRef}}
+ +

Властивість Number.prototype являє собою прототип для конструктора класу {{jsxref("Global_Objects/Number", "Number")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Кожен примірник класу {{jsxref("Global_Objects/Number", "Number")}} успадковує властивості й методи з Number.prototype. Зміни, внесені до прототипа, позначаться на всіх об'єктах, що є примірниками класу {{jsxref("Global_Objects/Number", "Number")}}.

+ +

Властивості

+ +
+
Number.prototype.constructor
+
Повертає функцію, що створила цей примірник об'єкта. Типово це об'єкт {{jsxref("Global_Objects/Number", "Number")}}, який водночас є і функцією.
+
+ +

Методи

+ +
+
{{jsxref("Number.prototype.toExponential()")}}
+
Повертає рядок, що містить експоненціальний запис числа.
+
{{jsxref("Number.prototype.toFixed()")}}
+
Повертає рядок, що містить запис числа у форматі з нерухомою комою.
+
{{jsxref("Number.prototype.toLocaleString()")}}
+
Повертає рядок, що містить узалежнений від мови запис числа. Перекриває метод {{jsxref("Object.prototype.toLocaleString()")}}.
+
{{jsxref("Number.prototype.toPrecision()")}}
+
Повертає рядок, що містить запис числа із зазначеною точністю у форматі з нерухомою комою чи експоненціальний.
+
{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}
+
Повертає рядок, що містить код мовою JavaScript, який створює об'єкт класу {{jsxref("Global_Objects/Number", "Number")}} з відповідним значенням. Цей код можна використати для створення нового об'єкта. Перекриває метод {{jsxref("Object.prototype.toSource()")}}.
+
{{jsxref("Number.prototype.toString()")}}
+
Повертає рядок, що містить числовий запис значення об'єкта в зазначеній системі числення. Перекриває метод {{jsxref("Object.prototype.toString()")}}.
+
{{jsxref("Number.prototype.valueOf()")}}
+
Повертає {{Glossary("Primitive", "просте числове значення")}} об'єкта. Перекриває метод {{jsxref("Object.prototype.valueOf()")}}.
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Первинне визначення. Реалізовано у JavaScript 1.1.
{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}{{Spec2('ESDraft')}} 
+ +

Підтримка веб-переглядачами

+ + + +

{{Compat("javascript.builtins.Number.prototype")}}

+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..33bdd86562 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/promise/index.html @@ -0,0 +1,70 @@ +--- +title: Promise.prototype +slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype +tags: + - JavaScript + - Promise + - ДжаваСкріпт + - Проміс +translation_of: Web/JavaScript/Reference/Global_Objects/Promise +translation_of_original: Web/JavaScript/Reference/Global_Objects/Promise/prototype +--- +
{{JSRef}}
+ +

Параметр Promise.prototype відображає прототип для конструктора {{jsxref("Promise")}} constructor.

+ +
{{js_property_attributes(0,0,0)}}
+ +

Опис

+ +

Екземпляри {{jsxref("Promise")}} успадковуються від {{jsxref("Promise.prototype")}}. Ви можете використовувати прототип конструктора, щоб добавляти параметри або методи до всіх екземплярів Promise.

+ +

Параметри

+ +
+
Promise.prototype.constructor
+
Повертає функцію, яка створила прототип екземпляра. Це є функція {{jsxref("Promise")}} по замовчуванню.
+
+ +

Методи

+ +
+
{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}
+
Добавляє колбек обробник відхилення проміса, і повертає новий проміс, який вирішується значенням, яке повертається з функції колбеку, якщо вона була викликана, або його початковий результат виконання, якщо даний проміс був виконаний.
+
{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}
+
Добавляє до проміса функції колбеки для випадків, коли проміс був виконаний (onFulfilled) і відхилений (onRejected) і повертає новий проміс, який вирішується значенням, яке було повернуто з onFulfilled функції колбеку, або з початковим значенням, яке було вирішено, коли даний проміс не був оброблений (тобто коли обробники onFulfilled або onRejected не є функцією).
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ES6')}}Початкове визначення.
{{SpecName('ESDraft', '#sec-promise.prototype', 'Promise.prototype')}}{{Spec2('ESDraft')}} 
+ +

Сумісність із браузерами

+ + + +

{{Compat("javascript/promise","Promise.prototype")}}

+ +

Дивитися також

+ + 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 new file mode 100644 index 0000000000..8a836ddd56 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/rangeerror/index.html @@ -0,0 +1,90 @@ +--- +title: RangeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +tags: + - Error + - JavaScript + - RangeError + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/RangeError +translation_of_original: Web/JavaScript/Reference/Global_Objects/RangeError/prototype +--- +
{{JSRef}}
+ +

Властивість RangeError.prototype є прототипом для конструктора {{jsxref("RangeError")}}

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Всі екземпляри {{jsxref("RangeError")}} успадковуються від RangeError.prototype. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.

+ +

Властивості

+ +
+
RangeError.prototype.constructor
+
Визначає функцію, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "RangeError.prototype.message")}}
+
Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("RangeError")}} має надавати власну властивість message, у SpiderMonkey, він успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "RangeError.prototype.name")}}
+
Ім'я помилки. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "RangeError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "RangeError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "RangeError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "RangeError.prototype.stack")}}
+
Трасування стеку. Успаковано від {{jsxref("Error", "Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("RangeError")}} не містить власних методів, екземпляри {{jsxref("RangeError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Визначено як NativeError.prototype.
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.RangeError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..cacfaf2719 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/referenceerror/index.html @@ -0,0 +1,91 @@ +--- +title: ReferenceError.prototype +slug: Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype +tags: + - Error + - JavaScript + - ReferenceError + - помилка + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/ReferenceError +translation_of_original: Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype +--- +
{{JSRef}}
+ +

Властивість ReferenceError.prototype є прототипом для конструктора {{jsxref("ReferenceError")}}.

+ +
{{js_property_attributes(0, 0, 0)}}
+ +

Опис

+ +

Всі екземпляри {{jsxref("ReferenceError")}} успадковуються від ReferenceError.prototype. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.

+ +

Властивості

+ +
+
ReferenceError.prototype.constructor
+
Визначає функцію, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "ReferenceError.prototype.message")}}
+
Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("ReferenceError")}} повинен мати власну властивість message, у SpiderMonkey він успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "ReferenceError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "ReferenceError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "ReferenceError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "ReferenceError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "ReferenceError.prototype.stack")}}
+
Трасування стеку. Успаковано від {{jsxref("Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("ReferenceError")}} не містить власних методів, екземпляри {{jsxref("ReferenceError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Визначено як NativeError.prototype.
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.ReferenceError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..b4d42f339c --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/syntaxerror/index.html @@ -0,0 +1,89 @@ +--- +title: SyntaxError.prototype +slug: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype +tags: + - Error + - JavaScript + - Prototype + - SyntaxError + - помилка +translation_of: Web/JavaScript/Reference/Global_Objects/SyntaxError +translation_of_original: Web/JavaScript/Reference/Global_Objects/SyntaxError/prototype +--- +
{{JSRef}}
+ +

Властивість SyntaxError.prototype є прототипом для конструктора {{jsxref("SyntaxError")}}.

+ +

Опис

+ +

Всі примірники {{jsxref("SyntaxError")}} успадковуються від SyntaxError.prototype, тож ви можете скористатися прототипом задля додавання властивостей чи методів до всіх примірників.

+ +

Властивості

+ +
+
SyntaxError.prototype.constructor
+
Функція, що створює прототип об'єкта.
+
{{jsxref("Error.prototype.message", "SyntaxError.prototype.message")}}
+
Повідомлення помилки. Попри те, що в ECMA-262 зазначено, що {{jsxref("SyntaxError")}} мусить мати свою властивість message, у SpiderMonkey він насправді успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "SyntaxError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.
+
{{jsxref("Error.prototype.fileName", "SyntaxError.prototype.fileName")}}
+
Шлях до файла, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "SyntaxError.prototype.lineNumber")}}
+
Номер рядка у файлі, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "SyntaxError.prototype.columnNumber")}}
+
Номер символа у рядку, де сталася ця помилка. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.
+
{{jsxref("Error.prototype.stack", "SyntaxError.prototype.stack")}}
+
Стек викликів. Успадковано від {{jsxref("Global_Objects/Error", "Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("SyntaxError")}} не містить власних методів, примірники {{jsxref("SyntaxError")}} успадковують деякі методи від ланцюжка прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3')}}{{Spec2('ES3')}}Первинне визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Визначено як NativeError.prototype.
+ +

Підтримка веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.SyntaxError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..7b9c55fc37 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/typeerror/index.html @@ -0,0 +1,88 @@ +--- +title: TypeError.prototype +slug: Web/JavaScript/Reference/Global_Objects/TypeError/prototype +tags: + - Error + - JavaScript + - TypeError + - помилка +translation_of: Web/JavaScript/Reference/Global_Objects/TypeError +translation_of_original: Web/JavaScript/Reference/Global_Objects/TypeError/prototype +--- +
{{JSRef}}
+ +

Властивість TypeError.prototype є прототипом для конструктора {{jsxref("TypeError")}}.

+ +

Опис

+ +

Всі екземпляри {{jsxref("TypeError")}} успадковуються від TypeError.prototype. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.

+ +

Властивості

+ +
+
TypeError.prototype.constructor
+
Визначає функцію, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "TypeError.prototype.message")}}
+
Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("TypeError")}} повинен мати власну властивість message, у SpiderMonkey, він успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "TypeError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "TypeError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "TypeError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "TypeError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "TypeError.prototype.stack")}}
+
Трасування стеку. Успаковано від {{jsxref("Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("TypeError")}} не містить власних методів, екземпляри {{jsxref("TypeError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES3')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як  NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як  NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}} 
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.TypeError")}}

+
+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..d8a4144790 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/global_objects/urierror/index.html @@ -0,0 +1,89 @@ +--- +title: URIError.prototype +slug: Web/JavaScript/Reference/Global_Objects/URIError/prototype +tags: + - Error + - JavaScript + - URIError + - помилка + - прототип +translation_of: Web/JavaScript/Reference/Global_Objects/URIError +translation_of_original: Web/JavaScript/Reference/Global_Objects/URIError/prototype +--- +
{{JSRef}}
+ +

Властивість URIError.prototype є прототипом для конструктора {{jsxref("URIError")}}.

+ +

Опис

+ +

Всі екземпляри {{jsxref("URIError")}} успадковуються від URIError.prototype. Ви можете використати прототип, щоб додати властивості чи методи до усіх екземплярів.

+ +

Властивості

+ +
+
URIError.prototype.constructor
+
Визначає функцію, яка створила прототип об'єкта.
+
{{jsxref("Error.prototype.message", "URIError.prototype.message")}}
+
Повідомлення помилки. Хоча ECMA-262 зазначає, що {{jsxref("URIError")}} повинен мати власну властивість message, у SpiderMonkey, він успадковує {{jsxref("Error.prototype.message")}}.
+
{{jsxref("Error.prototype.name", "URIError.prototype.name")}}
+
Ім'я помилки. Успадковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.fileName", "URIError.prototype.fileName")}}
+
Шлях до файлу, що спричинив помилку. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.lineNumber", "URIError.prototype.lineNumber")}}
+
Номер рядка файлу, в якому виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.columnNumber", "URIError.prototype.columnNumber")}}
+
Номер стовпця у рядку, де виникла помилка. Успаковано від {{jsxref("Error")}}.
+
{{jsxref("Error.prototype.stack", "URIError.prototype.stack")}}
+
Трасування стеку. Успаковано від {{jsxref("Error")}}.
+
+ +

Методи

+ +

Хоча прототип {{jsxref("URIError")}} не містить власних методів, екземпляри {{jsxref("URIError")}} успадковують деякі методи через ланцюжок прототипів.

+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES3', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES3')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-15.11.7.6', 'NativeError.prototype')}}{{Spec2('ES5.1')}}Визначено як  NativeError.prototype.
{{SpecName('ES6', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ES6')}}Визначено як  NativeError.prototype.
{{SpecName('ESDraft', '#sec-nativeerror.prototype', 'NativeError.prototype')}}{{Spec2('ESDraft')}}Визначено як  NativeError.prototype.
+ +

Сумісність з веб-переглядачами

+ +
+ + +

{{Compat("javascript.builtins.URIError")}}

+
+ +

Див. також

+ + diff --git a/files/uk/conflicting/web/javascript/reference/operators/index.html b/files/uk/conflicting/web/javascript/reference/operators/index.html new file mode 100644 index 0000000000..88128f5d99 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators/index.html @@ -0,0 +1,314 @@ +--- +title: Арифметичні оператори +slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Arithmetic_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Арифметичні оператори приймають числові значення (або літерали, або змінні) в якості операндів та повертають єдине числове значення. Стандартними арифметичними операторами є додавання (+), віднімання (-), множення (*) та ділення (/).

+ +
{{EmbedInteractiveExample("pages/js/expressions-arithmetic.html")}}
+ + + +

Додавання (+)

+ +

Оператор додавання повертає суму числових операндів або об'єднання рядків.

+ +

Синтаксис

+ +
Оператор: x + y
+
+ +

Приклади

+ +
// Number + Number -> сума
+1 + 2 // 3
+
+// Boolean + Number -> сума
+true + 1 // 2
+
+// Boolean + Boolean -> сума
+false + false // 0
+
+// Number + String -> об'єднання
+5 + 'foo' // "5foo"
+
+// String + Boolean -> об'єднання
+'foo' + false // "foofalse"
+
+// String + String -> об'єднання
+'foo' + 'bar' // "foobar"
+
+ +

Віднімання (-)

+ +

Оператор віднімання проводить операцію віднімання між двома операндами, повертаючи різницю між ними.

+ +

Синтаксис

+ +
Оператор: x - y
+
+ +

Приклади

+ +
5 - 3 // 2
+3 - 5 // -2
+'foo' - 3 // NaN
+ +

Ділення (/)

+ +

Оператор ділення повертає частку своїх операндів, де лівий операнд є діленим, а правий операнд є дільником.

+ +

Синтаксис

+ +
Оператор: x / y
+
+ +

Приклади

+ +
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
+ +

Множення (*)

+ +

Оператор множення повертає добуток операндів.

+ +

Синтаксис

+ +
Оператор: x * y
+
+ +

Приклади

+ +
2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+'foo' * 2 // NaN
+
+ +

Остача (%)

+ +

Оператор остачі повертає остачу від ділення першого операнду на другий. Він завжди приймає знак діленого.

+ +

Синтаксис

+ +
Оператор: var1 % var2
+
+ +

Приклади

+ +
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
+
+ +

Піднесення до степеня (**)

+ +

Оператор піднесення до степеня повертає результат піднесення першого операнду до показника степеня другого операнду. Тобто, var1var2 у наведеній інструкції, де var1 та var2 є змінними. Оператор піднесення до степеня правоасоціативний. a ** b ** c дорівнює a ** (b ** c).

+ +

Синтаксис

+ +
Оператор: var1 ** var2
+
+ +

Примітки

+ +

У більшості мов, таких як PHP, Python та інших, які мають оператор піднесення до степеня (**), оператор піднесення до степеня має вищий пріоритет, ніж унарні оператори, такі як унарний + та унарний -, але існує кілька винятків. Наприклад, у Bash оператор ** має нижчий пріоритет, ніж унарні оператори. У JavaScript неможливо написати неоднозначний вираз піднесення до степеня, тобто, ви не можете поставити унарний оператор (+/-/~/!/delete/void/typeof) одразу перед числом основи степеня.

+ +
-2 ** 2;
+// 4 у Bash, -4 у інших мовах.
+// Це помилка у JavaScript, оскільки операція неоднозначна.
+
+
+-(2 ** 2);
+// -4 у JavaScript, а наміри автора однозначні.
+
+ +

Приклади

+ +
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
+
+ +

Щоб поміняти знак результату виразу піднесення до степеня:

+ +
-(2 ** 2) // -4
+
+ +

Щоб зробити основу степеня у виразі від'ємним числом:

+ +
(-2) ** 2 // 4
+
+ +
+

Заувага: JavaScript також має бітовий оператор ^ (логічний XOR). ** та ^ відрізняються (наприклад: 2 ** 3 === 8, тоді як 2 ^ 3 === 1.)

+
+ +

Інкремент (++)

+ +

Оператор інкременту збільшує свій операнд (додає одиницю) та повертає його значення.

+ + + +

Синтаксис

+ +
Оператор: x++ або ++x
+
+ +

Приклади

+ +
// Постфіксний
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Префіксний
+var a = 2;
+b = ++a; // a = 3, b = 3
+
+ +

Декремент (--)

+ +

Оператор декременту зменшує свій операнд (віднімає одиницю) та повертає його значення.

+ + + +

Синтаксис

+ +
Оператор: x-- або --x
+
+ +

Приклади

+ +
// Постфіксний
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Префіксний
+var a = 2;
+b = --a; // a = 1, b = 1
+
+ +

Унарний мінус (-)

+ +

Унарний мінус ставиться перед своїм операндом та міняє його знак на протилежний.

+ +

Синтаксис

+ +
Оператор: -x
+
+ +

Приклади

+ +
var x = 3;
+y = -x; // y = -3, x = 3
+
+// Унарний мінус може перетворити нечислове значення на число
+var x = "4";
+y = -x; // y = -4
+
+ +

Унарний плюс (+)

+ +

Унарний плюс ставиться перед своїм операндом та повертає значення операнду, але намагається перетворити його на число, якщо він не є числом. Хоча унарний мінус (-) також вміє перетворювати нечислові значення, унарний плюс найшвидший та найкращий спосіб перетворити щось у число, тому що він не виконує ніяких інших операцій з числом. Він може перетворювати рядкові представлення цілих чисел та чисел з рухомою комою, а також нерядкові значення true, false та null. Підтримуються цілі числа у десятковому та шістнадцятковому форматах. Підтримуються від'ємні числа (хоча не у шістнадцятковому форматі). Якщо оператор не може розібрати певне значення, він поверне {{jsxref("NaN")}}.

+ +

Синтаксис

+ +
Оператор: +x
+
+ +

Приклади

+ +
+3     // 3
++'3'   // 3
++true  // 1
++false // 0
++null  // 0
++function(val){ return val } // NaN
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-additive-operators')}}{{Spec2('ESDraft')}}
{{SpecName('ES2016', '#sec-postfix-expressions')}}{{Spec2('ES2016')}}Доданий Оператор піднесення до степеня.
{{SpecName('ES2017', '#sec-postfix-expressions')}}{{Spec2('ES2017')}}
{{SpecName('ES2015', '#sec-postfix-expressions')}}{{Spec2('ES2015')}}Визначені у кількох розділах специфікації: Адитивні оператори, мультиплікативні оператори, постфіксні вирази, унарні оператори.
{{SpecName('ES5.1', '#sec-11.3')}}{{Spec2('ES5.1')}}Визначені у кількох розділах специфікації: Адитивні оператори, мультиплікативні оператори, постфіксні вирази, унарні оператори.
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення.
+ +

Сумісність з веб-переглядачами

+ + + +

{{Compat("javascript.operators.arithmetic")}}

+ +

Див. також

+ + 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 new file mode 100644 index 0000000000..4e635569ae --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators/spread_syntax/index.html @@ -0,0 +1,283 @@ +--- +title: Оператор розпакування +slug: Web/JavaScript/Reference/Operators/Оператор_розпакування +tags: + - Iterator + - JavaScript + - Operator + - Ітератор + - Оператор +translation_of: Web/JavaScript/Reference/Operators/Spread_syntax +translation_of_original: Web/JavaScript/Reference/Operators/Spread_operator +--- +
{{jsSidebar("Operators")}}
+ +

Оператор розпакування дозволяє розкласти колекцію в місця, де потрібні нуль чи декілька аргументів (як от виклики функцій), або декілька елементів (масиви), чи декілька змінних (деструктуризаційне присвоєння). Також можна розкласти об’єкт у місця де потрібні нуль чи більше пар ключ-значення (для оголошення об’єктів).

+ +

Синтаксис

+ +

Для виклику функцій:

+ +
myFunction(...iterableObj);
+
+ +

Для масивів:

+ +
[...iterableObj, 4, 5, 6];
+ +

Для об’єктів (нове в ECMAScript; чернетка в 3-ій стадії):

+ +
let objClone = { ...obj };
+ +

Приклади

+ +

Розпакування у викликах функції

+ +

Заміна apply

+ +

Приклад: {{jsxref( "Function.prototype.apply")}} прийнято використовувати у випадках, коли потрібно застосувати елементи масиву як аргументи функції.

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction.apply(null, args);
+ +

З розпакуванням тепер отак:

+ +
function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction(...args);
+ +

Оператор розпакування може бути застосований до будь-якого аргументу та може бути застосований кілька разів.

+ +
function myFunction(v, w, x, y, z) { }
+var args = [0, 1];
+myFunction(-1, ...args, 2, ...[3]);
+ +

Apply для new

+ +

Викликаючи конструктор з new, неможливо напряму використовувати на ньому apply (apply робить [[Call]], а не [[Construct]]). Проте з оператором розпакування можна легко розкладати масив у аргументи конструктора:

+ +
var dateFields = [1970, 0, 1]; // 1 Січ 1970
+// var d = new Date.apply(dateFields) не спрацює. Викине TypeError
+var d = new Date(...dateFields); // вуаля
+ +

Розпакування в масивах

+ +

Ліпше оголошення масивів

+ +

Без розпакування, коли потрібно створити новий масив так, щоб якийсь існуючий був його частиною, старого синтаксису оголошення масиву не достатньо та необхідно використовувати комбінацію методів push, splice, concat, тощо. З оператором розпакування це стає значно лаконічніше:

+ +
var parts = ['shoulders', 'knees'];
+var lyrics = ['head', ...parts, 'and', 'toes'];
+// ["head", "shoulders", "knees", "and", "toes"]
+ +

Як і з розпакуванням списку аргументів, ... можна використовувати будь-де в оголошенні масиву та будь-яку кількість разів.

+ +

Копіювання масиву

+ +
var arr = [1, 2, 3];
+var arr2 = [...arr]; // так само як arr.slice()
+arr2.push(4);
+
+// arr2 стає [1, 2, 3, 4]
+// arr залишається незміненим
+ +

Зауваження: оператор розпакування при копіюванні масиву йде лише на один рівень вглиб. Таким чином він не придатний для копіювання багатовимірних масивів, що видно з наступного прикладу (те саме з {{jsxref("Object.assign()")}} та розпакуванням об’єктів).

+ +
var a = [[1], [2], [3]];
+var b = [...a];
+b.shift().shift(); // 1
+// Тепер масив a також змінено: [[], [2], [3]]
+ +

Ліпше злиття масивів

+ +

{{jsxref("Array.concat")}} часто використовується, щоб додати один масив у кінець іншого. Без розпакування це робиться так:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Доддати всі елементи з arr2 в arr1
+arr1 = arr1.concat(arr2);
+ +

З розпакуванням це стає:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr1, ...arr2];
+ +

{{jsxref("Array.unshift")}} часто використовується для того, щоб вставити значення з одного масиву в початок іншого. Без розпакування це робиться так:

+ +
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]
+ +

З розпакуванням це стає:

+ +
var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr2, ...arr1]; // arr1 тепер [3, 4, 5, 0, 1, 2]
+ +

Розпакування об’єктів

+ +

Пропозиція Rest/Spread Properties for ECMAScript (стадія 3) додає розпакування до об’єктів. It copies own enumerable properties from a provided object onto a new object.

+ +

Однорівневе клонування (без прототипу) чи злиття об’єктів тепер можливе використовуючи коротший запис ніж {{jsxref("Object.assign()")}}.

+ +
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 }
+ +

Зауваж, що {{jsxref("Object.assign()")}} викликає сетери, а оператор розпакування - ні.

+ +

Лише для ітерованих

+ +

Розпакування може бути застосоване лише для ітерованик об’єктів:

+ +
var obj = {'key1': 'value1'};
+var array = [...obj]; // TypeError: obj is not iterable
+ +

Зауваження: наразі (липень 2017) можна говорити про появу розпакування об’єктів у специфікації (дивись попередній підзаголовок). Але ще не до кінця зрозуміло як працюватиме вищенаведений приклад, адже ще немає конкретного рішення щодо цього у спецефікації. Тобто тепер ти можеш розпакувати об’єкт в об’єкт, але не зрозуміло, що станеться, якщо об’єкт розпаковувати у масив і навпаки, масив у об’єкт. Наприклад транспілятор babel вертає наступні результати:

+ +
var obj = {'key1': 'value1'};
+var array = [...obj]; // запише в array пустий масив []
+
+var arr = [1,1,1];
+var obj1 = {...arr}; // запише в obj1 {'0': 1, '1': 1, '2': 1}
+ +

Розпакування великих колекцій

+ +

Використовуючи розпакування зважай на можливість досягнення ліміту аргументів, встановленого у JavaScript рушії, адже оператор розпакування витягує всі елементи колекції в стек, скільки б їх не було. Дивись apply() щоб дізнатись більше.

+ +

Оператор решти

+ +

Оператор решти виглядає точно так само як і оператор розпакування. До певної міри, він протилежний оператору розпакування - оператор розпакування розкладає колекцію на елементи, а оператор решти, натомість, складає кілька елементів у колекцію. Дивись решта параметрів.

+ +

Специфікація

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтанКоментар
{{SpecName('ES2015', '#sec-array-initializer')}}{{Spec2('ES2015')}}Визначено в деяких секціях специфікацій: Array Initializer, Argument Lists
{{SpecName('ESDraft', '#sec-array-initializer')}}{{Spec2('ESDraft')}}Без змін.
Rest/Spread Properties for ECMAScriptЧернеткаЧернетка в 3 стадії
+ +

Сумісність з браузерами

+ +

{{CompatibilityTable}}

+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari (WebKit)
Spread operation in array literals{{CompatChrome("46")}}{{ CompatGeckoDesktop("16") }}{{CompatIE("Edge/10240")}}{{CompatNo}}7.1
Spread operation in function calls{{CompatChrome("46")}}{{ CompatGeckoDesktop("27") }}{{CompatIE("Edge/10240")}}{{CompatNo}}7.1
Spread operation in destructuring{{CompatChrome("49")}}{{ CompatGeckoDesktop("34") }}{{CompatNo}}{{CompatUnknown}}{{CompatUnknown}}
+
+ +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
FeatureAndroidAndroid WebviewFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Spread operation in array literals{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("16") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Spread operation in function calls{{CompatNo}}{{CompatChrome("46")}}{{ CompatGeckoMobile("27") }}{{CompatNo}}{{CompatNo}}8{{CompatChrome("46")}}
Spread operation in destructuring{{CompatNo}}{{CompatNo}}{{ CompatGeckoDesktop("34") }}{{CompatUnknown}}{{CompatUnknown}}{{CompatUnknown}}{{CompatNo}}
+
+ +

See also

+ + diff --git a/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html b/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html new file mode 100644 index 0000000000..6c056272a1 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators_1cd48548c16282df3883f99267726c3e/index.html @@ -0,0 +1,419 @@ +--- +title: Оператори присвоєння +slug: Web/JavaScript/Reference/Operators/Оператори_присвоєння +tags: + - JavaScript + - Оператор +translation_of: Web/JavaScript/Reference/Operators#Assignment_operators +translation_of_original: Web/JavaScript/Reference/Operators/Assignment_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Оператор присвоєння присвоює своєму лівому операнду значення, на підставі значення правого операнду.

+ +

{{EmbedInteractiveExample("pages/js/expressions-assignment.html")}}

+ + + +

Огляд

+ +

Базовим оператором присвоєння є оператор дорівнює (=), який присвоює значення свого правого операнда лівому операнду. Таким чином, x = y присвоює змінній x значення змінної y. Інші оператори присвоєння у своїй більшості є скороченнями для стандарних операцій, як це вказано у наступній таблиці з визначеннями та прикладами.

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
НазваОператор скороченого записуЗначення
Присвоєнняx = yx = y
Присвоєння з додаваннямx += yx = x + y
Присвоєння з відніманнямx -= yx = x - y
Присвоєння з множеннямx *= yx = x * y
Присвоєння з діленнямx /= yx = x / y
Присвоєння остачіx %= yx = x % y
Присвоєння з піднесенням до степеняx **= yx = x ** y
Присвоєння з лівим зсувомx <<= yx = x << y
Присвоєння з правим зсувомx >>= yx = x >> y
Присвоєння з беззнаковим правим зсувомx >>>= yx = x >>> y
Присвоєння з побітовим Іx &= yx = x & y
Присвоєння з виключним побітовим АБОx ^= yx = x ^ y
Присвоєння з побітовим АБОx |= yx = x | y
+ +

Присвоєння

+ +

Простий оператор присвоєння використовується для присвоєння змінній значення. Оператор присвоєння обчислює значення, що присвоюється. Можна використовувати ланцюжок присвоюваннь, щоб присвоїти одне значення декільком змінним. Дивіться приклад нижче.

+ +

Синтаксис

+ +
Оператор: x = y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  x = 5
+//  y = 10
+//  z = 25
+
+x = y     // x дорівнює 10
+x = y = z // x, y та z усі дорівнюють 25
+
+ +

Присвоєння з додаванням

+ +

Оператор присвоєння з додаванням додає значення правого операнду до змінної (лівого перанду) та записує у неї отриманий результат. Типи двох операндів визначають поведінку оператора. Таким чином, його результатом може стати або додавання або конкатенація. Для більш детального огляду дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор додавання", "#Addition", 1)}}.

+ +

Синтаксис

+ +
Оператор:  x += y
+Значення:  x  = x + y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  foo = 'foo'
+//  bar = 5
+//  baz = true
+
+
+// число + число -> додавання
+bar += 2 // 7
+
+// булеве значення + число -> додавання
+baz += 1 // 2
+
+// булеве значення + булеве значення -> додавання
+baz += false // 1
+
+// число + рядок -> конкатенація
+bar += 'foo' // "5foo"
+
+// рядок + булеве значення -> конкатенація
+foo += false // "foofalse"
+
+// рядок + рядок -> конкатенація
+foo += 'bar' // "foobar"
+
+ +

Присвоєння з відніманням

+ +

Оператор присвоєння з відніманням віднімає значення правого операнду від змінної (лівого перанду) та записує у неї отриманий результат. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор віднімання", "#Subtraction", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x -= y
+Значення:  x  = x - y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  bar = 5
+
+bar -= 2     // 3
+bar -= 'foo' // NaN
+
+ +

Присвоєння з множенням

+ +

Оператор присвоєння з множенням помножує змінну (лівий операнд) на значення правого операнду та записує отриманий результат у змінну. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор множення", "#Multiplication", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x *= y
+Значення:  x  = x * y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  bar = 5
+
+bar *= 2     // 10
+bar *= 'foo' // NaN
+
+ +

Присвоєння з діленням

+ +

Оператор присвоєння з діленням ділить змінну (лівий операнд) на значення правого операнду та записує отриманий результат у змінну. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор ділення", "#Division", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x /= y
+Значення:  x  = x / y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  bar = 5
+
+bar /= 2     // 2.5
+bar /= 'foo' // NaN
+bar /= 0     // Infinity
+
+ +

Присвоєння остачі

+ +

Оператор присвоєння остачі ділить змінну на значення правого операнду та присвоює остачу змінній. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор остачі", "#Remainder", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x %= y
+Значення:  x  = x % y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  bar = 5
+
+bar %= 2     // 1
+bar %= 'foo' // NaN
+bar %= 0     // NaN
+
+ +

Присвоєння з піднесенням до степеня

+ +

Оператор присвоєння з піднесенням до степеня обчислює результат піднесення першого операнду до показника степеня другого операнду. Дивіться {{jsxref("Operators/Arithmetic_Operators", "оператор піднесення до степеня", "#Exponentiation", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x **= y
+Значення:  x  = x ** y
+
+ +

Приклади

+ +
// Розглянемо такі змінні:
+//  bar = 5
+
+bar **= 2     // 25
+bar **= 'foo' // NaN
+ +

Присвоєння з лівим зсувом

+ +

Оператор присвоєння з лівим зсувом виконує зсув першого операнду на вказану кількість бітів ліворуч та присвоює результат у змінну. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор лівого зсуву", "#Left_shift", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x <<= y
+Значення:  x   = x << y
+
+ +

Приклади

+ +
var bar = 5; //  (00000000000000000000000000000101)
+bar <<= 2; // 20 (00000000000000000000000000010100)
+
+ +

Присвоєння з правим зсувом

+ +

Оператор присвоєння з правим зсувом виконує зсув першого операнду на вказану кількість бітів праворуч та присвоює результат у змінну. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор правого зсуву", "#Right_shift", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x >>= y
+Значення:  x   = x >> y
+
+ +

Приклади

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>= 2;   // 1 (00000000000000000000000000000001)
+
+var bar -5; //    (-00000000000000000000000000000101)
+bar >>= 2;  // -2 (-00000000000000000000000000000010)
+
+ +

Присвоєння з беззнаковим правим зсувом

+ +

Оператор присвоєння з беззнаковим правим зсувом виконує зсув першого операнду на вказану кількість бітів праворуч та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", " оператор беззнакового правого зсуву", "#Unsigned_right_shift", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x >>>= y
+Значення:  x    = x >>> y
+
+ +

Приклади

+ +
var bar = 5; //   (00000000000000000000000000000101)
+bar >>>= 2;  // 1 (00000000000000000000000000000001)
+
+var bar = -5; // (-00000000000000000000000000000101)
+bar >>>= 2; // 1073741822 (00111111111111111111111111111110)
+ +

Присвоєння з побітовим І

+ +

Оператор присвоєння з побітовим І використовує двійкове представлення обох операндів, виконує над ними операцію побітового І та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор побітового І", "#Bitwise_AND", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x &= y
+Значення:  x  = x & y
+
+ +

Приклади

+ +
var bar = 5;
+// 5:     00000000000000000000000000000101
+// 2:     00000000000000000000000000000010
+bar &= 2; // 0
+
+ +

Присвоєння з виключним побітовим АБО

+ +

Оператор присвоєння з виключним побітовим АБО використовує двійкове представлення обох операндів, виконує над ними операцію виключного побітового АБО (XOR) та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор виключного побітового АБО", "#Bitwise_XOR", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x ^= y
+Значення:  x  = x ^ y
+
+ +

Приклади

+ +
var bar = 5;
+bar ^= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Присвоєння з побітовим АБО

+ +

Оператор присвоєння з побітовим АБО використовує двійкове представлення обох операндів, виконує над ними операцію побітового АБО та присвоює результат змінній. Дивіться {{jsxref("Operators/Bitwise_Operators", "оператор побітового АБО", "#Bitwise_OR", 1)}} для більш детального огляду.

+ +

Синтаксис

+ +
Оператор:  x |= y
+Значення:  x  = x | y
+
+ +

Приклади

+ +
var bar = 5;
+bar |= 2; // 7
+// 5: 00000000000000000000000000000101
+// 2: 00000000000000000000000000000010
+// -----------------------------------
+// 7: 00000000000000000000000000000111
+
+ +

Приклади

+ +

Лівий операнд з іншим оператором присвоєння

+ +

У незвичних ситуаціях оператор присвоєння (наприклад,  x += y) не є ідентичним виразу, який він означає (в даному випадку x = x + y). Коли лівий операнд оператора присвоєння сам містить оператор присвоєння, лівий операнд обчислюється лише один раз. Наприклад:

+ +
a[i++] += 5         // i обчислюється лише один раз
+a[i++] = a[i++] + 5 // i обчислюється двічі
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ESDraft', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ESDraft')}}
{{SpecName('ES2015', '#sec-assignment-operators', 'Assignment operators')}}{{Spec2('ES2015')}}
{{SpecName('ES5.1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES5.1')}}
{{SpecName('ES1', '#sec-11.13', 'Assignment operators')}}{{Spec2('ES1')}}Початкове визначення.
+ +

Сумісність з веб-переглядачами

+ + + +

{{Compat("javascript.operators.assignment")}}

+ +
+ +

Див. також

+ + diff --git a/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html b/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html new file mode 100644 index 0000000000..3107d5aa64 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators_7c8eb9475d97a4a734c5991857698560/index.html @@ -0,0 +1,560 @@ +--- +title: Бітові оператори +slug: Web/JavaScript/Reference/Operators/Bitwise_Operators +tags: + - JavaScript + - Довідка + - Оператор +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Bitwise_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Бітові оператори опрацьовують свої операнди як послідовність 32-х бітів (нулів та одиниць), а не як десяткові, шістнадцяткові чи вісімкові числа. Наприклад, десяткове число дев'ять має бітове представлення 1001. Бітові оператори виконують операції над цими бітовими представленнями, але повертають стандартні числові значення JavaScript.

+ +
{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}
+ + + +

Наступна таблиця наводить перелік бітових операторів JavaScript:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
ОператорЗастосуванняОпис
Побітове І (AND)a & bПовертає 1 на кожній позиції, де відповідні біти обох операндів дорівнюють 1.
Побітове АБО (OR)a | bПовертає 1 на кожній позиції, де відповідні біти одного чи обох операндів дорівнюють 1.
Виключне побітове АБО (XOR)a ^ bПовертає 1 на кожній позиції, де відповідний біт одного з двох, але не обох, операндів дорівнює 1.
Побітове НЕ (NOT)~ aВиконує інверсію бітів операнду.
Лівий зсувa << bЗсуває a у двійковому представленні на b (< 32) бітів ліворуч, заповнюючи позиції справа нулями.
Правий зсув з розширенням знакуa >> bЗсуває a у двійковому представленні на b (< 32) бітів праворуч, відкидаючи зсунуті біти.
Правий зсув із заповненням нулямиa >>> b  Зсуває a у двійковому представленні на b (< 32) бітів праворуч, відкидаючи зсунуті біти та заповнюючи позиції зліва нулями.
+ +

32-бітні цілі числа зі знаком

+ +

Операнди усіх бітових операторів перетворюються на 32-бітні цілі числа зі знаком у форматі доповняльного коду, окрім оператора правого зсуву із заповненням нулями, який повертає беззнакове ціле 32-бітне число. Формат доповняльного коду означає, що від'ємний еквівалент числа (наприклад, 5 та -5) - це інвертовані біти числа (побітове НЕ, або обернений код числа) плюс один. Для прикладу, наступний код представляє ціле число 314:

+ +
00000000000000000000000100111010
+
+ +

Наступний код представляє ~314, тобто, обернений код числа 314:

+ +
11111111111111111111111011000101
+
+ +

Нарешті, наступний код представляє доповняльний код числа -314:

+ +
11111111111111111111111011000110
+
+ +

Доповняльний код гарантує, що лівий біт дорівнює 0, коли число є додатним, і 1, коли число є від'ємним. Тому він відомий як знаковий біт.

+ +

Число 0 є цілим числом, усі біти якого дорівнюють 0.

+ +
0 (основа 10) = 00000000000000000000000000000000 (основа 2)
+
+ +

Число -1 є цілим числом, усі біти якого дорівнюють 1.

+ +
-1 (основа 10) = 11111111111111111111111111111111 (основа 2)
+
+ +

Число -2147483648 (шістнадцяткове представлення: -0x80000000) є цілим числом, усі біти якого дорівнюють 0, окрім першого (старшого) біта.

+ +
-2147483648 (основа 10) = 10000000000000000000000000000000 (основа 2)
+
+ +

Число 2147483647 (шістнадцяткове представлення: 0x7fffffff) є цілим числом, усі біти якого дорівнюють 1, окрім першого (старшого) біта.

+ +
2147483647 (основа 10) = 01111111111111111111111111111111 (основа 2)
+
+ +

Числа -2147483648 та 2147483647 є мінімальним та максимальним цілими числами, які можуть бути представлені 32-бітним знаковим числом.

+ +

Побітові логічні оператори

+ +

Концептуально побітові логічні оператори працюють наступним чином:

+ + + +

& (Побітове І)

+ +

Виконує операцію І (AND) над кожною парою бітів. a І b дає 1 тільки якщо обидва, a та b, дорівнюють 1. Таблиця істинності для операції І наступна:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba AND b
000
010
100
111
+ +
.    9 (основа 10) = 00000000000000000000000000001001 (основа 2)
+    14 (основа 10) = 00000000000000000000000000001110 (основа 2)
+                   --------------------------------
+14 & 9 (основа 10) = 00000000000000000000000000001000 (основа 2) = 8 (основа 10)
+
+ +

Побітове І над будь-яким числом x та 0 дає 0.

+ +

| (Побітове АБО)

+ +

Виконує операцію АБО (OR) над кожною парою бітів. a АБО b дає 1, якщо або a, або b дорівнює 1. Таблиця істинності для операції АБО наступна:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba OR b
000
011
101
111
+ +
.    9 (основа 10) = 00000000000000000000000000001001 (основа 2)
+    14 (основа 10) = 00000000000000000000000000001110 (основа 2)
+                   --------------------------------
+14 | 9 (основа 10) = 00000000000000000000000000001111 (основа 2) = 15 (основа 10)
+
+ +

Побітове АБО над будь-яким числом x та 0 дає x.

+ +

^ (Виключне побітове АБО)

+ +

Виконує операцію виключного АБО (XOR) над кожною парою бітів. a викл. АБО b дає 1, якщо a та b є різними. Таблиця істинності для операції XOR наступна:

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
aba XOR b
000
011
101
110
+ +
.    9 (основа 10) = 00000000000000000000000000001001 (основа 2)
+    14 (основа 10) = 00000000000000000000000000001110 (основа 2)
+                   --------------------------------
+14 ^ 9 (основа 10) = 00000000000000000000000000000111 (основа 2) = 7 (основа 10)
+
+ +

Виключне побітове АБО над будь-яким числом x та 0 дає x.

+ +

~ (Побітове НЕ)

+ +

Виконує операцію НЕ над кожним бітом. НЕ a повертає інвертоване значення (або обернений код) операнду a. Таблиця істинності для операції НЕ наступна:

+ + + + + + + + + + + + + + + + +
aNOT a
01
10
+ +
 9 (основа 10) = 00000000000000000000000000001001 (основа 2)
+               --------------------------------
+~9 (основа 10) = 11111111111111111111111111110110 (основа 2) = -10 (основа 10)
+
+ +

Побітове НЕ над будь-яким числом x дає -(x + 1). Наприклад, ~-5 дорівнює 4.

+ +

Зауважте, що через використання 32-бітного представлення чисел і ~-1, і ~4294967295 (232-1) повернуть 0.

+ +

Оператори бітового зсуву

+ +

Оператори бітового зсуву приймають два операнди: перший є величиною, в якій треба виконати зсув, а другий вказує кількість бітових позицій для зсуву. Напрямок операції зсуву контролюється застосованим оператором.

+ +

Оператори зсуву перетворюють свої операнди на 32-бітні цілі числа у порядку від старшого до молодшого байту та повертають результат того самого типу, до якого належить лівий операнд. Лише молодші п'ять бітів правого операнду будуть використані.

+ +

<< (Лівий зсув)

+ +

Цей оператор виконує зсув першого операнду на вказану кількість бітів ліворуч. Надлишкові біти, зсунуті ліворуч, відкидаються. Біти, додані справа, заповнюються нулями.

+ +

Наприклад, 9 << 2 дорівнює 36:

+ +
.    9 (основа 10): 00000000000000000000000000001001 (основа 2)
+                  --------------------------------
+9 << 2 (основа 10): 00000000000000000000000000100100 (основа 2) = 36 (основа 10)
+
+ +

Бітовий зсув будь-якого числа x ліворуч на y бітів дорівнює x * 2 ** y.
+ Отже, для прикладу: 9 << 3 можна перекласти як: 9 * (2 ** 3) = 9 * (8) = 72.

+ +

>> (Правий зсув з розширенням знаку)

+ +

Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються значенням старшого біта. Оскільки новий старший біт матиме те саме значення, що й попередній старший біт, знаковий (старший) біт не змінюється. Звідси назва "з розширенням знаку".

+ +

Наприклад, 9 >> 2 дорівнює 2:

+ +
.    9 (основа 10): 00000000000000000000000000001001 (основа 2)
+                  --------------------------------
+9 >> 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
+
+ +

Аналогічно, -9 >> 2 дорівнює -3, оскільки знак зберігається:

+ +
.    -9 (основа 10): 11111111111111111111111111110111 (основа 2)
+                   --------------------------------
+-9 >> 2 (основа 10): 11111111111111111111111111111101 (основа 2) = -3 (основа 10)
+
+ +

>>> (Правий зсув із заповненням нулями)

+ +

Цей оператор виконує зсув першого операнду на вказану кількість бітів праворуч. Надлишкові біти, зсунуті праворуч, відкидаються. Біти, додані зліва, заповнюються нулями. Знаковий біт отримує значення 0, а отже, результат завжди невід'ємний. На відміну від інших бітових операторів, правий зсув із заповненням нулями повертає беззнакове ціле 32-бітне число.

+ +

Для невід'ємних чисел, правий зсув із заповненням нулями та правий зсув з розширенням знаку дають однаковий результат. Наприклад, 9 >>> 2 дорівнює 2, так само, як 9 >> 2:

+ +
.     9 (основа 10): 00000000000000000000000000001001 (основа 2)
+                   --------------------------------
+9 >>> 2 (основа 10): 00000000000000000000000000000010 (основа 2) = 2 (основа 10)
+
+ +

Однак, це не одне й те саме для від'ємних чисел. Наприклад, -9 >>> 2 поверне 1073741821, що відрізняється від -9 >> 2 (що дорівнює -3):

+ +
.     -9 (основа 10): 11111111111111111111111111110111 (основа 2)
+                    --------------------------------
+-9 >>> 2 (основа 10): 00111111111111111111111111111101 (основа 2) = 1073741821 (основа 10)
+
+ +

Приклади

+ +

Прапори та бітові маски

+ +

Побітові логічні оператори часто використовуються для створення, маніпулювання та читання послідовностей прапорів, які грають роль двійкових змінних. Замість цих послідовностей можуть використовуватись зміні, але двійкові прапори займають набагато менше пам'яті (у 32 рази).

+ +

Припустимо, є 4 прапори:

+ + + +

Ці прапори представлені послідовністю бітів: DCBA. Коли прапор встановлений, він має значення 1. Коли прапор очищений, він має значення 0. Припустимо, змінна flags має двійкове значення 0101:

+ +
var flags = 5;   // двійкове значення 0101
+
+ +

Це значення вказує:

+ + + +

Оскільки бітові операнди 32-бітні, 0101 насправді дорівнює 00000000000000000000000000000101, але нулями попереду можна знехтувати, оскільки вони не містять корисної інформації.

+ +

Бітова маска - це послідовність бітів, які можуть маніпулювати прапорами та/або читати їх. Зазвичай, визначається "примітивна" бітова маска для кожного прапора:

+ +
var FLAG_A = 1; // 0001
+var FLAG_B = 2; // 0010
+var FLAG_C = 4; // 0100
+var FLAG_D = 8; // 1000
+
+ +

Нові бітові маски можуть створюватись застовуванням побітових логічних операторів до цих примітивних бітових масок. Наприклад, бітова маска 1011 може бути створена операцією АБО з прапорів FLAG_A, FLAG_B та FLAG_D:

+ +
var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 => 1011
+
+ +

Індивідуальні значення прапорів можна витягнути застосуванням операції І до них та бітової маски, де кожний біт, що має значення один, "витягне" відповідний прапор. Бітова маска маскує невідповідні прапори, об'єднуючи їх операцією І з нулями (звідси термін "бітова маска"). Наприклад, бітову маску 0100 можна використати, щоб побачити, чи встановлений прапор C:

+ +
// якщо ми маємо кота
+if (flags & FLAG_C) { // 0101 & 0100 => 0100 => true
+   // зробити щось
+}
+
+ +

Бітова маска з кількома встановленими прапорами діє як "або/або". Для прикладу, наступні два фрагменти еквівалентні:

+ +
// якщо ми маємо кажана або ми маємо кота
+// (0101 & 0010) || (0101 & 0100) => 0000 || 0100 => true
+if ((flags & FLAG_B) || (flags & FLAG_C)) {
+   // зробити щось
+}
+
+ +
// якщо ми маємо кажана або кота
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 => 0110
+if (flags & mask) { // 0101 & 0110 => 0100 => true
+   // зробити щось
+}
+
+ +

Прапори можна встановити, об'єднавши їх операцією АБО з бітовою маскою, де кожний біт, що має значення один, встановить відповідний прапор, якщо прапор ще не встановлений. Наприклад, бітову маску 1100 можна використати, щоб встановити прапори C та D:

+ +
// так, ми маємо кота та качку
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 => 1100
+flags |= mask;   // 0101 | 1100 => 1101
+
+ +

Прапори можна очистити, об'єднавши їх операцією І з бітовою маскою, де кожний біт, що має значення нуль, очистить відповідний прапор, якщо він ще не очищений. Ця бітова маска може бути створена застосуванням операції НЕ до примітивних бітових масок. Наприклад, бітову маску 1010 можна використати, щоб очистити прапори A та C:

+ +
// ні, ми не маємо проблеми з мурахами або кота
+var mask = ~(FLAG_A | FLAG_C); // ~0101 => 1010
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

Маску також можна створити за допомогою ~FLAG_A & ~FLAG_C (правило де Моргана):

+ +
// ні, ми не маємо проблеми з мурахами і ми не маємо кота
+var mask = ~FLAG_A & ~FLAG_C;
+flags &= mask;   // 1101 & 1010 => 1000
+
+ +

Прапори можна перемикати, об'єднуючи їх операцією виключне АБО з бітовою маскою, де кожний біт, що має значення один, переключить відповідний прапор. Наприклад, бітову маску 0110 можна використати, щоб переключити прапори B та C:

+ +
// якщо ми не мали кажана, тепер ми його маємо,
+// а якщо він в нас був, бувай, кажанчику
+// те саме для котів
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 => 1010
+
+ +

Нарешті, усі прапори можна перевернути оператором НЕ:

+ +
// входимо у паралельний всесвіт...
+flags = ~flags;    // ~1010 => 0101
+
+ +

Перетворення типів

+ +

Перетворити двійковий рядок на десяткове число:

+ +
var sBinString = '1011';
+var nMyNumber = parseInt(sBinString, 2);
+alert(nMyNumber); // виводить 11, тобто 1011
+
+ +

Перетворити десяткове число на двійковий рядок:

+ +
var nMyNumber = 11;
+var sBinString = nMyNumber.toString(2);
+alert(sBinString); // виводить 1011, тобто 11
+
+ +

Автоматизація створення маски

+ +

Ви можете створювати маски з набору булевих значень наступним чином:

+ +
function createMask() {
+  var nMask = 0, nFlag = 0, nLen = arguments.length > 32 ? 32 : arguments.length;
+  for (nFlag; nFlag < nLen; nMask |= arguments[nFlag] << nFlag++);
+  return nMask;
+}
+var mask1 = createMask(true, true, false, true); // 11, тобто: 1011
+var mask2 = createMask(false, false, true); // 4, тобто: 0100
+var mask3 = createMask(true); // 1, тобто: 0001
+// і т.д.
+
+alert(mask1); // виводить 11, тобто: 1011
+
+ +

Зворотний алгоритм: отримання масиву булевих значень з маски

+ +

Якщо ви бажаєте створити масив булевих значень з маски, можете скористатись цим кодом:

+ +
function arrayFromMask(nMask) {
+  // Значенння nMask має бути між -2147483648 та 2147483647
+  if (nMask > 0x7fffffff || nMask < -0x80000000) {
+    throw new TypeError('arrayFromMask - out of range');
+  }
+  for (var nShifted = nMask, aFromMask = []; nShifted;
+       aFromMask.push(Boolean(nShifted & 1)), nShifted >>>= 1);
+  return aFromMask;
+}
+
+var array1 = arrayFromMask(11);
+var array2 = arrayFromMask(4);
+var array3 = arrayFromMask(1);
+
+alert('[' + array1.join(', ') + ']');
+// виводить "[true, true, false, true]", тобто: 11, тобто: 1011
+
+ +

Ви можете перевірити обидва алгоритми одночасно…

+ +
var nTest = 19; // наша користувацька маска
+var nResult = createMask.apply(this, arrayFromMask(nTest));
+
+alert(nResult); // 19
+
+ +

Суто з навчальною метою (оскільки існує метод Number.toString(2)) ми показуємо, як можна модифікувати алгоритм arrayFromMask для створення рядка, що містить двійкове представлення числа, а не масиву булевих значень:

+ +
function createBinaryString(nMask) {
+  // Значення nMask має бути між -2147483648 та 2147483647
+  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag < 32;
+       nFlag++, sMask += String(nShifted >>> 31), nShifted <<= 1);
+  return sMask;
+}
+
+var string1 = createBinaryString(11);
+var string2 = createBinaryString(4);
+var string3 = createBinaryString(1);
+
+alert(string1);
+// виводить 00000000000000000000000000001011, тобто 11
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-11.7')}}{{Spec2('ES5.1')}}Визначені у кількох розділах специфікації: Побітовий оператор НЕ, Бітові оператори зсуву, Двійкові побітові оператори
{{SpecName('ES6', '#sec-bitwise-shift-operators')}}{{Spec2('ES6')}}Визначені у кількох розділах специфікації: Побітовий оператор НЕ, Бітові оператори зсуву, Двійкові побітові оператори
{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}{{Spec2('ESDraft')}}Визначені у кількох розділах специфікації: Побітовий оператор НЕ, Бітові оператори зсуву, Двійкові побітові оператори
+ +

Сумісність з веб-переглядачами

+ + + +

{{Compat("javascript.operators.bitwise")}}

+ +

Див. також

+ + diff --git a/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html b/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html new file mode 100644 index 0000000000..9285c5dd5a --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators_a8aa9ce42ce1749862961c61113d120b/index.html @@ -0,0 +1,245 @@ +--- +title: Оператори порівняння +slug: Web/JavaScript/Reference/Operators/Оператори_порівняння +tags: + - JavaScript + - Довідка + - Оператор +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Comparison_Operators +--- +
{{jsSidebar("Operators")}}
+ +

JavaScript має як строге порівняння, так і порівняння з перетворенням типів. Строге порівняння (===) є істинним лише в тому випадку, якщо операнди мають однаковий тип, а їхній зміст співпадає. Найчастіше вживане абстрактне порівняння (==) приводить операнди до спільного типу перед виконанням порівняння. Для абстрактних порівнянь (наприклад, <=) операнди спочатку приводяться до простих типів, потім приводяться до спільного типу, а вже тоді порівнюються.

+ +

Рядки порівнюються на основі стандартного лексикографічного упорядкування, використовуючи значення Unicode.

+ +

{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}

+ + + +

Особливості порівнянь:

+ + + +

Оператори рівності

+ +

Рівність (==)

+ +

Оператор рівності перетворює операнди, якщо вони не однакового типу, і після цього застосовує строге порівняння. Якщо обидва операнди є об'єктами, JavaScript порівнює внутрішні посилання, які є рівними, якщо операнди посилаються на один і той самий об'єкт у пам'яті.

+ +

Синтаксис

+ +
x == y
+
+ +

Приклади

+ +
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
+
+ +

Нерівність (!=)

+ +

Оператор нерівності повертає true,  якщо операнди не є рівними. Якщо два операнда не належать до одного типу, JavaScript намагається привести операнди до відповідного типу для порівняння. Якщо обидва операнда є об'єктами, JavaScript порівнює внутрішні посилання, які є нерівними, якщо операнди посилаються на різні об'єкти у пам'яті.

+ +

Синтаксис

+ +
x != y
+ +

Приклади

+ +
1 !=   2     // true
+1 !=  '1'    // false
+1 !=  "1"    // false
+1 !=  true   // false
+0 !=  false  // false
+
+ +

Ідентичність / строга рівність (===)

+ +

Оператор ідентичності повертає true, якщо операнди строго рівні (див. вище) без приведення типів. 

+ +

Синтаксис

+ +
x === y
+ +

Приклади

+ +
3 === 3   // true
+3 === '3' // false
+var object1 = {'key': 'value'}, object2 = {'key': 'value'};
+object1 === object2 //false
+ +

Неідентичність / строга нерівність (!==)

+ +

Оператор неідентичності повертає true, якщо операнди не є рівними та/або не однакового типу.

+ +

Синтаксис

+ +
x !== y
+ +

Приклади

+ +
3 !== '3' // true
+4 !== 3   // true
+
+ +

Оператори відношення

+ +

Кожен з цих операторів буде примусово приведений до простої величини перед порівнянням. Якщо обидва перетворюються на рядки, вони порівнюються з використанням лексикографічного порядку, інакше вони будуть перетворені на числа для порівняння. Порівняння із NaN завжди поверне false.

+ +

Більше ніж (>)

+ +

Оператор більше ніж повертає true, якщо значення лівого операнда більше за значення правого операнда.

+ +

Синтаксис

+ +
x > y
+ +

Приклади

+ +
4 > 3 // true
+
+ +

Більше чи дорівнює (>=)

+ +

Оператор більше чи дорівнює повертає true, якщо значення лівого операнда більше, або дорівнює значенню правого операнда.

+ +

Синтаксис

+ +
 x >= y
+ +

Приклади

+ +
4 >= 3 // true
+3 >= 3 // true
+
+ +

Менше ніж (<)

+ +

Оператор менше ніж повертає true, якщо значення лівого операнда менше значення правого операнда.

+ +

Синтаксис

+ +
 x < y
+ +

Приклади

+ +
3 < 4 // true
+
+ +

Менше чи дорівнює (<=)

+ +

Оператор менше чи дорівнює повертає true, якщо значення лівого операнда менше або дорівнює значенню правого операнда.

+ +

Синтаксис

+ +
 x <= y
+ +

Приклади

+ +
3 <= 4 // true
+
+ +

Застосування операторів порівняння

+ +

Стандартні оператори рівності (== та !=) використовують алгоритм абстрактної рівності для порівняння двох операндів. Якщо операнди належать до різних типів, алгоритм спробує привести їх до спільного типу перед порівнянням; наприклад, у виразі 5 == '5', рядок праворуч буде приведений до {{jsxref("Число","числа")}} перед здійсненням порівняння.

+ +

Оператори строгої рівності (=== та !==) використовують алгоритм строгої рівності та призначені для виконання перевірки рівності операндів одного типу. Якщо операнди належать до різних типів, результат завжди буде false, тому 5 !== '5'.

+ +

Використовуйте оператори строгого порівняння, якщо операнди мають належати до вказаного типу, як і їх значення, або, якщо конкретний тип операндів має значення. Інакше, використовуйте стандартні оператори рівності, які дозволяють перевіряти ідентичність двох операндів, навіть якщо вони не належать до одного типу.

+ +

Коли в порівнянні застосовується перетворення типів (тобто, це не строге порівняння), JavaScript перетворює типи операндів {{jsxref ("String")}}, {{jsxref ("Число","Number")}}, {{jsxref ("Boolean" )}} або {{jsxref ("Object")}} наступним чином:

+ + + +
Заувага: Рядкові об'єкти є об'єктами типу Object, а не String! Об'єкти типу String використовуються рідко, а отже, наведені нижче результати можуть бути несподіваними:
+ +
// 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'
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення. Реалізовано у JavaScript 1.0
{{SpecName('ES3')}}{{Spec2('ES3')}}Додані оператори === та !== . Реалізовано у JavaScript 1.3
{{SpecName('ES5.1', '#sec-11.8')}}{{Spec2('ES5.1')}}Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності
{{SpecName('ES6', '#sec-relational-operators')}}{{Spec2('ES6')}}Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності
{{SpecName('ESDraft', '#sec-relational-operators')}}{{Spec2('ESDraft')}}Дано визначення у декільках секціях специфікації: Оператори відношення, Оператори рівності
+ +

Підтримка веб-переглядачами

+ + + +

{{Compat("javascript.operators.comparison")}}

+ +

Див. також

+ + diff --git a/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html b/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html new file mode 100644 index 0000000000..ea1edb506a --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/operators_f71733c8e7001a29c3ec40d8522a4aca/index.html @@ -0,0 +1,253 @@ +--- +title: Логічні оператори +slug: Web/JavaScript/Reference/Operators/Logical_Operators +tags: + - JavaScript + - Оператор + - логічний +translation_of: Web/JavaScript/Reference/Operators +translation_of_original: Web/JavaScript/Reference/Operators/Logical_Operators +--- +
{{jsSidebar("Operators")}}
+ +

Логічні оператори зазвичай застосовуються до {{jsxref("Boolean", "булевих")}} (логічних) значень. В цьому випадку вони повертають значення типу Boolean. Однак, оператори && та || насправді повертають значення одного з заданих операндів, тому, якщо ці оператори використовуються зі значеннями не булевого типу, вони повернуть значення не булевого типу.

+ +
{{EmbedInteractiveExample("pages/js/expressions-logicaloperator.html")}}
+ + + +

Опис

+ +

Логічні оператори описані у наведеній нижче таблиці (вирази expr можуть належати до будь-якого типу, не лише булевого):

+ + + + + + + + + + + + + + + + + + + + + + + + +
ОператорСинтаксисОпис
Логічне І (&&)expr1 && expr2Якщо вираз expr1 може бути приведений до true, вертає expr2; інакше, вертає expr1.
Логічне АБО (||)expr1 || expr2Якщо вираз expr1 може бути приведений до true, вертає expr1; інакше, вертає expr2.
Логічне НЕ (!)!exprВертає false, якщо його єдиний операнд може бути приведений до true; інакше, вертає true.
+ +

Якщо значення може бути приведене до true, то воно називається {{Glossary("truthy","правдивим")}}. Якщо значення може бути приведене до false, воно називається {{Glossary("falsy","хибним")}}.

+ +

Приклади виразів, які можуть бути приведені до false:

+ + + +

Хоча оператори && та || можуть використовуватись з операндами не булевого (логічного) типу, вони все одно можуть вважатися логічними операторами, оскільки значення, які вони повертають, завжди можуть бути приведені до булевих примітивів. Щоб явно перетворити повернені значення (або, взагалі, будь-який вираз) до відповідного булевого значення, скористайтесь подвійним оператором НЕ або конструктором Boolean.

+ +

Коротке замикання обчислення

+ +

Оскільки логічні вирази обчислюються зліва направо, вони перевіряються на можливе "коротке замикання" обчислення за наступними правилами:

+ + + +

Коротке замикання означає, що наведені вирази expr не обчислюються, тому будь-які побічні ефекти від цього не відбудуться (наприклад, якщо expr є викликом функції, виклик не відбувається). Це відбувається тому, що значення оператора вже визначене після обчислення першого операнду. Дивіться приклад:

+ +
function A(){ console.log('викликано A'); return false; }
+function B(){ console.log('викликано B'); return true; }
+
+console.log( A() && B() );
+// виводить "викликано A" в результаті виклику функції,
+// потім виводить false (що є результатом виклику оператора)
+
+console.log( B() || A() );
+// виводить "викликано B" в результаті виклику функції,
+// потім виводить true (що є результатом виклику оператора)
+
+ +

Пріоритет операторів

+ +

Наступні вирази можуть виглядати еквівалентними, але це не так, оскільки оператор && виконується перед оператором || (дивіться Пріоритет операторів).

+ +
true || false && false      // вертає true, оскільки && виконується першим
+(true || false) && false    // вертає false, оскільки не можна застосувати пріоритет операторів
+ +

Логічне І (&&)

+ +

Наступний код наводить приклади оператора && (логічне І).

+ +
a1 = true  && true       // t && t вертає true
+a2 = true  && false      // t && f вертає false
+a3 = false && true       // f && t вертає false
+a4 = false && (3 == 4)   // f && f вертає false
+a5 = 'Кіт' && 'Пес'      // t && t вертає "Пес"
+a6 = false && 'Кіт'      // f && t вертає false
+a7 = 'Кіт' && false      // t && f вертає false
+a8 = ''    && false      // f && f вертає ""
+a9 = false && ''         // f && f вертає false
+
+ +

Логічне АБО (||)

+ +

Наступний код наводить приклади оператора || (логічне АБО).

+ +
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
+
+ +
+

Заувага: Якщо ви використовуєте цей оператор для присвоєння значення за замовчуванням якійсь змінній, пам'ятайте, що будь-яке хибне значення не буде використане. Якщо вам потрібно лише відфільтрувати {{jsxref("null")}} або {{jsxref("undefined")}}, розгляньте оператор null-об'єднання (однак, станом на листопад 2019 ця функціональність ще не була широко реалізована і має вважатися експериментальною, оскільки знаходиться на Стадії 3).

+
+ +

Логічне НЕ (!)

+ +

Наступний код демонструє приклади оператора ! (логічне НЕ).

+ +
n1 = !true               // !t вертає false
+n2 = !false              // !f вертає true
+n3 = !''                 // !f вертає true
+n4 = !'Cat'              // !t вертає false
+
+ +

Подвійне НЕ (!!)

+ +

Можна використовувати пару операторів НЕ поспіль, щоб явно викликати перетворення будь-якої величини на відповідний булевий примітив. Перетворення базується на "правдивості" або "хибності" значення (дивіться {{Glossary("truthy")}} та {{Glossary("falsy")}}).

+ +

Таке саме перетворення можна виконати функцією {{jsxref("Boolean")}}.

+ +
n1 = !!true                   // !!truthy вертає true
+n2 = !!{}                     // !!truthy вертає true: будь-який об'єкт є правдивим...
+n3 = !!(new Boolean(false))   // ...навіть об'єкти Boolean з false .valueOf()!
+n4 = !!false                  // !!falsy вертає false
+n5 = !!""                     // !!falsy вертає false
+n6 = !!Boolean(false)         // !!falsy вертає false
+
+ +

Правила перетворення для булевих значень

+ +

Перетворення І на АБО

+ +

Наступна операція з булевими значеннями:

+ +
умова1 && умова2
+ +

завжди дорівнює:

+ +
!(!умова1 || !умова2)
+ +

Перетворення АБО на І

+ +

Наступна операція з булевими значеннями:

+ +
умова1 || умова2
+ +

завжди дорівнює:

+ +
!(!умова1 && !умова2)
+ +

Перетворення НЕ

+ +

Наступна операція з булевими значеннями:

+ +
!!умова
+ +

завжди дорівнює:

+ +
умова
+ +

Прибирання вкладених дужок

+ +

Оскільки логічні вирази обчислюються зліва направо, завжди можна прибрати дужки зі складного виразу, дотримуючись деяких правил.

+ +

Прибирання вкладеного І

+ +

Наступна складена операція з булевими значеннями:

+ +
умова1 || (умова2 && умова3)
+ +

завжди дорівнює:

+ +
умова1 || умова2 && умова3
+ +

Прибирання вкладеного АБО

+ +

Наступна складена операція з булевими значеннями:

+ +
умова1 && (умова2 || умова3)
+ +

завжди дорівнює:

+ +
!(!умова1 || !умова2 && !умова3)
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES1')}}{{Spec2('ES1')}}Початкове визначення.
{{SpecName('ES5.1', '#sec-11.11')}}{{Spec2('ES5.1')}}Визначені у кількох розділах специфікації: Логічний оператор НЕ, Бінарні логічні оператори
{{SpecName('ES6', '#sec-binary-logical-operators')}}{{Spec2('ES6')}}Визначені у кількох розділах специфікації: Логічний оператор НЕ, Бінарні логічні оператори
{{SpecName('ESDraft', '#sec-binary-logical-operators')}}{{Spec2('ESDraft')}}Визначені у кількох розділах специфікації: Логічний оператор НЕ, Бінарні логічні оператори
+ +

Сумісність з веб-переглядачами

+ + + +

{{Compat("javascript.operators.logical")}}

+ +

Див. також

+ + diff --git a/files/uk/conflicting/web/javascript/reference/statements/switch/index.html b/files/uk/conflicting/web/javascript/reference/statements/switch/index.html new file mode 100644 index 0000000000..c766150f22 --- /dev/null +++ b/files/uk/conflicting/web/javascript/reference/statements/switch/index.html @@ -0,0 +1,118 @@ +--- +title: default +slug: Web/JavaScript/Reference/Statements/default +translation_of: Web/JavaScript/Reference/Statements/switch +translation_of_original: Web/JavaScript/Reference/Statements/default +--- +
{{jsSidebar("Statements")}}
+ +

Ключове слово default може використовуватись у двох ситуаціях у JavaScript: у конструкції {{jsxref("Statements/switch", "switch")}} або з оператором {{jsxref("Statements/export", "export")}}.

+ +
{{EmbedInteractiveExample("pages/js/statement-default.html")}}
+ + + +

Синтаксис

+ +

У конструкції {{jsxref("Statements/switch", "switch")}}:

+ +
switch (expression) {
+  case value1:
+    //Інструкції, що виконуються, коли значення expression дорівнює value1
+    [break;]
+  default:
+    //Інструкції, що виконуються, коли жодне значення не дорівнює значенню expression
+    [break;]
+}
+ +

З оператором {{jsxref("Statements/export", "export")}}:

+ +
export default nameN
+ +

Опис

+ +

Більш детально дивіться на сторінках

+ + + +

Приклади

+ +

Використання default у конструкціях switch

+ +

У наступному прикладі, якщо expr оцінюється як "Апельсини" або "Яблука", програма зайде або у блок case "Апельсини", або у "Яблука" та виконає відповідну інструкцію. Ключове слово default допоможе у будь-якому іншому випадку та виконає пов'язану інструкцію.

+ +
switch (expr) {
+  case 'Апельсини':
+    console.log('Апельсини коштують $0.59 за кілограм.');
+    break;
+  case 'Яблука':
+    console.log('Яблука коштують $0.32 за кілограм.');
+    break;
+  default:
+    console.log('На жаль, в нас закінчились ' + expr + '.');
+}
+ +

Використання default з export

+ +

Якщо ви хочете експортувати єдине значення, або вам потрібне запасне значення модуля, можна використати default у export:

+ +
// module "my-module.js"
+let cube = function cube(x) {
+  return x * x * x;
+};
+export default cube;
+ +

Тоді у іншому скрипті буде прямий імпорт експорту за замовчуванням:

+ +
// 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
+
+ +

Специфікації

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
СпецифікаціяСтатусКоментар
{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}{{Spec2('ES6')}}
{{SpecName('ES6', '#sec-exports', 'Exports')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}{{Spec2('ESDraft')}}
{{SpecName('ESDraft', '#sec-exports', 'Exports')}}{{Spec2('ESDraft')}}
+ +

Сумісність з веб-переглядачами

+ + + +

{{Compat("javascript.statements.default")}}

+ +

Див. також

+ + -- cgit v1.2.3-54-g00ecf