operadores JS - operadores aritméticos, operadores lógicos, operadores de asignación, operadores relacionales, operador condicional

1, el concepto básico del operador

• Operador también se llama operador
• Se puede operar en uno o más valores por el operador y adquiere el resultado de la operación
• Por ejemplo: typeof operador es, un valor puede obtenerse del tipo
• El tipo del valor que devuelve una cadena
• número de cuerda boolean objeto no definido

2, operadores aritméticos

• Los operadores aritméticos
• Cuando el valor de Tipo de Número de no calcula, entonces convertir estos valores a la Número aritmética y valores NaN hacer cualquier operación tuvo NaN
• + (Signo más):
• Se le puede agregar dos valores y devuelve el resultado
• Si la operación de adición de dos cadenas, la cadena va a luchar hará dos cadenas juntas en una cadena y retorna
• Cualquier valor de cadena y no sumador, se convierte primero en una cadena, entonces las operaciones de cadena y de cadena hacen lucha
• - (menos): puede ser la resta de dos valores y devuelve el resultado
• * (Multiplicación): multiplicación puede ser dos valores
• / (Número de división): puede ser división de los dos valores
• % (Resto): una operación de módulo (tomar el resto)

2.1 Plus

var a = 123;		
var result = typeof a;
result = a + 1;  // 拼串
result = 456 + 789;  //数值的加法运算
result = true + 1;  // 先对true进行数据转换，然后再进行加法运算
result = true + false;  // 先对true和false都进行数据转换，然后再进行加法运算
result = 2 + null;
result = 2 + NaN;
result = "你好" + "大帅哥";  //拼串
var str = "锄禾日当午，" +
          "汗滴禾下土，" +
          "谁知盘中餐，" +
          "粒粒皆辛苦";
result = 123 + "1";  // 拼串
result = true + "hello";  // 拼串

menos 2.2

result = 100 - 5;
result = 100 - true; // 先对true进行数据转换，然后再进行加法运算
result = 100 - "1";  // 99  先对字符串“1”进行数据转换，然后进行运算

2.3 El signo de multiplicación

result = 2 * 2;  // 4
result = 2 * "8"; // 16
result = 2 * undefined; // 0
result = 2 * null; // 0

2.4 Dividir

result = 2 / 2;  // 1
result = 2 / "8"; // 0.25

• resumen:
• Hacer cualquier valor - * / cuando la operación se convertirá automáticamente al Número
  • Podemos utilizar esta función para hacer la conversión de tipos implícita
  • Un by-0 * 1/1 para convertirlo Número
  • Principios y función Number (), al igual que, más fácil de usar

2,5 modulo (número restante)

result = 9 % 3;  // 0
result = 9 % 4;  // 1
result = 9 % true;  // 0
result = 9 % "5";  // 4

En tercer lugar, los operadores unarios

• operadores unitarios, solo operando
• signo positivo no tendrá ningún efecto sobre digitales
• Menos un signo negativo puede ser negado digitales
• Para el tipo de valor del número no, se puede convertir en número, a continuación, en la operación;
• Puede ser utilizado para un diferente tipo de datos +, para convertirlo en número, los mismos principios y su función Number ().

var a = 123;
a = -a;
a = true;  // 1
a = "18";  // 18
a = +a;  // 可以将true及字符串“18”转换为对应的数值
console.log(typeof a);
var result = 1 + +"2" + 3;

En cuarto lugar, el incremento decremento

• Incremento ++
  • Puede aumentar la variable se incrementa en 1 en su propia base
  • Para Valor mínimo de una variable subsiguiente, el valor de la variable original se incrementa inmediatamente 1
  • Incremento divide en dos: después ++ (a ++) y un frente ++ (++ a)
  • Ya se trate de un ++ ++ o una, hará que el valor inmediato de la variable original se incrementa en uno
• Y excepto que a ++ a ++ un valor diferente
  • A ++ un valor igual al valor de la variable original (valor antes de incremento)
  • ++ un valor igual al nuevo valor (a partir del valor aumentado)
