JavaScript
Unary Operators

Syntax

• ogiltigt uttryck; // Utvärderar uttryck och kastar returvärde
• + Uttryck; // Försök att konvertera uttrycket till ett nummer
• ta bort object.property; // Radera objektets egendom
• radera objekt ["egenskap"]; // Radera objektets egendom
• typof operand; // Returnerar typ av operand
• ~ Expression; // Utför INTE operation på varje uttrycksbit
• !uttryck; // Utför logisk negation vid uttryck
• -uttryck; // Negera uttrycket efter att ha försökt konvertering till nummer

Unary plus-operatören (+)

Unary plus ( + ) föregår sin operand och utvärderar till sin operand. Den försöker konvertera operand till ett nummer, om den inte redan är det.

Syntax:

+expression

Returns:

• ett Number .

Beskrivning

Unary plus ( + ) -operatören är den snabbaste (och föredragna) metoden att konvertera något till ett nummer.

Det kan konvertera:

• strängrepresentation av heltal (decimal eller hexadecimal) och flyter.
• booleans: true , false .
• null

Värden som inte kan konverteras utvärderas till NaN .

Exempel:

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

Observera att försök att konvertera en matris kan resultera i oväntade värden på retur.
I bakgrunden konverteras matriser först till sina strängrepresentationer:

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

Operatören försöker sedan konvertera dessa strängar till siffror:

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

Radera operatören

delete raderar en egenskap från ett objekt.

Syntax:

delete object.property

delete object['property']

Returns:

Om borttagningen är framgångsrik eller om fastigheten inte fanns:

• true

Om den egendom som ska raderas är en egen icke-konfigurerbar egenskap (kan inte raderas):

• false i icke-strikt läge.
• Kasta ett fel i strikt läge

Beskrivning

delete frigör inte direkt minnet. Det kan indirekt frigöra minne om operationen innebär att alla referenser till egenskapen är borta.

delete verk på ett objekts egenskaper. Om en egenskap med samma namn finns i objektets prototypkedja, kommer den att ärvas från prototypen.
delete fungerar inte på variabler eller funktionsnamn.

Exempel:

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

Typ av operatör

typeof operatören returnerar typeof för den ovärderade operanden som en sträng.

Syntax:

typeof operand

Returns:

Dessa är de möjliga typeof från typeof :

document.all ovanliga beteende med typeof operatören är från dess tidigare användning för att upptäcka gamla webbläsare. Mer information finns i Varför definieras document.all men typ av document.all returnerar "odefinierat"?

Exempel:

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

Den ogiltiga operatören

Den void operatören utvärderar det givna uttrycket och returnerar sedan undefined .

Syntax:

void expression

Returns:

• undefined

Beskrivning

void används ofta för att erhålla det undefined primitiva värdet, genom att skriva void 0 eller void(0) . Observera att void är en operatör, inte en funktion, så () krävs inte.

Vanligtvis kan resultatet av ett void uttryck och undefined användas omväxlande.
I äldre versioner av ECMAScript kan window.undefined emellertid tilldelas valfritt värde, och det är fortfarande möjligt att använda undefined som namn för funktionsparametrarvariabler inuti funktioner, och därmed störa annan kod som förlitar sig på undefined värde.
void kommer dock alltid att ge det verkliga undefined värdet.

void 0 används också ofta vid kodminifiering som ett kortare sätt att skriva undefined . Dessutom är det förmodligen säkrare eftersom någon annan kod kunde ha manipulerat med window.undefined .

Exempel:

Återvända undefined :

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

Ändra värdet av undefined inom ett visst omfång:

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

Operatören för unary negation (-)

Den unary negationen ( - ) föregår sin operand och negerar den, efter att ha försökt konvertera den till nummer.

Syntax:

-expression

Returns:

• ett Number .

Beskrivning

Unary negation ( - ) kan konvertera samma typer / värden som operatören unary plus ( + ) kan.

Värden som inte kan konverteras utvärderas till NaN (det finns inget -NaN ).

Exempel:

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

Observera att försök att konvertera en matris kan resultera i oväntade värden på retur.
I bakgrunden konverteras matriser först till sina strängrepresentationer:

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

Operatören försöker sedan konvertera dessa strängar till siffror:

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

Operatören för bitvis INTE (~)

Den bitvisa INTE ( ~ ) utför en INTE-operation på varje bit i ett värde.

Syntax:

~expression

Returns:

• ett Number .

Beskrivning

Sanningstabellen för INTE-operationen är:

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

Litevis inte på ett tal resulterar i: -(x + 1) .

Exempel:

Den logiska INTE operatören (!)

Den logiska INTE ( ! ) Operatören utför logisk negation på ett uttryck.

Syntax:

!expression

Returns:

• en Boolean .

Beskrivning

Den logiska INTE ( ! ) Operatören utför logisk negation på ett uttryck.

Booleska värden blir helt enkelt inverterade !true === false och !false === true .
Icke-booleska värden konverteras först till booleska värden och negeras sedan.

Detta innebär att en dubbel logisk INTE ( !! ) kan användas för att kasta valfritt värde till en booleska:

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

Dessa är alla lika med !true :

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

Dessa är alla lika !false :

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

Exempel:

!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

Översikt

Unary-operatörer är operatörer med endast en operand. Unary-operatörer är mer effektiva än vanliga JavaScript-funktionssamtal. Dessutom kan unary operatörer inte åsidosättas och därför garanteras deras funktionalitet.

Följande unary operatörer är tillgängliga: