[Note: les opérateurs de base JS]

1, les opérateurs arithmétiques

Description sur les opérateurs arithmétiques:

1). En plus de plus, lorsque la valeur des opérations non performants de type Number, numéro sera ensuite converti en faire de l' arithmétique.
2) faire en ajoutant, si les deux chaînes sont ajoutées, il le fera pour combattre le fonctionnement de la chaîne, les deux personnages sont connectés comme une chaîne.
3) Les valeurs de chaîne et font l'addition, seront convertis en une chaîne, puis la lutte string.
4) Le calcul de la valeur devait faire et NaN NaN.

  1. « + »: Ajout de deux valeurs et renvoie le résultat
result = 456 + 789;
result = "你好" + "大帅哥";
result = 123 + "1";
result = true + "hello";
result = 123 + ""; //空字符串转换为Number类型之后为0
  1. « - »: soustraction de deux valeurs et renvoie le résultat
result = 100 - 5;
result = 100 - true;  //相当于100-1
  1. « * »: Multiplication des deux valeurs et renvoie le résultat
result = 2 * 2;
result = 2 * "8";
result = 2 * undefined; //undefined转换为Number类型之后为NaN
result = 2 * null; //null转换为Number类型之后为0
  1. « / »: Division des deux valeurs et renvoie le résultat
result = 4 / 2;
result = 3 / 2;
  1. « % »: Deux valeurs et renvoie le résultat modulo opération
result = 4 % 2;  //输出结果为0
result = 3 % 2;  //输出结果为1
  1. « ++ »: incrément peut faire sur la base de la valeur initiale de la variable est incrémentée par un

Incrément peut être utilisé avant et après ++ (++ a) ++ (a ++)
soit (++ a) ou (a ++) serait immédiatement passer de la variable d' origine 1

La différence est (++ a) et la valeur (a ++) est différente:
(++ a) la valeur est la nouvelle valeur de la variable (de l' augmentation de la valeur), a été effectuée deux fois l' équivalent (a ++)

var a = 2;
result = ++a;  //输出结果为3

Une valeur initiale de la valeur de la variable (la valeur avant l'augmentation)

var a = 2;
result = a++;  //输出结果为2
result = a++;  //第二次执行输出结果才会为3
  1. « - »: Enregistrer de la valeur initiale peut être variable sur la base du décrémenté 1

Décrémentation peut être utilisé avant - (- a) ou après - (a-)
soit (-a) ou (A-) provoquera immédiatement la variable d' origine est décrémenté 1

La différence est « --a » valeur et « a-- » sont différents:
valeur -a est la nouvelle valeur de la variable (la valeur après décrémentation), a été effectuée deux fois l' équivalent (A)

var a = 2;
result = --a;  //输出结果为1

A- valeur d'origine est la valeur de la variable (valeur avant décrémentation)

var a = 2;
result = a--;  //输出结果为2
result = a--;  //输出结果为1

2, un opérateur unaire

Les opérateurs unaires, dans l'équivalent mathématique d'une valeur dans un sens positif ou négatif, un seul opérande

  1. Signe positif: un signe positif n'aura aucun impact sur les chiffres.
  2. Négatif: signe négatif peut être inversé signe négatif numérique.
Pour le type de valeur de la non Nombre

1). Il sera converti en nombre, puis en fonctionnement.
2) peut être utilisé pour un autre type de données + pour le convertir en nombre.

3, les opérateurs logiques

! Non : une valeur peut être utilisée pour non-opération, une opération NON est appelée une valeur booléenne pour annuler la valeur de l' opération,

Les catégories : vrai devient faux, faux devient vrai

Description de non-fonctionnement

1). Si une valeur est inversée deux fois, il ne change pas.
2). Si les éléments de la valeur non booléenne, puis les convertit en une valeur booléenne, puis réduit à néant.
3). On peut donc utiliser cette fonction à un autre type de données à une valeur booléenne.
4) peut être considéré comme un inverse deux types de données arbitraire, qui sera convertie en une valeur booléenne.

!true; //输出false
!false; //输出ture

Et && : && peut les valeurs de symbole des deux côtés de l'opération et retourner le résultat

A propos des instructions d'utilisation

1). Tant qu'il y a deux valeurs renvoie une valeur fausse est fausse.
2) seulement lorsque les deux valeurs sont vraies, il retourne vrai.
3). JS dans le « avec » et appartenant à un court - circuit, si la première valeur est fausse, ne verra pas la deuxième valeur.
4) Si le premier faux, le retour direct à la première valeur.

//如果两个值都是true则返回true
var result = true && true;
//只要有一个false,就返回false,所以下面三个的输出都是false
result = true && false;
result = false && true;
result = false && false;
true && alert("弹出框···");//第一个值为true时,才会检查第二个值,所以会输出后面的弹出框
false && alert("弹出框···");//第一个值为false时,不会检查第二个值,不会输出后面的弹出框

Ou || : || peut être des valeurs de symboles ou les deux côtés de l'opération et renvoie le résultat

Ou des instructions sur le fonctionnement

1) Les deux valeurs aussi longtemps qu'un vrai, renvoie vrai.
2) Si les deux valeurs sont fausses, il retourne faux.
3). JS « ou » appartient à, ou un court - circuit.
4) Si la première valeur est vraie, la seconde valeur est pas cochée.
5) Si la première valeur est fausse, la seconde valeur est renvoyée.

