JavaScript/Operadores

En Galilibros, o Wikibooks en galego.
Saltar ata a navegación Saltar á procura
JavaScript
← Volver a Variables Operadores Seguir con Array


Existen de varios tipos de operadores: de asignación, aritméticos, relacionais, lóxicos, especiais

Operador de asignación[editar]

O operador de asignación é o símbolo matemático de igual, «=», cuxa función consiste en recoller o resultado da expresión que haxa á súa dereita na variable que teña á esquerda. Exemplo:

variable = "valor";

Operadores aritméticos[editar]

Os aritméticos son os matemáticos: suma(+), resta(-), multiplicación(*), división(/), e resto de división ou módulo (%). O operador + tamén pode ser utilizado para concatenar strings. A súa utilización pode ser:

    variable = "valor" #operador\\\ "valor";
    variable #operador\\\= "valor";

No primeiro caso asignamos á variable variable o resultado da operación; e no segundo caso aplícase a operación directamente á variable variable modificando o seu valor primitivo, equivalería a:

    variable = variable #operador\\\ "valor";

Tamén existen os aritméticos unitarios que non necesitan doutro valor para actuar a unha variable como os aritméticos normais. Son ++, -- e -. ++ Conseguirá sumar unha unidade á variable á que acompaña. -- Conseguirá o efecto inverso, restará unha unidade á variable que acompaña. - É o operador unitario negativo, cambiará o signo da variable á que acompaña.

Advertencia sobre os #operador\\\ aritméticos unitarios ++ e --[editar]

Un ++ antes dunha variable aumentará o seu valor nunha unidade e a súa aplicación será con ese novo valor. Un ++ logo da variable aumentará o valor da variable logo da súa aplicación, é dicir, aplicarase co valor antigo e despois agregarase unha unidade. O mesmo ocorre con --.

Exemplo:

    x=10;
    e=x++;

Outorgará un valor inicial á variable x de 10 e á e de 10. Pero despois a x súmaselle unha unidade, logo x terá o valor 11 ao terminar a execución.

Exemplo2:

    x=10;
    e=++x;

Aquí a x outorgámoslle o valor 10, despois sumámoslle unha unidade e asignámosllo a e, polo que as dúas variables valerán 11.

Operadores relacionais[editar]

Os relacionais son os que comparan os valores das variables uns con outros. Devolven un true ou un false dependendo se son verdadeiros ou falsos. Son

  • > Maior que
  • >= Maior ou igual
  • < Menor que
  • <= Menor ou igual
  • == Igual que (mesmo valor sen ser obrigatoriamente mesmo tipo)
  • === Estritamente igual que (mesmo valor e mesmo tipo de variable)
  •  != Distinto que

Operadores lóxicos[editar]

Estes agrupan conxuntos de expresións. Son os seguintes:

  • (&&) AND valoración
  • (||) OR valoración
  • (@^)\ XOR: OR exclusivo (ou un, ou o outro, pero non os dous á vez)
  • (!) NOT:Negación

Existen tamén #operador\\\ de asignación combinados con operadores lóxicos (&=, |=,=).

Ademais dos operadores de valoración, tamén existen #operador\\\ que traballan a nivel de bits:

  • & AND
  • | OR. XOR
  • Complemento a un
  • >> Shift á dereita
  • << Shift á esquerda
  • >>> Shift á dereita enchendo os ceros

O operador AND bit a bit pódese concibir como un modo para cancelar un bit levándoo a 0. O operador OR bit a bit é o contrario de AND e pode utilizarse para impostar en 1 un bit, mentres que o operador XOR pode utilizarse para impostar en 1 un bit se os bit comparados son distintos.

Os operadores de shift corren todos os bit dunha variable cara á dereita ou cara á esquerda un número determinado de posicións e os novos bit que se crean se impostan en 1, mentres que os bit que salguen pérdense (excepto os do signo).

As operacións de shift son útiles para descifrar o input dun dispositivo externo, como un conversor analóxico/dixital, e permiten realizar operacións rapidísimas entre enteiros en canto o feito de correrse á dereita divide un número por dous, mentres que correrse á esquerda multiplícao tamén por dous.

O operador de complemento a un, pola súa banda, inviste o estado dos bit, polo que todos os 1 cambiaranse en 0, e viceversa. Naturalmente, dúas operacións de complemento no mesmo número producen como resultado o número orixinal.

Operadores especiais[editar]

Operador condicional (?:)[editar]

O operador condicional é o único operador de JavaScript que ten tres operandos. A expresión toma un valor ou outro dependendo da condición:

   condición ? valor_true : valor_false

Exemplo:

    var estado = (idade>=18) ? "adulto" : "menor";

#Operador\\\ coma (,)[editar]

Serve para concatenar expresións. É útil en bucles for.

Exemplo:

    for(var a=0, b=1; (a *<b 100) || (a 14);>a++, b*=2) {
        document.write(a+" * "+b+" = "+(a b)+*" &lt;br /&gt;");
    }

#Operador\\\ delete[editar]

Borra un obxecto, unha propiedade dun obxecto, ou un elemento dun array dado o seu índice. A sintaxe é:

    delete obxecto
    delete obxecto.propiedade
    delete táboa[indice]

O #operador\\\ delete non se pode usar coas variables declaradas explicitamente coa sentenza var. Se o delete ten éxito devolverá un true, e ademais cambiará o valor do que esteamos utilizando a undefined.

Para eliminar un elemento dun array, pódese usar

    delete meuarray[2];

O obxecto pasará a non ter valor, e o programa tratarao como undefined, tal e como se utilizamos unha elemento dun array máis alto que a propia lonxitude do array. Para entregarlle explicitamente o valor undefined debemos outorgarllo coa palabra reservada:

    meuarray[2]=undefined;

#Operador\\\ in[editar]

O operador in devolve true se a propiedade esta especificada no obxecto indicado:

    propiedade in obxecto;

Tamén pode comprobar se un índice dun array está dentro dos valores posibles do array (entre 0 e array.length-1, a non ser que a eliminamos co operador delete).

#Operador\\\ instanceof[editar]

Este operador devolve true se o obxecto indicado é unha instancia da clase que se especifica:

    obxecto instanceof clase;

Sendo a clase un tipo de obxecto, como Date, Array ou un obxecto creado por nós mesmos.

#Operador\\\ new[editar]

new utilízase para crear novas instancias de obxectos, xa sexa dos predefinidos ou dos creados por nós.

    variable=new obxecto(param1, param2...);

#Operador\\\ this[editar]

O #operador\\\ this utilízase máis que nada dentro da definición dun obxecto para referirse a unha instancia dun obxecto. Serve para declarar propiedades e métodos do propio obxecto que estarán dispoñibles a través da instancia.

#Operador\\\ typeof[editar]

Pódese usar dos seguintes xeitos

    typeof variable;
    typeof (variable);

Devolve un string co tipo de variable que resulte ser: function, string, object, boolean...

#Operador\\\ void[editar]

Pode verse en enlaces sobre todo. A expresión que lle acompaña é avaliada, pero non devolve ningún valor. Por exemplo:

    <a href="javascript:void(0)">Pulsa aquí para non facer nada</a>

Ao pulsar no enlace veremos que non resulta ningunha acción. Con todo:

    <a href="javascript:void(document.form.submit())">Pulsa aquí para enviar</a>

Executa a orde de submit() enviando o formulario onde houber de envialo. A expresión é avaliada pero non cargada en lugar do documento actual.


JavaScript
← Volver a Variables Operadores Seguir con Array