JavaScript
Унарные операторы

Синтаксис

• void выражение; // Вычисляет выражение и отбрасывает возвращаемое значение
• + Выражение; // Попытка преобразования выражения в число
• delete object.property; // Удалить свойство объекта
• delete object ["property"]; // Удалить свойство объекта
• тип операнда; // Возвращает тип операнда
• ~ Выражение; // Выполнять НЕ операцию на каждом бите выражения
• ! Выражение; // Выполните логическое отрицание выражения
• -expression; // Отрицать выражение после попытки преобразования в число

Унарный оператор плюс (+)

Унарный плюс ( + ) предшествует его операнду и оценивает его операнд. Он пытается преобразовать операнд в число, если оно еще не было.

Синтаксис:

+expression

Возвращает:

• Number .

Описание

Унарный плюс ( + ) оператор является самым быстрым (и предпочтительным) способом преобразования чего-либо в число.

Он может конвертировать:

• строковые представления целых чисел (десятичные или шестнадцатеричные) и поплавки.
• booleans: true , false .
• null

Значения, которые не могут быть преобразованы, будут оцениваться до NaN .

Примеры:

+42           // 42
+"42"         // 42
+true         // 1
+false        // 0
+null         // 0
+undefined    // NaN
+NaN          // NaN
+"foo"        // NaN
+{}           // NaN
+function(){} // NaN

Обратите внимание, что попытка преобразования массива может привести к неожиданным значениям возврата.
В фоновом режиме массивы сначала преобразуются в их строковые представления:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

Затем оператор пытается преобразовать эти строки в числа:

+[]           // 0   ( === +'' )
+[1]          // 1   ( === +'1' )
+[1, 2]       // NaN ( === +'1,2' )

Оператор удаления

Оператор delete удаляет свойство из объекта.

Синтаксис:

delete object.property

delete object['property']

Возвращает:

Если удаление выполнено успешно или свойство не существует:

• true

Если свойство, подлежащее удалению, является собственным неконфигурируемым свойством (его нельзя удалить):

• false в нестрогом режиме.
• Выдает ошибку в строгом режиме

Описание

Оператор delete напрямую не освобождает память. Он может косвенно освобождать память, если операция означает, что все ссылки на свойство исчезли.

delete работы над свойствами объекта. Если свойство с тем же именем существует в цепочке прототипов объекта, свойство будет унаследовано от прототипа.
delete не работает с именами переменных или функций.

Примеры:

// Deleting a property
foo = 1;              // a global variable is a property of `window`: `window.foo`
delete foo;           // true
console.log(foo);     // Uncaught ReferenceError: foo is not defined

// Deleting a variable
var foo = 1;
delete foo;           // false
console.log(foo);     // 1 (Not deleted)

// Deleting a function
function foo(){ };
delete foo;           // false
console.log(foo);     // function foo(){ } (Not deleted)

// Deleting a property
var foo = { bar: "42" };
delete foo.bar;       // true
console.log(foo);     // Object { } (Deleted bar)

// Deleting a property that does not exist
var foo = { };
delete foo.bar;       // true
console.log(foo);     // Object { } (No errors, nothing deleted)

// Deleting a non-configurable property of a predefined object
delete Math.PI;       // false  ()
console.log(Math.PI); // 3.141592653589793 (Not deleted)

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

Оператор typeof возвращает тип данных неопубликованного операнда в виде строки.

Синтаксис:

typeof operand

Возвращает:

Это возможные возвращаемые значения из typeof :

Необычное поведение document.all с оператором typeof связано с его прежним использованием для обнаружения старых браузеров. Дополнительные сведения см. В разделе Почему document.all определен, но typeof document.all возвращает «undefined»?

Примеры:

// returns 'number'
typeof 3.14;
typeof Infinity;
typeof NaN;               // "Not-a-Number" is a "number"

// returns 'string'
typeof "";
typeof "bla";
typeof (typeof 1);        // typeof always returns a string

// returns 'boolean'
typeof true;
typeof false;

// returns 'undefined'
typeof undefined;
typeof declaredButUndefinedVariable;
typeof undeclaredVariable;
typeof void 0;
typeof document.all       // see above

// returns 'function'
typeof function(){};
typeof class C {};
typeof Math.sin;

// returns 'object'
typeof { /*<...>*/ };
typeof null;
typeof /regex/;           // This is also considered an object
typeof [1, 2, 4];         // use Array.isArray or Object.prototype.toString.call.
typeof new Date();
typeof new RegExp();
typeof new Boolean(true); // Don't use!
typeof new Number(1);     // Don't use!
typeof new String("abc"); // Don't use!