//两个都是false,则返回false
result = false || false;
//只有有一个true,就返回true,所以下面三个的输出都是true
result = true || false;
result = false || true ;
result = true || true ;
false || alert("弹出框···");//第一个值为false时,则会检查第二个值,所以会有弹出框
true || alert("弹出框···");//第一个值为true,则不再检查第二个值,所以不会有弹出框
&&, || pas une note de valeur booléenne

Lorsque la non-opération booléenne OU pour, va d'abord le convertir en une valeur booléenne, puis retourne l'opération la valeur initiale et

4, l'opérateur d'affectation

  1. « = »: Le côté droit des valeurs de symbole peut être attribué à la gauche du symbole
  2. "+ =": A + = 5 est équivalent à a = a + 5
  3. "- =": a - = 5 est équivalent à = a - 5
  4. " =" :. 5 est équivalent à A = A = A . 5
  5. "/ =": A / = 5 est équivalent à a = a / 5
  6. "% =": A% = 5 est équivalent à a = a% 5

5, opérateurs relationnels

Comparer les rapports entre les deux valeurs par l'opérateur relationnel, il retournera si la relation est vrai, si la relation est pas établie il retourne faux

  1. « > »: Aucune valeur est supérieure à la valeur de jugement est plus grand que le symbole à gauche du droit.
  2. « > = »: Déterminer si une valeur supérieure ou signe égal gauche supérieur ou égal à droite.
  3. « < »: Moins que le nombre de la valeur de détermination de symbole à gauche est inférieure à la juste valeur.
  4. « <= »: Inférieur ou égal à la valeur de détermination du symbole de gauche est inférieure ou égale à la valeur du côté droit.
var result = 5 > 10;//false
result = 5 > 4; //true
result = 5 > 5; //false
result = 5 >= 5; //true
result = 5 >= 4; //true
result = 5 < 4; //false
result = 4 <= Na; //true
Sans valeur

1). En comparaison des non-numérique, puis la convertit en une comparaison numérique.
2). Si les deux valeurs sont des chaînes de symboles, il ne sera pas converti en un comparateur numérique, le comparateur va coder chaque caractères Unicode dans la chaîne.
3). L' égalité opérateur de comparer les deux valeurs sont égales, si un rendement égal vrai, sinon retourne false.
4) Toutes les valeurs NaN et faire des comparaisons sont fausses

console.log("1" < "5"); //true
console.log("11" < "5"); //true
//比较两个字符串时,比较的是字符串的字符编码
console.log("a" < "b");//true
//比较字符编码时是一位一位进行比较
//如果两位一样,则比较下一位,所以借用它来对英文进行排序
console.log("abc" < "bcd");//true
//比较中文时没有意义
console.log("戒" > "我"); //true
//如果比较的两个字符串型的数字,可能会得到不可预期的结果
//注意:在比较两个字符串型的数字时,一定一定一定要转型
console.log("11123123123123123123" < +"5"); //true
  1. « == »: égal à l'opérateur de le faire
    lors de l' utilisation == pour comparer deux valeurs, si les valeurs de différents types, le type est automatiquement converti, converti au même type et dans la comparaison.
console.log(a == 4); //false
console.log("1" == 1); //true
console.log(true == "1"); //true
console.log(null == 0); //false
/*
 * undefined 衍生自 null
 * 	所以这两个值做相等判断时,会返回true
 */
console.log(undefined == null);
/*
 * NaN不和任何值相等,包括他本身
 * 可以通过isNaN()函数来判断一个值是否是NaN
 * 如果该值是NaN则返回true,否则返回false
 */
console.log(NaN == NaN); //false
  1. « ! = »: Ne correspond pas à la valeur utilisée pour déterminer si les deux ne sont pas égaux, les rendements réels sinon égal, sinon faux.
    Utilisez! = Ne pas EGAL ne correspondront pas aux conversions de type variable automatique, elle renvoie également égale false si la conversion.
console.log(10 != 5); //true
console.log(10 != 10); //false
console.log("abcd" != "abcd"); //"abcd"转换为Number类型时为NaN,所以会输出false
console.log("1" != 1);//false
  1. « === »: congruent congruent utilisé pour déterminer si les deux valeurs, qui sont égales et semblables, sauf qu'il ne fait pas de conversion de type automatique, si les deux valeurs de type différent, renvoie directement faux.
console.log(123 === 123);//false
console.log("123" === 123);//false
console.log(null === undefined);//false
  1. « ==! »: Utilisé pour déterminer l'insuffisance si deux valeurs ne sont pas en harmonie, et l'inégalité similaire, sauf qu'il ne fait pas la conversion de type automatique, si la valeur de deux types différents, des retours directs vrai.
console.log("123" !== 123);//true
console.log(null !== undefined);//true

6, l'opérateur ternaire

? ** Syntaxe: ** 1 instruction conditionnelle expressions: Déclaration 2;

Exécution du processus:

1) Condition opérateur lorsqu'il est exécuté, les premières expressions conditionnelles sont évaluées:
2) Si la valeur est true, exécutez l'instruction 1, et retourne un résultat d'exécution ;.
3) Si la valeur est fausse, l' exécution de l'instruction. 2, et renvoie le résultat de l' exécution;
4) Si les évalue l'expression de condition à une valeur non booléenne, qui sera ensuite converti en des opérations booléennes.

var a = 300;
var b = 143;
a > b ? alert("a大"):alert("b大");
//因为字符串转Boolean类型会为true,所以
"hello"?alert("语句1"):alert("语句2");
Publié 20 articles originaux · a gagné les éloges 11 · vues 1751

Je suppose que tu aimes

Origine blog.csdn.net/qq_16221009/article/details/102868438
conseillé
Classement