Une expression est une phrase en JavaScript, et l'interprète JavaScript calculera un résultat. Les quantités couramment utilisées dans les programmes sont le type d'expressions le plus simple qui sont des variables. Les noms de variables sont également une expression simple et leur valeur est la valeur attribuée à la variable.
Des expressions complexes sont composées d'expressions simples. Par exemple, une expression d'accès à réseau est composée d'une expression représentant un tableau, des crochets et une expression entière. La nouvelle opération d'expression qu'ils forment est la valeur d'élément à une position spécifique dans le tableau. Même lettre
Une expression d'appel numérique consiste en une expression représentant un objet de fonction et 0 plus de 0 expressions de paramètres. La méthode la plus courante pour combiner des expressions simples en expressions complexes est les opérateurs.
Ce chapitre (cet article) expliquera tous les opérateurs JavaScript. Il explique également les expressions qui n'impliquent pas les opérateurs (tels que l'accès aux éléments de tableau et aux appels de fonction), et leur style de syntaxe et de programmation est très similaire à ceux du langage C.
1. Expression d'élément
L'expression la plus simple est "l'expression originale", qui est la plus petite unité d'une expression - ils ne contiennent pas d'autres expressions. Les expressions originales en JavaScript contiennent des constantes ou des quantités directes. Mots-clés et variables.
Une quantité directe est une valeur constante qui apparaît directement dans le programme. Ils ressemblent:
La copie de code est la suivante:
1,23 // Quantité directe
"bonjour" // supporte la quantité directe
/ motif / // Expression régulière Quantité directe
Quelques mots réservés en javascript forment l'expression originale
La copie de code est la suivante:
Vrai // Valeur booléenne: vrai
faux // faux
null // renvoie une valeur: vide
ce // renvoie l'objet "actuel"
Grâce à l'apprentissage du chapitre 3, contrairement à d'autres mots clés, ce n'est pas une constante et les valeurs qu'il renvoie dans différentes parties du programme sont également différentes. Ce mot-clé apparaît souvent dans la programmation orientée objet. Cela renvoie l'objet de la méthode carrée.
Enfin, la troisième expression originale est une variable
La copie de code est la suivante:
je // renvoie la valeur de la variable i
sum // renvoie la valeur de somme
Undefined // est une variable globale, contrairement à Null, ce n'est pas un mot-clé
2. Expressions d'initialisation des objets et des tableaux.
L'initialisation des objets et du tableau est en fait des objets et des tableaux nouvellement créés. Ces expressions initialisées sont parfois appelées «quantité directe d'objet» et «quantité directe de tableau». Cependant, contrairement aux quantités directes booléennes, ce ne sont pas des expressions originales car les membres ou les éléments qu'ils contiennent sont des sous-expressions.
La syntaxe de l'expression d'initialisation d'un tableau est très simple, commençons ci-dessous
L'expression d'initialisation d'un tableau est composée d'une paire de crochets et d'une liste séparée par des virgules. Le résultat d'initialisation est un tableau nouvellement créé. Les éléments d'un tableau sont des valeurs d'expressions séparées par les virgules.
[] // un tableau vide; [] Laisser vide signifie que le tableau n'a pas d'éléments
[1 + 2,3 + 4] // Array avec deux éléments, le premier est 3, le second est 7
L'expression d'initialisation de l'élément dans une expression d'initialisation du tableau peut être une expression d'initialisation du tableau. C'est-à-dire que les expressions peuvent être imbriquées
La copie de code est la suivante:
var mat = [[1,2,3], [4,5,6], [7,8,9]];
Les éléments entre les listes du tableau peuvent être omis et l'espace sera rempli de non-défini. Par exemple:
La copie de code est la suivante:
var a = [1 ,,,, 5]
Quatre des éléments ne sont pas définis. Une virgule est laissée à la fin de la quantité directe du tableau, et un nouvel élément avec une valeur non définie ne sera pas créé.
Les expressions d'initialisation des objets sont très similaires aux expressions d'initialisation du tableau, sauf que les crochets sont remplacés par des supports bouclés. Et chaque expression de mot contient un nom d'attribut et un non-colon en tant que préfixe.
La copie de code est la suivante:
var p = {x: 2.1, y: -3} // un objet avec deux membres d'attribut
var q = {}; // objet vide
qx = 2,1; qy = -3; // Les membres d'attribut de Q sont les mêmes que ceux de P
L'objet peut également être imbriqué directement, par exemple
La copie de code est la suivante:
var anh = {gauche: {x: 2, y: 3},
à droite: {x: 4, y: 5}}
Lorsque JavaScript calcule la valeur d'une expression d'initialisation d'objet, les expressions d'objet sont calculées à chaque fois, et elles n'ont pas à inclure des valeurs constantes: elles peuvent être une expression JavaScript. De même, le nom de la propriété dans la quantité directe de l'objet peut être une chaîne au lieu d'un identifiant. (Il est très utile lorsque seuls les mots réservés ou certains identifiants illégaux sont utilisés comme noms d'attribut sur cette ligne)
La copie de code est la suivante:
Var Side = 1;
var carré = {"Left": {x: px, y: py},
'droite': {x: p.x + côté, y: p.y + côté}}
Le chapitre 67 discutera également des expressions d'initialisation des objets et des tableaux.
3. Expressions de fonction
L'expression de définition de fonction définit une fonction javascript. La valeur de l'expression est cette fonction nouvellement définie. Dans un sens, les expressions de définition de fonction peuvent devenir des quantités de fonction directes et les expressions de fonction peuvent être appelées "quantités de fonction directes", après toutes les expressions d'initialisation des objets sont également appelées "quantités d'objets directes". Une expression de définition de fonction typique contient la fonction de mot-clé, suivie d'une paire de parenthèses, d'une liste séparée par des virgules et de la liste contient 0 identificateurs ou plus (noms de paramètres). Suivez ensuite le segment de code JavaScript (corps de fonction) enveloppé dans des accolades bouclées.
var carré = fonction (x) {return x * x};
Les expressions de définition de fonction peuvent également contenir le nom de la fonction. Les fonctions peuvent également être définies par des instructions de fonction, plutôt que par des expressions de fonction. Plus de contenu sera décrit au chapitre 8.
4. Expression d'accès à l'attribut
L'opération d'expression d'accès d'attribut obtient la valeur d'un objet ou d'un élément de tableau. JavaScript définit deux méthodes d'accès à la propriété.
La copie de code est la suivante:
expression . entenfiant
Expression [Expression]
La première façon est d'écrire une expression suivie d'une période et d'un identifiant. L'expression spécifie l'objet et l'identifiant spécifie l'attribut mingchuan à l'accès.
Le chapitre 2 est écrit à l'aide de crochets, qui est une expression (cette méthode convient aux objets et aux tableaux). La deuxième expression spécifie la propriété Mingchuan à accéder ou l'index représentant l'élément de tableau à accéder. Voici quelques exemples spécifiques
La copie de code est la suivante:
ox // => 1x attribut d'expression o
Oyz // => 3 z Attribut d'expression oy
o. ["x"] // => 1 objet O Attribut
a [1] // => 4 élément avec l'indice d'expression a est 1
A [2] ["1"] // => 6 Élément avec l'index 1 dans l'expression a [2]
a [0] .x // => 1: x attribut de l'expression a [0]
Quelle que soit la forme des expressions d'accès aux attributs utilisées, les expressions avant "." et "[" sont toujours évalués en premier. Si le résultat d'évaluation est nul ou non défini, l'expression lancera une exception d'erreur de type car aucune de ces valeurs ne peut contenir d'attributs. Si le résultat de l'opération n'est pas un objet ou un tableau, JavaScript le convertira en un objet (chapitre 3, section 6)
Bien que le .Identificateur soit écrit plus simplement, il convient de noter que cette méthode ne s'applique qu'au nom d'attribut pour être accessible et est un identifiant légal. Et vous devez connaître le nom de l'attribut à l'accès. Si le nom de la propriété est un mot réservé ou contient des espaces et des marques de ponctuation et est un nombre (pour un tableau), les crochets doivent être écrits. Lorsque le nom d'attribut est une valeur dérivée d'un opérateur plutôt qu'une valeur fixe, les crochets doivent être écrits. (Chapitre 6, 2, 1 bar)
5. Expression de transport
Une expression d'invocation dans JavaScript est une représentation de syntaxe de l'appel (ou de l'exécution) une fonction ou une méthode. Il commence par une expression de fonction qui fait référence à la fonction à appeler. L'expression de la fonction est suivie d'une paire de parenthèses, avec une liste de paramètres séparée par des virgules. Il peut y avoir 0 paramètres ou paramètres multiples.
F (0) // F est une expression de fonction: 0 est une expression de paramètre.
Math.max (x, y, z) //math.max est une fonction; x, y et z sont des paramètres
a.sort () //a.sort () est une fonction qui n'a pas de paramètres.
Lorsqu'une expression est appelée pour l'évaluation, calculez d'abord l'expression de la fonction, puis calculez l'expression des paramètres pour obtenir un ensemble de valeurs de paramètre. Si la valeur de l'expression de la fonction n'est pas un objet appelable, une exception d'erreur de type est lancée. Les valeurs des paramètres sont ensuite attribuées aux paramètres formels, qui sont définis lors de la définition de la fonction. Ensuite, exécutez le corps de la fonction. Si la fonction utilise l'instruction RETOUR pour donner une valeur de retour, cette valeur de retour est la valeur de toute l'expression de l'appel. Sinon, la valeur de l'expression appelée n'est pas définie. Les détails de l'appel de fonction - y compris le nombre d'expressions de paramètres formels et le nombre de paramètres réels dans la définition de la fonction - seront expliqués en détail au chapitre 8.
Toute expression d'appel contient une paire de parenthèses et d'expressions avant les parenthèses gauche. Si cette expression est une expression d'accès à la propriété, cet appel est appelé "Invitation de méthode". Lors de l'exécution d'un corps de fonction dans un appel de méthode, l'objet et le tableau qui sont accessibles en tant qu'attributs sont le pointeur de cela dans la méthode d'appel. Cette fonctionnalité permet aux fonctions (dont le nom OO est "Méthode") d'appeler leur objet hôte (plus sur le chapitre 9).
6. Expression de la création d'objets
L'expression de la création d'objets crée un objet et appelle une fonction (constructeur) pour initialiser les propriétés de l'objet. Les expressions de création d'objets sont très similaires aux expressions d'appel de fonction, sauf qu'il existe un mot-clé supplémentaire nouveau avant les expressions de création d'objets:
Nouveau objet ()
nouveau point (2,3)
Si l'expression de la création d'objets ne nécessite pas de paramètres pour être transmis au constructeur, cette paire de supports peut être omise. Plus de détails sur le constructeur seront expliqués au chapitre 9
nouvel objet
nouveau point
7. Aperçu des opérateurs
Les opérateurs en JavaScript sont utilisés pour calculer les expressions de table, les expressions de comparaison, les expressions logiques, les expressions d'affectation, etc.
Il convient de noter que la plupart des opérateurs sont représentés par des marques de ponctuation, telles que la suppression et l'instance OFF. Qu'il s'agisse d'opérateurs de mots clés ou d'opérateurs symboliques, les opérateurs représentés sont des opérateurs réguliers et leur syntaxe est très concise.
La priorité de l'opérateur d'indice est triée et la priorité de l'opérateur précédent est supérieure à la priorité de l'opérateur ultérieur. Les opérateurs séparés par Huafeng horizontal ont des priorités différentes.
A représente la nature contraignante de l'opérateur.
L de gauche à droite ou R (de droite à gauche)
La liste du titre N représente le nombre d'opérandes.
Le type représente le type de l'opérande attendu et le type de résultat de l'opérateur (après le symbole "→")
| Opérateurs | fonctionner | UN | N | taper |
| ++ | Avant / après l'incrément | R | 1 | lval → num |
| - | Réduire avant et après | R | 1 | lval → num |
| - | Chercher inverse | R | 1 | num → num |
| + | Convertir en nombres | R | 1 | num → num |
| ~ | Inversé | R | 1 | int → int |
| ! | Logique non logique | R | 1 | bool → bool |
| Supprimer la suppression | Supprimer les attributs | R | 1 | lval → bool |
| typeof | Détecter le type d'opération | R | 1 | n'importe quel → str |
| vide | Renvoie une valeur non définie | R | 1 | n'importe quel → undef |
| *, /,% | Multiplier et diviser pour trouver le reste | L | 2 | num, num → num |
| +, - | Ajouter, soustraire | L | 2 | num, num → num |
| + | Connexion de chaîne | L | 2 | str, str → str → str |
| << | Changement de gauche | L | 2 | int, int → int |
| >> | Changement de droite | L | 2 | int, int → int |
| >>> | Non signé | L | 2 | int, int → int |
| <, <=,>,> = | Comparez l'ordre des nombres | L | 2 | num, num → bool |
| <, <=,>,> = | Comparez la commande en lettres | L | 2 | str, str → bool |
| instance de | Tester la classe d'objets | L | 2 | obj, func → bool |
| dans | Testez si l'attribut existe | L | 2 | str, obj → bool |
| == | Jugement égal | L | 2 | tout, n'importe quel → bool |
| ! = | Jugement insatisfait | L | 2 | tout, n'importe quel → bool |
| === | Juger les qualités | L | 2 | tout, n'importe quel → bool |
| ! == | Juger non constant | L | 2 | tout, n'importe quel → bool |
| & | dans le monde et | L | 2 | int, int → int |
| ^ | XOR | L | 2 | int, int → int |
| | | bit ou | L | 2 | int, int → int |
| && | Logique et | L | 2 | n'importe quel → n'importe quel |
| || | Logique ou | L | 2 | n'importe quel → n'importe quel |
| ?: | Opérateur conditionnel | R | 3 | bool, tout, tout → tout |
| = | Affectation variable ou affectation d'attribut d'objet | R | 2 | lval, tout → tout |
* = / =% = + = - = & = ^ = | = << = >> = >>> = | Calculer et attribuer des valeurs | R | 2 | lval, tout → tout |
| , | Ignorer le premier opérande, Renvoie le deuxième opérande. | L | 2 | n'importe quel → n'importe quel |
je. Nombre d'opérandes
Les opérateurs peuvent être classés par le nombre d'opérandes.
La plupart des opérateurs en JavaScript sont des opérateurs binaires qui combinent deux expressions dans une expression légèrement plus complexe.
JavaScript prend également en charge certains opérateurs unaires qui convertissent une expression en une autre expression légèrement plus complexe. L'opérateur "-" dans l'expression -x est un opérateur unaire. C'est pour trouver une valeur négative pour x.
JavaScript prend en charge un opérateur ternaire: l'opérateur de jugement conditionnel "?:", Qui combine trois expressions en une seule expression
ii Type d'opérande et type de résultat
Certains opérateurs peuvent être utilisés pour n'importe quel type de données, mais ils veulent toujours qu'ils fonctionnent sur des données du type spécifié.
iii.lvalue
Les opérateurs d'affectation et les autres opérateurs du tableau s'attendent à ce que leur type d'opérande, LVALUE est un terme ancien. Cela signifie que "les expressions ne peuvent apparaître que sur le côté gauche de l'opérateur d'affectation". En JavaScript, les variables, les propriétés d'objets et les éléments de tableau sont tous des LVALUes. La spécification ECMAScript permet à une fonction intégrée de plage de renvoyer une LVALUE, mais les fonctions définies ne peuvent pas renvoyer une LVALUE.
iiii. priorité de l'opérateur
Dans le tableau ci-dessus, les opérateurs indiqués sont triés de haut à bas par priorité, avec un ensemble d'opérateurs dans chaque séparateur horizontal ayant la même priorité. La priorité de l'opérateur contrôle l'ordre dans lequel les opérateurs sont exécutés. Les opérateurs à haut (haut du tableau) sont toujours exécutés plus haut que les opérateurs avec une faible priorité (bas du tableau).
Voir l'expression suivante
w = x + y * z;
L'opérateur de multiplication "*" a une priorité plus élevée que l'addition "+", donc la multiplication est exécutée en premier. Ensuite, puisque l'opérateur d'affectation "=" a la priorité la plus basse. Par conséquent, l'opération d'attribution est effectuée après l'expression à droite calcule le résultat.
La priorité de l'opérateur peut être écrite à l'aide des parentaux de jardin. L'expression ci-dessus peut être écrite comme ceci.
w = (x + y) * z;
Il convient de noter que la priorité des expressions d'accès à la propriété et des expressions d'appel est supérieure à celle de tous les opérateurs du tableau.
typeof my.function [x] (y)
Bien que le typeof soit l'un des opérateurs de priorité les plus élevés, le typeof est également exécuté après deux accès à la propriété et des appels de fonction.
En fait, si vous n'êtes vraiment pas sûr de la priorité de l'opérateur que vous utilisez, le moyen le plus simple est d'utiliser des parentaux de jardin pour forcer l'ordre des opérations. Certaines règles importantes doivent être mémorisées: la multiplication et la division sont plus élevées que l'addition et la soustraction, et la priorité des opérations d'affectation est très faible et est généralement exécutée en dernier.
iiiiiii.opérationalité
Dans cette section, la colonne intitulée A illustre la noduness de l'opérateur. L fait référence à la combinaison de gauche à droite, et R fait référence à la combinaison de droite à gauche. La tuberculose spécifie l'ordre des opérations dans plusieurs expressions d'opérateurs avec la même priorité.
Par exemple, l'opération de soustraction est effectuée dans une combinaison de gauche à droite.
La copie de code est la suivante:
w = x - y - z
Comme ce code:
La copie de code est la suivante:
w = ((x - y) - z)
Inversement, l'expression suivante:
La copie de code est la suivante:
x = ~ -y;
w = x = y = z;
Q = a? B: C? D: E? F: G;
Exactement le même que ce code
La copie de code est la suivante:
x = ~ (-y);
w = (x = (y = z));
Q = a? B: (C? D: (E? F: G))
Parce que les opérateurs unaires, les affectations et les opérateurs de conditions ternaires ont tous une combinaison de droite à gauche.
iiiiiiiii.Operation ordonnance
La priorité et la liaison des opérateurs définissent leur ordre de fonctionnement dans l'équation d'attribution, mais ne spécifie pas l'ordre des opérations dans le processus de calcul des expressions de mots. JavaScript calcule toujours les expressions strictement dans l'ordre de gauche à droite, par exemple:
Dans l'expression w = x + y * z, l'expression w sera calculée d'abord, alors x, y et z seront calculés, puis les valeurs de y seront multipliées par Z, ajoutant la valeur de x. Enfin, la variable ou l'attribut mentionné par son expression w est mentionnée. L'ajout d'un support de cercle à une expression modifiera la relation entre les opérations de multiplication, d'addition et d'attribution. Mais l'ordre de gauche à droite ne changera pas.
8. Expressions arithmétiques
Cette section couvre ces opérateurs de calcul arithmétique, ainsi que les opérations arithmétiques sur les opérandes. Les opérateurs de multiplication, de division et de soustraction sont très simples. L'opération d'addition est une section distincte car l'opérateur d'addition peut faire fonctionner la concaténation des chaînes et sa conversion de type est quelque peu spéciale.
Les opérateurs arithmétiques de base sont *, /,%, +, -. En plus de + ajout, les autres opérateurs sont particulièrement simples. Ils sont juste convertis en nombres lorsque cela est nécessaire, puis ils peuvent trouver le produit, le quotient, le résidu (module) et la différence. Toutes les opérations qui ne peuvent pas être converties en nombres seront converties en valeurs NAN. Si l'opérande (ou le résultat de conversion) est une valeur nan, le résultat de l'opération arithmétique est également nan
L'opérateur "/" divise le deuxième opérande par le premier opérande, si vous avez utilisé des langages de programmation qui distinguent entier et le point flottant. Ensuite, lorsque vous divisez un entier par un entier, le résultat souhaité est également un entier. Dans JavaScript, tous les nombres sont des nombres à virgule flottante et le résultat des opérations de division est également des types de points flottants. Par exemple, le résultat de 5/2 est de 2,5, pas 2. Le résultat de l'opération avec le diviseur 0 est l'infini positif ou l'infini négatif. Et le résultat de 0/0 est nan. Toutes ces opérations ne signaleront pas les erreurs.
L'opérateur "%" calcule le module du premier opérande au deuxième opérande, en d'autres termes, le premier opérande est divisé par le reste du deuxième opérande. Le symbole de résultat est cohérent avec le premier symbole de souris d'opération (divisé). Par exemple, le résultat de 5% 2 est 1 et -5% 2 est -1.
Les opérandes de l'opérateur résident sont généralement des entiers, mais ils conviennent également aux nombres à virgule flottante. 6,5% 2.1 Le résultat est de 0,2. (0.19999999999999999973)
je. opérateur "+"
L'opérateur d'addition binaire "+" peut ajouter deux nombres ou des opérations de concaténate de chaîne:
La copie de code est la suivante:
1 + 2 // => 3
"Hello" + "" + "là" // => "Bonjour"
"1" + "2" // => "12"
Lorsque les deux opérandes sont des nombres ou des chaînes, les résultats du calcul sont évidents. Cependant, pour d'autres cas, une conversion de type nécessaire est nécessaire. Et le comportement de l'opérateur dépend du résultat de la conversion du type. Techniquement parlant, le comportement de l'opérateur d'addition est:
Si un opérande est un objet, l'objet suivra la règle de conversion de l'objet à la valeur d'origine à la valeur de classe d'origine (voir chapitre 3, section 8, 3). La date effectue une conversion sur la méthode d'objet toString (), tandis que d'autres objets effectuent une conversion via la méthode de valeur de () (si la méthode de valeur de () renvoie une valeur primitive). Étant donné que la plupart des objets n'ont pas la méthode de valeur disponible (), ils utiliseront la méthode toString () pour effectuer le rampage
Une fois que l'objet à la valeur d'origine a été converti, si l'une des opérations est une chaîne, l'autre opérande sera également converti en chaîne. Ensuite, faites la concaténation des cordes.
Sinon, les deux opérandes seront convertis en numéros (ou NAN) puis ajoutés.
Voici quelques exemples
La copie de code est la suivante:
1 + 2 // => 3 ajout
"1" + "2" // => "12" Connexion de chaîne
"1" + 2 // => "12" Les nombres sont convertis en chaînes et concaténés
1 + {} // => "1 [objet objet]": L'objet est converti en chaîne, puis la concaténation de la chaîne est effectuée.
Vrai + True // => 2 La valeur booléenne est convertie en nombre et ajoutée
2 + null // => 2 null converti en 0 et faire l'ajout
2 + Undefined // => nan non défini se convertit en nan pour l'ajout
Enfin, il est important de noter. Lorsque l'opération de signe plus est utilisée en ligne avec les chaînes, l'effet de l'addition sur l'ordre des opérations doit être pris en compte. C'est-à-dire que le résultat de l'opération dépend de l'ordre de fonctionnement de l'opérateur, par exemple
La copie de code est la suivante:
1 + 2 + "bmice" // => "3 bmice"
1 + (2 + "BMICE") => "12BMICE"
ii opérateur unary
L'opérateur Unary agit sur un opérande séparé. et générer une nouvelle valeur. En JavaScript, les opérateurs unaires ont une grande priorité et sont tous combinés à droite. Cette section décrit les opérateurs unaires (+, -, ++ et -), et lorsque cela est nécessaire, ils convertissent les opérations en nombres. Il convient de noter que + - est un opérateur unaire et est également un opérateur binaire.
Ajout d'un-yuan +
L'opérateur d'addition unaire convertit le numéro d'opérande en nombre (ou NAN) et renvoie le numéro converti. Si l'opérande lui-même est un nombre, le nombre est renvoyé directement.
Soustraction one-yuan-
Lorsque le signe est un opérateur unaire, il convertira l'opérande en un nombre selon les besoins, puis modifiera le symbole du résultat de l'opération.
Incrément ++
Incrémentez l'opérateur "++" pour incrémenter (+1) l'opérande, et l'opérande est un LVALUE (variable, élément de tableau ou attribut d'objet). L'opérateur convertit les opérandes en numéros. Ensuite, ajoutez 1 au nombre et réaffectez la valeur après avoir ajouté 1 à la variable, à l'élément de tableau ou à l'attribut objet.
L'opération Incrément ++ renvoie la valeur dépendante de sa position sur l'opérande.
Lorsque l'opérateur est avant le numéro de l'opérande, il est appelé l'opérateur "pré-incidence", qui calcule progressivement l'opérande et renvoie la valeur calculée.
Lorsque l'opérateur est après l'opérande, il est appelé l'opérateur "post-incidence". Il effectue des calculs incrémentiels sur l'opérande, mais renvoie la valeur non inscrite qui est utilisée pour les calculs incrémentiels. comme
var i = 1, j = ++ i // Les valeurs de i et j sont toutes deux 2
var i = 1, j = i ++; // i est 2, j est 1
Il convient de noter que la somme de ++ x = x + 1 est exactement la même. L'opérateur "++" n'effectue jamais des opérations de concaténation de chaîne. Il convertira toujours l'opérande en un nombre et l'augmentera de 1. Si x est la chaîne "1", le résultat de ++ x est le numéro 2, et x + 1 est la chaîne "11"
Les opérations décroissantes et incréments sont les mêmes, ce qui convertit les opérandes en un tableau puis soustrait de 1.
iii. opérateur de bits
L'opérateur de bits peut effectuer des opérations de niveau bit de niveau inférieur sur des données binaires représentées par des nombres. Bien qu'ils ne soient pas des opérations mathématiques pure traditionnelles, ils sont également classés ici comme opérateurs arithmétiques car ils agissent sur les opérations des types numériques et des numéros de retour. Ces opérateurs ne sont pas courants en JavaScript. (Non décrit ici, veuillez utiliser baidu pour plus de détails ~ - ~)
9. Expressions relationnelles
Cette section décrit les opérateurs relationnels de JavaScript. Les opérateurs relationnels sont utilisés pour tester la relation entre deux valeurs (égalité, inférieure à ou "attributs") et renvoient vrai et faux en fonction de la question de savoir si la relation existe. Les expressions relationnelles renvoient toujours une valeur booléenne et utilisent généralement des expressions relationnelles dans si ou pour les instructions (chapitre 5) pour contrôler le processus d'exécution du programme.
Les prochaines sections parleront de l'égalité et des opérations inégales, des opérateurs de comparaison et les deux autres personnages relationnels en javascript et par exemple
I Égalité et opérateurs inégaux
Les opérateurs "==" et "===" sont utilisés pour comparer si deux valeurs sont égales, et les deux opérateurs autorisent les opérateurs de tout type. Retour True s'il est égal, sinon renvoyez false. "===" est également appelé l'opérateur d'égalité strict (parfois appelé l'opérateur d'identité), qui est utilisé pour détecter si deux opérandes sont strictement égaux. L'opérateur "==" est appelé l'opérateur d'égalité. Il est utilisé pour détecter si deux opérandes sont égaux. La définition d'égalité ici est lâche et permet la conversion de type.
JavaScript prend en charge les opérateurs "=", "==", "===", vous devez comprendre les différences entre les opérateurs (affectation, égalité, identité). Et soyez prudent lors de la programmation. Afin de réduire la confusion, "=" "doit être appelé" get ou affecter "," == "" doit être appelé "égal", et "===" doit être appelé "strictement égal".
Les règles des opérateurs "! =" Et "! ==" sont "==", l'inverse de l'opérateur "===", et "!" est un non-opérateur booléen. Nous appelons "! =", "! ==" inégal et pas strictement égal.
La comparaison des objets JavaScript est une comparaison des références, et non une comparaison des valeurs. Les objets et eux-mêmes sont égaux, mais ils ne sont pas égaux aux personnes et aux objets. Si deux objets ont le même nombre d'attributs, les mêmes noms et valeurs d'attribut, ils sont toujours inégaux. Les éléments du tableau à la position correspondante sont égaux et deux tableaux sont également inégaux.
L'opérateur d'égalité stricte "===" Calculez d'abord la valeur de l'opérande, puis comparez ces deux valeurs. Il n'y a pas de conversion dans le processus de comparaison.
Si les deux types de valeur ne veulent pas être les mêmes, ils ne sont pas égaux
Si les deux valeurs sont nulles ou non définies, elles ne sont pas égales
Si les deux valeurs sont booléennes vraies ou fausses, elles sont égales
Si l'une des valeurs est NAN, ou les deux sont NAN, elles ne sont pas égales, et NAN et d'autres valeurs ne sont pas égales, y compris elle-même.
Si deux valeurs sont des nombres et sont égales, elles sont égales. Si une valeur est 0 et qu'une valeur est de -0, elles sont également égales.
Si les deux valeurs sont des chaînes et que les nombres à 16 chiffres (voir chapitre 3, 2) contenus dans les bits correspondants sont exactement égaux, ils sont égaux. Si leur longueur ou leur contenu sont différents, ils ne sont pas égaux. Les deux chaînes peuvent avoir exactement la même fonction et les caractères affichés sont les mêmes, mais ont des valeurs 16 bits qui ne sont pas codées. JavaScript n'effectue pas de conversions standard sur Unicode, donc ces chaînes ne sont pas égales par rapport aux opérateurs "===" et "==". String.LocaleCompare () dans la troisième partie fournit une autre façon de comparer les chaînes.
Si deux valeurs de référence pointent vers le même objet, le même tableau ou la même fonction, ils sont égaux. Si vous pointez vers différents objets, ce sont des inégalités, bien que les deux objets aient exactement les mêmes propriétés.
L'opérateur d'égalité "==" est similaire à l'opérateur d'identité, mais l'opérateur d'égalité n'est pas strictement comparé. Si les deux nombres ne sont pas du même type, l'opérateur d'égalité essaie de faire une conversion de type puis se compare.
Si les deux opérations sont les mêmes, les règles de comparaison pour les opérateurs d'égalité ci-dessus sont les mêmes. S'il est strictement égal, les résultats de comparaison sont égaux. S'ils ne sont pas strictement égaux, les résultats de comparaison ne sont pas égaux.
Si les deux types d'opération sont différents, l'opérateur "==" égal les considérera également égaux. La détection de l'égalité suivra les règles et les conversions de type suivantes:
Si un type est nul et que l'autre soit indéfini, ils sont égaux
Si une valeur est un nombre et l'autre est une chaîne, convertissez d'abord la chaîne en nombre, puis utilisez la valeur convertie pour la comparaison.
Si une valeur est vraie, elle est convertie en 1 puis comparée. Si une valeur est fausse, elle est convertie en 0 et comparée.
Si une valeur est un objet et l'autre est un nombre ou une chaîne, utilisez les règles de conversion de la méthode du chapitre 3, section 8, 3 pour convertir l'objet en valeur d'origine, puis la comparer. L'objet est converti en la valeur d'origine via la méthode toString () ou la méthode de valeur de (). Les classes intégrées dans le cœur de la langue JavaScript essaient d'abord d'utiliser VALLEOF (), puis essaient d'utiliser ToString (). En plus de la classe de date, la classe de date ne peut être convertie que via toString (). Les objets qui ne sont pas dans le cœur de la langue JavaScript sont convertis en valeurs d'origine par des méthodes définies dans l'implémentation.
Les comparaisons entre les autres types ne sont pas égales
Voici un petit exemple de jugement égal
"1" == true
Le résultat de cette expression est vrai, ce qui indique que les résultats de comparaison de types de valeurs complètement différents sont égaux. La valeur booléenne est vraie d'abord convertie au numéro 1, puis la comparaison est effectuée. Ensuite, la chaîne "1" est également convertie en nombre 1, car les valeurs des deux nombres sont égales, donc le résultat est vrai.
ii Opérateur de comparaison
Moins de (<)
Si le premier opérande est plus petit que le deuxième opérande, le résultat de l'opération "<" est vrai, sinon il est faux
Moins que ou égal à (<=)
Supérieur à (>)
Supérieur ou égal à (> =)
.... (Aucune introduction détaillée au sens)
Les opérandes de l'opérateur de comparaison peuvent être de tout type. Cependant, seuls les nombres et les chaînes peuvent réellement effectuer des opérateurs de comparaison, de sorte que les opérandes qui ne sont pas des nombres et des chaînes seront convertis. Les règles de conversion de type sont les suivantes:
Si l'opérande est un objet, il sera converti en valeur d'origine en fonction des règles de conversion décrites dans la section 3, section 8, 3: Si la valeur de () renvoie une valeur primitive, utilisez directement cette valeur d'origine. Sinon, utilisez le résultat de la conversion de toString () pour comparaison.
Après avoir converti en valeur d'origine, si les deux opérandes sont des chaînes, les deux chaînes seront comparées dans l'ordre de l'alphabet. Le "Order Alphabet" mentionné ici est l'ordre d'index des caractères Unicode 16 bits qui composent les deux chaînes.
Une fois l'objet converti en valeur d'origine, si au moins un opérande n'est pas une chaîne, les deux opérandes compareront les valeurs des nombres. 0 et -0 sont égaux. Tout autre nombre dans la paroi de l'infini est grand (sauf l'infini lui-même), -Infinty est plus petit que n'importe quel nombre (sauf lui-même). Si un opérande (ou converti) est nan, le caractère de comparaison renvoie toujours faux
Pour les opérateurs numériques et chaînes, le comportement de l'opérateur de signe plus est différent de l'opérateur de comparaison. L'ancienne préfère les chaînes et effectue des opérations de concaténation de chaîne si l'un de ses opérandes est une chaîne. Les opérateurs comparatifs ne préfèrent les nombres que lorsque les deux opérandes sont des chaînes de chaînes. Ce n'est qu'alors que la comparaison des chaînes sera effectuée.
La copie de code est la suivante:
1 + 2 // => 3 ajout, le résultat est 3
"1" + "2" // Connecter la chaîne, le résultat est "12"
"1" + 2 // Connect String, 2 est converti en "2", le résultat est "12"
11 <3 // La comparaison du nombre, le résultat est vrai
"11" <"3" // Comparaison du stand, le résultat est vrai
"11" <3 // Comparaison des nombres, "11" est converti en 11, et le résultat est vrai
"un" <3 // comparaison des nombres, "un" est converti en nan, et le résultat est faux
Enfin, il convient de noter que lors du jugement de l'égalité, les opérateurs "<=" et "> =" ne reposent pas sur l'opérateur d'égalité et les règles de comparaison de l'opération d'égalité stricte. Au contraire, l'opérateur Zhi qui est inférieur ou égal à est simplement "pas plus grand que", tandis que l'opération qui est supérieure ou égale à n'est "pas moins que". À une seule exception, lorsque l'opérande (après converti) est NAN, les 4 opérateurs de comparaison retourneront Fasle.
iii.in opérateur
L'opérateur in veut que son opérande gauche soit une chaîne ou peut être converti en chaîne, et espère qu'il est un objet à droite. Si l'objet à droite a un nom d'attribut appelé la valeur de l'opérande gauche, l'expression renvoie true. Par exemple
La copie de code est la suivante:
var point = {
X: 1,
Y: 1
} // définir un objet
"x" en point // => true l'objet a une propriété nommée x
"z" en point // => false l'objet n'a pas d'attribut de nom z
"toString" dans le point // => True objet hérite de la méthode de tostring
Var Data = [7, 8, 8]
"0" dans les données // => true le tableau contient 0
1 dans les données // => True Convert Number en chaîne
3 en données // => fase Aucun élément avec index de 3
IIII.Instance de l'opérateur
L'opérateur d'instance OFF souhaite que l'opérateur de gauche soit un objet et l'opérande droit indique la classe de l'objet. Si l'objet à gauche est une instance de la classe à droite, l'expression renvoie true; il est responsable du retour false. Le chapitre 9 en parlera. Les classes d'objets JavaScript sont définies en initialisant leurs constructeurs. De cette façon, le bon opérande d'instance de l'instance devrait être une fonction. Par exemple:
La copie de code est la suivante:
var d = new Date (); // construire un nouvel objet
d instance de date; //The result of the calculation is true, d is created by Date()
d instanceof Object //计算结果为true ,所有的对象都是Object的实例
d instanceof Number //计算结果为false，d不是一个Number对象
var a = [1,2,3] //数组直接量创建数组
a instanceof Array //计算结果true a为数组
a instanceof Object //true 所有的数组都是对象
a instanceof RegExp //fasle 数组不是正则表达式
需要注意的是，所有对象都是Object的实例。当通过instanceof盘对一个对象是否为一个类的实例的时候，这个判断也叫“父类”(superclass)的检测，如果instanceof的左侧操作对象不是对象的话，instanceof返回false。如果右侧操作不是函数，则抛出类型错误的异常。
为了理解instanceof运算符是如何工作的，必须首先理解“原型类”（prototype chain），原型链作为javascript的继承机制，将在6章2节2小节详细描述。
为了计算表达式o instanceof f ,javascript笔仙首先计算f.prototyoe,然后在原型链中查询o,如果找到，那么o是f（或者f的父类）的一个实例，那么返回true。反之false
10.逻辑表达式
逻辑运算符"&&"、“||”、“!”是对操作进行布尔算术运算，经常和关系运算符一起配合使用，逻辑运算符将多个关系表达式组合起来组成一个更复杂的表达式。
je. Logic and
"&&"运算符可以从三个不同的层次进行理解。最简单一层理解是，当操作数都是布尔值是，“&&”对两个布尔值执行布尔与（AND）操作，只有在第一个操作数和第二个操作数都是true的时候，它才返回true.如果其中有一个操作数为false.则它返回false.
"&&"长用来连接两个关系表达式
x == 0 && y == 0; //只有在x和y都是0时，才返回true
关系表达式总是返回true或false,因此当这样使用的时候，“&&”本身也返回true或false。关系运算符的优先级要比"&&"（和“||”）要高，因此类似这种表达式可以放心地书写，而不用补充园括号。
"&&"操作数并不一定是布尔值，回想一下，有些值是可以当做“真值”和“假值”的。（如3章3节，假值是:false null undefined 0 -0 NaN和""，所有和其它的值包括所有的对象都是真值）。对“&&”第二层理解是，“&&”是可以对真值和假值进行布尔与（AND）操作。如果两个操作数都是真值的，则那么返回一个真值；否则，至少一个操作数是假值的。javascript中在任何使用布尔值的地方的时候，表达式语句都会将其当做真值或假值来对待，因此实际上“&&”并不总是返回true和false.但也并无大碍。
需要注意的是，上文提到了运算符返回“真值”和“假值”，但并没说说明这个“真值”或者“假值”到底是什么值，为此我们深入讨论对“&&”第三层的理解。运算符首先计算左操作数的值，即首先计算“&&”左侧的表达式，如果计算结果是假值，那么整个表达式的结果一定是假值，因此“&&”这时简单的返回左操作的值，而并不会对右边的操作数进行计算。
La copie de code est la suivante:
var o = {
x: 1
};
var p = null;
o && ox; //=>1 : 1:0是真值，因此返回值是ox
p && px //= null :p是假值，因此将其返回，而并不计算px
这对于理解“&&”可能不计算右操作数的情况至关重要，在上述代码中，变量P的值是null，而如果计算px的话则会抛出一个异常错误，因此，只有p为真值（不能是null或undefined）的情况下才计算px
"&&"的行为有时候被称为“短路”（short circuiting）,我们经常能看到很多代码利用了这一也行来有条件的执行代码。例如下面的两条代码是等价的
La copie de code est la suivante:
if (a == b) stop(); //只有a==b时才能调运stop()
(a == b) && stop(); //同上
一般来讲，当“&&”右侧的表达式具有副作用的时候（赋值，递增，递减和函数调用表达式）要格外小心。因为这些带有副作用的表达式的执行时候，依赖于左操作鼠的计算结果。
尽管“&&”可以按照第二层和第三层的理解进行一些复杂的表达式运算，但大多数的情况下，“&&”仅用来对真值和假值的做布尔计算。
ii Logical or (||)
"||"运算符对两个操作数做布尔或（OR）运算。如果其中一个为真值，则返回真值，两个操作数都为假值，返回假值。
尽管“||”运算符大多情况下只是做简单的布尔或（OR）运算，和“&&”一样，也具备一些更复杂的行为，它首先计算第一个操作数的值，也就是说回首先计算左侧的表达式，如果计算结果为真，则返回真值，否则，再计算第二个值。
和“&&”一样，用于应该避免右操作数包含一些具有副作用的表达式，除非你目地明确在右侧使用带副作用的表达式，而有可能不会计算右侧的表达式。
这个运算符最常用的方式是用来从一组备选的表达中选取第一个真值的表达式。
La copie de code est la suivante:
//如果max_width已经定义了，则直接使用它。赋值在preferences对象中查找max_width
//如果没有定义它，则使用一个写死的常量。
var max =max_width || preferences.max_windth || 500;
这种贯用法通常在函数体内，用来给参数提供默认值。
La copie de code est la suivante:
//将o成功的属性复制到p中，并返回p
function copy(o, p) {
p = p || {}; //If no object is passed into the parameter p, a newly created object is used.
//函数体内的主逻辑
iii.逻辑非(!)
Le "!" operator is a unary operator that is placed before a separate operand. Its purpose is to invert the boolean value of the operand.
Unlike the "&&" and "||" operators, the "!" operator first converts its operands into a Boolean value (see the Rules in Chapter 3), and then inverses the Boolean value. C'est, "!" always returns true and false. Furthermore, the Boolean value of a value can be obtained by using two logical non-operations: (!!x, refer to Section 8, Section 2, Chapter 3)
"!" has a high priority and is closely tied to the operand. If you want to use p && q, you need to bracket! (p && q). The following code:
La copie de code est la suivante:
!(p && q) === !p || !q
!(p || q) === !p && !q
对于p和q取任何值，这两个表达式永远成立。
11.赋值表达式
javascript使用"="运算符给变量或者属性来赋值，例如：
La copie de code est la suivante:
i = 0 //将变量i设置为0
ox = 1 //将对象o的属性x 设置为1
“=”运算符希望它的左操作数为一个左值：一个变量或者对象属性（或数组元素），它的右操作鼠可以是任意的类型的任意值。赋值表达式的值就是右操作数的值。赋值表达式的副作用是，右操作数的值赋值给左侧的变量或对象属性。这样的话，后续对这个变量和对象的属性的引用都将得到这个值。
尽管赋值表达式的值非常简单，但有时候会看到一些复杂表达式包含赋值表达式的情况。例如：将赋值和检测操作放在一个表达式中：
La copie de code est la suivante:
(a = b) == 0
如果这样的话，应该清楚地知道"="和"=="区别！，需要注意的是，“=”有非常低的优先级，通常在一个较长的表达式中用到一条赋值语句时，需要补充园括号以保障正确的运算顺序。
赋值操作符的结合性是从右至左，也就是说，一个表达式中出现了多个赋值运算符，运算顺序也从右至左，因此，可以通过以下方式对多个变量赋值。
La copie de code est la suivante:
i=j=k=0; //把三个变量初始化为0
带操作的赋值运算：
除了常规的赋值运算外，javascript还支持需要其他的赋值运算符，这些运算符将赋值运算符合其他的运算符连接起来。提供一种更为快捷的运算方式。例如+=运算符执行的是加法运算符和赋值操作，下面的表达式：
total += salaes_tax;
和下面的表达式等价的
total = total + salaes_tax
运算符“+=”可以作用于数字或字符串，如果其操作是数字，它将执行加法运算和赋值操作；如果是字符串，他就执行字符串的连接和赋值操作。
此类型的运算符还包括，"-=","*=","&="等，如下表赋值运算符
运算符示例等价于
+=a+=ba=a+b
-=a-=ba=ab
*=a*=ba=a*b
/=a/=ba=a/b
%=a%=ba=a%b
<<=a<<=ba=a<<b
>>=a>>=ba=a>>b
>>>=a>>>=ba=a>>>b
&=a&=ba=a&b
|=a|=ba=a|b
^=a^=ba=a^b
大多数情况下，表达式为
a op =b
这里的op代表一个运算符，这个表达式等价于
a =a op b
在第一行中，表达式a计算了一次，在第二行中，表达式a计算了两次。
只有a包含具有副作用的表达式（比如函数调用和赋值操作）的时候，两者才不等价。如下两个表达式不等价
La copie de code est la suivante:
data[i++] *= 2;
data[i++] = data[i++] * 2
12.表达式计算
和很多解释性语言一样，javascript同样可以解释运行由javascript源代码组成的字符串，并产生一个值。javascript通过全局函数eval()来完成这个工作。
eval("3+2") //=>5
动态判断源代码中的字符串是一种强大语言的特性，几乎没有必要在实际中应用。如果你使用了eval()，你应该仔细考虑真的需要它。
下面降价eval()基础用法，并介绍两种严格使用它的方法，从代码优化的角度来讲，这两种方法对原有的代码影响是最小的。
i.eval （eval()是一个函数，但由于它已经被当做运算符来对待了。）
eval()只有一个参数，如果传入的参数不是字符串，它直接返回这个参数。如果参数是字符串，它会把字符串当成javascript进行编译(parse)，如果编译失败则抛出一个语法错误(SyntaxError)。如果编译成功，则开始执行这段代码，并返回字符串中最后一个表达式或语句的值，如果最后一个表达式没有语句或者值，则最终返回undefined。如果字符串抛出一个异常，这个异常把该调用的传给eval()
关于eveal()最重要的是，它使用了调用它的变量作用域环境，也就是说，它查找变量的值和定义新变量和函数的操作和局部的代码作用域中的代码一样。如果一个函数定义了一个局部变量x,然后调用了eval("x"),它会返回局部变量的值。如果它调用eval("x=1"),它会改变局部变量的值。如果函数调用了eval("var y=3;")它声明一个新的局部变量y。同样的，一个函数可以通过如下代码声明一个局部函数：
eval("function f(){return x+1;}");
如果最顶层的代码中调用了eval()。当然它会作用于全局变量和全局函数。
ii Global eval()
eval()具有改变局部变量的能力，这对javascript优化器来说，是一个很大的问题，然而作为一种权宜之计，javascript征对那行调用了eval()函数所做的优化并不多。但当脚本定义了一个别名，并且用令一个名称来调用它，javascript解释器又如何工作呢，为了javascript解释器更加简化。ECMAScipt3标准规定了任何解释器都不允许对eval()赋予别名。如果eval()使用别的别名来调用的话，则会抛出EvalError异常。
实际上，大多数的实现并不是这样做的。当通过别名调用时，eval()会将其字符串当成顶层的全局代码来执行。执行代码可能会定义新的全局变量和全局函数。执行的代码可能会定义新的全局变量和全局函数，或者给全局变量赋值。但却不能修改或修改主调函数中的局部变量，因此这不会影响到函数内的代码优化。
ECMAScript5是反对使用EvalError的，并且规范了eval()的行为。“直接的eval”，当直接使用非限定的“eval”名称，来调用eval()函数时，它总共是在它的上下文作用域内支线。其它间接调用则使用全局函数为其上下文作用域。并且无法读、写、定义局部变量和函数。下面有一段代码实例：
La copie de code est la suivante:
var geval = eval; //使用别名调用eval将是全局eval
var x = "global",
y = "global"; //两个全局变量
function f() { //函数内执行的局部eval
var x = "local" //定于局部变量
eval("x += 'changed';"); //直接eval更改了局部变量的
return x; //返回更改后的局部变量
}
function g() { //这个函数执行了全局eval
var y = "local" //定义了局部变量
geval("y += 'changed';"); //间接改变了局部变量的值
return y; //返回未更改的局部变量
}
console.log(f(), x); //更改了局部变量，输出local changed global
console.log(g(), y); //更改了全局变量，输出local globalchanged
13.其它运算符。
javascript支持很多其它各种各样的运算符。
je. Conditional operator (?:)
The conditional operator is the only ternary operator in javascript. Usually this operator is written as "?:". This operator has the third operand, the first operand is before "?", and the second operand is between "?" et ":". The third operand is long after ":", e.g.
x > 0 ? x : -x; //求x的绝对值
条件运算符的操作数可以是任意类型。第一个操作数当成布尔值，如果它是真值，那么将计算第二个操作数，并返回计算结果。赋值如果第一个值操作数是假值，那么将计算第三个操作数。并返回计算结果。第二个和第三个操作数总会计算其中之一。不可能两者同时进行。其实使用if语句也达到同样的效果(5.4.1),“?:”运算符只是提供了一种简写形式。这里是一个"?:"的典型使用场景，判断一个变量是否有定义，如果有定义则使用它，如果无定义，则使用一个默认值。
La copie de code est la suivante:
grett = "hello" + (username ? username : "three");
和以下的代码是等价的，但上面的更加简洁
La copie de code est la suivante:
grett = "hello";
if (username)
grett += username;
autre
grett + "three"
ii.typeof()运算符
typeof是一元运算符，放在单个操作数前面，操作数可以是任何类型，返回值表示操作类型的一个字符串。
La copie de code est la suivante:
x __ typeof x
undefined __ "undefined"
null __ "object"
ture或false __"boolean"
任意数字或NaN __ "Number"
任意字符串__ "String"
任意函数__ "function"
任意内容对象（非函数）__ "object"
任意宿主对象__ 由编译器各自实现的字符串，但不是"undefined" "boolean" "number" "string"
typeof最常用的用法写在表达式中们就像这样
(typeof value == "string") ? "" + value + "":value;
typeof运算符同样在swith语句中（5.4.3）非常有用，需要注意的是，typeof运算可以带上园括号。这样让typeof看起来像一个函数名，而非关键字
typeof(i)
iii.delete运算符
delete是一元操作符，它用来删除对象的属性或者数组的元素。就像赋值、递增、递减运算符一样。delete也是具有副作用的。它是用来做删除操作的。不是用来返回一个值的。
La copie de code est la suivante:
var o = {
x: 1,
y: 2
}
delete ox;
"x" in o; //=>false
var a = [1, 2, 3];
delete a[2]; // 删除数组中最后一个元素
2 in a; //=> false 元素2已经在数组中不存在了
a.length; //=>3,注意，数组长度并没有改变，尽管上一行删除了这个元素，但删除操作留下了一个洞。实际上并没有修改数组的长度，因此a的长度仍然为3
需要注意的是，删除属性或删除数组元素不仅仅设置了一个undefined值，当删除一个属性时，这个属性不复存在。读取一个不存在的值将会返回undefined.关于delete删除还有严格模式下的一些情况，需要学习的人自己试验，这里给一些例子。
La copie de code est la suivante:
var o = {x: 1,y: 2};
delete ox; //删除一个对象属性，返回true
typeof ox; //属性不存在，返回"undefined"
delete ox; //删除不存在的属性，返回true;
delete o; //不能删除通过var关键字声明的变量，返回false
delete 1; //参数不是一个左值。
this.x = 1;// 给全局定义一个属性，这里没有使用var
delete x ; //试图删除它，在非严格模式下返回true
//在严格模式下回抛出异常，这时使用"delete this.x"来代替
x; //运行时出错，没有定义x
6章第三节还有关于delete的讨论。
iii.void运算符。
void是一元运算符，在出现操作数之前，操作数可以是任何类型。这个运算符并不是经常使用：操作数会照常计算，但会忽略计算结果并返回undefined。由于void会忽略操作数的值，因此在操作数具有副作用时使用void来程序更有意义。
这个最常用的带客户端url.在url写带有副作用的表达式，而void则让浏览器不显示在这个表达式的运算结果。
La copie de code est la suivante:
<a href="javascript:void window.open();">new</a>
iiii.逗号运算符。(,)
逗号运算符是二元运算符，它的操作数可以是任意类型。它首先计算左操作数，然后计算右操作数。
La copie de code est la suivante:
i = 0, j = 1, k = 2;
它和下面的代码基本上等价的
i = 0; j = 1; k = 2;
总是会计算左侧的表达式，但计算结果忽略掉，也就是说，只有左侧表达式具有副作用，才会使用逗号运算让代码变得更通畅。逗号运算符最常用的场景是for循环中，这个for循环通常有多个循环变量。
La copie de code est la suivante:
//for循环中的第一个逗号是var语句的一部分
//第二个逗号是逗号运算符
//它将两个表达式(i++和j++)放在一条(for循环中)语句中
for (var i = 0, j = 10; i < j; i++, j--);
console.log(i + j);