• disminución -
  • Puede hacerse variable por sí mismo de Save Guardar 1 sobre la base de
  • Después - (a-) y un frente - (-a): decrementa dividido en dos
  • Ya sea A-- o --una hará que el valor inmediato de la variable original desde menos 1
• La diferencia es que los valores diferentes de A-- y --una
  • variable de A-- es el valor original (el valor antes de decrementar)
  • variable de -a es el nuevo valor (el valor después de decremento)

var num = 10;		
console.log(num--);  // 10
console.log(num--); // 9

var num = 10;		
console.log(--num);	  // 9

console.log("num = "+num);

Cinco operadores lógicos

• JS nos proporciona tres tipos de operadores lógicos, tres operadores pueden hacer las tres cosas siguientes:

  • Para los tipos booleanos de operaciones de datos directamente;
  • Con tipos no booleanas se primera convertirlo en un valor booleano, entonces la operación, y devuelve el valor original;
  • Para declaración JS , la primera instrucción JS resultado de ejecución de determinación, y luego determina si se debe realizar la segunda base en los resultados.

• ! NO operación

  • ! El valor puede ser utilizado para un no-operativa
  • cálculo del valor se denomina no- operación Valor negate booleano , true se convierte en falsa, falsa se convierte en realidad
  • Si un valor de dos veces negada, no va a cambiar
  • Si los elementos del valor no booleano, a continuación, lo convierte a un valor booleano y, a continuación, negada
  • Así que podemos utilizar esta función para convertir a otro tipo de datos en un valor booleano;
  • Puede tomarse dos veces al trans a cualquier tipo de datos, para ser convertido en un valor booleano, el principio y la función Boolean () como

• && operación AND

  • && valores de símbolo puede en ambos lados de la operación y devolver el resultado
  • regla de operación : dos valores, siempre y cuando hay un falso valor vuelve falsa,
  • Sólo cuando ambos valores son verdaderos, devolverá verdadero, el JS en "y" que pertenece a la operación de corto circuito y , si el primer valor es falso, no quiere ver el segundo valor.

• || OR

  • || operadores pueden inscribirse en ambos lados del valor y devuelve el resultado con OR
  • ** regla de operación: dos valores ** Siempre y cuando no es un verdadero, devuelve verdadero
  • Si los dos valores son falsos, devuelve false, la JS en "o" perteneciente o corto, si el primer valor es cierto, no se comprueba el segundo valor.

5.1! Operación NOT (otros tipos de datos pueden ser transferidos de Boole)

var a = false;
a = !a; //对a进行非运算
//console.log("a = "+a);
var b = 10;
b = !!b; //对B进行数据类型转换

//如果两个值都是true则返回true
var result = true && true;
//只要有一个false，就返回false
result = true && false;  //第一个值为true，会检查第二个值
result = false && true;  //第一个值为false，不会检查第二个值
result = false && false;

5.3 || OR (condición encontrada es cierto, la terminación)

//两个都是false，则返回false
result = false || false;
//只有有一个true，就返回true
result = false || true ; //第一个值为false，则会检查第二个值
result = true || false;  //第一个值为true，则不再检查第二个值
result = true || true ;

valor 5,4 para no Boolean

result = 0 && 2;  // 0
result = 2 && 0;   // 2
//false &&　false
result = NaN && 0;  // NAN
result = 0 && NaN;  // 0

//如果第一个值为true，则直接返回第一个值
result = 2 || NaN;  // 2
result = 2 || 0;  // 2
//如果第一个值为false，则直接返回第二个值
result = NaN || 1;  // NAN
result = NaN || 0;  // NAN

En sexto lugar, el operador de asignación

• = (Signo igual) // símbolos valor correcto se pueden asignar a la izquierda del símbolo
• + = (Signo igual) // a + = 5 es equivalente a a = a + 5
• - = (signo menos igual) // a - = 5 es equivalente a a = a - 5
• * = (Multiplicación signo igual) // a * = 5 es equivalente a a = a * 5
• / = (Signo igual otra) // a / = 5 es equivalente a a = a / 5
• % = (Equal resto signo) // un% = 5 es equivalente a a = a% 5

