JavaScript
Unary Operators

Składnia

• nieważne wyrażenie; // Ocenia wyrażenie i odrzuca zwracaną wartość
• + wyrażenie; // Próba konwersji wyrażenia na liczbę
• usuń object.property; // Usuń właściwość obiektu
• usuń obiekt [„właściwość”]; // Usuń właściwość obiektu
• operand typu; // Zwraca typ operandu
• ~ wyrażenie; // Wykonaj operację NIE dla każdego bitu wyrażenia
• !wyrażenie; // Wykonaj logiczną negację wyrażenia
• -wyrażenie; // Neguj wyrażenie po próbie konwersji na liczbę

Jednoargumentowy operator plus (+)

Jednoargumentowy plus ( + ) poprzedza swój operand i ocenia na operand. Próbuje przekonwertować operand na liczbę, jeśli jeszcze nie jest.

Składnia:

+expression

Zwroty:

• Number .

Opis

Jednoargumentowy operator plus ( + ) jest najszybszą (i preferowaną) metodą konwersji czegoś na liczbę.

Może konwertować:

• ciąg znaków reprezentujący liczby całkowite (dziesiętne lub szesnastkowe) i zmiennoprzecinkowe.
• booleany: true , false .
• null

Wartości, których nie można przekonwertować, zostaną przeliczone na NaN .

Przykłady:

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

Pamiętaj, że próba konwersji tablicy może spowodować nieoczekiwane zwracane wartości.
W tle tablice są najpierw konwertowane na ich reprezentacje łańcuchowe:

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

Operator następnie próbuje przekonwertować te ciągi na liczby:

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

Operator usuwania

delete operator usuwa właściwość z obiektu.

Składnia:

delete object.property

delete object['property']

Zwroty:

Jeśli usunięcie się powiedzie lub właściwość nie istnieje:

• true

Jeśli właściwość do usunięcia jest własną właściwością nieskonfigurowalną (nie można jej usunąć):

• false w trybie innym niż ścisły.
• Zgłasza błąd w trybie ścisłym

Opis

Operator delete nie zwalnia bezpośrednio pamięci. Może pośrednio zwolnić pamięć, jeśli operacja oznacza, że zniknęły wszystkie odwołania do właściwości.

delete działa na właściwościach obiektu. Jeśli właściwość o tej samej nazwie istnieje w łańcuchu prototypów obiektu, właściwość zostanie odziedziczona z prototypu.
delete nie działa na nazwach zmiennych i funkcji.

Przykłady:

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

Operator typeof

Operator typeof zwraca typ danych nieocenionego operandu jako ciąg.

Składnia:

typeof operand

Zwroty:

Oto możliwe wartości zwracane z typeof :

Nietypowe zachowanie document.all z operatorem typeof wynika z jego wcześniejszego użycia do wykrywania starszych przeglądarek. Aby uzyskać więcej informacji, zobacz Dlaczego zdefiniowano document.all, ale typeof document.all zwraca „undefined”?

Przykłady:

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

Operator pustki

Operator void ocenia podane wyrażenie, a następnie zwraca undefined .

Składnia:

void expression

Zwroty:

• undefined

Opis

Operator void jest często używany do uzyskania undefined wartości pierwotnej, poprzez zapisanie void 0 lub void(0) . Zauważ, że void jest operatorem, a nie funkcją, więc () nie jest wymagane.

Zwykle wynik wyrażenia void i undefined można stosować zamiennie.
Jednak w starszych wersjach ECMAScript do window.undefined można przypisać dowolną wartość, a nadal można użyć undefined nazwy dla zmiennych parametrów funkcji wewnątrz funkcji, zakłócając w ten sposób inny kod, który opiera się na wartości undefined .
void zawsze da jednak prawdziwą undefined wartość.

void 0 jest również powszechnie używany w minimalizacji kodu jako krótszy sposób pisania undefined . Ponadto jest to prawdopodobnie bezpieczniejsze, ponieważ jakiś inny kod mógł sfałszować funkcję window.undefined .

Przykłady:

Zwrot undefined :

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

Zmiana wartości undefined w pewnym zakresie:

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

Jednoargumentowy operator negacji (-)

Jednoczesna negacja ( - ) poprzedza operand i neguje go, po próbie przekształcenia go w liczbę.

Składnia:

-expression

Zwroty:

• Number .

Opis

Jednoargumentowa negacja ( - ) może konwertować te same typy / wartości, co jednoargumentowy operator plus ( + ).

Wartości, których nie można przekonwertować, zostaną obliczone na NaN (nie ma -NaN ).

Przykłady:

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

Pamiętaj, że próba konwersji tablicy może spowodować nieoczekiwane zwracane wartości.
W tle tablice są najpierw konwertowane na ich reprezentacje łańcuchowe:

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

Operator następnie próbuje przekonwertować te ciągi na liczby:

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

Bitowy operator NOT (~)

Bitowe NOT ( ~ ) wykonuje operację NOT na każdym bicie w wartości.

Składnia:

~expression

Zwroty:

• Number .

Opis

Tabela prawdy dla operacji NOT to:

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

Bitowe nie na liczbie powoduje: -(x + 1) .

Przykłady:

Logiczny operator NOT (!)

Operator logiczny NOT ( ! ) Wykonuje logiczną negację wyrażenia.

Składnia:

!expression

Zwroty:

• Boolean .

Opis

Operator logiczny NOT ( ! ) Wykonuje logiczną negację wyrażenia.

Wartości boolowskie są po prostu odwracane !true === false i !false === true .
Wartości inne niż logiczne są najpierw konwertowane na wartości logiczne, a następnie są negowane.

Oznacza to, że podwójnego logicznego NOT ( !! ) można użyć do wyrzucenia dowolnej wartości na wartość logiczną:

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

Wszystkie są równe !true :

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

Wszystkie są równe !false :

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

Przykłady:

!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

Przegląd

Jednostkowe operatory to operatory z tylko jednym operandem. Jednostopniowi operatorzy są bardziej wydajni niż standardowe wywołania funkcji JavaScript. Ponadto nie można zastąpić jednoargumentowych operatorów, dlatego ich funkcjonalność jest gwarantowana.

Dostępne są następujące jednoargumentowe operatory: