Une expression est une phrase en JavaScript que l'interpréteur JavaScript calculera pour obtenir un résultat. Le type d’expression le plus simple couramment utilisé dans les programmes est celui des variables. Un nom de variable est également une expression simple et sa valeur est la valeur attribuée à la variable.
Les expressions complexes sont composées d'expressions simples. Par exemple, une expression d'accès à un tableau se compose d'une expression représentant un tableau, de crochets et d'une expression entière. Le résultat de la nouvelle expression qu’ils forment est la valeur de l’élément à une position spécifique du tableau. Même lettre
L'expression d'appel numérique se compose d'une expression représentant un objet fonction et de 0 expressions de paramètres multiples. La manière la plus courante de combiner des expressions simples en expressions complexes consiste à utiliser des opérateurs.
Ce chapitre (cet article) expliquera tous les opérateurs javascript. Il explique également les expressions qui n'impliquent pas d'opérateurs (comme l'accès aux éléments d'un tableau et aux appels de fonction). Sa syntaxe et son style de programmation sont très similaires à ceux du langage C.
1.Expression des éléments
Les expressions les plus simples sont les "expressions primitives", qui sont les plus petites unités d'expressions - elles ne contiennent aucune autre expression. Les expressions primitives en JavaScript contiennent des constantes ou des littéraux. Mots-clés et variables.
Les quantités directes sont des valeurs constantes qui apparaissent directement dans le programme. Ils ressemblent à :
L'initialisation d'objets et de tableaux est en fait des objets et des tableaux nouvellement créés. Ces expressions d'initialisation sont parfois appelées « littéraux d'objet » et « littéraux de tableau ». Cependant, contrairement aux littéraux booléens, ce ne sont pas des expressions primitives car les membres ou é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 par ce qui suit
.L'expression d'initialisation du tableau est composée d'une paire de crochets et d'une liste séparées par des virgules. Le résultat de l'initialisation est un tableau nouvellement créé. Les éléments du tableau sont les valeurs d'une expression séparées par des virgules.
[] //Un tableau vide ; laisser vide entre [] signifie que le tableau ne contient aucun élément
[1 2,3 4] //Tableau avec deux éléments, le premier est 3, le second est 7
Une expression d’initialisation d’élément dans une expression d’initialisation de tableau peut être une expression d’initialisation de tableau. En d'autres termes, les expressions peuvent être imbriquées
Quatre des éléments ne sont pas définis. Laisser une virgule à la fin du littéral du tableau ne créera pas un nouvel élément avec une valeur indéfinie.
Les expressions d'initialisation d'objet sont très similaires aux expressions d'initialisation de tableau, sauf que les crochets sont remplacés par des accolades. Et chaque sous-expression contient un nom de propriété et un préfixe autre que deux points.
Les littéraux d'objet peuvent également être imbriqués, tels que
3. Expression 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 littéraux de fonction, et les expressions de fonction peuvent être appelées « littéraux de fonction ». Après tout, les expressions d'initialisation d'objet sont également appelées « littéraux d'objet ». Une expression de définition de fonction typique contient le mot-clé function, suivi d'une paire de parenthèses. À l'intérieur des parenthèses se trouve une liste séparée par des virgules contenant 0 ou plusieurs identifiants (noms de paramètres). Suivez ensuite le segment de code JavaScript (corps de la fonction) entouré d'accolades.var carré = function(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 via des instructions de fonction au lieu d'expressions de fonction. Plus de détails seront décrits au chapitre 8.
4. Expression d'accès aux attributs
L'opération d'expression d'accès aux attributs obtient la valeur d'un objet ou d'un élément de tableau. JavaScript définit deux méthodes d'accès aux propriétés.
Le chapitre 2 est écrit entre crochets, et à l'intérieur des crochets se trouve une expression (cette méthode s'applique aux objets et aux tableaux). La deuxième expression spécifie l'index de la propriété à laquelle accéder ou représente l'index de l'élément du tableau auquel accéder. Voici quelques exemples concrets
Quelle que soit la forme d'expression d'accès aux attributs utilisée, les expressions avant "." et "[" seront toujours évaluées en premier. Si l’expression est évaluée à null ou non définie, elle lèvera une exception TypeError car aucune des deux valeurs ne peut contenir de propriétés. Si le résultat de l'opération n'est pas un objet ou un tableau, JavaScript le convertira en objet (Chapitre 3, Section 6)
Bien que .identifier soit plus simple à écrire, il convient de noter que cette méthode n'est applicable que lorsque le nom de l'attribut auquel accéder est un identifiant légal. Et besoin de connaître le nom de l’attribut auquel accéder. Si le nom de la propriété est un mot réservé ou contient des espaces et des signes de ponctuation, ou est un nombre (pour les tableaux), il doit être écrit entre crochets. Lorsque le nom de l'attribut est une valeur obtenue par un opérateur plutôt qu'une valeur fixe, des crochets doivent être utilisés. (Chapitre 6, verset 2, section 1)
5. Expression du mouvement
L'expression d'invocation en JavaScript est une représentation grammaticale de l'appel (ou de l'exécution) d'une fonction ou d'une méthode. Cela commence par une expression de fonction qui fait référence à la fonction à appeler. Une expression de fonction est suivie d'une paire de parenthèses contenant une liste de paramètres séparés par des virgules. Il peut y avoir 0 ou plusieurs paramètres.
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, elle n'a pas de paramètres.
Lorsqu'une expression est appelée pour évaluation, l'expression de fonction est d'abord évaluée, puis l'expression de paramètre est évaluée pour obtenir un ensemble de valeurs de paramètre. Si la valeur de l'expression de fonction n'est pas un objet appelable, une exception d'erreur de type est levée. Ensuite, les valeurs des paramètres sont affectées à leur tour aux paramètres formels, qui sont définis lors de la définition de la fonction. Exécutez ensuite le corps de la fonction. Si la fonction utilise l'instruction return pour donner une valeur de retour, alors la valeur de retour est la valeur de l'intégralité de l'expression appelante. Sinon, la valeur de l'expression appelante n'est pas définie. Les détails des appels de fonction, y compris ce qui se passe lorsque le nombre d'expressions de paramètres formels ne correspond pas au 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 l'expression avant la parenthèse gauche. Si l'expression est une expression d'accès à une propriété, alors l'appel est appelé une "inviation de méthode". Lorsque le corps de la fonction est exécuté dans un appel de méthode, les objets et tableaux utilisés comme attributs pour accéder au corps en sont les points dans la méthode appelante. Cette propriété permet à une fonction (dont le nom OO est une « méthode ») d'appeler son objet hôte dans le paradigme de programmation orientée objet (plus de détails à ce sujet au chapitre 9).
6. Expression de création d'objet
L'expression de création d'objet crée un objet et appelle une fonction (constructeur) pour initialiser les propriétés de l'objet. Les expressions de création d'objet sont très similaires aux expressions d'appel de fonction, sauf qu'il existe un mot-clé supplémentaire new:
avant l'expression de création d'objet. nouvel Objet()
nouveau Point(2,3)
Si l'expression de création d'objet ne nécessite qu'aucun paramètre soit transmis au constructeur, alors cette paire de parenthèses peut être omise. Plus de détails sur le constructeur seront expliqués au chapitre 9
nouvel objet
nouveau point
7. Aperçu de l'opérateur
Les opérateurs en JavaScript sont utilisés pour 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 signes de ponctuation, tels que delete et instanceof. Qu'il s'agisse d'opérateurs de mots-clés ou d'opérateurs symboliques, les opérateurs représentés sont tous des opérateurs réguliers et leur syntaxe est très concise et complète.
Trié par priorité des opérateurs d'indice, la priorité de l'opérateur est supérieure à la priorité de ce dernier opérateur. Les opérateurs séparés par des scalaires horizontaux ont une priorité différente.
A représente l'associativité de l'opérateur.
L de gauche à droite ou R (de droite à gauche)
La liste d'en-tête N représente le nombre d'opérandes.
Le type indique le type des opérandes attendus, et le type de résultat de l'opérateur (après le symbole "→")
| Opérateur | Fonctionnement | A | N | Tapez |
| Incrément pré/post | R | 1 | lval→num | |
| -- | Diminution avant et après | R | 1 | lval→num |
| - | Inverser | R | 1 | num→num |
| Convertir en nombre | R | 1 | num→num | |
| ~ | Négation au niveau du bit | R | 1 | int→int |
| ! | NON logique | R | 1 | bool → bool |
| supprimer | Supprimer les attributs | R | 1 | lval→bool |
| type de | Détecter le type d'opération | R | 1 | any→Str |
| vide | Renvoyer une valeur non définie | R | 1 | any→undef |
| *,/,% | Multipliez et divisez pour trouver le reste | L | 2 | num, num→num |
| , - | Ajouter, soustraire | L | 2 | num, num→num |
| Concaténation de chaînes | L | 2 | str, str→str | |
| << | Décalage vers la gauche | L | 2 | int, int→int |
| >> | Décaler vers la droite | L | 2 | int, int→int |
| >>> | Décalage à droite non signé |
L |
2 | int, int→int |
| <, <=, >, >= | Comparer l'ordre numérique | L | 2 | num,num→bool |
| <, <=, >, >= | Comparez la commande en lettres | L | 2 | str, str→bool |
| instance de | Classe d'objet de test | L | 2 | obj, func→bool |
| dans | Tester si l'attribut existe | L | 2 | str,obj→bool |
| == | Jugement d'égalité | L | 2 | n'importe lequel, n'importe lequel→bool |
| ! = | Jugement inégal | L | 2 | n'importe lequel, n'importe lequel→bool |
| === | Identité du juge | L | 2 | n'importe lequel, n'importe lequel→bool |
| ! == | Juger la non-identité | L | 2 | n'importe lequel, n'importe lequel→bool |
| & | ET au niveau du bit | L | 2 | int, int→int |
| ^ | XOR au niveau du bit | L | 2 | int, int→int |
| | | OU au niveau du bit | L | 2 | int, int→int |
| && | ET logique | L | 2 | n'importe lequel, n'importe lequel→n'importe lequel |
| || | OU Logique | L | 2 | n'importe lequel, n'importe lequel→n'importe lequel |
| ?: | Opérateur conditionnel | R | 3 | bool, any, any→any |
| = | Affectation de variable ou affectation de propriété d'objet | R | 2 | lval, n'importe lequel → n'importe lequel |
|
*= /= %= = -= &= ^= |= <<= >>= >>>= |
Fonctionnement et affectation | R | 2 | lval, n'importe lequel → n'importe lequel |
| , |
Ignorer le premier opérande, Renvoie le deuxième opérande. |
L | 2 | n'importe lequel, n'importe lequel→n'importe lequel |
i.Nombre d'opérandes
Les opérateurs peuvent être classés selon le nombre d'opérandes.
La plupart des opérateurs en JavaScript sont des opérateurs binaires, combinant deux expressions en 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. est de prendre la valeur négative de x.
JavaScript prend en charge un opérateur ternaire : l'opérateur de jugement conditionnel "?:", qui combine trois expressions en une seule
ii.Type d'opérande et type de résultat
Certains opérateurs peuvent être utilisés sur n'importe quel type de données, mais vous êtes toujours censé opérer sur des données d'un type spécifié.
iii. Valeur gauche
L'opérateur d'affectation et quelques autres opérateurs du tableau s'attendent à ce que leurs opérandes soient de type lval, lvalue étant un terme archaïque. Cela signifie "une expression ne peut apparaître que sur le côté gauche d'un opérateur d'affectation". En JavaScript, les variables, les propriétés d'objet et les éléments de tableau sont tous des valeurs l. La spécification ECMAScript permet aux fonctions intégrées étendues de renvoyer une valeur l, mais les fonctions définies ne le peuvent pas.
iiii.Priorité des opérateurs
Dans le tableau ci-dessus, les opérateurs affichés sont classés de priorité élevée à faible, et un groupe d'opérateurs au sein de chaque ligne de démarcation horizontale a la même priorité. La priorité des opérateurs contrôle l'ordre dans lequel les opérateurs sont exécutés. Les opérateurs avec une priorité plus élevée (en haut du tableau) sont toujours exécutés avant les opérateurs avec une priorité inférieure (en bas du tableau).
Regardez l'expression suivante
w=x y*z;
L'opérateur de multiplication "*" a une priorité plus élevée que l'addition " ", la multiplication est donc 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’affectation est effectuée une fois que l’expression du côté droit a été évaluée.
La priorité des opérateurs peut être écrite à l'aide de parenthèses. L’expression ci-dessus peut s’écrire ainsi.
w = (x y) * z;
Notez que les expressions d'accès aux propriétés et les expressions d'appel ont une priorité plus élevée que tous les opérateurs du tableau.
type de ma.Fonction[x](y)
Bien que typeof soit l'un des opérateurs de priorité la plus élevée, typeof est également exécuté après deux accès aux propriétés et appels de fonction.
En fait, si vous n'êtes vraiment pas sûr de la priorité des opérateurs que vous utilisez, le plus simple est d'utiliser des parenthèses pour forcer l'ordre des opérations. Il y a quelques règles importantes à retenir : la multiplication et la division sont supérieures à l'addition et à la soustraction, et les opérations d'affectation ont une très faible priorité et sont généralement exécutées en dernier.
iiiiii. Associativité des opérateurs
Dans cette section du tableau, la colonne intitulée A décrit la nodularité de l'opérateur. L signifie combiner de gauche à droite, R signifie combiner de droite à gauche. Tuberculity spécifie l'ordre des opérations dans plusieurs expressions d'opérateurs avec la même priorité.
Par exemple, les opérations de soustraction sont effectuées de manière associative de gauche à droite.
Identique à ce code :
À l'inverse, l'expression suivante :
Exactement le même que ce code
Parce que les opérateurs unaires, les affectations et les opérateurs conditionnels ternaires ont tous une associativité de droite à gauche.
iiiiiii. Ordre des opérations
La priorité et l'associativité des opérateurs précisent leur ordre d'opérations dans l'expression d'affectation, mais ne précisent pas l'ordre des opérations dans le processus de calcul des sous-expressions. JavaScript évalue toujours les expressions strictement de gauche à droite, par exemple :
Dans l'expression w=x y*z, l'expression w sera calculée en premier, puis x, y et z seront calculés. Ensuite, la valeur de y est multipliée par z et la valeur de x est ajoutée. Enfin, la variable ou l'attribut pointé par son expression w. L'ajout de parenthèses à une expression modifie la relation entre les opérations de multiplication, d'addition et d'affectation. Mais l’ordre de gauche à droite ne changera pas.
8. Expressions arithmétiques
Cette section couvre les opérateurs qui effectuent des calculs arithmétiques, ainsi que des opérations arithmétiques sur les opérandes. Les opérateurs de multiplication, division et soustraction sont très simples. L'opération d'addition est une section distincte, car l'opérateur d'addition peut opérer la concaténation de chaînes et sa conversion de type est quelque peu spéciale.
Les opérateurs arithmétiques de base sont *, /, %, , -. À l'exception de l'addition, les autres opérateurs sont très simples. Ils convertissent simplement les opérateurs en nombres lorsque cela est nécessaire, puis calculent le produit, le quotient, le reste (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 résultat de la 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 font la distinction entre les entiers et les nombres à virgule flottante. Ensuite, en divisant un entier par un entier, le résultat souhaité est également un entier. Tous les nombres en JavaScript sont de type à virgule flottante et les résultats des opérations de division sont également de type à virgule flottante. Par exemple, le résultat de 5/2 est 2,5 et non 2. Le résultat d’une opération qui divise par 0 est l’infini positif ou l’infini négatif. Et le résultat de 0/0 est NaN. Toutes ces opérations sont sans erreur.
L'opérateur "%" calcule le module du premier opérande au deuxième opérande. Autrement dit, c'est le reste du premier opérande divisé par le deuxième opérande. Le signe du résultat reste le même que le signe du premier opérande (le dividende). Par exemple, le résultat de 5%2 est 1 et le résultat de -5%2 est -1.
Les opérandes de l'opérateur reste sont généralement des entiers, mais ils fonctionnent également avec des nombres à virgule flottante. 6,5%2,1 s'avère être 0,2. (0.199999999999999973)
i. " opérateur
L'opérateur d'addition binaire " " peut ajouter deux nombres, et peut également effectuer des opérations de concaténation de chaînes :
Lorsque les deux opérandes sont des nombres ou des chaînes, le résultat du calcul est évident. Cependant, dans d'autres cas, certaines conversions de type nécessaires doivent être effectuées. Et le comportement de l'opérateur dépend du résultat de la conversion de type. Techniquement parlant, l'opérateur d'addition se comporte ainsi :
Si un opérande est un objet, l'objet sera converti en valeur de classe primitive en suivant les règles de conversion des objets en valeurs primitives (voir Chapitre 3, Section 8, Section 3). Les dates sont converties par la méthode d'objets toString() et les autres objets sont convertis par la méthode valueOf() (si la méthode valueOf() renvoie une valeur primitive). Étant donné que la plupart des objets n'ont pas de méthode valueOf() disponible, ils effectueront la capture et le remplacement via la méthode toString()
Après avoir converti l'objet en valeur primitive, si l'un des opérandes est une chaîne, l'autre opérande est également converti en chaîne. Effectuez ensuite la concaténation des chaînes.
Sinon, les deux opérandes sont convertis en nombres (ou NaN) et l'opération d'addition est effectuée.
Voici quelques exemples
Enfin, quelque chose de spécial à noter. Lorsque l'opération d'addition est utilisée avec des chaînes, l'effet de l'addition sur l'ordre des opérations doit être pris en compte. Autrement dit, le résultat de l'opération dépend de l'ordre des opérations des opérateurs, comme
ii. Opérateur unaire
Les opérateurs unaires agissent sur un seul opérande. et produire une nouvelle valeur. En JavaScript, les opérateurs unaires ont une priorité élevée et sont associatifs à droite. Cette section décrit les opérateurs unaires ( ,- et --), qui convertissent les opérations en nombres si nécessaire. Il est à noter que - est un opérateur unaire et un opérateur binaire,
Un dollar supplémentaire
L'opérateur d'addition unaire convertit le numéro d'opérande en nombre (ou NaN) et renvoie le nombre converti. Si l'opérande lui-même est un nombre, ce nombre est renvoyé directement.
Soustraction d'un dollar-
Lorsque le signe - est utilisé comme opérateur unaire, il convertira les opérandes en nombres selon les besoins, puis changera le signe du résultat de l'opération
.incrément
L'opérateur d'incrémentation " " effectue une opération d'incrémentation (1) sur son opérande, qui est une lvalue (variable, élément de tableau ou attribut d'objet). Les opérateurs convertissent les opérandes en nombres. Ajoutez ensuite 1 au nombre et réaffectez la valeur ajoutée à une variable, un élément de tableau ou une propriété d'objet.
Incrément La valeur de retour d'une opération dépend de la position de ses opérandes.
Lorsque l'opérateur précède l'opérande, on l'appelle opérateur "pré-incrémenté". Il effectue des calculs incrémentaux sur l'opérande et renvoie la valeur calculée.
Lorsque l'opérateur est après l'opérande, on l'appelle un opérateur "post-incrémenté". Il effectue un calcul incrémental sur l'opérande, mais renvoie une valeur non incrémentée. Comme
var i = 1,j = i //Les valeursde i et j sont toutes deux 2
var i = 1,j = i; //i vaut 2, j vaut 1
Il est à noter que, tout comme x et sum x=x 1, l'opérateur " " n'effectue jamais de concaténation de chaînes, il convertit toujours l'opérande en nombre et l'incrémente de 1. Si x est la chaîne "1", le résultat de x est le nombre 2, et x 1 est la chaîne "11"
La méthode de fonctionnement de décrémentation et d'incrémentation est la même. Elle convertit l'opérande en tableau puis le diminue de 1.
iii. Opérateurs de bits
Les opérateurs au niveau du bit peuvent effectuer des opérations au niveau du bit de niveau inférieur sur des données binaires représentées par des nombres. Bien qu’il ne s’agisse pas d’opérations mathématiques pures traditionnelles, elles sont classées ici comme opérateurs arithmétiques car elles opèrent sur des types numériques et renvoient des nombres. Ces opérateurs sont rares en JavaScript. (Non décrit ici, veuillez vous référer à Baidu pour plus de détails~-~)
9. Expressions relationnelles
Cette section décrit les opérateurs relationnels de JavaScript. Les opérateurs relationnels permettent de tester la relation entre deux valeurs (égal, inférieur à ou "est un attribut de..."), et renvoient vrai et faux en fonction de. si la relation existe. Les expressions relationnelles renvoient toujours une valeur booléenne. Les expressions relationnelles sont généralement utilisées dans les instructions if while ou for (Chapitre 5) pour contrôler le flux d'exécution du programme.Les prochaines sections parleront des opérations d'égalité et d'inégalité, des opérateurs de comparaison et des deux autres opérateurs relationnels dans et instanceof en JavaScript
iOpérateurs d'égalité et d'inégalités
Les opérateurs "==" et "===" sont utilisés pour comparer si deux valeurs sont égales. Les deux opérateurs autorisent tout type d'opérateur. Renvoie vrai s'ils sont égaux, sinon renvoie faux. "===" est également appelé opérateur d'égalité stricte (parfois appelé opérateur d'identité), qui est utilisé pour détecter si deux opérandes sont strictement égaux. L'opérateur "==" est appelé opérateur d'égalité, qui est utilisé pour vérifier si deux opérandes sont égaux. La définition de l'égalité ici est vague et permet la conversion de type.Javascript prend en charge les opérateurs "=", "==", "===", vous devez comprendre la différence entre les opérateurs (affectation, égalité, identité). Et utilisez-le avec précaution dans la programmation. Pour réduire la confusion, "=" doit être appelé "obtenir ou attribuer", "==" doit être appelé "égalité" et "===" doit être appelé "égalité stricte".
Les règles des opérateurs "!=" et "!==" sont "==", la négation de l'opérateur "===", "!" est un non-opérateur booléen, nous allons "!=", " !==" s'appelle l'inégalité, pas l'égalité stricte
La comparaison d'objets JavaScript est une comparaison de référence, pas une comparaison de valeurs. L'objet est égal à lui-même, mais ni la personne ni l'objet ne sont égaux. Si deux objets ont le même nombre de propriétés, les mêmes noms et valeurs de propriété, ils ne sont toujours pas égaux. Même si les éléments du tableau aux positions correspondantes sont égaux, les deux tableaux sont également inégaux.
L'opérateur d'égalité stricte "===" calcule d'abord la valeur de l'opérande, puis compare les deux valeurs sans aucune conversion de type.
Si deux types de valeur ne sont pas identiques, ils ne sont pas égaux
Si les deux valeurs sont nulles ou indéfinies, elles ne sont pas égales
Si les deux valeurs sont booléennes vraies ou fausses, alors elles sont égales
Si l'une des valeurs est NaN, ou si les deux valeurs sont NaN, alors elles ne sont pas égales. NaN n'est pas égal aux autres valeurs, y compris lui-même.
Deux valeurs sont égales si elles sont des nombres et égales. Si une valeur est 0 et une valeur est -0, elles sont également égales.
Deux valeurs sont égales si ce sont des chaînes et contiennent exactement les mêmes 16 chiffres dans les bits correspondants (voir chapitre 3, section 2). S’ils sont différents en longueur ou en contenu, ils ne sont pas égaux. Deux chaînes peuvent fonctionner exactement de la même manière et afficher les mêmes caractères, mais avoir des valeurs de 16 bits sans codage. JavaScript n'effectue pas de conversion standard en Unicode, ces chaînes sont donc transmises via "===" et "==". les résultats de comparaison des opérateurs ne sont pas non plus égaux. String.localeCompare() dans la partie 3 fournit une autre façon de comparer des chaînes.
Deux valeurs de référence sont égales si elles pointent vers le même objet, tableau ou fonction. S’ils pointent vers des objets différents, ils ne sont pas égaux, même si les deux objets ont exactement les mêmes propriétés.
L'opérateur d'égalité "==" est similaire à l'opérateur d'identité, mais la comparaison des opérateurs d'égalité n'est pas stricte. Si les deux nombres ne sont pas du même type, l'opérateur d'égalité tente une conversion de type puis les compare.
Si les deux types d'opérations sont identiques, les règles de comparaison sont les mêmes que celles de l'opérateur d'égalité ci-dessus. S'ils sont strictement égaux, les résultats de la comparaison sont égaux. S’ils ne sont pas strictement égaux, la comparaison aboutit à une inégalité.
Si deux types d'opérations sont différents, l'opérateur d'égalité "==" les considérera également comme égaux. La détection de l'égalité suivra les règles et conversions de type suivantes :
Si un type est nul et un autre indéfini, alors 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 les valeurs converties à des fins de comparaison.
Si une valeur est vraie, elle est convertie en 1 et comparée. Si une valeur est fausse, elle est convertie en 0 pour comparaison.
Si une valeur est un objet et l'autre valeur est un nombre ou une chaîne, utilisez les règles de conversion de la méthode du chapitre 3, section 8, sous-section 3 pour convertir l'objet en une valeur primitive, puis comparez. L'objet est converti en valeur primitive via la méthode toString() ou la méthode valueOf(). Les classes intégrées au cœur du langage JavaScript essaient d'abord d'utiliser valueOf(), puis d'utiliser toString(). À l'exception de la classe date, la classe date ne peut être convertie que via toString(). Les objets qui ne font pas partie du langage JavaScript principal sont convertis en valeurs primitives à l'aide de méthodes définies dans l'implémentation.
Les comparaisons entre d'autres types différents ne sont pas égales
Voici un petit exemple d'égalité
"1" == vrai
Cette expression est évaluée à vrai, ce qui indique que des valeurs de types complètement différents sont égales. Le booléen vrai est d'abord converti en nombre 1 avant que la comparaison ne soit effectuée. Ensuite, la chaîne "1" sera également convertie en nombre 1, car les valeurs des deux nombres sont égales, donc le résultat est vrai.
ii. Opérateurs de comparaison
Moins de (<)
Si le premier opérande est inférieur au deuxième opérande, le résultat de l'opération "<" est vrai, sinon il est faux
Inférieur ou égal à (<=)
Supérieur à (>)
Supérieur ou égal à (>=)
....(ne détaillant pas le sens)
Les opérandes des opérateurs de comparaison peuvent être de n'importe quel type. Cependant, seuls les nombres et les chaînes peuvent réellement effectuer des opérateurs de comparaison, donc tous les opérandes qui ne sont pas des nombres ou des chaînes subiront une conversion de type. Les règles de conversion de type sont les suivantes :
Si l'opérande est un objet, il est converti en valeur primitive selon les règles de conversion décrites dans la description du verrou au chapitre 3, section 8, sous-section 3 : Si valueOf() renvoie une valeur primitive, alors utilisez cette primitive valeur directement. Sinon, le résultat de la conversion de toString() est utilisé à des fins de comparaison.
Après avoir converti la paire en valeur primitive, si les deux opérandes sont des chaînes, alors les deux chaînes seront comparées par ordre alphabétique. L'ordre alphabétique mentionné ici constitue l'ordre d'indexation des caractères Unicode 16 bits.
Une fois l'objet converti en valeur primitive, si au moins un opérande n'est pas une chaîne, les deux opérandes seront comparés numériquement. 0 et -0 sont égaux. L'infini est plus grand que tout autre nombre (sauf l'infini lui-même) et -infinty est plus petit que n'importe quel nombre (sauf lui-même.) Si un opérande (ou converti) est NaN, l'opérateur de comparaison renvoie toujours false
Pour les opérateurs numériques et de chaîne, l'opérateur plus se comporte différemment de l'opérateur de comparaison. Le premier préfère les chaînes et effectue une concaténation de chaînes si l'un de ses opérandes est une chaîne. Les opérateurs de comparaison préfèrent les nombres uniquement lorsque les deux opérandes sont des chaînes. Une comparaison de chaînes sera effectuée.
Enfin, il convient de noter que les opérateurs "<=" et ">=" ne s'appuient pas sur l'opérateur d'égalité et sur des règles strictes de comparaison d'égalité pour déterminer l'égalité. En revanche, l'opérateur inférieur ou égal est simplement "pas supérieur à" et l'opérateur supérieur ou égal est simplement "pas inférieur à". Il n'y a qu'une seule exception, lorsque l'un des opérandes (après conversion) est NaN, les quatre opérateurs de comparaison renverront fasle.
opérateur iii.in
L'opérateurin s'attend à ce que son opérande gauche soit une chaîne ou convertible en chaîne, et que son côté droit soit un objet. Si l'objet de droite a un nom de propriété nommé valeur de l'opérande de gauche, alors l'expression renvoie vrai. Par exemple,
. données var = [7, 8, 8]
"0" dans les données //=> le vrai tableau contient 0
1 en données //=> ;true Nombres convertis en chaînes
3 dans les données //=>fase Il n'y a aucun élément avec l'index 3
iiii.instanceof opérateur
L'opérateur instanceof s'attend à ce que l'opérateur de gauche soit un objet et que l'opérande de droite indique la classe de l'objet. Si l'objet de gauche est une instance de la classe de droite, l'expression renvoie true ; elle est chargée de renvoyer false. Le chapitre 9 en parlera. Les classes d'objets JavaScript sont définies en initialisant leurs constructeurs. Dans ce cas, l'opérande droit de instanceof doit être une fonction. Par exemple :
Il convient de noter que tous les objets sont des instances de Object. Lors de la vérification si un objet est une instance d'une classe via instanceof, ce jugement est également appelé détection de "superclasse". Si l'objet d'opération gauche d'instanceof n'est pas un objet, instanceof renvoie false. Si l’opération de droite n’est pas une fonction, une exception de typewrong est levée.
Afin de comprendre le fonctionnement de l'opérateur instanceof, vous devez d'abord comprendre la "chaîne de prototypes". La chaîne de prototypes, en tant que mécanisme d'héritage de JavaScript, sera décrite en détail dans le chapitre 6, section 2, section 2.
Afin de calculer l'expression o instanceof f, JavaScript PenXian calcule d'abord f.prototyoe, puis interroge o dans la chaîne de prototypes. S'il est trouvé, alors o est une instance de f (ou la classe parent de f), alors. true est renvoyé. Sinon faux
10.Expression logique
Les opérateurs logiques "&&", "||" et "!" effectuent des opérations arithmétiques booléennes sur les opérations. Ils sont souvent utilisés avec des opérateurs relationnels qui combinent plusieurs expressions relationnelles pour en former une plus complexe.
i. Logique ET
L'opérateur "&&" peut être compris à trois niveaux différents. La compréhension la plus simple est que lorsque les opérandes sont tous deux des valeurs booléennes, "&&" effectue une opération booléenne ET (ET) sur deux valeurs booléennes, uniquement lorsque le premier opérande et le deuxième opérande sont tous deux vrais, il renvoie vrai. l'opérande est faux, alors il renvoie faux.
"&&" est utilisé pour relier deux expressions relationnelles
x == 0 && y == 0; //Renvoie vrai uniquement lorsque x et y sont tous deux 0
Les expressions relationnelles renvoient toujours vrai ou faux, donc lorsqu'elles sont utilisées ainsi, "&&" lui-même renvoie également vrai ou faux. Les opérateurs relationnels ont une priorité plus élevée que "&&" (et "||"), donc des expressions comme celle-ci peuvent être écrites en toute sécurité sans avoir besoin de parenthèses.
L'opérande "&&" n'est pas forcément une valeur booléenne. Rappelons que certaines valeurs peuvent être considérées comme des "vraies valeurs" et des "fausses valeurs". (Comme au chapitre 3, section 3, les fausses valeurs sont : false null undefined 0 -0 NaN et "", toutes les valeurs, y compris tous les objets, sont de vraies valeurs). Le deuxième niveau de compréhension de "&&" est que "&&" peut effectuer une opération booléenne ET (ET) sur des valeurs vraies et fausses. Si les deux opérandes sont vrais, alors une valeur vraie est renvoyée ; sinon, au moins un opérande est faux. Chaque fois qu'une valeur booléenne est utilisée en JavaScript, l'instruction d'expression la traitera comme une valeur vraie ou fausse, donc en fait "&&" ne renvoie pas toujours vrai et faux. Mais ce n'est pas grave.
Il convient de noter que l'opérateur mentionné ci-dessus renvoie la « vraie valeur » et la « fausse valeur », mais il n'explique pas ce qu'est la « vraie valeur » ou la « fausse valeur ». Pour cette raison, nous en discuterons en profondeur. . Compréhension de la troisième couche de "&&". L'opérateur calcule d'abord la valeur de l'opérande de gauche, c'est-à-dire qu'il calcule d'abord l'expression à gauche de "&&". Si le résultat du calcul est une valeur fausse, alors le résultat de l'expression entière doit être une valeur fausse. donc "&&" renvoie simplement l'opérande de gauche La valeur de l'opération, sans calculer l'opérande de droite.
Il est crucial de comprendre que "&&" peut ne pas calculer le bon opérande. Dans le code ci-dessus, la valeur de la variable P est nulle, et si p.x est calculé, une erreur d'exception sera générée. Par conséquent, seul p p.x.
est calculé uniquement s'il s'agit d'une valeur vraie (ne peut pas être nulle ou indéfinie)Le comportement de "&&" est parfois appelé "court-circuit", et nous voyons souvent beaucoup de code en profiter pour exécuter du code de manière conditionnelle. Par exemple, les deux codes suivants sont équivalents
En général, soyez prudent lorsque l'expression à droite de "&&" a des effets secondaires (expressions d'affectation, d'incrémentation, de décrémentation et d'appel de fonction). Car l'exécution de ces expressions avec effets secondaires dépend du résultat du calcul de l'opérateur gauche de la souris.
Bien que "&&" puisse effectuer certaines opérations d'expression complexes selon la compréhension des deuxième et troisième niveaux, dans la plupart des cas, "&&" n'est utilisé que pour effectuer des calculs booléens sur des valeurs vraies et fausses.
ii. OU logique (||)
L'opérateur "||" effectue une opération booléenne OR (OR) sur deux opérandes. Si l'un des opérandes est vrai, il renvoie vrai, si les deux opérandes sont faux, il renvoie faux.
Bien que l'opérateur "||" effectue simplement une simple opération booléenne OR (OR) dans la plupart des cas, comme "&&", il a également des comportements plus complexes. Il calcule d'abord la valeur du premier opérande, et c'est le cas. c'est-à-dire que l'expression de gauche est calculée en premier. Si le résultat du calcul est vrai, la vraie valeur est renvoyée. Sinon, la deuxième valeur est calculée.
Comme "&&", vous devez éviter l'opérande de droite contenant certaines expressions avec des effets secondaires, sauf si vous utilisez explicitement une expression avec des effets secondaires sur le côté droit, et l'expression sur le côté droit peut ne pas être évaluée.
La manière la plus courante d'utiliser cet opérateur est de sélectionner la première expression à valeur vraie parmi un ensemble d'expressions alternatives.
Cet usage courant se fait généralement dans le corps d'une fonction pour fournir des valeurs par défaut pour les paramètres.
iii. NON logique (!)
L'opérateur "!" est un opérateur unaire qui se place avant un seul opérande. Son but est d'annuler la valeur booléenne de l'opérande.
Différent des opérateurs "&&" et "||", l'opérateur "!" convertit d'abord son opérande en une valeur booléenne (voir les règles d'appel au chapitre 3), puis annule la valeur booléenne. Autrement dit, "!" renvoie toujours vrai et faux. De plus, la valeur booléenne d'une valeur peut être obtenue en utilisant deux opérations NON logiques : (!!x, reportez-vous au chapitre 3, section 8, section 2)
"!" a une priorité élevée et est étroitement lié aux opérandes. Si vous souhaitez comparer p && q, vous avez besoin de supports de jardin (p && q). Le code suivant :
11. Expression d'affectation
Javascript utilise l'opérateur "=" pour attribuer des valeurs à des variables ou des attributs, par exemple :
L'opérateur "=" s'attend à ce que son opérande de gauche soit une lvalue : une variable ou une propriété d'objet (ou un élément de tableau), et son opérande de droite peut être n'importe quelle valeur de n'importe quel type. La valeur de l'expression d'affectation est la valeur de l'opérande de droite. Un effet secondaire d'une expression d'affectation est que la valeur de l'opérande de droite est affectée à la variable ou à la propriété d'objet de gauche. Dans ce cas, les références ultérieures à cette variable et aux propriétés de l'objet obtiendront cette valeur.
Bien que la valeur d'une expression d'affectation soit très simple, vous verrez parfois des expressions complexes contenant des expressions d'affectation. Par exemple : mettez les opérations d’affectation et de détection dans une seule expression :
Si tel est le cas, vous devez clairement connaître la différence entre "=" et "==" ! , il convient de noter que "=" a une très faible priorité. Habituellement, lorsqu'une instruction d'affectation est utilisée dans une expression longue, des crochets de jardin doivent être ajoutés pour garantir le bon ordre des opérations.
L'associativité des opérateurs d'affectation s'effectue de droite à gauche. C'est-à-dire que plusieurs opérateurs d'affectation apparaissent dans une expression, et l'ordre des opérations est également de droite à gauche. Par conséquent, plusieurs variables peuvent être affectées des manières suivantes. .
Opération d'affectation avec opération :
En plus des opérations d'affectation régulières, JavaScript prend également en charge d'autres opérateurs d'affectation, qui connectent les opérations d'affectation à d'autres opérateurs. Fournir une méthode de calcul plus rapide. Par exemple, l'opérateur = effectue l'opérateur d'addition et l'opération d'affectation, l'expression suivante :
total = salaes_tax;
Équivalent à l'expression suivante
total = total salaes_tax
L'opérateur "=" peut agir sur des nombres ou des chaînes. Si son opération est un nombre, il effectuera des opérations d'addition et d'affectation ; s'il s'agit d'une chaîne, il effectuera des opérations de concaténation et d'affectation de chaînes.
Ce type d'opérateurs inclut également "-=","*=","&=", etc., comme indiqué dans le tableau suivant des opérateurs d'affectation
Exemple d'opérateur Équivalent à
= une =b une=une b
-= a-=b a=a-b
*= a*=b a=a*b
/= a/=b a=a/b
%= a%=b a=a%b
<<= a<<=b a=a<
>>>= a>>>=b a=a>>>b
&= a&=b a=a&b
|= une|=b une=une|b
^= a^=b a=a^b
Dans la plupart des cas, l'expression est
a op =b
L'op représente ici un opérateur, et cette expression est équivalente à
a =a op b
Sur la première ligne, l'expression a est évaluée une fois et sur la deuxième ligne, l'expression a est évaluée deux fois.
Les deux ne sont pas équivalents uniquement si a contient des expressions avec des effets secondaires (tels que des appels de fonction et des opérations d'affectation). Les deux expressions suivantes ne sont pas équivalentes
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.全域eval()
eval()具有改變局部變數的能力，這對javascript優化器來說，是一個很大的問題，然而作為一種權宜之計，javascript徵對那行調用了eval()函數所做的優化並不多。但當腳本定義了一個別名，並且用令一個名稱來呼叫它，javascript解釋器又如何運作呢，為了javascript解釋器更加簡化。 ECMAScipt3標準規定了任何解釋器都不允許對eval()賦予別名。如果eval()使用別的別名來呼叫的話，則會拋出EvalError異常。
實際上，大多數的實作並不是這樣做的。當透過別名呼叫時，eval()會將其字串當成頂層的全域程式碼來執行。執行程式碼可能會定義新的全域變數和全域函數。執行的程式碼可能會定義新的全域變數和全域函數，或為全域變數賦值。但卻不能修改或修改主調函數中的局部變量，因此這不會影響到函數內的程式碼最佳化。
ECMAScript5是反對使用EvalError的，並且規範了eval()的行為。 “直接的eval”，當直接使用非限定的“eval”名稱，來呼叫eval()函數時，它總共是在它的上下文作用域內支線。其它間接呼叫則使用全域函數為其上下文作用域。且無法讀取、寫入、定義局部變數和函數。下面有一段程式碼實例：
13.其它運算子。
javascript支援許多其它各種各樣的運算符。
i.條件運算子(?:)
條件運算子是javascript中的唯一一個三元運算子。通常這個運算子寫成"?:"，這個運算子擁有三哥運算元，第一個運算元在"?"之前，第二個運算元在「?」和":"之間。第三個操作數早在":"之後，例如
x > 0 ? x : -x; //求x的絕對值
條件運算子的操作數可以是任意型別。第一個操作數當成布林值，如果它是真值，那麼將計算第二個操作數，並傳回計算結果。賦值如果第一個值運算元是假值，那麼就會計算第三個運算元。並傳回計算結果。第二個和第三個運算元總是會計算其中一個。不可能兩者同時進行。其實使用if語句也達到同樣的效果(5.4.1),「?:」運算子只是提供了一種簡寫形式。這裡有一個"?:"的典型使用場景，判斷一個變數是否有定義，如果有定義則使用它，如果無定義，則使用一個預設值。
和以下的程式碼是等價的，但上面的比較簡潔
Résumé des connaissances de base de Java
Quels sont les opérateurs en langage Go ?
Expressions couramment utilisées en php
Qu'est-ce qu'un tableau vide en php
Supprimer la ligne d'en-tête
Méthode de retrait OuYi
Utilisation de l'annotation de vitesse
Utilisation des fonctions aléatoires du langage C
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