Siete, operadores relacionales

• Es posible comparar la relación de tamaño entre los dos valores de los operadores relacionales, si la relación se mantiene devuelve true, si la relación no se establece devuelve falso.
• > Mayor que signo
  • La determinación de si el valor es mayor que el valor del símbolo a la izquierda de la derecha
  • Si se establece la relación, devuelve verdadero, si la relación no se establece retornos falsos
• > = Mayor o igual
  • La determinación de si el valor es mayor o igual símbolo a la izquierda del valor justo
• <menor
• <= Menor o igual
• Sin valor
  • Cuando se compara para no numérico, entonces la convierte a una comparación digital de
  • Si ambos valores son cadenas de símbolos, no será convertido a un comparador digital, el comparador codificará cada uno cadenas de caracteres Unicode;
  • Puede utilizar el método charCodeAt () para consultar la correspondiente codificación Unicode.

console.log(1 > true); //false
console.log(1 >= true); //true
console.log(1 > "0"); //true
console.log(10 > null); //true
//任何值和NaN做任何比较都是false
console.log(10 <= "hello"); //false
console.log(true > false); //true
console.log("1" < "5"); //true

Ocho operadores de igualdad,

• == operadores de igualdad: operador de igualdad para comparar los dos valores son iguales,
  • El mismo tipo de datos y la igualdad de rendimientos verdaderos, de lo contrario devuelve false;
  • Si un tipo diferente del valor, la conversión de tipo se realiza de forma automática, para convertirlo en el mismo tipo, entonces la comparación.
• ! = Distinto: desigual utiliza para determinar si dos valores no son iguales devuelve verdadero si no igual, falso en caso contrario
  • Uso! = No lo hacen igual operador
  • No será igual a las conversiones de tipos de variables automáticas, la conversión es igual a si va a devolver false
• === congruentes (se puede utilizar para la determinación de tipo)
  • Se utiliza para determinar si dos valores congruentes que son iguales y similares, excepto que no hace conversiones de tipo automático, si los dos valores de diferente tipo, regresa directamente falsa.
• ! == estricta desigualdad (se puede utilizar para hacer el tipo de juicio)
  • Se utiliza para determinar si los dos valores y incompleta y desigual, y similares, excepto que no hace conversiones de tipo automático, si los dos valores de diferente tipo, regresa directamente verdadera.

console.log(10 != 5);   //true
console.log(10 != 10);   //false
console.log("abcd" != "abcd");   //false
console.log("1" != 1);  //false
console.log("123" === 123);  //false
console.log(null === undefined);   //false
console.log(1 !== "1");   //true

** Nota: ** puede funcionar isNaN () para determinar si el valor es un NaN, NaN si el valor es true se devuelve, falso en caso contrario

IX operador condicional

• operador condicional también se llama operador ternario
• sintaxis:
  • ? Condicional expresiones Declaración 1: Declaración 2;
• La ejecución del proceso:
  • operador condicional, cuando se ejecuta, en primer lugar, se evalúa la expresión condicional, si el valor es verdadero, ejecutar una instrucción, y devuelve el resultado. Si el valor es falsa, se ejecuta la instrucción 2, y devuelve el resultado.
  • Si la expresión condición se evalúa como un valor no booleano, que luego se convierte en operaciones booleanas.

Ejemplo de sintaxis:

false?alert("语句1"):alert("语句2");

var a = 300;
var b = 143;
var c = 50;
a > b ? alert("a大"):alert("b大");
// 获取a和b中的最大值
var max = a > b ? a : b;
// 获取a b c 中的大值
max = max > c ? max : c;

false?alert("语句1"):alert("语句2");

var a = 300;
var b = 143;
var c = 50;
a > b ? alert("a大"):alert("b大");
// 获取a和b中的最大值
var max = a > b ? a : b;
// 获取a b c 中的大值
max = max > c ? max : c;