// returns 'symbol'
typeof Symbol();
typeof Symbol.iterator;

Оператор пустоты

Оператор void вычисляет данное выражение и затем возвращает undefined .

Синтаксис:

void expression

Возвращает:

• undefined

Описание

Оператор void часто используется для получения undefined примитивного значения посредством записи void 0 или void(0) . Обратите внимание, что void является оператором, а не функцией, поэтому () не требуется.

Обычно результат выражения void и undefined может использоваться взаимозаменяемо.
Однако в более старых версиях ECMAScript window.undefined может быть назначено любое значение, и по-прежнему можно использовать undefined как имя для переменных параметров функций внутри функций, что нарушает другой код, который полагается на значение undefined .
void всегда будет давать истинное undefined значение.

void 0 также обычно используется в кодировании кода как более короткий способ написания undefined . Кроме того, это, вероятно, более безопасно, так как некоторые другие коды могут быть window.undefined с помощью window.undefined .

Примеры:

Возврат undefined :

function foo(){
    return void 0;
}
console.log(foo()); // undefined

Изменение значения undefined внутри определенной области:

(function(undefined){
    var str = 'foo';
    console.log(str === undefined); // true
})('foo');

Унарный оператор отрицания (-)

Унарное отрицание ( - ) предшествует его операнду и отрицает его, пытаясь преобразовать его в число.

Синтаксис:

-expression

Возвращает:

• Number .

Описание

Унарное отрицание ( - ) может преобразовывать те же типы / значения, что и оператор унарного плюса ( + ).

Значения, которые не могут быть преобразованы, будут оцениваться до NaN (нет -NaN ).

Примеры:

-42           // -42
-"42"         // -42
-true         // -1
-false        // -0
-null         // -0
-undefined    // NaN
-NaN          // NaN
-"foo"        // NaN
-{}           // NaN
-function(){} // NaN

Обратите внимание, что попытка преобразования массива может привести к неожиданным значениям возврата.
В фоновом режиме массивы сначала преобразуются в их строковые представления:

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

Затем оператор пытается преобразовать эти строки в числа:

-[]           // -0  ( === -'' )
-[1]          // -1  ( === -'1' )
-[1, 2]       // NaN ( === -'1,2' )

Побитовый оператор NOT (~)

Побитовое NOT ( ~ ) выполняет операцию NOT для каждого бита в значении.

Синтаксис:

~expression

Возвращает:

• Number .

Описание

Таблица истинности операции NOT:

1337  (base 10) = 0000010100111001 (base 2)
~1337 (base 10) = 1111101011000110 (base 2) = -1338 (base 10)

Побитовое число не приводит к: -(x + 1) .

Примеры:

Логический оператор NOT (!)

Логический NOT ( ! ) Оператор выполняет логическое отрицание выражения.

Синтаксис:

!expression

Возвращает:

• Boolean .

Описание

Логический NOT ( ! ) Оператор выполняет логическое отрицание выражения.

Булевы значения просто инвертируются !true === false и !false === true .
Небулевые значения сначала преобразуются в булевские значения, а затем отрицаются.

Это означает, что двойное логическое NOT ( !! ) может использоваться для приведения любого значения в boolean:

!!"FooBar" === true
!!1 === true
!!0 === false

Все они равны !true :

!'true' === !new Boolean('true');
!'false' === !new Boolean('false');
!'FooBar' === !new Boolean('FooBar');
![] === !new Boolean([]);
!{} === !new Boolean({});

Все они равны !false :

!0 === !new Boolean(0);
!'' === !new Boolean('');
!NaN === !new Boolean(NaN);
!null === !new Boolean(null);
!undefined === !new Boolean(undefined);

Примеры:

!true         // false
!-1           // false
!"-1"         // false
!42           // false
!"42"         // false
!"foo"        // false
!"true"       // false
!"false"      // false
!{}           // false
![]           // false
!function(){} // false

!false        // true
!null         // true
!undefined    // true
!NaN          // true
!0            // true
!""           // true

обзор

Унарные операторы - это операторы с одним операндом. Унарные операторы более эффективны, чем стандартные вызовы функций JavaScript. Кроме того, унарные операторы не могут быть переопределены, и поэтому их функциональность гарантирована.

Доступны следующие унарные операторы: