JavaScript
Operadores Unarios

Sintaxis

• expresión vacía // Evalúa la expresión y descarta el valor de retorno
• + expresión; // Intenta convertir la expresión a un número
• eliminar object.property; // Eliminar propiedad del objeto
• eliminar objeto ["propiedad"]; // Eliminar propiedad del objeto
• typeof operando; // Devuelve el tipo de operando
• ~ expresión; // Realizar la operación NOT en cada bit de expresión
• !expresión; // Realizar negación lógica en expresión
• -expresión; // Negar expresión después de intentar la conversión a número

El operador unario plus (+)

El plus unario ( + ) precede a su operando y evalúa a su operando. Intenta convertir el operando en un número, si no lo está ya.

Sintaxis:

+expression

Devoluciones:

• un Number .

Descripción

El operador unario plus ( + ) es el método más rápido (y preferido) de convertir algo en un número.

Se puede convertir:

• Representaciones de cadenas de enteros (decimal o hexadecimal) y flotantes.
• booleanos: true , false .
• null

Los valores que no se pueden convertir se evaluarán en NaN .

Ejemplos:

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

Tenga en cuenta que intentar convertir una matriz puede generar valores de retorno inesperados.
En el fondo, las matrices se convierten primero a sus representaciones de cadena:

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

El operador intenta convertir esas cadenas en números:

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

El operador de borrado

El delete operador elimina una propiedad de un objeto.

Sintaxis:

delete object.property

delete object['property']

Devoluciones:

Si la eliminación es exitosa, o la propiedad no existe:

• true

Si la propiedad a eliminar es una propiedad no configurable propia (no se puede eliminar):

• false en modo no estricto.
• Lanza un error en modo estricto.

Descripción

El operador de delete no libera directamente la memoria. Puede liberar memoria de forma indirecta si la operación significa que todas las referencias a la propiedad han desaparecido.

delete trabajos en las propiedades de un objeto. Si existe una propiedad con el mismo nombre en la cadena del prototipo del objeto, la propiedad se heredará del prototipo.
delete no funciona en variables o nombres de funciones.

Ejemplos:

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

El operador de typeof

El operador typeof devuelve el tipo de datos del operando no evaluado como una cadena.

Sintaxis:

typeof operand

Devoluciones:

Estos son los valores de retorno posibles de typeof :

El comportamiento inusual de document.all con el operador typeof es de su uso anterior para detectar navegadores heredados. Para obtener más información, consulte ¿Por qué se define document.all pero typeof document.all devuelve "undefined"?

Ejemplos:

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

El operador del vacío.

El operador void evalúa la expresión dada y luego devuelve undefined .

Sintaxis:

void expression

Devoluciones:

• undefined

Descripción

El operador void se utiliza a menudo para obtener el valor primitivo undefined , mediante la escritura de void 0 o void(0) . Tenga en cuenta que void es un operador, no una función, por lo que () no es necesario.

Por lo general, el resultado de una expresión void y undefined se pueden usar indistintamente.
Sin embargo, en versiones anteriores de ECMAScript, a window.undefined podría asignar cualquier valor, y aún es posible usar undefined como nombre para las variables de parámetros de función dentro de las funciones, interrumpiendo así otro código que se basa en el valor de undefined .
Sin embargo, void siempre producirá el verdadero valor undefined .

void 0 también se usa comúnmente en la reducción de códigos como una forma más corta de escribir undefined . Además, es probable que sea más seguro ya que algún otro código podría haber manipulado window.undefined .

Ejemplos:

Volviendo undefined :

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

Cambiando el valor de undefined dentro de un cierto alcance:

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

El operador unario de negación (-)

La negación unaria ( - ) precede a su operando y la niega, después de intentar convertirla en número.

Sintaxis:

-expression

Devoluciones:

• un Number .

Descripción

La negación unaria ( - ) puede convertir los mismos tipos / valores que el operador unario más ( + ).

Los valores que no se pueden convertir se evaluarán en NaN (no hay -NaN ).

Ejemplos:

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

Tenga en cuenta que intentar convertir una matriz puede generar valores de retorno inesperados.
En el fondo, las matrices se convierten primero a sus representaciones de cadena:

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

El operador intenta convertir esas cadenas en números:

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

El operador NO bit a bit (~)

El bit a bit NO ( ~ ) realiza una operación NOT en cada bit en un valor.

Sintaxis:

~expression

Devoluciones:

• un Number .

Descripción

La tabla de verdad para la operación NO es:

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

Un bitwise no en un número resulta en: -(x + 1) .

Ejemplos:

El operador lógico NO (!)

El operador lógico NOT ( ! ) Realiza una negación lógica en una expresión.

Sintaxis:

!expression

Devoluciones:

• un Boolean .

Descripción

El operador lógico NOT ( ! ) Realiza una negación lógica en una expresión.

Los valores booleanos simplemente se invierten !true === false y !false === true .
Los valores no booleanos se convierten primero en valores booleanos, luego se niegan.

Esto significa que se puede usar un NOT lógico doble ( !! ) para emitir cualquier valor a un booleano:

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

Todos estos son iguales a !true :

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

Todos estos son iguales a !false :

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

Ejemplos:

!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

Visión general

Los operadores únicos son operadores con un solo operando. Los operadores únicos son más eficientes que las llamadas de función de JavaScript estándar. Además, los operadores unarios no pueden ser anulados y, por lo tanto, su funcionalidad está garantizada.

Los siguientes operadores unarios están disponibles: