Operadores unarios ECMAScript

Los operadores unarios tienen un solo parámetro, es decir, el objeto o el valor que se debe operar. Son los operadores más simples en ECMAScript.

delete

El operador delete elimina la referencia a las propiedades o métodos de objetos definidos anteriormente. Por ejemplo:

var o = new Object;
o.name = "David";
alert(o.name); // salida "David"
eliminar o.name;
alert(o.name);	// Sale "undefined"

En este ejemplo, se eliminó la propiedad name, lo que significa que se canceló la referencia a la misma, configurándola como undefined (es decir, el valor de una variable no inicializada).

El operador delete no puede eliminar propiedades y métodos no definidos por el desarrollador. Por ejemplo, el siguiente código generará un error:

delete o.toString;

Incluso si toString es un nombre de método válido, esta línea de código generará un error porque toString() es un método original de ECMAScript y no uno definido por el desarrollador.

void

El operador void devuelve undefined para cualquier valor. Este operador se utiliza generalmente para evitar la salida de valores no deseados, por ejemplo, al llamar a una función JavaScript desde un elemento <a> de HTML. Para hacerlo correctamente, la función no debe retornar un valor válido, de lo contrario, el navegador borrará la página y solo mostrará el resultado de la función. Por ejemplo:

<a href="javascript:window.open('about:blank')">Haz clic aquí</a>

Si pones esta línea de código en una página HTML, al hacer clic en el enlace, verás que se muestra "[object]" en la pantalla.TIY

Esto se debe a que el método window.open() devuelve una referencia a la ventana recién abierta. Luego, ese objeto se convierte en la cadena que se mostrará.

Para evitar este efecto, puedes llamar a la función window.open() con el operador void:

<a href="javascript:void(window.open('about:blank'))">Haz clic aquí</a>

Esto hace que la llamada window.open() retorne undefined, que no es un valor válido y no se mostrará en la ventana del navegador.

Consejo:Recuerda, las funciones que realmente retornan algo sin valor de retorno son undefined.

Operadores de增量/decremento en prefijo

Los dos operadores que se prestan directamente de C (y Java) son el operador de增量 en prefijo y el operador de decremento en prefijo.

El operador de增量 en prefijo es agregar 1 al valor, con la forma de dos signos más antes de la variable (++):

var iNum = 10;
++iNum;

La segunda línea de código aumenta iNum a 11, lo que es equivalente a:

var iNum = 10;
iNum = iNum + 1;

Del mismo modo, el operador de decremento en prefijo restará 1 al valor, con la forma de dos guiones bajos antes de la variable (--):

var iNum = 10;
--iNum;

En este ejemplo, la segunda línea de código reduce el valor de iNum a 9.

Al usar operadores de prefijo, ten en cuenta que las operaciones de增量 y decremento ocurren antes de la evaluación de la expresión. Considera el siguiente ejemplo:

var iNum = 10;
--iNum;
alert(iNum);	//输出 "9"
alert(--iNum);	//输出 "8"
alert(iNum);	//输出 "8"

第二行代码对 iNum 进行减量运算，第三行代码显示的结果是（"9"）。第四行代码又对 iNum 进行减量运算，不过这次前减量运算和输出操作出现在同一个语句中，显示的结果是 "8"。为了证明已实现了所有的减量操作，第五行代码又输出一次"8"。

在算术表达式中，前增量和前减量运算符的优先级是相同的，因此要按照从左到右的顺序计算之。例如：

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = --iNum1 + ++iNum2;	//等于 "22"
var iNum4 = iNum1 + iNum2;		//igual a "22"

在前面的代码中，iNum3 等于 22，因为表达式要计算的是 1 + 21。变量 iNum4 也等于 22，也是 1 + 21。

后增量/后减量运算符

还有两个直接从 C（和 Java）借用的运算符，即后增量运算符和后减量运算符。

后增量运算符也是给数值上加 1，形式是在变量后放两个加号（++）：

var iNum = 10;
iNum++;

不出所料，后减量运算符也是从数值上减 1，形式为在变量后加两个减号（--）：

var iNum = 10;
iNum--;

第二行代码把 iNum 的 值减到 9。

与前缀式运算符不同的是，后缀式运算符是在计算过包含它们的表达式后才进行增量或减量运算的。考虑以下的例子：

var iNum = 10;
iNum--;
alert(iNum);	//输出 "9"
alert(iNum--);	//输出 "9"
alert(iNum);	//输出 "8"

与前缀式运算符的例子相似，第二行代码对 iNum 进行减量运算，第三行代码显示结果（"9"）。第四行代码继续显示 iNum 的值，不过这次是在同一语句中应用减量运算符。由于减量运算发生在计算过表达式之后，所以这条语句显示的数是 "9"。执行了第五行代码后，alert 函数显示的是 "8"，因为在执行第四行代码之后和执行第五行代码之前，执行了后减量运算。

在算术表达式中，后增量和后减量运算符的优先级是相同的，因此要按照从左到右的顺序计算之。例如：

var iNum1 = 2;
var iNum2 = 20;
var iNum3 = iNum1-- + iNum2++;	//igual a "22"
var iNum4 = iNum1 + iNum2;		//igual a "22"

En el código anterior, iNum3 es igual a 22, porque la expresión debe calcular 2 + 20. La variable iNum4 también es igual a 22, pero calcula 1 + 21, porque las operaciones de增量 y decremento ocurren después de asignar a iNum3.

Adición y resta una sola

La mayoría de las personas están familiarizadas con la adición y la resta una sola, su uso en ECMAScript es similar al que aprendiste en matemáticas de secundaria.

La adición una sola no tiene ningún efecto en esencia en los números:

var iNum = 20;
iNum = +iNum;
alert(iNum);	// Sale "20"

Este código aplica la adición una sola al número 20, devolviendo 20.

A pesar de que la adición una sola no tiene efecto en los números, tiene efectos interesantes en las cadenas, convirtiendo las cadenas en números.

var sNum = "20";
alert(typeof sNum);	// Sale "string"
var iNum = +sNum;
alert(typeof iNum);	// Sale "number"

Este código convierte la cadena "20" en un número real. Cuando el operador de una sola adición opera sobre una cadena, calcula la cadena de manera similar a parseInt(), la principal diferencia es que solo los operadores unarios pueden convertir las cadenas que comienzan con "0x" (representando números hexadecimales) en valores decimales. Por lo tanto, al convertir "010", siempre sale 10, mientras que "0xB" se convertirá en 11.

Por otro lado, la resta una sola es obtener el valor negativo de un número (por ejemplo, convertir 20 en -20):

var iNum = 20;
iNum = -iNum;
alert(iNum);	// Sale "-20"

Similar al operador de una sola adición, el operador de una sola resta también convertirá la cadena en un número近似, además de obtener el valor negativo. Por ejemplo:

var sNum = "20";
alert(typeof sNum);	// Sale "string"
var iNum = -sNum;
alert(iNum);		// Sale "-20"
alert(typeof iNum);	// Sale "number"

En el código superior, el operador de una sola resta convertirá la cadena "-20" en -20 (el operador de una sola resta trata los hexadecimales y decimales de manera similar al operador de una sola adición, pero también obtiene el valor negativo).