Operadores Unários ECMAScript

Os operadores unários têm apenas um parâmetro, que é o objeto ou valor a ser operado. Eles são os operadores mais simples do ECMAScript.

delete

O operador delete remove a referência a propriedades ou métodos de objetos definidos anteriormente. Por exemplo:

var o = new Object;
o.name = "David";
alert(o.name);	//exibe "David"
delete o.name;
alert(o.name); // Exibe "undefined"

Neste exemplo, a propriedade name foi deletada, o que significa que foi forçado a desreferenciar, configurado como undefined (ou seja, o valor de uma variável não inicializada).

O operador delete não pode excluir atributos e métodos não definidos pelo desenvolvedor. Por exemplo, o seguinte código causará um erro:

delete o.toString;

Mesmo que toString seja um nome de método válido, essa linha de código causará um erro, porque o método toString() é um método original do ECMAScript, não definido pelo desenvolvedor.

void

O operador void retorna undefined para qualquer valor. Este operador é geralmente usado para evitar a saída de valores que não devem ser exibidos, por exemplo, ao chamar uma função JavaScript a partir de um elemento <a> de HTML. Para fazer isso corretamente, a função não deve retornar um valor válido, pois o navegador apagará a página, exibindo apenas o resultado da função. Por exemplo:

<a href="javascript:window.open('about:blank')">Clique aqui</a>

Se você inserir essa linha de código em uma página HTML e clicar no link, você verá "[object]" sendo exibido na tela.TIY

Isso é porque o método window.open() retorna uma referência para a nova janela aberta. Em seguida, o objeto será convertido em uma string para ser exibida.

Para evitar esse efeito, você pode usar o operador void para chamar a função window.open():

<a href="javascript:void(window.open('about:blank'))">Clique aqui</a>

Isso faz com que a chamada window.open() retorne undefined, que não é um valor válido e não será exibido na janela do navegador.

Dica:Lembre-se, uma função que não retorna valor realmente retorna undefined.

Operadores de incremento/decremento prefixo

Os dois operadores diretamente emprestados do C (e Java) são os operadores de incremento e decremento prefixo.

O operador de incremento prefixo é adicionar 1 ao valor, na forma de dois pontos antes da variável (++):

var iNum = 10;
++iNum;

A segunda linha de código aumenta iNum para 11, o que é equivalente a:

var iNum = 10;
iNum = iNum + 1;

Da mesma forma, o operador de decremento prefixo diminui o valor em 1, na forma de dois hífen antes da variável (--):

var iNum = 10;
--iNum;

Neste exemplo, a segunda linha de código diminui o valor de iNum para 9.

Ao usar operadores de prefixo, note que os operadores de incremento e decremento ocorrem antes da avaliação da expressão. Considere o seguinte exemplo:

var iNum = 10;
--iNum;
alert(iNum);	//saída "9"
alert(--iNum);	//saída "8"
alert(iNum);	//saída "8"

O segundo código linha realiza a operação de decremento em iNum, o terceiro código linha exibe o resultado ("9"). O quarto código linha novamente realiza a operação de decremento em iNum, mas dessa vez a operação de pré-decremento e a operação de saída aparecem na mesma instrução, exibindo o resultado "8". Para provar que todas as operações de decremento foram realizadas, a linha quinto código novamente exibe "8".

Na expressão aritmética, a prioridade dos operadores de pré-incremento e pré-decremento é a mesma, portanto, deve-se calcular em ordem de esquerda para direita. Por exemplo:

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

No código anterior, iNum3 é igual a 22, porque a expressão a ser calculada é 1 + 21. A variável iNum4 também é igual a 22, também é 1 + 21.

Operadores pós-incremento/pós-decremento

Existem também dois operadores diretamente emprestados do C (e Java), que são os operadores de incrementação e decremento pós-operadores.

O operador de incrementação pós-operador também adiciona 1 ao valor, na forma de dois pontos e vírgulas ao lado do nome da variável (++):

var iNum = 10;
iNum++;

Como esperado, o operador de decremento pós-operador também diminui o valor em 1, na forma de dois hífens ao lado do nome da variável (--):

var iNum = 10;
iNum--;

O segundo código linha reduz o valor de iNum para 9.

Diferente dos operadores de prefixo, os operadores de sufixo são operações de incrementação ou decremento realizadas após a avaliação da expressão que os contém. Considere o seguinte exemplo:

var iNum = 10;
iNum--;
alert(iNum);	//saída "9"
alert(iNum--);	//saída "9"
alert(iNum);	//saída "8"

Da mesma forma que no exemplo do operador de prefixo, o segundo código linha realiza a operação de decremento em iNum, o terceiro código linha exibe o resultado ("9"). O quarto código linha continua a exibir o valor de iNum, mas dessa vez aplica o operador de decremento na mesma expressão. Como o decremento pós-operador ocorre após a avaliação da expressão, a linha dessa instrução exibe o número "9". Após a execução da linha quinto código, a função alert exibe "8", porque entre a execução da linha quarto código e a execução da linha quinto código, foi executado o decremento pós-operador.

Na expressão aritmética, a prioridade dos operadores de pós-incremento e pós-decremento é a mesma, portanto, deve-se calcular em ordem de esquerda para direita. Por exemplo:

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

No código anterior, iNum3 é igual a 22, porque a expressão calcula 2 + 20. A variável iNum4 também é igual a 22, mas ela calcula 1 + 21, porque os operadores de incremento e decremento ocorrem após a atribuição de iNum3.

Adição e subtração unárias

A maioria das pessoas está familiarizada com a adição e subtração unárias, suas aplicações no ECMAScript são semelhantes ao que você aprendeu na matemática do ensino médio.

A adição unária não tem efeito nenhuma sobre números na essência:

var iNum = 20;
iNum = +iNum;
alert(iNum); // Saída "20"

Este código aplica o operador de adição unário ao número 20, retornando ainda 20.

Embora o operador de adição unário não tenha efeito sobre números, ele tem efeitos interessantes com strings, convertendo-as em números.

var sNum = "20";
alert(typeof sNum); // Saída "string"
var iNum = +sNum;
alert(typeof iNum); // Saída "number"

Este código converte a string "20" em um número real. Quando o operador de adição unário opera em uma string, ele calcula a string de maneira semelhante ao parseInt(), a principal diferença é que apenas strings que começam com "0x" (representando números hexadecimais) podem ser convertidas em valores decimais pelo operador unário. Portanto, ao usar o operador de adição unário para converter "010", sempre obterá 10, enquanto "0xB" será convertido em 11.

Por outro lado, a subtração unária é simplesmente negar um número (por exemplo, transformar 20 em -20):

var iNum = 20;
iNum = -iNum;
alert(iNum); // Saída "-20"

Da mesma forma que o operador de adição unário, o operador de subtração unário também convertirá strings em números aproximados, negando ainda o valor. Por exemplo:

var sNum = "20";
alert(typeof sNum); // Saída "string"
var iNum = -sNum;
alert(iNum); // Saída "-20"
alert(typeof iNum); // Saída "number"

No código acima, o operador de subtração unário convertirá a string "-20" em -20 (o operador de subtração unário lida com hexadecimal e decimal da mesma forma que o operador de adição unário, mas também negará o valor).